pheval 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

pheval/utils/phenopacket_utils.py

@@ -0,0 +1,356 @@
+import json
+
+# import logging
+import os
+from collections import defaultdict
+from copy import copy
+from dataclasses import dataclass
+from pathlib import Path
+
+import pandas as pd
+from google.protobuf.json_format import MessageToJson, Parse
+from phenopackets import (
+    Family,
+    File,
+    GenomicInterpretation,
+    Interpretation,
+    Phenopacket,
+    PhenotypicFeature,
+)
+
+from pheval.prepare.custom_exceptions import IncorrectFileFormatError
+
+
+class IncompatibleGenomeAssemblyError(Exception):
+    """Exception raised for incompatible genome assembly."""
+
+    def __init__(self, assembly, phenopacket, message="Incompatible Genome Assembly"):
+        self.assembly: str = assembly
+        self.phenopacket: Path = phenopacket
+        self.message: str = message
+        super().__init__(self.message)
+
+    def __str__(self):
+        return f"{self.message} -> {self.assembly} in {self.phenopacket}"
+
+
+@dataclass
+class GenomicVariant:
+    chrom: str
+    pos: int
+    ref: str
+    alt: str
+
+
+@dataclass
+class ProbandCausativeVariant:
+    proband_id: str
+    assembly: str
+    variant: GenomicVariant
+    genotype: str
+    info: str = None
+
+
+@dataclass
+class ProbandCausativeGene:
+    gene_symbol: str
+    gene_identifier: str
+
+
+def read_hgnc_data() -> pd.DataFrame:
+    return pd.read_csv(
+        os.path.dirname(__file__).replace("utils", "resources/hgnc_complete_set_2022-10-01.txt"),
+        delimiter="\t",
+        dtype=str,
+    )
+
+
+def create_hgnc_dict() -> defaultdict:
+    """Creates reference for updating gene symbols and identifiers."""
+    hgnc_df = read_hgnc_data()
+    hgnc_data = defaultdict(dict)
+    for _index, row in hgnc_df.iterrows():
+        previous_names = []
+        hgnc_data[row["symbol"]]["ensembl_id"] = row["ensembl_gene_id"]
+        hgnc_data[row["symbol"]]["hgnc_id"] = row["hgnc_id"]
+        hgnc_data[row["symbol"]]["entrez_id"] = row["entrez_id"]
+        hgnc_data[row["symbol"]]["refseq_accession"] = row["refseq_accession"]
+        previous = str(row["prev_symbol"]).split("|")
+        for p in previous:
+            previous_names.append(p.strip('"'))
+        hgnc_data[row["symbol"]]["previous_symbol"] = previous_names
+
+    return hgnc_data
+
+
+def create_gene_identifier_map() -> dict:
+    hgnc_df = read_hgnc_data()
+    identifier_map = {}
+    for _index, row in hgnc_df.iterrows():
+        identifier_map[row["ensembl_gene_id"]] = row["symbol"]
+        identifier_map[row["hgnc_id"]] = row["symbol"]
+        identifier_map[row["entrez_id"]] = row["symbol"]
+        identifier_map[row["refseq_accession"]] = row["symbol"]
+    return identifier_map
+
+
+def phenopacket_reader(file: Path):
+    """Reads a phenopacket file, returning its contents."""
+    file = open(file, "r")
+    phenopacket = json.load(file)
+    file.close()
+    if "proband" in phenopacket:
+        return Parse(json.dumps(phenopacket), Family())
+    else:
+        return Parse(json.dumps(phenopacket), Phenopacket())
+
+
+class PhenopacketUtil:
+    """Retrieves relevant data from a phenopacket."""
+
+    def __init__(self, phenopacket_contents: Phenopacket):
+        self.phenopacket_contents = phenopacket_contents
+
+    def sample_id(self) -> str:
+        """Retrieve the sample ID from a phenopacket or proband of a family."""
+        if hasattr(self.phenopacket_contents, "proband"):
+            return self.phenopacket_contents.proband.subject.id
+        else:
+            return self.phenopacket_contents.subject.id
+
+    def phenotypic_features(self) -> list[PhenotypicFeature]:
+        """Retrieves a list of all HPO terms."""
+        if hasattr(self.phenopacket_contents, "proband"):
+            return self.phenopacket_contents.proband.phenotypic_features
+        else:
+            return self.phenopacket_contents.phenotypic_features
+
+    def observed_phenotypic_features(self) -> list[PhenotypicFeature]:
+        """Removes any HPO terms labelled as excluded."""
+        phenotypic_features = []
+        all_phenotypic_features = self.phenotypic_features()
+        for p in all_phenotypic_features:
+            if p.excluded:
+                continue
+            phenotypic_features.append(p)
+        return phenotypic_features
+
+    def negated_phenotypic_features(self) -> [PhenotypicFeature]:
+        """Retrieve negated phenotypic features."""
+        negated_phenotypic_features = []
+        all_phenotypic_features = self.phenotypic_features()
+        for p in all_phenotypic_features:
+            if p.excluded:
+                negated_phenotypic_features.append(p)
+        return negated_phenotypic_features
+
+    def interpretations(self) -> list[Interpretation]:
+        """Returns all interpretations of a phenopacket."""
+        if hasattr(self.phenopacket_contents, "proband"):
+            return self.phenopacket_contents.proband.interpretations
+        else:
+            return self.phenopacket_contents.interpretations
+
+    def causative_variants(self) -> list[ProbandCausativeVariant]:
+        """Returns a list of all causative variants listed in a phenopacket."""
+        all_variants = []
+        interpretation = self.interpretations()
+        for i in interpretation:
+            for g in i.diagnosis.genomic_interpretations:
+                vcf_record = g.variant_interpretation.variation_descriptor.vcf_record
+                genotype = g.variant_interpretation.variation_descriptor.allelic_state
+                variant_data = ProbandCausativeVariant(
+                    self.phenopacket_contents.subject.id,
+                    vcf_record.genome_assembly,
+                    GenomicVariant(
+                        vcf_record.chrom,
+                        vcf_record.pos,
+                        vcf_record.ref,
+                        vcf_record.alt,
+                    ),
+                    genotype.label,
+                    vcf_record.info,
+                )
+                all_variants.append(variant_data)
+        return all_variants
+
+    def files(self) -> list:
+        """Returns all files associated with a phenopacket."""
+        return self.phenopacket_contents.files
+
+    def vcf_file_data(self, phenopacket_path: Path, vcf_dir: Path) -> File:
+        """Retrieves the genome assembly and vcf name from a phenopacket."""
+        compatible_genome_assembly = ["GRCh37", "hg19", "GRCh38", "hg38"]
+        vcf_data = [file for file in self.files() if file.file_attributes["fileFormat"] == "vcf"][0]
+        if not Path(vcf_data.uri).name.endswith(".vcf") and not Path(vcf_data.uri).name.endswith(
+            ".vcf.gz"
+        ):
+            raise IncorrectFileFormatError(Path(vcf_data.uri), ".vcf or .vcf.gz file")
+        if vcf_data.file_attributes["genomeAssembly"] not in compatible_genome_assembly:
+            raise IncompatibleGenomeAssemblyError(
+                vcf_data.file_attributes["genomeAssembly"], phenopacket_path
+            )
+        vcf_data.uri = str(vcf_dir.joinpath(Path(vcf_data.uri).name))
+        return vcf_data
+
+    @staticmethod
+    def _extract_diagnosed_gene(
+        genomic_interpretation: GenomicInterpretation,
+    ) -> ProbandCausativeGene:
+        """Returns the disease causative gene from the variant descriptor field if not empty,
+        otherwise, returns from the gene descriptor from a phenopacket."""
+        if genomic_interpretation.variant_interpretation.ByteSize() != 0:
+            return ProbandCausativeGene(
+                genomic_interpretation.variant_interpretation.variation_descriptor.gene_context.symbol,
+                genomic_interpretation.variant_interpretation.variation_descriptor.gene_context.value_id,
+            )
+
+        else:
+            return ProbandCausativeGene(
+                gene_symbol=genomic_interpretation.gene.symbol,
+                gene_identifier=genomic_interpretation.gene.value_id,
+            )
+
+    def diagnosed_genes(self) -> list[ProbandCausativeGene]:
+        """Returns a unique list of all causative genes and the corresponding gene identifiers from a phenopacket."""
+        pheno_interpretation = self.interpretations()
+        genes = []
+        for i in pheno_interpretation:
+            for g in i.diagnosis.genomic_interpretations:
+                genes.append(self._extract_diagnosed_gene(g))
+                genes = list({gene.gene_symbol: gene for gene in genes}.values())
+        return genes
+
+    def diagnosed_variants(self) -> list[GenomicVariant]:
+        """Returns a list of all variants from a phenopacket - for use in assess-prioritisation."""
+        variants = []
+        pheno_interpretation = self.interpretations()
+        for i in pheno_interpretation:
+            for g in i.diagnosis.genomic_interpretations:
+                variant = GenomicVariant(
+                    chrom=g.variant_interpretation.variation_descriptor.vcf_record.chrom,
+                    pos=g.variant_interpretation.variation_descriptor.vcf_record.pos,
+                    ref=g.variant_interpretation.variation_descriptor.vcf_record.ref,
+                    alt=g.variant_interpretation.variation_descriptor.vcf_record.alt,
+                )
+                variants.append(variant)
+        return variants
+
+
+class PhenopacketRebuilder:
+    """Rebuilds a Phenopacket."""
+
+    def __init__(self, phenopacket: Phenopacket or Family):
+        self.phenopacket = phenopacket
+
+    def update_interpretations(self, interpretations) -> Phenopacket or Family:
+        """Adds the updated interpretations to a phenopacket."""
+        phenopacket = copy(self.phenopacket)
+        if hasattr(phenopacket, "proband"):
+            del phenopacket.proband.interpretations[:]
+            phenopacket.proband.interpretations.extend(interpretations)
+        else:
+            del phenopacket.interpretations[:]
+            phenopacket.interpretations.extend(interpretations)
+        return phenopacket
+
+    def add_randomised_hpo(self, randomised_hpo) -> Phenopacket or Family:
+        """Adds randomised phenotypic profile to phenopacket."""
+        phenopacket = copy(self.phenopacket)
+        if hasattr(phenopacket, "proband"):
+            del phenopacket.proband.phenotypic_features[:]
+            phenopacket.proband.phenotypic_features.extend(randomised_hpo)
+        else:
+            del phenopacket.phenotypic_features[:]
+            phenopacket.phenotypic_features.extend(randomised_hpo)
+        return phenopacket
+
+    def add_spiked_vcf_path(self, spiked_vcf_file_data: File) -> Phenopacket or Family:
+        """Adds spiked vcf path to phenopacket."""
+        phenopacket = copy(self.phenopacket)
+        phenopacket_files = [
+            file for file in phenopacket.files if file.file_attributes["fileFormat"] != "vcf"
+        ]
+        phenopacket_files.append(spiked_vcf_file_data)
+        del phenopacket.files[:]
+        phenopacket.files.extend(phenopacket_files)
+        return phenopacket
+
+
+def create_json_message(phenopacket: Phenopacket or Family) -> str:
+    """Creates json message for writing to file."""
+    return MessageToJson(phenopacket)
+
+
+def write_phenopacket(phenopacket: Phenopacket or Family, output_file: Path) -> None:
+    """Writes a phenopacket."""
+    phenopacket_json = create_json_message(phenopacket)
+    with open(output_file, "w") as outfile:
+        outfile.write(phenopacket_json)
+    outfile.close()
+
+
+class GeneIdentifierUpdater:
+    def __init__(self, gene_identifier: str, hgnc_data: dict = None, identifier_map: dict = None):
+        self.hgnc_data = hgnc_data
+        self.gene_identifier = gene_identifier
+        self.identifier_map = identifier_map
+
+    def find_identifier(self, gene_symbol: str) -> str:
+        """Finds the specified gene identifier for a gene symbol."""
+        if gene_symbol in self.hgnc_data.keys():
+            return self.hgnc_data[gene_symbol][self.gene_identifier]
+        else:
+            for _symbol, data in self.hgnc_data.items():
+                for prev_symbol in data["previous_symbol"]:
+                    if prev_symbol == gene_symbol:
+                        return data[self.gene_identifier]
+
+    def obtain_gene_symbol_from_identifier(self, query_gene_identifier: str) -> str:
+        """
+        Obtain gene symbol from a gene identifier. (e.g.)
+        "
+        obtain_gene_symbol_from_identifier(query_gene_identifier="HGNC:5")
+        "
+        """
+        return self.identifier_map[query_gene_identifier]
+
+    def _find_alternate_ids(self, gene_symbol: str) -> list[str]:
+        """Finds the alternate IDs for a gene symbol."""
+        if gene_symbol in self.hgnc_data.keys():
+            return [
+                self.hgnc_data[gene_symbol]["hgnc_id"],
+                "ncbigene:" + self.hgnc_data[gene_symbol]["entrez_id"],
+                "ensembl:" + self.hgnc_data[gene_symbol]["ensembl_id"],
+                "symbol:" + gene_symbol,
+            ]
+        else:
+            for symbol, data in self.hgnc_data.items():
+                for prev_symbol in data["previous_symbol"]:
+                    if prev_symbol == gene_symbol:
+                        return [
+                            data["hgnc_id"],
+                            "ncbigene:" + data["entrez_id"],
+                            "ensembl:" + data["ensembl_id"],
+                            "symbol:" + symbol,
+                        ]
+
+    def update_genomic_interpretations_gene_identifier(
+        self, interpretations: list[Interpretation]
+    ) -> list[Interpretation]:
+        """Updates the genomic interpretations of a phenopacket."""
+        updated_interpretations = copy(list(interpretations))
+        for updated_interpretation in updated_interpretations:
+            for g in updated_interpretation.diagnosis.genomic_interpretations:
+                g.variant_interpretation.variation_descriptor.gene_context.value_id = (
+                    self.find_identifier(
+                        g.variant_interpretation.variation_descriptor.gene_context.symbol
+                    )
+                )
+                del g.variant_interpretation.variation_descriptor.gene_context.alternate_ids[:]
+                g.variant_interpretation.variation_descriptor.gene_context.alternate_ids.extend(
+                    self._find_alternate_ids(
+                        g.variant_interpretation.variation_descriptor.gene_context.symbol
+                    )
+                )
+        return updated_interpretations

