pheval-exomiser 0.1.3__py3-none-any.whl → 0.2.1__py3-none-any.whl

pheval_exomiser/constants.py

@@ -0,0 +1,8 @@
+PHENOPACKET_TARGET_DIRECTORY_DOCKER = "/exomiser-testdata-phenopacket/"
+RAW_RESULTS_TARGET_DIRECTORY_DOCKER = "/exomiser-results/"
+OUTPUT_OPTIONS_TARGET_DIRECTORY_DOCKER = "/exomiser-testdata-output-options/"
+VCF_TARGET_DIRECTORY_DOCKER = "/exomiser-testdata-vcf/"
+EXOMISER_YAML_TARGET_DIRECTORY_DOCKER = "/exomiser-yaml-template/"
+EXOMISER_DATA_DIRECTORY_TARGET_DOCKER = "/exomiser-data/"
+INPUT_COMMANDS_TARGET_DIRECTORY_DOCKER = "/exomiser-batch-file/"
+EXOMISER_CONFIG_TARGET_DIRECTORY_DOCKER = "/exomiser-config/"

pheval_exomiser/post_process/post_process.py

@@ -1,22 +1,26 @@
-import os
 from pathlib import Path
 
-from pheval_exomiser.config_parser import ExomiserConfig
 from pheval_exomiser.post_process.post_process_results_format import create_standardised_results
+from pheval_exomiser.prepare.tool_specific_configuration_options import ExomiserConfigurations
 
 
 def post_process_result_format(
-    input_dir: Path, testdata_dir: Path, output_dir: Path, config: ExomiserConfig
+    config: ExomiserConfigurations,
+    raw_results_dir: Path,
+    output_dir: Path,
+    variant_analysis: bool,
+    gene_analysis: bool,
+    disease_analysis: bool,
 ):
     """Standardise Exomiser json format to separated gene and variant results."""
     print("...standardising results format...")
-    run_output_dir = Path(output_dir).joinpath(
-        f"exomiser_{config.run.exomiser_configurations.exomiser_version.replace('.', '_')}"
-        f"_{os.path.basename(input_dir)}{os.sep}{os.path.basename(testdata_dir)}_results"
-    )
     create_standardised_results(
-        results_dir=Path(run_output_dir).joinpath("exomiser_results"),
-        output_dir=run_output_dir,
-        ranking_method=config.post_process.ranking_method,
+        results_dir=raw_results_dir,
+        output_dir=output_dir,
+        score_name=config.post_process.score_name,
+        sort_order=config.post_process.sort_order,
+        variant_analysis=variant_analysis,
+        gene_analysis=gene_analysis,
+        disease_analysis=disease_analysis,
     )
     print("done")

pheval_exomiser/post_process/post_process_results_format.py

@@ -1,109 +1,15 @@
 #!/usr/bin/python
-import dataclasses
 import json
-from dataclasses import dataclass
 from pathlib import Path
 
 import click
-import pandas as pd
+from pheval.post_processing.post_processing import (
+    PhEvalDiseaseResult,
+    PhEvalGeneResult,
+    PhEvalVariantResult,
+    generate_pheval_result,
+)
 from pheval.utils.file_utils import files_with_suffix
