gpsea.view package

class gpsea.view.GpseaReport

Bases: object

GpseaReport summarizes an aspect of an analysis for the user.

abstract write(fh: IOBase | str)

Write the report into the provided path or file handle.

Parameters:

fh – a str with path or io.IOBase with the file-like object for writing the report into.

class gpsea.view.CohortVariantViewer(tx_id: str)

Bases: BaseViewer

CohortVariantViewer creates an HTML report with the cohort variants.

The report can be either written into an HTML file or displayed in a Jupyter notebook.

See :ref:show-cohort-variants: for an example usage.

process(cohort: Cohort, only_hgvs: bool = True) → GpseaReport

Generate the variant report.

Parameters:

• cohort (Cohort) – The cohort being analyzed in the current notebook.

• only_hgvs (bool) – Do not show the transcript ID part of the HGVS annotation, just the annotation.

Returns:

a report that can be stored to a path or displayed in

interactive environment such as Jupyter notebook.

Return type:

GpseaReport

class gpsea.view.CohortViewer(hpo: MinimalOntology, top_phenotype_count: int = 10, top_variant_count: int = 10)

Bases: BaseViewer

CohortViewer summarizes the most salient Cohort aspects into an HTML report.

process(cohort: Cohort, transcript_id: str) → GpseaReport

Generate the report for a given cohort.

The variant effects will be reported with respect to the provided transcript.

Parameters:

• cohort (Cohort) – the cohort to visualize

• transcript_id (str) – the accession of the target transcript (e.g. NM_123456.7)

Returns:

a report that can be stored to a path or displayed in

interactive environment such as Jupyter notebook.

Return type:

GpseaReport

class gpsea.view.BaseProteinVisualizer

Bases: object

The visualizer for plotting cohort variants on a protein diagram.

abstract draw_protein(cohort: Cohort, protein_metadata: ProteinMetadata, ax, **kwargs)

Draw the locations of the cohort variants on the provided axes.

Keyword Arguments:

• (kwargs) (The function can take multiple keyword arguments)

• labeling_method (*) – Valid values of labeling_method are {'abbreviate', 'enumerate'}

:keyword : :kwtype : param cohort: the cohort to plot. :keyword : :kwtype : param protein_metadata: information for the protein of interest. :keyword : :kwtype : param ax: a Matplotlib Axes to plot on

gpsea.view.configure_default_protein_visualizer(random_seed: int = 42) → BaseProteinVisualizer

class gpsea.view.CohortArtist(protein_visualizer: BaseProteinVisualizer, protein_metadata_service: ProteinMetadataService)

Bases: object

CohortArtist draws all types of figures to visualize the salient aspects of the Cohort of interest.

draw_protein(cohort: Cohort, protein_id: str, ax, **kwargs)

Draw the locations of the cohort variants on the provided axes.

See the draw_protein() for more info about the arguments.

gpsea.view.configure_default_cohort_artist(protein_source: Literal['UNIPROT'] = 'UNIPROT', cache_dir: str | None = None, timeout: float | int = 30.0, random_seed: int = 42) → CohortArtist

Get the default CohortArtist.

Parameters:

• protein_source – a str with the code of the protein data sources (currently accepting just UNIPROT).

• cache_dir – path to the folder where we will cache the results fetched from the remote APIs or None if the data should be cached as described by get_cache_dir_path() function. In any case, the directory will be created if it does not exist (including any non-existing parents).

• timeout – a float or an int for the timeout in seconds for the REST APIs.

class gpsea.view.ProteinVisualizer(random_seed: int = 42)

Bases: BaseProteinVisualizer

Draw a schema of a protein with variants of the cohort.

draw_protein(cohort: Cohort, protein_metadata: ProteinMetadata, ax, **kwargs)

Draw the locations of the cohort variants on the provided axes.

Keyword Arguments:

• (kwargs) (The function can take multiple keyword arguments)

• labeling_method (*) – Valid values of labeling_method are {'abbreviate', 'enumerate'}

:keyword : :kwtype : param cohort: the cohort to plot. :keyword : :kwtype : param protein_metadata: information for the protein of interest. :keyword : :kwtype : param ax: a Matplotlib Axes to plot on