pheval/utils/semsim_utils.py

@@ -0,0 +1,156 @@
+"""
+Contains all pheval utility methods
+"""
+from pathlib import Path
+
+import numpy
+import pandas as pd
+import plotly.express as px
+
+import pheval.utils.file_utils as file_utils
+
+
+def filter_non_0_score(data: pd.DataFrame, col: str) -> pd.DataFrame:
+    """Removes rows that have value equal to 0 based on the given column passed by col parameter
+
+    Args:
+        data (pd.DataFrame): Dirty dataframe
+        col (str): Column to be filtered
+
+    Returns:
+        pd.DataFrame: Filtered dataframe
+    """
+    return data[data[col] != 0]
+
+
+def parse_semsim(df: pd.DataFrame, cols: list) -> pd.DataFrame:
+    """Parses semantic similarity profiles converting the score column as a numeric value and dropping the null ones
+
+    Args:
+        df (pd.DataFrame): semantic similarity profile dataframe
+        cols (list): list of columns that will be selected on semsim data
+
+    Returns:
+        pd.Dataframe: parsed semantic similarity dataframe
+    """
+    df[cols[-1]] = pd.to_numeric(df[cols[-1]], errors="coerce")
+    df.replace("None", numpy.nan).dropna(subset=cols[-1], inplace=True)
+    return df
+
+
+def diff_semsim(
+    semsim_left: pd.DataFrame, semsim_right: pd.DataFrame, score_column: str, absolute_diff: bool
+) -> pd.DataFrame:
+    """Calculates score difference between two semantic similarity profiles
+
+    Args:
+        semsim_left (pd.DataFrame): first semantic similarity dataframe
+        semsim_right (pd.DataFrame): second semantic similarity dataframe
+        score_column (str): Score column that will be computed (e.g. jaccard_similarity)
+        absolute_diff (bool, optional): Whether the difference is absolute (True) or percentage (False).
+        Defaults to True.
+
+    Returns:
+        pd.DataFrame: A dataframe with terms and its scores differences
+    """
+    df = pd.merge(semsim_left, semsim_right, on=["subject_id", "object_id"], how="outer")
+    if absolute_diff:
+        df["diff"] = df[f"{score_column}_x"] - df[f"{score_column}_y"]
+        return df[["subject_id", "object_id", "diff"]]
+    df["diff"] = df.apply(
+        lambda row: get_percentage_diff(row[f"{score_column}_x"], row[f"{score_column}_y"]), axis=1
+    )
+    return df[["subject_id", "object_id", f"{score_column}_x", f"{score_column}_y", "diff"]]
+
+
+def percentage_diff(semsim_left: Path, semsim_right: Path, score_column: str, output: Path):
+    """Compares two semantic similarity profiles
+
+    Args:
+        semsim_left (Path): File path of the first semantic similarity profile
+        semsim_right (Path): File path of the second semantic similarity profile
+        score_column (str): Score column that will be computed (e.g. jaccard_similarity)
+        output (Path): Output path for the difference tsv file
+    """
+    clean_df = semsim_analysis(semsim_left, semsim_right, score_column, absolute_diff=False)
+    clean_df.sort_values(by="diff", ascending=False).to_csv(output, sep="\t", index=False)
+
+
+def semsim_heatmap_plot(semsim_left: Path, semsim_right: Path, score_column: str):
+    """Plots semantic similarity profiles heatmap
+
+    Args:
+        semsim_left (Path): File path of the first semantic similarity profile
+        semsim_right (Path): File path of the second semantic similarity profile
+        score_column (str): Score column that will be computed (e.g. jaccard_similarity)
+    """
+    clean_df = semsim_analysis(semsim_left, semsim_right, score_column)
+    df = clean_df.pivot(index="subject_id", columns="object_id", values="diff")
+    fig = px.imshow(df, text_auto=True)
+    fig.show()
+
+
+def semsim_analysis(
+    semsim_left: Path, semsim_right: Path, score_column: str, absolute_diff=True
+) -> pd.DataFrame:
+    """semsim_analysis
+
+    Args:
+        semsim_left (Path): File path of the first semantic similarity profile
+        semsim_right (Path): File path of the second semantic similarity profile
+        score_column (str): Score column that will be computed (e.g. jaccard_similarity)
+        absolute_diff (bool, optional): Whether the difference is absolute (True) or percentage (False).
+        Defaults to True.
+
+    Returns:
+        [pd.DataFrame]: DataFrame with the differences between two semantic similarity profiles
+    """
+    validate_semsim_file_comparison(semsim_left, semsim_right)
+    cols = ["subject_id", "object_id", score_column]
+    semsim_left = pd.read_csv(semsim_left, sep="\t")
+    semsim_right = pd.read_csv(semsim_right, sep="\t")
+    file_utils.ensure_columns_exists(
+        cols=cols,
+        err_message="must exist in semsim dataframes",
+        dataframes=[semsim_left, semsim_right],
+    )
+    semsim_left = parse_semsim(semsim_left, cols)
+    semsim_right = parse_semsim(semsim_right, cols)
+    diff_df = diff_semsim(semsim_left, semsim_right, score_column, absolute_diff)
+    return filter_non_0_score(diff_df, "diff")
+
+
+def validate_semsim_file_comparison(semsim_left: Path, semsim_right: Path):
+    """Checks if files exist and whether they're different
+    Args:
+        semsim_left (Path): File path of the first semantic similarity profile
+        semsim_right (Path): File path of the second semantic similarity profile
+    Raises:
+        Exception: FileNotFoundException
+    """
+    if semsim_left == semsim_right:
+        errmsg = "Semantic similarity profiles are equal. Make sure you have selected different files to analyze"
+        raise Exception(errmsg)
+    file_utils.ensure_file_exists(semsim_left, semsim_right)
+
+
+def get_percentage_diff(current_number: float, previous_number: float) -> float:
+    """Gets the percentage difference between two numbers
+
+    Args:
+        current_number (float): second number in comparison
+        previous_number (float): first number in comparison
+
+    Returns:
+        float: percentage difference between two numbers
+    """
+    try:
+        if current_number == previous_number:
+            return "{:.2%}".format(0)
+        if current_number > previous_number:
+            number = (1 - ((current_number / previous_number))) * 100
+        else:
+            number = (100 - ((previous_number / current_number) * 100)) * -1
+        return "{:.2%}".format(number / 100)
+    except ZeroDivisionError:
+        return None