-from pheval.utils.phenopacket_utils import VariantData
-
-
-@dataclass
-class SimplifiedExomiserGeneResult:
-    """A simplified gene result format from Exomiser json."""
-
-    exomiser_result: dict
-    simplified_exomiser_gene_result: list
-    ranking_method: str
-
-    def add_gene_record(self) -> dict:
-        """Add the gene and gene identifier record to simplified result format."""
-        return {
-            "gene_symbol": self.exomiser_result["geneSymbol"],
-            "gene_identifier": self.exomiser_result["geneIdentifier"]["geneId"],
-        }
-
-    def add_ranking_score(self, simplified_result_entry: dict) -> dict:
-        """Add the ranking score to simplified result format."""
-        simplified_result_entry["score"] = round(self.exomiser_result[self.ranking_method], 4)
-        return simplified_result_entry
-
-    def create_simplified_gene_result(self) -> [dict]:
-        """Create a simplified Exomiser Gene result."""
-        self.simplified_exomiser_gene_result.append(self.add_ranking_score(self.add_gene_record()))
-        return self.simplified_exomiser_gene_result
-
-
-@dataclass
-class SimplifiedExomiserVariantResult:
-    """A simplified variant result format from Exomiser json."""
-
-    exomiser_result: dict
-    simplified_exomiser_variant_result: list
-    ranking_method: str
-    ranking_score: float
-
-    def create_simplified_variant_result(self) -> [dict]:
-        """Add data for contributing variants to simplified result format."""
-        for cv in self.exomiser_result["contributingVariants"]:
-            self.simplified_exomiser_variant_result.append(
-                {
-                    "variant": dataclasses.asdict(
-                        VariantData(
-                            cv["contigName"],
-                            cv["start"],
-                            cv["ref"],
-                            cv["alt"],
-                            self.exomiser_result["geneIdentifier"]["geneSymbol"],
-                        )
-                    ),
-                    "score": self.ranking_score,
-                }
-            )
-        return self.simplified_exomiser_variant_result
-
-
-class RankExomiserResult:
-    """Add ranks to simplified Exomiser gene/variant results - taking care of ex-aequo scores."""
-
-    def __init__(self, simplified_exomiser_result: [dict], ranking_method: str):
-        self.simplified_exomiser_result = simplified_exomiser_result
-        self.ranking_method = ranking_method
-
-    def sort_exomiser_result(self) -> [dict]:
-        """Sorts simplified Exomiser result by ranking method in decreasing order."""
-        return sorted(
-            self.simplified_exomiser_result,
-            key=lambda d: d["score"],
-            reverse=True,
-        )
-
-    def sort_exomiser_result_pvalue(self) -> [dict]:
-        """Sort simplified Exomiser result by pvalue, most significant value first."""
-        return sorted(
-            self.simplified_exomiser_result,
-            key=lambda d: d["score"],
-            reverse=False,
-        )
-
-    def rank_results(self) -> [dict]:
-        """Add ranks to the Exomiser results, equal scores are given the same rank e.g., 1,1,3."""
-        sorted_exomiser_result = (
-            self.sort_exomiser_result_pvalue()
-            if self.ranking_method == "pValue"
-            else self.sort_exomiser_result()
-        )
-        rank, count, previous = 0, 0, None
-        for exomiser_result in sorted_exomiser_result:
-            count += 1
-            if exomiser_result["score"] != previous:
-                rank += count
-                previous = exomiser_result["score"]
-                count = 0
-            exomiser_result["rank"] = rank
-        return sorted_exomiser_result
 
 
 def read_exomiser_json_result(exomiser_result_path: Path) -> dict:
@@ -114,78 +20,214 @@ def read_exomiser_json_result(exomiser_result_path: Path) -> dict:
     return exomiser_result
 
 
-class StandardiseExomiserResult:
-    """Standardise Exomiser output into simplified gene and variant results for analysis."""
+def trim_exomiser_result_filename(exomiser_result_path: Path) -> Path:
+    """Trim suffix appended to Exomiser JSON result path."""
+    return Path(str(exomiser_result_path.name).replace("-exomiser", ""))
 
-    def __init__(self, exomiser_json_result: [dict], ranking_method: str):
+
+class PhEvalGeneResultFromExomiserJsonCreator:
+    def __init__(self, exomiser_json_result: [dict], score_name: str):
         self.exomiser_json_result = exomiser_json_result
-        self.ranking_method = ranking_method
+        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 simplify_gene_result(self) -> [dict]:
-        """Simplify Exomiser json output into gene results."""
+    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 in self.exomiser_json_result:
-            if self.ranking_method in result:
-                simplified_exomiser_result = SimplifiedExomiserGeneResult(
-                    result, simplified_exomiser_result, self.ranking_method
-                ).create_simplified_gene_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),
+                    )
+                )
+
         return simplified_exomiser_result
 
-    def simplify_variant_result(self) -> [dict]:
-        """Simplify Exomiser json output into variant results."""
+
+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 in self.exomiser_json_result:
-            for gene_hit in result["geneScores"]:
-                if self.ranking_method in gene_hit:
+        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:
-                        simplified_exomiser_result = SimplifiedExomiserVariantResult(
-                            gene_hit,
-                            simplified_exomiser_result,
-                            self.ranking_method,
-                            round(result[self.ranking_method], 4),
-                        ).create_simplified_variant_result()
+                        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
 