draw_protein_diagram(tx_coordinates: TranscriptCoordinates, protein_metadata: ProteinMetadata, cohort: Cohort, ax: Axes | None = None, labeling_method: Literal['abbreviate', 'enumerate'] = 'abbreviate') → Axes | None

draw_fig(pvis: ProteinVisualizable, ax: Axes | None = None, labeling_method: Literal['abbreviate', 'enumerate'] = 'abbreviate') → Axes | None

Visualize the cohort variants on a protein diagram.

By default, the legend is drawn to the right of the figure to avoid overlap between the variant markers and the legend.

Parameters:

• pvis – ProteinVisualizable with information about the transcript coordinates, protein metadata, and the cohort for plotting

• ax – a Matplotlib plt.Axes to plot on or None if a new Axes should be created

• labeling_method – the strategy for generating labels. Valid values of labeling_method are {‘abbreviate’, ‘enumerate’}

Returns:

None if an plt.Axes was provided via ax argument or an Axes created by the visualizer if ax was None.

class gpsea.view.ProteinVisualizable(tx_coordinates: TranscriptCoordinates | None, protein_meta: ProteinMetadata, cohort: Cohort)

Bases: object

property cohort: Cohort

property protein_id: str

property protein_metadata: ProteinMetadata

property protein_feature_starts: Sequence[int]

property protein_feature_ends: Sequence[int]

property protein_feature_types: Sequence[str]

property protein_length: int

property protein_feature_names: Sequence[str]

property variant_effects: Sequence[VariantEffect]

property variant_locations_counted_absolute: ndarray

property marker_counts

property variant_locations: ndarray

Get an array with 0-based start coordinates of aminoacids that overlap with the variant regions.

Returns

a 1D array with ints containing a coordinate for each variant

class gpsea.view.ProteinVariantViewer(protein_metadata: ProteinMetadata, tx_id: str)

Bases: BaseViewer

Class to create a pretty HTML table to display the protein information in the Jupyter notebook.

process(cohort: Cohort) → GpseaReport

Summarize the data regarding the protein into a HTML table.

Parameters:

cohort (Cohort) – the cohort of patients being analyzed

Returns:

a report that can be stored to a path or displayed in

interactive environment such as Jupyter notebook.

Return type:

GpseaReport

class gpsea.view.DiseaseViewer(hpo: MinimalOntology, transcript_id: str | None = None)

Bases: BaseViewer

TODO

process(cohort: Cohort) → GpseaReport

class gpsea.view.MtcStatsViewer

Bases: BaseViewer

MtcStatsViewer uses a Jinja2 template to create an HTML element for showing in the Jupyter notebook or for writing into a standalone HTML file.

process(result: HpoTermAnalysisResult) → GpseaReport

Create an HTML to present MTC part of the HpoTermAnalysisResult.

Parameters:

result (HpoTermAnalysisResult) – the result to show

Returns:

a report that can be stored to a path or displayed in

interactive environment such as Jupyter notebook.

Return type:

GpseaReport

gpsea.view.summarize_hpo_analysis(hpo: MinimalOntology, result: HpoTermAnalysisResult) → DataFrame

Create a dataframe with counts, frequencies, and p values for the tested HPO terms.

The HPO terms that were not tested will not be included in the frame.

Parameters:

• hpo – HPO data.

• result – the HPO term analysis results to show.

class gpsea.view.VariantTranscriptVisualizer

Bases: object

VariantTranscriptProteinArtist creates a graphic to show distributions of variants across a provided transcript and its protein product.

draw_variants(variants: Iterable[Variant], tx: TranscriptCoordinates, protein: ProteinMetadata)

class gpsea.view.Formatter

Bases: Generic[T]

abstract format_as_string(item: T) → str

Inputs an item and outputs a human readable string that can be used to more easily read the item in tables or other visualizers.

Parameters:

item (T) – an element to be formatted

Returns:

a human readable string

Return type:

str

class gpsea.view.VariantFormatter(tx_id: str | None = None)

Bases: Formatter[Variant]

A class that can be used to format a Variant to a human readable string

format_as_string(item: Variant) → str

Parameters:

item (Variant) – An object of class Variant representing a variant.

Returns:

A human readable string for the variant.

Return type:

str

class gpsea.view.BaseViewer

Bases: object