{pheval-0.1.0.dist-info → pheval-0.2.0.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: pheval
-Version: 0.1.0
+Version: 0.2.0
 Summary: 
-Author: Nico Matentzoglu
-Author-email: nicolas.matentzoglu@gmail.com
-Requires-Python: >=3.9
+Author: Yasemin Bridges
+Author-email: y.bridges@qmul.ac.uk
+Requires-Python: >=3.9,<4.0.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -12,8 +12,16 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: class-resolver (>=0.3.10,<0.4.0)
 Requires-Dist: click (>=8.1.3)
 Requires-Dist: deprecation (>=2.1.0)
+Requires-Dist: google (>=3.0.0,<4.0.0)
 Requires-Dist: jaydebeapi (>=1.2.3)
+Requires-Dist: matplotlib (>=3.7.0,<4.0.0)
+Requires-Dist: oaklib (>=0.1.55,<0.2.0)
 Requires-Dist: pandas (>=1.5.1)
+Requires-Dist: phenopackets (>=2.0.2,<3.0.0)
+Requires-Dist: plotly (>=5.13.0,<6.0.0)
+Requires-Dist: pyaml (>=21.10.1,<22.0.0)
+Requires-Dist: pyserde (>=0.9.8,<0.10.0)
+Requires-Dist: seaborn (>=0.12.2,<0.13.0)
 Requires-Dist: tqdm (>=4.64.1)
 Description-Content-Type: text/markdown
 

pheval-0.2.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+pheval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pheval/analyse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pheval/analyse/analysis.py,sha256=4Yhlkokx3pezXrslJDZtYfF2Y-BrP6y4_mCetpegkT4,24825
+pheval/analyse/generate_plots.py,sha256=KDV1x7JnS9hX5cwMEUI63TVndC59-Fm0HNfaLtP8tJ4,14483
+pheval/analyse/generate_summary_outputs.py,sha256=HGpg916t5MthSpTSjKQI3sS5Y7jjO1QVqzn4TdR0veE,7266
+pheval/analyse/rank_stats.py,sha256=HMmLECGGCJrCdNstmCbEkODoYgqYdJRfv3NgqaUaA94,1933
+pheval/cli.py,sha256=Ubw4Rup_hF18UszJIFTUB7_dhnr2P88dD33T0WzLblc,1412
+pheval/cli_pheval.py,sha256=aP7UAvmNZdj74raSANF6uSxHk_wCQ9ckHOVOySaW4dE,2423
+pheval/cli_pheval_utils.py,sha256=_rmgFcee8-u4A5eQg4TtY1KbduERSHsm2DQGboYb91E,7307
+pheval/config_parser.py,sha256=R_ivbMBVHMOuctQxVUIl9ojQTE0cX-X6v6YToLlwh64,1030
+pheval/constants.py,sha256=07xfY0nVEkHeDiZXfo5X7TTCOV0GrsERkm2mx6-JiiI,45
+pheval/implementations/__init__.py,sha256=2mkbEaA7o-NAkfoLYkn2q50xp82cavu_qGcjt3k8m-I,1227
+pheval/post_processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pheval/post_processing/post_processing.py,sha256=clrWnGds8QXcOTeKt3bl4FuqyyuYeM19GjScYpQrA04,7244
+pheval/prepare/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pheval/prepare/create_noisy_phenopackets.py,sha256=405f_kAOFlBN6J9ClB5ZyJ4Z094JE6XEQgrwPZK7LyQ,6920
+pheval/prepare/create_spiked_vcf.py,sha256=1cYMcaU66lnsWoF7PRJ5SZXLZy0Ao3Myux2T_4YIXNU,12988
+pheval/prepare/custom_exceptions.py,sha256=_G3_95dPtHIs1SviYBV1j7cYc-hxlhuw8hhnYdzByYY,1719
+pheval/prepare/update_phenopacket.py,sha256=ZC-i8VVQbzAP_pebat9_Xy13c4MRWSdVplRdUigdXrM,2252
+pheval/resources/alternate_ouputs/CADA_results.txt,sha256=Rinn2TtfwFNsx0aEWegKJOkjKnBm-Mf54gdaT3bWP0k,547
+pheval/resources/alternate_ouputs/DeepPVP_results.txt,sha256=MF9MZJYa4r4PEvFzALpi-lNGLxjENOnq_YgrgFMn-oQ,1508
+pheval/resources/alternate_ouputs/OVA_results.txt,sha256=_5XFCR4W04D-W7DObpALLsa0-693g2kiIUB_uo79aHk,9845
+pheval/resources/alternate_ouputs/Phen2Gene_results.json,sha256=xxKsuiHKW9qQOz2baFlLW9RYphA4kxjoTsg1weZkTY8,14148
+pheval/resources/alternate_ouputs/Phenolyzer_results.txt,sha256=TltiEzYm2PY79u6EdZR3f4ZqadNDCUN_d4f0TFF-t5A,594
+pheval/resources/alternate_ouputs/lirical_results.tsv,sha256=0juf5HY6ttg-w7aWgYJUmSP5zmoaooEQDY8xhOcerLk,431068
+pheval/resources/alternate_ouputs/svanna_results.tsv,sha256=OpTamPhJwh12wkdAxoIGb0wWs_T7TcqNWgqkQzgOek4,714
+pheval/resources/hgnc_complete_set_2022-10-01.txt,sha256=PLD2-FJizl0detUtjvgeC1qc1FNq2jnykRvfw7ahF2w,16274884
+pheval/run_metadata.py,sha256=lDiLNFSRueX2pfyuRwNRbcRo_XxWQbSTLy45Yhgicsc,919
+pheval/runners/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pheval/runners/runner.py,sha256=FOpFxUuEeV2-2vYQkaDVye8BTfN9WqSJHIpBF0X14Os,3774
+pheval/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pheval/utils/docs_gen.py,sha256=rYP_76SSRx-G95r25aJcGtEEHCYgfi6-1hR0aV2UZXA,3192
+pheval/utils/docs_gen.sh,sha256=LyKLKjaZuf4UJ962CWfM-XqkxtvM8O2N9wHZS5mcb9A,477
+pheval/utils/file_utils.py,sha256=n3GKOOkd1mENpWOWcWHIUFvhh1iV2TCp1daMPOP0f_c,3068
+pheval/utils/phenopacket_utils.py,sha256=uZ_SGtrctZgg6iJqyOaseV9bqQ5paYN8FJvnTSg1qMg,14245
+pheval/utils/semsim_utils.py,sha256=jDqSUYBP6Q5yPNq024kDe2fpqWmwwRzv41o2fP1q-vA,6150
+pheval-0.2.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pheval-0.2.0.dist-info/METADATA,sha256=2Elv0CtIfOBLW79u8EtQtbgmWjTqa-QCyX1Hyzwt5Gw,1688
+pheval-0.2.0.dist-info/WHEEL,sha256=WGfLGfLX43Ei_YORXSnT54hxFygu34kMpcQdmgmEwCQ,88
+pheval-0.2.0.dist-info/entry_points.txt,sha256=o9gSwDkvT4-lqKy4mlsftd1nzP9WUOXQCfnbqycURd0,81
+pheval-0.2.0.dist-info/RECORD,,

{pheval-0.1.0.dist-info → pheval-0.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.3.2
+Generator: poetry-core 1.6.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pheval/utils.py

@@ -1,7 +0,0 @@
-"""
-Contains all pheval utility methods
-"""
-
-
-def example():
-    return True

pheval-0.1.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-pheval/__init__.py,sha256=amR2KDYWGlaKIqzfpeFlXYvDacBV-zCV_KH-Po9SQVk,44
-pheval/cli.py,sha256=FAj7ImzjoAMGu41L6odPUamtLLYli9sbWPYGioQSCnk,970
-pheval/cli_pheval.py,sha256=ThAKnnodHwrDxTeb0NLysZJHL1fxN3TRUGKJgpB90zw,1851
-pheval/cli_pheval_utils.py,sha256=tmFzWhQMZYrhQml8XC7HP8dcIYwCDvFlzrzmzGxUgo0,606
-pheval/implementations/__init__.py,sha256=rZoxRBHzQWTUlNeofu_gZcVCYZNF9kEbiw3BKaeMHso,1241
-pheval/runners/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pheval/runners/runner.py,sha256=A9m_ZfAKvFhWvrj7dRml8JsDIotc6HR-8krTxV2IP44,942
-pheval/utils.py,sha256=M63N6EkO_-AajNWy1YgxxgdE1bqdaFLy5nD47DBYhE4,77
-pheval-0.1.0.dist-info/entry_points.txt,sha256=o9gSwDkvT4-lqKy4mlsftd1nzP9WUOXQCfnbqycURd0,81
-pheval-0.1.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pheval-0.1.0.dist-info/WHEEL,sha256=vxFmldFsRN_Hx10GDvsdv1wroKq8r5Lzvjp6GZ4OO8c,88
-pheval-0.1.0.dist-info/METADATA,sha256=CBwt3Ufa7WM9-ffr_lTp-asefXOmbXc4KinIA81sj1Y,1360
-pheval-0.1.0.dist-info/RECORD,,