-    def standardise_gene_result(self) -> [dict]:
-        """Standardise Exomiser json to gene results for analysis."""
-        simplified_exomiser_result = self.simplify_gene_result()
-        return RankExomiserResult(simplified_exomiser_result, self.ranking_method).rank_results()
-
-    def standardise_variant_result(self) -> [dict]:
-        """Standardise Exomiser json to gene results for analysis."""
-        simplified_exomiser_result = self.simplify_variant_result()
-        return RankExomiserResult(simplified_exomiser_result, self.ranking_method).rank_results()
-
-
-def create_standardised_results(results_dir: Path, output_dir: Path, ranking_method) -> None:
-    """Write standardised gene and variant results from default Exomiser json output."""
-    output_dir.joinpath("pheval_gene_results/").mkdir(exist_ok=True, parents=True)
-    output_dir.joinpath("pheval_variant_results/").mkdir(exist_ok=True, parents=True)
-    for result in files_with_suffix(results_dir, ".json"):
-        exomiser_result = read_exomiser_json_result(result)
-        standardised_gene_result = StandardiseExomiserResult(
-            exomiser_result, ranking_method
-        ).standardise_gene_result()
-        standardised_variant_result = StandardiseExomiserResult(
-            exomiser_result, ranking_method
-        ).standardise_variant_result()
-        gene_df = pd.DataFrame(standardised_gene_result)
-        gene_df = gene_df.loc[:, ["rank", "score", "gene_symbol", "gene_identifier"]]
-        gene_df.to_csv(
-            output_dir.joinpath("pheval_gene_results/" + result.stem + "-pheval_gene_result.tsv"),
-            sep="\t",
-            index=False,
-        )
-        variant_df = pd.DataFrame(standardised_variant_result)
-        variant_df = variant_df.drop("variant", axis=1).join(variant_df.variant.apply(pd.Series))
-        variant_df = variant_df.loc[:, ["rank", "score", "chrom", "pos", "ref", "alt", "gene"]]
-        variant_df.to_csv(
-            output_dir.joinpath(
-                "pheval_variant_results/" + result.stem + "-pheval_variant_result.tsv"
-            ),
-            sep="\t",
-            index=False,
-        )
+
+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),
+                        )
+                    )
+            except KeyError:
+                pass
+        return simplified_exomiser_result
+
+
+def create_standardised_results(
+    results_dir: Path,
+    output_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)
+        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,
+                output_dir=output_dir,
+                tool_result_path=trim_exomiser_result_filename(exomiser_json_result),
+            )
+        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,
+                output_dir=output_dir,
+                tool_result_path=trim_exomiser_result_filename(exomiser_json_result),
+            )
+        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,
+                output_dir=output_dir,
+                tool_result_path=trim_exomiser_result_filename(exomiser_json_result),
+            )
 
 
 @click.command()
@@ -206,18 +248,81 @@ def create_standardised_results(results_dir: Path, output_dir: Path, ranking_met
     type=Path,
 )
 @click.option(
-    "--ranking-method",
-    "-r",
+    "--score-name",
+    "-s",
     required=True,
-    help="ranking method",
+    help="Score name to extract from results.",
     type=click.Choice(["combinedScore", "priorityScore", "variantScore", "pValue"]),
     default="combinedScore",
     show_default=True,
 )
-def post_process_exomiser_results(output_dir: Path, results_dir: Path, ranking_method):
-    """Post-process Exomiser json results into standardised gene and variant outputs."""
-    try:
-        output_dir.mkdir()
-    except FileExistsError:
-        pass
-    create_standardised_results(results_dir, output_dir, ranking_method)
+@click.option(
+    "--sort-order",
+    "-so",
+    required=True,
+    help="Ordering of results for ranking.",
+    type=click.Choice(["ascending", "descending"]),
+    default="descending",
+    show_default=True,
+)
+@click.option(
+    "--gene-analysis/--no-gene-analysis",
+    type=bool,
+    default=False,
+    help="Specify whether to create PhEval gene results.",
+)
+@click.option(
+    "--variant-analysis/--no-variant-analysis",
+    type=bool,
+    default=False,
+    help="Specify whether to create PhEval variant results.",
+)
+@click.option(
+    "--disease-analysis/--no-disease-analysis",
+    type=bool,
+    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,
+    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."""
+    (
+        output_dir.joinpath("pheval_gene_results").mkdir(parents=True, exist_ok=True)
+        if gene_analysis
+        else None
+    )
+    (
+        output_dir.joinpath("pheval_variant_results").mkdir(parents=True, exist_ok=True)
+        if variant_analysis
+        else None
+    )
+    (
+        output_dir.joinpath("pheval_disease_results").mkdir(parents=True, exist_ok=True)
+        if disease_analysis
+        else None
+    )
+    create_standardised_results(
+        results_dir,
+        output_dir,
+        score_name,
+        sort_order,
+        variant_analysis,
+        gene_analysis,
+        disease_analysis,
+        include_acmg,
+    )