pheval-exomiser 0.2.7__py3-none-any.whl → 0.3.1__py3-none-any.whl

pheval_exomiser/post_process/post_process.py

@@ -8,6 +8,7 @@ def post_process_result_format(
     config: ExomiserConfigurations,
     raw_results_dir: Path,
     output_dir: Path,
+    phenopacket_dir: Path,
     variant_analysis: bool,
     gene_analysis: bool,
     disease_analysis: bool,
@@ -15,12 +16,13 @@ def post_process_result_format(
     """Standardise Exomiser json format to separated gene and variant results."""
     print("...standardising results format...")
     create_standardised_results(
-        results_dir=raw_results_dir,
+        result_dir=raw_results_dir,
         output_dir=output_dir,
-        score_name=config.post_process.score_name,
+        phenopacket_dir=phenopacket_dir,
         sort_order=config.post_process.sort_order,
-        variant_analysis=variant_analysis,
+        score_name=config.post_process.score_name,
         gene_analysis=gene_analysis,
         disease_analysis=disease_analysis,
+        variant_analysis=variant_analysis,
     )
     print("done")

pheval_exomiser/post_process/post_process_results_format.py

@@ -1,23 +1,24 @@
-#!/usr/bin/python
-import json
+import uuid
+from enum import Enum
 from pathlib import Path
 
 import click
+import polars as pl
 from pheval.post_processing.post_processing import (
-    PhEvalDiseaseResult,
-    PhEvalGeneResult,
-    PhEvalVariantResult,
-    generate_pheval_result,
+    SortOrder,
+    generate_disease_result,
+    generate_gene_result,
+    generate_variant_result,
 )
 from pheval.utils.file_utils import files_with_suffix
 
 
-def read_exomiser_json_result(exomiser_result_path: Path) -> dict:
-    """Load Exomiser json result."""
-    with open(exomiser_result_path) as exomiser_json_result:
-        exomiser_result = json.load(exomiser_json_result)
-    exomiser_json_result.close()
-    return exomiser_result
+class ModeOfInheritance(Enum):
+    AUTOSOMAL_DOMINANT = 1
+    AUTOSOMAL_RECESSIVE = 2
+    X_DOMINANT = 1
+    X_RECESSIVE = 2
+    MITOCHONDRIAL = 3
 
 
 def trim_exomiser_result_filename(exomiser_result_path: Path) -> Path:
@@ -25,213 +26,144 @@ def trim_exomiser_result_filename(exomiser_result_path: Path) -> Path:
     return Path(str(exomiser_result_path.name).replace("-exomiser", ""))
 
 
-class PhEvalGeneResultFromExomiserJsonCreator:
-    def __init__(self, exomiser_json_result: [dict], score_name: str):
-        self.exomiser_json_result = exomiser_json_result
-        self.score_name = score_name
-
-    @staticmethod
-    def _find_gene_symbol(result_entry: dict) -> str:
-        """Return gene symbol from Exomiser result entry."""
-        return result_entry["geneSymbol"]
-
-    @staticmethod
-    def _find_gene_identifier(result_entry: dict) -> str:
-        """Return ensembl gene identifier from Exomiser result entry."""
-        return result_entry["geneIdentifier"]["geneId"]
+def extract_gene_results_from_json(
+    exomiser_json_result: pl.DataFrame, score_name: str
+) -> pl.DataFrame:
+    return exomiser_json_result.select(
+        [
+            pl.col("geneSymbol").alias("gene_symbol"),
+            pl.col("geneIdentifier").struct.field("geneId").alias("gene_identifier"),
+            pl.col(score_name).fill_null(0).round(4).alias("score"),
+        ]
+    ).drop_nulls()
+
+
+def extract_disease_results_from_json(exomiser_json_result: pl.DataFrame) -> pl.DataFrame:
+    return (
+        exomiser_json_result.select(
+            [
+                pl.col("priorityResults")
+                .struct.field("HIPHIVE_PRIORITY")
+                .struct.field("diseaseMatches")
+            ]
+        )
+        .explode("diseaseMatches")
+        .unnest("diseaseMatches")
+        .unnest("model")
+        .select([pl.col("diseaseId").alias("disease_identifier"), pl.col("score").round(4)])
+        .drop_nulls()
+    )
 
-    def _find_relevant_score(self, result_entry: dict):
-        """Return score from Exomiser result entry."""
-        return round(result_entry[self.score_name], 4)
 
-    def extract_pheval_gene_requirements(self) -> [PhEvalGeneResult]:
-        """Extract data required to produce PhEval gene output."""
-        simplified_exomiser_result = []
-        for result_entry in self.exomiser_json_result:
-            if self.score_name in result_entry:
-                simplified_exomiser_result.append(
-                    PhEvalGeneResult(
-                        gene_symbol=self._find_gene_symbol(result_entry),
-                        gene_identifier=self._find_gene_identifier(result_entry),
-                        score=self._find_relevant_score(result_entry),
+def extract_variant_results_from_json(
+    exomiser_json_result: pl.DataFrame, score_name: str
+) -> pl.DataFrame:
+    return (
+        exomiser_json_result.filter(pl.col("geneScores").is_not_null())
+        .select([pl.col("geneScores"), pl.col(score_name).alias("score"), pl.col("geneSymbol")])
+        .explode("geneScores")
+        .unnest("geneScores")
+        .filter(pl.col("contributingVariants").is_not_null())
+        .explode("contributingVariants")
+        .with_columns(
+            [
+                pl.col("contributingVariants").struct.field("contigName").alias("chrom"),
+                pl.col("contributingVariants").struct.field("start"),
+                pl.col("contributingVariants").struct.field("end"),
+                pl.col("contributingVariants").struct.field("ref"),
+                pl.col("contributingVariants")
+                .struct.field("alt")
+                .fill_null("")
+                .str.strip_chars("<>")
+                .alias("alt"),
+                pl.col("modeOfInheritance")
+                .map_elements(lambda moi: ModeOfInheritance[moi].value, return_dtype=pl.Int8)
+                .alias("moi_enum"),
+            ]
+        )
+        .with_columns(
+            [
+                (pl.col("moi_enum") == 2).alias("is_recessive"),
+                pl.when(pl.col("moi_enum") == 2)
+                .then(
+                    pl.format(
+                        "recessive|{}|{}|{}",
+                        pl.col("geneSymbol"),
+                        pl.col("score"),
+                        pl.col("moi_enum"),
                     )
                 )
-
-        return simplified_exomiser_result
-
-
-class PhEvalVariantResultFromExomiserJsonCreator:
-
-    def __init__(self, exomiser_json_result: [dict], score_name: str):
-        self.exomiser_json_result = exomiser_json_result
-        self.score_name = score_name
-
-    @staticmethod
-    def _find_chromosome(result_entry: dict) -> str:
-        """Return chromosome from Exomiser result entry."""
-        return result_entry["contigName"]
-
-    @staticmethod
-    def _find_start_pos(result_entry: dict) -> int:
-        """Return start position from Exomiser result entry."""
-        return result_entry["start"]
-
-    @staticmethod
-    def _find_end_pos(result_entry: dict) -> int:
-        """Return end position from Exomiser result entry."""
-        return result_entry["end"]
-
-    @staticmethod
-    def _find_ref(result_entry: dict) -> str:
-        """Return reference allele from Exomiser result entry."""
-        return result_entry["ref"]
-
-    @staticmethod
-    def _find_alt(result_entry: dict) -> str:
-        """Return alternate allele from Exomiser result entry."""
-        if "alt" in result_entry and result_entry["alt"] is not None:
-            return result_entry["alt"].strip(">").strip("<")
-        else:
-            return ""
-
-    def _find_relevant_score(self, result_entry) -> float:
-        """Return score from Exomiser result entry."""
-        return round(result_entry[self.score_name], 4)
-
-    def _filter_for_acmg_assignments(
-        self, variant: PhEvalVariantResult, score: float, variant_acmg_assignments: dict
-    ) -> bool:
-        """Filter variants if they meet the PATHOGENIC or LIKELY_PATHOGENIC ACMG classification."""
-        for assignment in variant_acmg_assignments:
-            if variant == PhEvalVariantResult(
-                chromosome=self._find_chromosome(assignment["variantEvaluation"]),
-                start=self._find_start_pos(assignment["variantEvaluation"]),
-                end=self._find_end_pos(assignment["variantEvaluation"]),
-                ref=self._find_ref(assignment["variantEvaluation"]),
-                alt=self._find_alt(assignment["variantEvaluation"]),
-                score=score,
-            ) and (
-                assignment["acmgClassification"] == "PATHOGENIC"
-                or assignment["acmgClassification"] == "LIKELY_PATHOGENIC"
-            ):
-                return True
-
-    def extract_pheval_variant_requirements(
-        self, use_acmg_filter: bool = False
-    ) -> [PhEvalVariantResult]:
-        """Extract data required to produce PhEval variant output."""
-        simplified_exomiser_result = []
-        for result_entry in self.exomiser_json_result:
-            for gene_hit in result_entry["geneScores"]:
-                if self.score_name in result_entry:
-                    if "contributingVariants" in gene_hit:
-                        score = self._find_relevant_score(result_entry)
-                        contributing_variants = gene_hit["contributingVariants"]
-                        variant_acmg_assignments = gene_hit["acmgAssignments"]
-                        for cv in contributing_variants:
-                            variant = PhEvalVariantResult(
-                                chromosome=self._find_chromosome(cv),
-                                start=self._find_start_pos(cv),
-                                end=self._find_end_pos(cv),
-                                ref=self._find_ref(cv),
-                                alt=self._find_alt(cv),
-                                score=score,
-                            )
-                            if use_acmg_filter and self._filter_for_acmg_assignments(
-                                variant, score, variant_acmg_assignments
-                            ):
-                                simplified_exomiser_result.append(variant)
-                            if not use_acmg_filter:
-                                simplified_exomiser_result.append(variant)
-        return simplified_exomiser_result
-
-
-class PhEvalDiseaseResultFromExomiserJsonCreator:
-    def __init__(self, exomiser_json_result: [dict]):
-        self.exomiser_json_result = exomiser_json_result
-
-    @staticmethod
-    def _find_disease_name(result_entry: dict) -> str:
-        """Return disease term from Exomiser result entry."""
-        return result_entry["diseaseTerm"]
-
-    @staticmethod
-    def _find_disease_identifier(result_entry: dict) -> int:
-        """Return disease ID from Exomiser result entry."""
-        return result_entry["diseaseId"]
-
-    @staticmethod
-    def _find_relevant_score(result_entry) -> float:
-        """Return score from Exomiser result entry."""
-        return round(result_entry["score"], 4)
-
-    def extract_pheval_disease_requirements(self) -> [PhEvalDiseaseResult]:
-        """Extract data required to produce PhEval disease output."""
-        simplified_exomiser_result = []
-        for result_entry in self.exomiser_json_result:
-            try:
-                for disease in result_entry["priorityResults"]["HIPHIVE_PRIORITY"][
-                    "diseaseMatches"
-                ]:
-                    simplified_exomiser_result.append(
-                        PhEvalDiseaseResult(
-                            disease_name=self._find_disease_name(disease["model"]),
-                            disease_identifier=self._find_disease_identifier(disease["model"]),
-                            score=self._find_relevant_score(disease),
-                        )
+                .otherwise(
+                    pl.format(
+                        "dominant|{}|{}|{}|{}|{}|{}",
+                        pl.col("chrom"),
+                        pl.col("start"),
+                        pl.col("end"),
+                        pl.col("ref"),
+                        pl.col("alt"),
+                        pl.col("score"),
                     )
-            except KeyError:
-                pass
-        return list(
-            {
-                (result.disease_identifier, result.score): result
-                for result in simplified_exomiser_result
-            }.values()
+                )
+                .alias("group_key"),
+            ]
+        )
+        .with_columns(
+            [
+                pl.col("group_key")
+                .rank("dense")
+                .cast(pl.UInt32)
+                .map_elements(
+                    lambda i: str(uuid.uuid5(uuid.NAMESPACE_DNS, str(i))), return_dtype=pl.String
+                )
+                .alias("grouping_id")
+            ]
         )
+        .select(
+            ["chrom", "start", "end", "ref", "alt", "score", "modeOfInheritance", "grouping_id"]
+        )
+    )
 
 
 def create_standardised_results(
-    results_dir: Path,
+    result_dir: Path,
     output_dir: Path,
+    phenopacket_dir: Path,
     score_name: str,
     sort_order: str,
-    variant_analysis: bool,
     gene_analysis: bool,
     disease_analysis: bool,
-    include_acmg: bool = False,
-) -> None:
-    """Write standardised gene/variant/disease results from default Exomiser json output."""
-    for exomiser_json_result in files_with_suffix(results_dir, ".json"):
-        exomiser_result = read_exomiser_json_result(exomiser_json_result)
+    variant_analysis: bool,
+):
+    sort_order = SortOrder.ASCENDING if sort_order.lower() == "ascending" else SortOrder.DESCENDING
+    for exomiser_json_result_path in files_with_suffix(result_dir, ".json"):
+        exomiser_json_result = pl.read_json(exomiser_json_result_path)
         if gene_analysis:
-            pheval_gene_requirements = PhEvalGeneResultFromExomiserJsonCreator(
-                exomiser_result, score_name
-            ).extract_pheval_gene_requirements()
-            generate_pheval_result(
-                pheval_result=pheval_gene_requirements,
-                sort_order_str=sort_order,
+            gene_results = extract_gene_results_from_json(exomiser_json_result, score_name)
+            generate_gene_result(
+                results=gene_results,
+                sort_order=sort_order,
                 output_dir=output_dir,
-                tool_result_path=trim_exomiser_result_filename(exomiser_json_result),
+                result_path=trim_exomiser_result_filename(exomiser_json_result_path),
+                phenopacket_dir=phenopacket_dir,
             )
-        if variant_analysis:
-            pheval_variant_requirements = PhEvalVariantResultFromExomiserJsonCreator(
-                exomiser_result, score_name
-            ).extract_pheval_variant_requirements(include_acmg)
-            generate_pheval_result(
-                pheval_result=pheval_variant_requirements,
-                sort_order_str=sort_order,
+        if disease_analysis:
+            disease_results = extract_disease_results_from_json(exomiser_json_result)
+            generate_disease_result(
+                results=disease_results,
+                sort_order=sort_order,
                 output_dir=output_dir,
-                tool_result_path=trim_exomiser_result_filename(exomiser_json_result),
+                result_path=trim_exomiser_result_filename(exomiser_json_result_path),
+                phenopacket_dir=phenopacket_dir,
             )
-        if disease_analysis:
-            pheval_disease_requirements = PhEvalDiseaseResultFromExomiserJsonCreator(
-                exomiser_result
-            ).extract_pheval_disease_requirements()
-            generate_pheval_result(
-                pheval_result=pheval_disease_requirements,
-                sort_order_str=sort_order,
+
+        if variant_analysis:
+            variant_results = extract_variant_results_from_json(exomiser_json_result, score_name)
+            generate_variant_result(
+                results=variant_results,
+                sort_order=sort_order,
                 output_dir=output_dir,
-                tool_result_path=trim_exomiser_result_filename(exomiser_json_result),
+                result_path=trim_exomiser_result_filename(exomiser_json_result_path),
+                phenopacket_dir=phenopacket_dir,
             )
 
 
@@ -252,6 +184,14 @@ def create_standardised_results(
     help="Full path to Exomiser results directory to be standardised.",
     type=Path,
 )
+@click.option(
+    "--phenopacket-dir",
+    "-p",
+    required=True,
+    metavar="DIRECTORY",
+    help="Full path to phenopacket dir used to generate the raw results.",
+    type=Path,
+)
 @click.option(
     "--score-name",
     "-s",
@@ -288,22 +228,15 @@ def create_standardised_results(
     default=False,
     help="Specify whether to create PhEval disease results.",
 )
-@click.option(
-    "--include-acmg",
-    is_flag=True,
-    type=bool,
-    default=False,
-    help="Specify whether to include ACMG filter for PATHOGENIC or LIKELY_PATHOGENIC classifications.",
-)
 def post_process_exomiser_results(
     output_dir: Path,
     results_dir: Path,
+    phenopacket_dir: Path,
     score_name: str,
     sort_order: str,
     gene_analysis: bool,
     variant_analysis: bool,
     disease_analysis: bool,
-    include_acmg: bool,
 ):
     """Post-process Exomiser json results into PhEval gene and variant outputs."""
     (
@@ -322,12 +255,12 @@ def post_process_exomiser_results(
         else None
     )
     create_standardised_results(
-        results_dir,
-        output_dir,
-        score_name,
-        sort_order,
-        variant_analysis,
-        gene_analysis,
-        disease_analysis,
-        include_acmg,
+        result_dir=results_dir,
+        output_dir=output_dir,
+        phenopacket_dir=phenopacket_dir,
+        score_name=score_name,
+        sort_order=sort_order,
+        variant_analysis=variant_analysis,
+        gene_analysis=gene_analysis,
+        disease_analysis=disease_analysis,
     )

pheval_exomiser/prepare/create_batch_commands.py

@@ -100,8 +100,14 @@ class CommandCreator:
             )
 
     def add_variant_analysis_arguments(self, vcf_dir: Path) -> ExomiserCommandLineArguments:
-        vcf_file_data = PhenopacketUtil(self.phenopacket).vcf_file_data(
-            self.phenopacket_path, vcf_dir
+        vcf_file_data = (
+            PhenopacketUtil(self.phenopacket).vcf_file_data(self.phenopacket_path, vcf_dir)
+            if vcf_dir.exists()
+            else [
+                file
+                for file in self.phenopacket.files
+                if file.file_attributes["fileFormat"] == "vcf"
+            ][0]
         )
         output_options_file = self.assign_output_options_file()
         if self.environment == "local":

pheval_exomiser/runner.py

@@ -67,6 +67,7 @@ class ExomiserPhEvalRunner(PhEvalRunner):
             config=config,
             raw_results_dir=self.raw_results_dir,
             output_dir=self.output_dir,
+            phenopacket_dir=self.testdata_dir.joinpath("phenopackets"),
             variant_analysis=self.input_dir_config.variant_analysis,
             gene_analysis=self.input_dir_config.gene_analysis,
             disease_analysis=self.input_dir_config.disease_analysis,

{pheval_exomiser-0.2.7.dist-info → pheval_exomiser-0.3.1.dist-info}/METADATA

@@ -1,12 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: pheval_exomiser
-Version: 0.2.7
+Version: 0.3.1
 Summary: 
 Author: Yasemin Bridges
 Author-email: y.bridges@qmul.ac.uk
-Requires-Python: >=3.9,<4.0.0
+Requires-Python: >=3.10,<4.0.0
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -16,9 +15,8 @@ Requires-Dist: docker (>=6.0.1,<7.0.0)
 Requires-Dist: google (>=3.0.0,<4.0.0)
 Requires-Dist: numpy (<2)
 Requires-Dist: oaklib (>=0.5.12,<0.6.0)
-Requires-Dist: pandas (>=1.5.2,<2.0.0)
 Requires-Dist: phenopackets (>=2.0.2,<3.0.0)
-Requires-Dist: pheval (>=0.4.0,<0.5.0)
+Requires-Dist: pheval (>=0.5.1,<0.6.0)
 Requires-Dist: pyaml (>=21.10.1,<22.0.0)
 Requires-Dist: pydantic (>=2.7.1,<3.0.0)
 Description-Content-Type: text/markdown
@@ -164,6 +162,9 @@ e.g.,
    └── vcf
 ```
 
+> [!IMPORTANT]  
+> If a `vcf` directory is not found in the testdata directory then the path to the VCF will be taken from the phenopacket if `variant_analysis` is set to True.
+
 ## Run command
 
 Once the testdata and input directories are correctly configured for the run, the `pheval run` command can be executed.

{pheval_exomiser-0.2.7.dist-info → pheval_exomiser-0.3.1.dist-info}/RECORD

@@ -2,17 +2,16 @@ pheval_exomiser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pheval_exomiser/cli.py,sha256=0SR1-L2sREEkFRfUPwYwkbSaBsz_L_Sxq1S4c9LQLJg,350
 pheval_exomiser/constants.py,sha256=o_pLWF8kX74BqyTsAZa7twwSKzedLnpupCI90k_bMqY,517
 pheval_exomiser/post_process/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pheval_exomiser/post_process/post_process.py,sha256=ZLIGPeADGZn08jFc152QraiJnYSADlL35GOwxkCQDwA,901
-pheval_exomiser/post_process/post_process_results_format.py,sha256=F1TpgLgeoNFFZTk7XaXLptCLOr6G3tdZC2cltXFtHx8,12261
+pheval_exomiser/post_process/post_process.py,sha256=2vkwe60Ptf7UuPCR2ShcI80-kn-1WaPDa74cCBTUKF0,968
+pheval_exomiser/post_process/post_process_results_format.py,sha256=zMz2HwAJENuKyRjkbJZrydrZDoULWuPjaDWC5Dc5hxg,8432
 pheval_exomiser/prepare/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pheval_exomiser/prepare/create_batch_commands.py,sha256=tDUBtpfSmNGqHte-vrGnusYZzM59pOX1IAumqRDlnBE,17205
+pheval_exomiser/prepare/create_batch_commands.py,sha256=R06cn1c5pf_agUQfrFUQ2KEo8il0Z4fJntS2HKYCQXw,17410
 pheval_exomiser/prepare/tool_specific_configuration_options.py,sha256=4gedZ9iadRXK6tF9P-ju-dhj8-F2-fhrXVhfYIsAxFQ,2922
 pheval_exomiser/prepare/write_application_properties.py,sha256=KmG7GvkQo8AhnhRyqohTFvqjfhEhbcs78UYYoigxJ3w,8933
-pheval_exomiser/prepare/yaml_to_family_phenopacket.py,sha256=Hz77dHpVaRMV1fQWKmOCqCKJfmk_hdpZh_6o7hq9Sec,14452
 pheval_exomiser/run/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pheval_exomiser/run/run.py,sha256=bK_gL52zRl71Lxe-i-P6L4-dMstxFAG6SVNPO6G823o,7109
-pheval_exomiser/runner.py,sha256=LaWhC0F9LoPvP0Ie1sG2GkC8EG-tWjBBY_tFYmx6dxA,2548
-pheval_exomiser-0.2.7.dist-info/METADATA,sha256=bN6tBR-8becl8WG4nD7cHpbH-xTnOmD9uVKCWFEnHMw,7551
-pheval_exomiser-0.2.7.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pheval_exomiser-0.2.7.dist-info/entry_points.txt,sha256=lbZMu-x7ns8UrFveWSqEQ1UB5l33TbRMomqBUyGYIwI,131
-pheval_exomiser-0.2.7.dist-info/RECORD,,
+pheval_exomiser/runner.py,sha256=3-0kec2yzQoZNpqZXSBIWBD1QR24s_BmHGCLXmP4fos,2620
+pheval_exomiser-0.3.1.dist-info/METADATA,sha256=qq-FsEKnIUuILxreIMSsaoQ3gRFogzE-XZ87bf01c7E,7641
+pheval_exomiser-0.3.1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+pheval_exomiser-0.3.1.dist-info/entry_points.txt,sha256=lbZMu-x7ns8UrFveWSqEQ1UB5l33TbRMomqBUyGYIwI,131
+pheval_exomiser-0.3.1.dist-info/RECORD,,

{pheval_exomiser-0.2.7.dist-info → pheval_exomiser-0.3.1.dist-info}/WHEEL

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

pheval_exomiser/prepare/yaml_to_family_phenopacket.py

@@ -1,392 +0,0 @@
-from copy import copy
-from pathlib import Path
-
-import click
-import pandas as pd
-import yaml
-from google.protobuf.timestamp_pb2 import Timestamp
-from oaklib.implementations.pronto.pronto_implementation import ProntoImplementation
-from oaklib.resource import OntologyResource
-from phenopackets import (
-    Diagnosis,
-    Family,
-    File,
-    GeneDescriptor,
-    GenomicInterpretation,
-    Individual,
-    Interpretation,
-    MetaData,
-    OntologyClass,
-    Pedigree,
-    Phenopacket,
-    PhenotypicFeature,
-    Resource,
-    VariantInterpretation,
-    VariationDescriptor,
-    VcfRecord,
-)
-from pheval.prepare.create_noisy_phenopackets import load_ontology
-from pheval.utils.file_utils import files_with_suffix
-from pheval.utils.phenopacket_utils import create_hgnc_dict, write_phenopacket
-
-
-def load_genotype_ontology():
-    """Load genotype ontology"""
-    genotype_resource = OntologyResource(slug="geno.owl", local=False)
-    return ProntoImplementation(genotype_resource)
-
-
-def exomiser_analysis_yml_reader(yaml_job_file_path: Path) -> dict:
-    """Read an exomiser analysis yaml file."""
-    with open(yaml_job_file_path) as yaml_job_file:
-        yaml_job = yaml.safe_load(yaml_job_file)
-    yaml_job_file.close()
-    return yaml_job
-
-
-def read_diagnoses_file(diagnoses_file_path: Path) -> pd.DataFrame:
-    """Read a diagnoses file."""
-    return pd.read_csv(diagnoses_file_path, delimiter="t")
-
-
-def read_pedigree_file(pedigree_path: Path) -> list[str]:
-    """Return the contents of a pedigree file"""
-    return open(pedigree_path).readlines()
-
-
-class ExomiserYamlToPhenopacketConverter:
-    def __init__(self, genotype_ontology, human_phenotype_ontology, hgnc_data):
-        self.genotype_ontology = genotype_ontology
-        self.human_phenotype_ontology = human_phenotype_ontology
-        self.hgnc_data = hgnc_data
-
-    @staticmethod
-    def construct_individual(yaml_job: dict, diagnoses: pd.DataFrame) -> Individual:
-        """Construct individual for phenopacket."""
-        return Individual(
-            id=yaml_job["analysis"]["proband"],
-            sex=diagnoses[diagnoses.ProbandId == yaml_job["analysis"]["proband"]]
-            .iloc[0]["Sex"]
-            .upper(),
-        )
-
-    @staticmethod
-    def get_diagnoses_for_proband(yaml_job: dict, diagnoses: pd.DataFrame):
-        """Get all diagnoses for proband."""
-        return diagnoses.loc[diagnoses["ProbandId"] == yaml_job["analysis"]["proband"]]
-
-    def construct_phenotypic_interpretations(self, yaml_job: dict) -> list[PhenotypicFeature]:
-        """Construct the phenotypic features for the proband."""
-        hpo_ids = yaml_job["analysis"]["hpoIds"]
-        phenotypic_features = []
-        for hpo_id in hpo_ids:
-            try:
-                rels = self.human_phenotype_ontology.entity_alias_map(hpo_id)
-                hpo_term = "".join(rels[(list(rels.keys())[0])])
-                hpo = PhenotypicFeature(type=OntologyClass(id=hpo_id, label=hpo_term))
-                phenotypic_features.append(hpo)
-            except AttributeError:
-                hpo = PhenotypicFeature(type=OntologyClass(id=hpo_id))
-                phenotypic_features.append(hpo)
-        return phenotypic_features
-
-    @staticmethod
-    def construct_vcf_record(yaml_job: dict, diagnosis: pd.DataFrame) -> VcfRecord:
-        """Construct the VCF record for a diagnosis."""
-        return VcfRecord(
-            genome_assembly=yaml_job["analysis"]["genomeAssembly"],
-            chrom=diagnosis["Chr"],
-            pos=int(diagnosis["Start"]),
-            ref=str(diagnosis["Ref/Alt"]).split("/")[0],
-            alt=str(diagnosis["Ref/Alt"]).split("/")[1],
-        )
-
-    def construct_allelic_state(self, diagnosis: pd.DataFrame) -> OntologyClass:
-        """Construct the allelic state for a diagnosis."""
-        return OntologyClass(
-            id=list(self.genotype_ontology.basic_search(diagnosis["Genotype"].lower()))[0],
-            label=diagnosis["Genotype"].lower(),
-        )
-
-    def construct_gene_descriptor(self, diagnosis: pd.DataFrame) -> GeneDescriptor:
-        """Construct the Gene Descriptor for a diagnosis."""
-        try:
-            return GeneDescriptor(
-                value_id=self.hgnc_data[diagnosis["Gene"]]["ensembl_id"],
-                symbol=diagnosis["Gene"],
-            )
-        except KeyError:
-            for _gene, gene_info in self.hgnc_data.items():
-                for previous_name in gene_info["previous_names"]:
-                    if diagnosis["Gene"] == previous_name:
-                        return GeneDescriptor(
-                            value_id=self.hgnc_data[gene_info["ensembl_id"]],
-                            symbol=diagnosis["Gene"],
-                        )
-
-    def construct_variation_descriptor(
-        self, yaml_job: dict, diagnosis: pd.DataFrame
-    ) -> VariationDescriptor:
-        """Construct a variation descriptor for a diagnosis."""
-        return VariationDescriptor(
-            id=yaml_job["analysis"]["proband"]
-            + ":"
-            + diagnosis["Chr"]
-            + ":"
-            + diagnosis["Start"]
-            + ":"
-            + diagnosis["Ref/Alt"],
-            gene_context=self.construct_gene_descriptor(diagnosis),
-            vcf_record=self.construct_vcf_record(yaml_job, diagnosis),
-            allelic_state=self.construct_allelic_state(diagnosis),
-        )
-
-    def construct_variant_interpretation(
-        self, yaml_job: dict, diagnosis: pd.DataFrame
-    ) -> VariantInterpretation:
-        """Construct the variant interpretation for a diagnosis."""
-        return VariantInterpretation(
-            variation_descriptor=self.construct_variation_descriptor(yaml_job, diagnosis),
-        )
-
-    def construct_genomic_interpretations(
-        self, yaml_job: dict, diagnoses: pd.DataFrame
-    ) -> list[GenomicInterpretation]:
-        """Construct a list of genomic interpretations for a proband."""
-        genomic_interpretations = []
-        for _index, row in self.get_diagnoses_for_proband(yaml_job, diagnoses).iterrows():
-            genomic_interpretation = GenomicInterpretation(
-                subject_or_biosample_id=yaml_job["analysis"]["proband"],
-                variant_interpretation=self.construct_variant_interpretation(
-                    yaml_job=yaml_job, diagnosis=row
-                ),
-            )
-            genomic_interpretations.append(genomic_interpretation)
-        return genomic_interpretations
-
-    def construct_diagnosis(self, yaml_job: dict, diagnoses: pd.DataFrame) -> Diagnosis:
-        """Construct the diagnosis for a proband."""
-        return Diagnosis(
-            genomic_interpretations=self.construct_genomic_interpretations(yaml_job, diagnoses)
-        )
-
-    def construct_interpretations(
-        self, yaml_job: dict, diagnoses: pd.DataFrame
-    ) -> list[Interpretation]:
-        """Construct interpretations for a proband."""
-        return [
-            Interpretation(
-                id=yaml_job["analysis"]["proband"] + "-interpretation",
-                diagnosis=self.construct_diagnosis(yaml_job, diagnoses),
-            )
-        ]
-
-    @staticmethod
-    def construct_meta_data() -> MetaData:
-        """Construct the meta-data."""
-        timestamp = Timestamp()
-        timestamp.GetCurrentTime()
-        return MetaData(
-            created=timestamp,
-            created_by="pheval-converter",
-            resources=[
-                Resource(
-                    id="hp",
-                    name="human phenotype ontology",
-                    url="http://purl.obolibrary.org/obo/hp.owl",
-                    version="hp/releases/2019-11-08",
-                    namespace_prefix="HP",
-                    iri_prefix="http://purl.obolibrary.org/obo/HP_",
-                )
-            ],
-            phenopacket_schema_version="2.0",
-        )
-
-    @staticmethod
-    def construct_files(yaml_job_file: dict) -> list[File]:
-        """Construct the files."""
-        return [
-            File(
-                uri=yaml_job_file["analysis"]["vcf"],
-                file_attributes={
-                    "fileFormat": "VCF",
-                    "genomeAssembly": yaml_job_file["analysis"]["genomeAssembly"],
-                },
-            )
-        ]
-
-
-def construct_pedigree(pedigree: list[str]) -> tuple[str, Pedigree]:
-    """Construct the pedigree message from a ped file."""
-    persons = []
-    family_id = None
-    for individual in pedigree:
-        entry = individual.split("\t")
-        family_id = entry[0]
-        sex = "."
-        if (
-            int(entry[4]) == 1
-        ):  # until this is fixed with the phenopackets package, sex has to be reassigned
-            sex = 2
-        if int(entry[4]) == 2:
-            sex = 1
-        if str(entry[3]) == "0" and str(entry[2]) == "0":
-            person = Pedigree.Person(
-                family_id=family_id, individual_id=entry[1], sex=sex, affected_status=int(entry[5])
-            )
-            persons.append(person)
-        if str(entry[3]) == "0" and str(entry[2]) != "0":
-            person = Pedigree.Person(
-                family_id=family_id,
-                individual_id=entry[1],
-                paternal_id=entry[2],
-                sex=sex,
-                affected_status=int(entry[5]),
-            )
-            persons.append(person)
-        if str(entry[2]) == "0" and str(entry[3]) != "0":
-            person = Pedigree.Person(
-                family_id=family_id,
-                individual_id=entry[1],
-                maternal_id=entry[3],
-                sex=sex,
-                affected_status=int(entry[5]),
-            )
-            persons.append(person)
-        if str(entry[2]) != "0" and str(entry[3] != "0"):
-            person = Pedigree.Person(
-                family_id=family_id,
-                individual_id=entry[1],
-                paternal_id=entry[2],
-                maternal_id=entry[3],
-                sex=sex,
-                affected_status=int(entry[5]),
-            )
-            persons.append(person)
-    return family_id, Pedigree(persons=persons)
-
-
-def construct_phenopacket(
-    yaml_job_file: dict,
-    diagnoses: pd.DataFrame,
-    exomiser_yaml_to_phenopacket_converter: ExomiserYamlToPhenopacketConverter,
-) -> Phenopacket:
-    """Construct a phenopacket."""
-    return Phenopacket(
-        id=yaml_job_file["analysis"]["proband"],
-        subject=exomiser_yaml_to_phenopacket_converter.construct_individual(
-            yaml_job=yaml_job_file, diagnoses=diagnoses
-        ),
-        phenotypic_features=exomiser_yaml_to_phenopacket_converter.construct_phenotypic_interpretations(
-            yaml_job=yaml_job_file
-        ),
-        interpretations=exomiser_yaml_to_phenopacket_converter.construct_interpretations(
-            yaml_job=yaml_job_file, diagnoses=diagnoses
-        ),
-        files=exomiser_yaml_to_phenopacket_converter.construct_files(yaml_job_file),
-        meta_data=exomiser_yaml_to_phenopacket_converter.construct_meta_data(),
-    )
-
-
-def construct_family(
-    yaml_job_file: dict,
-    diagnoses: pd.DataFrame,
-    exomiser_yaml_to_phenopacket_converter: ExomiserYamlToPhenopacketConverter,
-    pedigree: list[str],
-) -> Family:
-    """Construct a Family"""
-    phenopacket = construct_phenopacket(
-        yaml_job_file, diagnoses, exomiser_yaml_to_phenopacket_converter
-    )
-    proband = copy(phenopacket)
-    del proband.files[:]
-    del proband.meta_data[:]
-    family_id, ped = construct_pedigree(pedigree)
-    return Family(
-        id=family_id,
-        proband=proband,
-        pedigree=ped,
-        files=phenopacket.files,
-        meta_data=phenopacket.meta_data,
-    )
-
-
-def create_phenopacket(
-    yaml_job_file: Path,
-    diagnoses: pd.DataFrame,
-    exomiser_converter: ExomiserYamlToPhenopacketConverter,
-) -> Phenopacket or Family:
-    """Construct either a family or phenopacket from an analysis yaml."""
-    yaml_job = exomiser_analysis_yml_reader(yaml_job_file)
-    phenopacket = (
-        construct_phenopacket(yaml_job, diagnoses, exomiser_converter)
-        if yaml_job["analysis"]["ped"] == ""
-        else construct_family(
-            yaml_job,
-            diagnoses,
-            exomiser_converter,
-            read_pedigree_file(yaml_job["analysis"]["ped"]),
-        )
-    )
-    return phenopacket
-
-
-@click.command()
-@click.option(
-    "--directory",
-    "-d",
-    required=True,
-    help="Directory for Exomiser yaml job files to be converted.",
-    type=Path,
-)
-@click.option("--diagnoses-file", "-d", required=True, help="Diagnoses file", type=Path)
-@click.option(
-    "--output-dir", "-o", required=True, help="Output directory to write phenopackets", type=Path
-)
-def convert_exomiser_analysis_yamls_to_phenopacket(
-    output_dir: Path, directory: Path, diagnoses_file: Path
-):
-    """Convert an Exomiser YAML file to a phenopacket schema given a .tsv diagnoses file containing the following
-    required fields: ..."""
-    try:
-        output_dir.mkdir()
-    except FileExistsError:
-        pass
-    diagnoses = read_diagnoses_file(diagnoses_file)
-    exomiser_converter = ExomiserYamlToPhenopacketConverter(
-        load_genotype_ontology(), load_ontology(), create_hgnc_dict()
-    )
-    for yaml_job_file in files_with_suffix(directory, ".yml"):
-        phenopacket = create_phenopacket(yaml_job_file, diagnoses, exomiser_converter)
-        write_phenopacket(
-            phenopacket, output_dir.joinpath(yaml_job_file.name.replace(".yml", ".json"))
-        )
-
-
-@click.command()
-@click.option(
-    "--yaml-file",
-    "-y",
-    required=True,
-    help="Path to Exomiser analysis yaml file for phenopacket conversion.",
-    type=Path,
-)
-@click.option("--diagnoses-file", "-d", required=True, help="Diagnoses file", type=Path)
-@click.option(
-    "--output-dir", "-o", required=True, help="Output directory to write phenopackets", type=Path
-)
-def convert_exomiser_analysis_yaml_to_phenopacket(
-    output_dir: Path, yaml_file: Path, diagnoses_file: Path
-):
-    """Convert Exomiser YAML files to the phenopacket schema given a .tsv diagnoses file containing the following
-    required fields: ..."""
-    try:
-        output_dir.mkdir()
-    except FileExistsError:
-        pass
-    diagnoses = read_diagnoses_file(diagnoses_file)
-    exomiser_converter = ExomiserYamlToPhenopacketConverter(
-        load_genotype_ontology(), load_ontology(), create_hgnc_dict()
-    )
-    phenopacket = create_phenopacket(yaml_file, diagnoses, exomiser_converter)
-    write_phenopacket(phenopacket, Path(yaml_file.name + ".json"))