pheval-exomiser 0.3.3__tar.gz → 0.4.0__tar.gz

{pheval_exomiser-0.3.3 → pheval_exomiser-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pheval_exomiser
-Version: 0.3.3
+Version: 0.4.0
 Summary: 
 Author: Yasemin Bridges
 Author-email: y.bridges@qmul.ac.uk
@@ -10,13 +10,14 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: click (>=8.1.3,<9.0.0)
 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: phenopackets (>=2.0.2,<3.0.0)
-Requires-Dist: pheval (>=0.6.1,<0.7.0)
+Requires-Dist: pheval (>=0.6.7,<0.7.0)
 Requires-Dist: pyaml (>=21.10.1,<22.0.0)
 Requires-Dist: pydantic (>=2.7.1,<3.0.0)
 Description-Content-Type: text/markdown

{pheval_exomiser-0.3.3 → pheval_exomiser-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pheval_exomiser"
-version = "0.3.3"
+version = "0.4.0"
 description = ""
 authors = ["Yasemin Bridges <y.bridges@qmul.ac.uk>",
     "Julius Jacobsen <j.jacobsen@qmul.ac.uk>",
@@ -19,7 +19,7 @@ oaklib = "^0.5.12"
 docker = "^6.0.1"
 pydantic = "^2.7.1"
 numpy = "<2"
-pheval = "^0.6.1"
+pheval = "^0.6.7"
 
 [tool.poetry.dev-dependencies]
 pytest = "^7.1.2"

{pheval_exomiser-0.3.3 → pheval_exomiser-0.4.0}/src/pheval_exomiser/post_process/post_process.py

@@ -12,9 +12,9 @@ def post_process_result_format(
     variant_analysis: bool,
     gene_analysis: bool,
     disease_analysis: bool,
+    exomiser_version: str,
 ):
     """Standardise Exomiser json format to separated gene and variant results."""
-    print("...standardising results format...")
     create_standardised_results(
         result_dir=raw_results_dir,
         output_dir=output_dir,
@@ -24,5 +24,5 @@ def post_process_result_format(
         gene_analysis=gene_analysis,
         disease_analysis=disease_analysis,
         variant_analysis=variant_analysis,
+        exomiser_version=exomiser_version,
     )
-    print("done")

{pheval_exomiser-0.3.3 → pheval_exomiser-0.4.0}/src/pheval_exomiser/post_process/post_process_results_format.py

@@ -4,6 +4,7 @@ from pathlib import Path
 
 import click
 import polars as pl
+from packaging import version
 from pheval.post_processing.post_processing import (
     SortOrder,
     generate_disease_result,
@@ -15,10 +16,15 @@ from pheval.utils.file_utils import files_with_suffix
 
 class ModeOfInheritance(Enum):
     AUTOSOMAL_DOMINANT = 1
+    AD = 1
     AUTOSOMAL_RECESSIVE = 2
+    AR = 2
     X_DOMINANT = 1
+    XD = 1
     X_RECESSIVE = 2
+    XR = 2
     MITOCHONDRIAL = 3
+    MT = 3
 
 
 def trim_exomiser_result_filename(exomiser_result_path: Path) -> Path:
@@ -38,6 +44,18 @@ def extract_gene_results_from_json(
     ).drop_nulls()
 
 
+def extract_gene_results_from_parquet(
+    exomiser_parquet_result: pl.DataFrame, score_name: str
+) -> pl.DataFrame:
+    return exomiser_parquet_result.select(
+        [
+            pl.col("geneSymbol").alias("gene_symbol"),
+            pl.col("ensemblGeneId").alias("gene_identifier"),
+            pl.col(score_name).fill_null(0).round(4).alias("score"),
+        ]
+    )
+
+
 def extract_disease_results_from_json(exomiser_json_result: pl.DataFrame) -> pl.DataFrame:
     return (
         exomiser_json_result.select(
@@ -55,6 +73,18 @@ def extract_disease_results_from_json(exomiser_json_result: pl.DataFrame) -> pl.
     )
 
 
+def extract_disease_results_from_parquet(exomiser_parquet_result: pl.DataFrame) -> pl.DataFrame:
+    return (
+        exomiser_parquet_result.select(pl.col("diseaseMatches"))
+        .explode("diseaseMatches")
+        .select(
+            pl.col("diseaseMatches").struct.field("diseaseId").alias("disease_identifier"),
+            pl.col("diseaseMatches").struct.field("score").alias("score"),
+        )
+        .drop_nulls()
+    )
+
+
 def extract_variant_results_from_json(
     exomiser_json_result: pl.DataFrame, score_name: str
 ) -> pl.DataFrame:
@@ -124,6 +154,67 @@ def extract_variant_results_from_json(
     )
 
 
+def extract_variant_results_from_parquet(
+    exomiser_parquet_result: pl.DataFrame, score_name: str
+) -> pl.DataFrame:
+    contributing_variant_only = exomiser_parquet_result.filter(
+        pl.col("isContributingVariant") == True  # noqa
+    )
+    return (
+        contributing_variant_only.select(
+            [
+                pl.col("geneSymbol"),
+                pl.col("contigName").alias("chrom").cast(pl.String),
+                pl.col("start").cast(pl.Int64),
+                pl.col("end").cast(pl.Int64),
+                pl.col("ref"),
+                pl.col("alt"),
+                pl.col(score_name).alias("score"),
+                pl.col("moi")
+                .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"),
+                    )
+                )
+                .otherwise(
+                    pl.format(
+                        "dominant|{}|{}|{}|{}|{}|{}",
+                        pl.col("chrom"),
+                        pl.col("start"),
+                        pl.col("end"),
+                        pl.col("ref"),
+                        pl.col("alt"),
+                        pl.col("score"),
+                    )
+                )
+                .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")
+            ]
+        )
+    )
+
+
 def create_standardised_results(
     result_dir: Path,
     output_dir: Path,
@@ -133,36 +224,55 @@ def create_standardised_results(
     gene_analysis: bool,
     disease_analysis: bool,
     variant_analysis: bool,
+    exomiser_version: str,
 ):
     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, infer_schema_length=None)
+    use_parquet = True if version.parse(exomiser_version) >= version.parse("15.0.0") else False
+    read_result = pl.read_parquet if use_parquet else pl.read_json
+    result_files = (
+        files_with_suffix(result_dir, ".parquet")
+        if use_parquet
+        else files_with_suffix(result_dir, ".json")
+    )
+    for exomiser_result_path in result_files:
+        exomiser_result = read_result(exomiser_result_path)
         if gene_analysis:
-            gene_results = extract_gene_results_from_json(exomiser_json_result, score_name)
+            gene_results = (
+                extract_gene_results_from_parquet(exomiser_result, score_name)
+                if use_parquet
+                else extract_gene_results_from_json(exomiser_result, score_name)
+            )
             generate_gene_result(
                 results=gene_results,
                 sort_order=sort_order,
                 output_dir=output_dir,
-                result_path=trim_exomiser_result_filename(exomiser_json_result_path),
+                result_path=trim_exomiser_result_filename(exomiser_result_path),
                 phenopacket_dir=phenopacket_dir,
             )
         if disease_analysis:
-            disease_results = extract_disease_results_from_json(exomiser_json_result)
+            disease_results = (
+                extract_disease_results_from_parquet(exomiser_result)
+                if use_parquet
+                else extract_disease_results_from_json(exomiser_result)
+            )
             generate_disease_result(
                 results=disease_results,
                 sort_order=sort_order,
                 output_dir=output_dir,
-                result_path=trim_exomiser_result_filename(exomiser_json_result_path),
+                result_path=trim_exomiser_result_filename(exomiser_result_path),
                 phenopacket_dir=phenopacket_dir,
             )
-
         if variant_analysis:
-            variant_results = extract_variant_results_from_json(exomiser_json_result, score_name)
+            variant_results = (
+                extract_variant_results_from_parquet(exomiser_result, score_name)
+                if use_parquet
+                else extract_variant_results_from_json(exomiser_result, score_name)
+            )
             generate_variant_result(
                 results=variant_results,
                 sort_order=sort_order,
                 output_dir=output_dir,
-                result_path=trim_exomiser_result_filename(exomiser_json_result_path),
+                result_path=trim_exomiser_result_filename(exomiser_result_path),
                 phenopacket_dir=phenopacket_dir,
             )
 
@@ -228,6 +338,14 @@ def create_standardised_results(
     default=False,
     help="Specify whether to create PhEval disease results.",
 )
+@click.option(
+    "--version",
+    "-v",
+    required=True,
+    help="Exomiser version used to generate results.",
+    default="15.0.0",
+    show_default=True,
+)
 def post_process_exomiser_results(
     output_dir: Path,
     results_dir: Path,
@@ -237,6 +355,7 @@ def post_process_exomiser_results(
     gene_analysis: bool,
     variant_analysis: bool,
     disease_analysis: bool,
+    version: str,
 ):
     """Post-process Exomiser json results into PhEval gene and variant outputs."""
     (
@@ -263,4 +382,5 @@ def post_process_exomiser_results(
         variant_analysis=variant_analysis,
         gene_analysis=gene_analysis,
         disease_analysis=disease_analysis,
+        exomiser_version=version,
     )

{pheval_exomiser-0.3.3 → pheval_exomiser-0.4.0}/src/pheval_exomiser/prepare/create_batch_commands.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from typing import List, Optional
 
 import click
+from packaging import version
 from phenopackets import Family, Phenopacket
 from pheval.prepare.custom_exceptions import MutuallyExclusiveOptionError
 from pheval.utils.file_utils import all_files, files_with_suffix
@@ -23,13 +24,13 @@ class ExomiserCommandLineArguments:
     """Store command line arguments for each phenopacket to be run with Exomiser."""
 
     sample: Path
-    analysis_yaml: Path or None = None
-    vcf_file: Path or None = None
-    vcf_assembly: str or None = None
-    raw_results_dir: Path or None = None
-    variant_analysis: bool or None = None
+    analysis_yaml: Optional[Path] = None
+    vcf_file: Optional[Path] = None
+    vcf_assembly: Optional[str] = None
+    raw_results_dir: Optional[Path] = None
+    variant_analysis: Optional[bool] = None
     output_options_file: Optional[Path] = None
-    output_formats: List[str] or None = None
+    output_formats: Optional[List[str]] = None
 
 
 def get_all_files_from_output_opt_directory(output_options_dir: Path) -> List[Path] or None:
@@ -80,39 +81,41 @@ class CommandCreator:
         output_options_file = self.assign_output_options_file()
         if self.environment == "docker":
             return ExomiserCommandLineArguments(
-                sample=f"{PHENOPACKET_TARGET_DIRECTORY_DOCKER}{Path(self.phenopacket_path.name)}",
+                sample=Path(f"{PHENOPACKET_TARGET_DIRECTORY_DOCKER}{self.phenopacket_path.name}"),
                 variant_analysis=self.variant_analysis,
                 output_options_file=(
-                    f"{OUTPUT_OPTIONS_TARGET_DIRECTORY_DOCKER}{Path(output_options_file).name}"
-                    if output_options_file is not None
+                    Path(f"{OUTPUT_OPTIONS_TARGET_DIRECTORY_DOCKER}{output_options_file.name}")
+                    if output_options_file
                     else None
                 ),
-                raw_results_dir=RAW_RESULTS_TARGET_DIRECTORY_DOCKER,
+                raw_results_dir=Path(RAW_RESULTS_TARGET_DIRECTORY_DOCKER),
                 output_formats=self.output_formats,
             )
         elif self.environment == "local":
             return ExomiserCommandLineArguments(
-                sample=Path(self.phenopacket_path),
+                sample=self.phenopacket_path,
                 variant_analysis=self.variant_analysis,
                 output_options_file=output_options_file,
                 raw_results_dir=self.results_dir,
                 output_formats=self.output_formats,
             )
+        raise ValueError(f"Unknown environment: {self.environment}")
 
     def add_variant_analysis_arguments(self, vcf_dir: Path) -> ExomiserCommandLineArguments:
-        vcf_file_data = (
-            PhenopacketUtil(self.phenopacket).vcf_file_data(self.phenopacket_path, vcf_dir)
-            if vcf_dir.exists()
-            else [
+        if vcf_dir.exists():
+            vcf_file_data = PhenopacketUtil(self.phenopacket).vcf_file_data(
+                self.phenopacket_path, vcf_dir
+            )
+        else:
+            vcf_file_data = next(
                 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":
             return ExomiserCommandLineArguments(
-                sample=Path(self.phenopacket_path),
+                sample=self.phenopacket_path,
                 vcf_file=Path(vcf_file_data.uri),
                 vcf_assembly=vcf_file_data.file_attributes["genomeAssembly"],
                 output_options_file=output_options_file,
@@ -123,18 +126,24 @@ class CommandCreator:
             )
         elif self.environment == "docker":
             return ExomiserCommandLineArguments(
-                sample=f"{PHENOPACKET_TARGET_DIRECTORY_DOCKER}{Path(self.phenopacket_path.name)}",
-                vcf_file=f"{VCF_TARGET_DIRECTORY_DOCKER}{Path(vcf_file_data.uri).name}",
+                sample=Path(f"{PHENOPACKET_TARGET_DIRECTORY_DOCKER}{self.phenopacket_path.name}"),
+                vcf_file=Path(f"{VCF_TARGET_DIRECTORY_DOCKER}{Path(vcf_file_data.uri).name}"),
                 vcf_assembly=vcf_file_data.file_attributes["genomeAssembly"],
                 output_options_file=(
-                    f"{OUTPUT_OPTIONS_TARGET_DIRECTORY_DOCKER}{Path(output_options_file).name}"
-                    if output_options_file is not None
+                    Path(f"{OUTPUT_OPTIONS_TARGET_DIRECTORY_DOCKER}{output_options_file.name}")
+                    if output_options_file
                     else None
                 ),
                 variant_analysis=self.variant_analysis,
-                raw_results_dir=RAW_RESULTS_TARGET_DIRECTORY_DOCKER,
-                analysis_yaml=f"{EXOMISER_YAML_TARGET_DIRECTORY_DOCKER}{Path(self.analysis_yaml).name}",
+                raw_results_dir=Path(RAW_RESULTS_TARGET_DIRECTORY_DOCKER),
+                analysis_yaml=(
+                    Path(f"{EXOMISER_YAML_TARGET_DIRECTORY_DOCKER}{self.analysis_yaml.name}")
+                    if self.analysis_yaml
+                    else None
+                ),
+                output_formats=self.output_formats,
             )
+        raise ValueError(f"Unknown environment: {self.environment}")
 
     def add_command_line_arguments(self, vcf_dir: Path or None) -> ExomiserCommandLineArguments:
         """Return a dataclass of all the command line arguments corresponding to phenopacket sample."""
@@ -181,92 +190,89 @@ def create_command_arguments(
 class CommandsWriter:
     """Write a command to file."""
 
-    def __init__(self, file: Path, variant_analysis: bool):
+    def __init__(self, file: Path, variant_analysis: bool, exomiser_version: str):
         self.file = open(file, "w")
         self.variant_analysis = variant_analysis
+        self.exomiser_version = exomiser_version
 
     def write_basic_analysis_command(self, command_arguments: ExomiserCommandLineArguments):
         """Write basic analysis command for Exomiser"""
-        try:
-            self.file.write(
-                "--analysis "
-                + str(command_arguments.analysis_yaml)
-                + " --sample "
-                + str(command_arguments.sample)
-                + " --vcf "
-                + str(command_arguments.vcf_file)
-                + " --assembly "
-                + command_arguments.vcf_assembly
-                + " --output-filename "
-                + f"{command_arguments.sample.stem}-exomiser"
-            )
-        except IOError:
-            print("Error writing ", self.file)
+        self.file.write(
+            "--analysis "
+            + str(command_arguments.analysis_yaml)
+            + " --sample "
+            + str(command_arguments.sample)
+            + " --vcf "
+            + str(command_arguments.vcf_file)
+            + " --assembly "
+            + command_arguments.vcf_assembly
+            + " --output-filename "
+            + f"{command_arguments.sample.stem}-exomiser"
+        )
 
     def write_results_dir(self, command_arguments: ExomiserCommandLineArguments) -> None:
         """Write results directory for exomiser ≥13.2.0 to run."""
-        try:
-            (
-                self.file.write(" --output-directory " + str(command_arguments.raw_results_dir))
-                if command_arguments.raw_results_dir is not None
-                else None
-            )
-        except IOError:
-            print("Error writing ", self.file)
+        (
+            self.file.write(" --output-directory " + str(command_arguments.raw_results_dir))
+            if command_arguments.raw_results_dir is not None
+            else None
+        )
 
     def write_output_options(self, command_arguments: ExomiserCommandLineArguments) -> None:
         """Write a command out for exomiser ≤13.1.0 to run - including output option file specified."""
-        try:
-            (
-                self.file.write(" --output " + str(command_arguments.output_options_file))
-                if command_arguments.output_options_file is not None
-                else None
-            )
-        except IOError:
-            print("Error writing ", self.file)
+        (
+            self.file.write(" --output " + str(command_arguments.output_options_file))
+            if command_arguments.output_options_file is not None
+            else None
+        )
 
     def write_output_format(self, command_arguments: ExomiserCommandLineArguments) -> None:
         """Write output formats for Exomiser raw result output."""
+        (
+            self.file.write(" --output-format " + ",".join(command_arguments.output_formats))
+            if command_arguments.output_formats is not None
+            else None
+        )
+
+    def write_analysis_command(self, command_arguments: ExomiserCommandLineArguments):
         try:
-            (
-                self.file.write(" --output-format " + ",".join(command_arguments.output_formats))
-                if command_arguments.output_formats is not None
-                else None
-            )
+            self.write_basic_analysis_command(command_arguments)
+            self.write_results_dir(command_arguments)
+            self.write_output_options(command_arguments)
+            self.write_output_format(command_arguments)
+            self.file.write("\n")
         except IOError:
             print("Error writing ", self.file)
 
-    def write_analysis_command(self, command_arguments: ExomiserCommandLineArguments):
-        self.write_basic_analysis_command(command_arguments)
-        self.write_results_dir(command_arguments)
-        self.write_output_options(command_arguments)
-        self.write_output_format(command_arguments)
-        self.file.write("\n")
-
     def write_basic_phenotype_only_command(
         self, command_arguments: ExomiserCommandLineArguments
     ) -> None:
         """Write a phenotype-only command out for exomiser ≥13.2.0 to run."""
+        phenotype_only = (
+            "phenotype-only"
+            if version.parse(self.exomiser_version) < version.parse("15.0.0")
+            else "phenotype_only"
+        )
+        self.file.write(
+            "--sample "
+            + str(command_arguments.sample)
+            + " --output-directory "
+            + str(command_arguments.raw_results_dir)
+            + " --output-filename "
+            + f"{Path(command_arguments.sample).stem}-exomiser"
+            + " --preset "
+            + phenotype_only
+        )
+
+    def write_phenotype_only_command(self, command_arguments: ExomiserCommandLineArguments):
         try:
-            self.file.write(
-                "--sample "
-                + str(command_arguments.sample)
-                + " --output-directory "
-                + str(command_arguments.raw_results_dir)
-                + " --output-filename "
-                + f"{Path(command_arguments.sample).stem}-exomiser"
-                + " --preset "
-                + "phenotype-only"
-            )
+            self.write_basic_phenotype_only_command(command_arguments)
+            self.write_output_options(command_arguments)
+            self.write_output_format(command_arguments)
+            self.file.write("\n")
         except IOError:
             print("Error writing ", self.file)
 
-    def write_phenotype_only_command(self, command_arguments: ExomiserCommandLineArguments):
-        self.write_basic_phenotype_only_command(command_arguments)
-        self.write_output_options(command_arguments)
-        self.write_output_format(command_arguments)
-        self.file.write("\n")
-
     def write_local_commands(self, command_arguments: ExomiserCommandLineArguments):
         (
             self.write_analysis_command(command_arguments)
@@ -291,11 +297,13 @@ class BatchFileWriter:
         variant_analysis: bool,
         output_dir: Path,
         batch_prefix: str,
+        exomiser_version: str,
     ):
         self.command_arguments_list = command_arguments_list
         self.variant_analysis = variant_analysis
         self.output_dir = output_dir
         self.batch_prefix = batch_prefix
+        self.exomiser_version = exomiser_version
 
     def write_commands(self, commands_writer: CommandsWriter) -> None:
         """Write command arguments to a file."""
@@ -306,7 +314,9 @@ class BatchFileWriter:
     def write_temp_file(self) -> str:
         """Write commands out to a temporary file."""
         temp = tempfile.NamedTemporaryFile(delete=False)
-        commands_writer = CommandsWriter(Path(temp.name), self.variant_analysis)
+        commands_writer = CommandsWriter(
+            Path(temp.name), self.variant_analysis, self.exomiser_version
+        )
         self.write_commands(commands_writer)
         return temp.name
 
@@ -315,6 +325,7 @@ class BatchFileWriter:
         commands_writer = CommandsWriter(
             Path(self.output_dir).joinpath(self.batch_prefix + "-exomiser-batch.txt"),
             self.variant_analysis,
+            self.exomiser_version,
         )
         self.write_commands(commands_writer)
 
@@ -350,6 +361,7 @@ def create_batch_file(
     max_jobs: int,
     variant_analysis: bool,
     results_dir: Path,
+    exomiser_version: str,
     output_options_dir: Path = None,
     output_options_file: Path = None,
     output_formats: List[str] = None,
@@ -368,10 +380,7 @@ def create_batch_file(
     )
     (
         BatchFileWriter(
-            command_arguments,
-            variant_analysis,
-            output_dir,
-            batch_prefix,
+            command_arguments, variant_analysis, output_dir, batch_prefix, exomiser_version
         ).write_all_commands()
         if max_jobs == 0
         else BatchFileWriter(
@@ -379,6 +388,7 @@ def create_batch_file(
             variant_analysis,
             output_dir,
             batch_prefix,
+            exomiser_version,
         ).create_split_batch_files(max_jobs)
     )
 
@@ -403,19 +413,18 @@ def create_batch_file(
 )
 @click.option(
     "--phenopacket-dir",
-    "-P",
+    "-p",
     required=True,
     metavar="PATH",
     type=Path,
-    help="Path to phenopackets.",
+    help="Path to phenopacket directory.",
 )
 @click.option(
     "--vcf-dir",
     "-v",
-    required=True,
     metavar="PATH",
     type=Path,
-    help="Path to VCF files.",
+    help="Path to VCF directory.",
 )
 @click.option(
     "--batch-prefix",
@@ -437,19 +446,34 @@ def create_batch_file(
     help="Number of jobs in each file.",
 )
 @click.option(
-    "--phenotype-only",
+    "--variant-analysis",
     type=bool,
     default=False,
-    cls=MutuallyExclusiveOptionError,
-    mutually_exclusive=["vcf_dir", "analysis_yaml"],
+    is_flag=True,
     help="Run Exomiser with phenotype only preset - strongly recommended to run with versions 13.2.0 onwards.",
 )
+@click.option(
+    "--output-dir",
+    "-d",
+    type=Path,
+    required=False,
+    help="Results directory for Exomiser results - compatible with versions 13.2.0 onwards.",
+)
 @click.option(
     "--results-dir",
+    "-r",
     type=Path,
     required=False,
     help="Results directory for Exomiser results - compatible with versions 13.2.0 onwards.",
 )
+@click.option(
+    "--exomiser-version",
+    "-v",
+    required=True,
+    help="Exomiser version used to generate results.",
+    default="15.0.0",
+    show_default=True,
+)
 @click.option(
     "--output-options-dir",
     "-O",
@@ -470,29 +494,41 @@ def create_batch_file(
     type=Path,
     help="Path to the output options file. ",
 )
+@click.option(
+    "--output-formats",
+    "-f",
+    multiple=True,
+    help="One or more output formats (e.g., --output-format vcf --output-format json).",
+)
 def prepare_exomiser_batch(
     environment: str,
     analysis_yaml: Path,
     phenopacket_dir: Path,
     vcf_dir: Path,
     output_dir: Path,
+    results_dir: Path,
     batch_prefix: str,
     max_jobs: int,
-    phenotype_only: bool,
+    variant_analysis: bool,
+    exomiser_version: str,
     output_options_dir: Path = None,
     output_options_file: Path = None,
+    output_formats: List[str] = None,
 ):
     """Generate Exomiser batch files."""
     Path(output_dir).joinpath("tool_input_commands").mkdir(exist_ok=True)
     create_batch_file(
-        environment,
-        analysis_yaml,
-        phenopacket_dir,
-        vcf_dir,
-        output_dir,
-        batch_prefix,
-        max_jobs,
-        phenotype_only,
-        output_options_dir,
-        output_options_file,
+        environment=environment,
+        analysis=analysis_yaml,
+        phenopacket_dir=phenopacket_dir,
+        vcf_dir=vcf_dir,
+        output_dir=output_dir,
+        results_dir=results_dir,
+        batch_prefix=batch_prefix,
+        max_jobs=max_jobs,
+        variant_analysis=variant_analysis,
+        output_options_dir=output_options_dir,
+        output_options_file=output_options_file,
+        output_formats=list(output_formats),
+        exomiser_version=exomiser_version,
     )

{pheval_exomiser-0.3.3 → pheval_exomiser-0.4.0}/src/pheval_exomiser/run/run.py

@@ -27,15 +27,17 @@ def prepare_batch_files(
     tool_input_commands_dir: Path,
     raw_results_dir: Path,
     variant_analysis: bool,
+    exomiser_version: str,
 ) -> None:
     """Prepare the exomiser batch files"""
     print("...preparing batch files...")
     vcf_dir_name = Path(testdata_dir).joinpath("vcf")
-    output_formats = (
-        config.output_formats + ["JSON"]
-        if config.output_formats and "JSON" not in config.output_formats
-        else config.output_formats
-    )
+    if version.parse(exomiser_version) >= version.parse("15.0.0"):
+        if "PARQUET" not in config.output_formats:
+            config.output_formats.append("PARQUET")
+    elif version.parse(exomiser_version) < version.parse("15.0.0"):
+        if "JSON" not in config.output_formats:
+            config.output_formats.append("JSON")
     create_batch_file(
         environment=config.environment,
         analysis=input_dir.joinpath(config.analysis_configuration_file),
@@ -48,7 +50,8 @@ def prepare_batch_files(
         output_options_dir=None,
         results_dir=raw_results_dir,
         variant_analysis=variant_analysis,
-        output_formats=output_formats,
+        output_formats=config.output_formats,
+        exomiser_version=exomiser_version,
     )
 
 
@@ -121,18 +124,32 @@ def run_exomiser_local(
     ][0]
     exomiser_jar_file_path = config.exomiser_software_directory.joinpath(exomiser_jar_file)
     for file in batch_files:
-        subprocess.run(
-            [
-                "java",
-                "-Xmx4g",
-                "-jar",
-                exomiser_jar_file_path,
-                "--batch",
-                file,
-                f"--spring.config.location={Path(input_dir).joinpath('application.properties')}",
-            ],
-            shell=False,
-        )
+        if version.parse(exomiser_version) < version.parse("15.0.0"):
+            subprocess.run(
+                [
+                    "java",
+                    "-Xmx4g",
+                    "-jar",
+                    exomiser_jar_file_path,
+                    "--batch",
+                    file,
+                    f"--spring.config.location={Path(input_dir).joinpath('application.properties')}",
+                ],
+                shell=False,
+            )
+        elif version.parse(exomiser_version) >= version.parse("15.0.0"):
+            subprocess.run(
+                [
+                    "java",
+                    "-Xmx4g",
+                    f"-Dspring.config.location={str(Path(input_dir).joinpath('application.properties'))}",
+                    "-jar",
+                    exomiser_jar_file_path,
+                    "batch",
+                    file,
+                ],
+                shell=False,
+            )
     if version.parse(exomiser_version) < version.parse("13.1.0"):
         os.rename(
             f"{output_dir}/results",

{pheval_exomiser-0.3.3 → pheval_exomiser-0.4.0}/src/pheval_exomiser/runner.py

@@ -45,6 +45,7 @@ class ExomiserPhEvalRunner(PhEvalRunner):
             tool_input_commands_dir=self.tool_input_commands_dir,
             raw_results_dir=self.raw_results_dir,
             variant_analysis=self.input_dir_config.variant_analysis,
+            exomiser_version=self.version,
         )
         run_exomiser(
             input_dir=self.input_dir,
@@ -71,4 +72,5 @@ class ExomiserPhEvalRunner(PhEvalRunner):
             variant_analysis=self.input_dir_config.variant_analysis,
             gene_analysis=self.input_dir_config.gene_analysis,
             disease_analysis=self.input_dir_config.disease_analysis,
+            exomiser_version=self.version,
         )