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

pheval_exomiser/prepare/write_application_properties.py

@@ -0,0 +1,182 @@
+import inspect
+from pathlib import Path
+
+from pheval_exomiser.constants import EXOMISER_DATA_DIRECTORY_TARGET_DOCKER
+from pheval_exomiser.prepare.tool_specific_configuration_options import ExomiserConfigurations
+
+
+class ExomiserConfigurationFileWriter:
+    def __init__(self, input_dir: Path, configurations: ExomiserConfigurations):
+        self.input_dir = input_dir
+        self.configurations = configurations
+        self.application_properties = open(input_dir.joinpath("application.properties"), "w")
+
+    def write_remm_version(self) -> None:
+        """Write the remm version to application.properties file."""
+        if self.configurations.application_properties.remm_version is not None:
+            self.application_properties.write(
+                f"remm.version={self.configurations.application_properties.remm_version}\n"
+            )
+
+    def write_cadd_version(self) -> None:
+        """Write the cadd version to application.properties file."""
+        if self.configurations.application_properties.cadd_version is not None:
+            self.application_properties.write(
+                f"cadd.version={self.configurations.application_properties.cadd_version}\n"
+            )
+
+    def write_exomiser_data_directory(self) -> None:
+        """Write the exomiser data directory to application.properties file."""
+        if self.configurations.environment.lower() == "docker":
+            self.application_properties.write(
+                f"exomiser.data-directory={EXOMISER_DATA_DIRECTORY_TARGET_DOCKER}\n"
+            )
+        if self.configurations.environment.lower() == "local":
+            self.application_properties.write(f"exomiser.data-directory={self.input_dir}\n")
+
+    def write_exomiser_hg19_data_version(self) -> None:
+        """Write the hg19 data version to application.properties file."""
+        if self.configurations.application_properties.hg19_data_version is not None:
+            self.application_properties.write(
+                f"exomiser.hg19.data-version={self.configurations.application_properties.hg19_data_version}\n"
+            )
+
+    def write_exomiser_hg19_cadd_snv_path(self) -> None:
+        """Write the hg19 cadd snv path to application.properties file."""
+        if (
+            self.configurations.application_properties.cadd_version is not None
+            and self.configurations.application_properties.hg19_data_version is not None
+        ):
+            self.application_properties.write(
+                "exomiser.hg19.cadd-snv-path="
+                "${exomiser.data-directory}/cadd/${cadd.version}/hg19/"
+                "whole_genome_SNVs.tsv.gz\n"
+            )
+
+    def write_exomiser_hg19_cadd_indel_path(self) -> None:
+        """Write the hg19 cadd indel path to application.properties file."""
+        if (
+            self.configurations.application_properties.cadd_version is not None
+            and self.configurations.application_properties.hg19_data_version is not None
+        ):
+            self.application_properties.write(
+                "exomiser.hg19.cadd-in-del-path="
+                "${exomiser.data-directory}/cadd/${cadd.version}/hg19/"
+                "InDels.tsv.gz\n"
+            )
+
+    def write_exomiser_hg19_remm_path(self) -> None:
+        """Write the hg19 remm path to application.properties file."""
+        if (
+            self.configurations.application_properties.remm_version is not None
+            and self.configurations.application_properties.hg19_data_version is not None
+        ):
+            self.application_properties.write(
+                "exomiser.hg19.remm-path="
+                "${exomiser.data-directory}/remm/ReMM.v${remm.version}.hg19.tsv.gz\n"
+            )
+
+    def write_exomiser_hg19_local_frequency_path(self) -> None:
+        """Write the hg19 local frequency path to application.properties file."""
+        if self.configurations.application_properties.hg19_local_frequency_path is not None:
+            self.application_properties.write(
+                f"exomiser.hg19.local-frequency-path="
+                f"${{exomiser.data-directory}}/local/"
+                f"{self.configurations.application_properties.hg19_local_frequency_path}\n"
+            )
+
+    def write_exomiser_hg38_data_version(self) -> None:
+        """Write the hg38 data version to application.properties file."""
+        if self.configurations.application_properties.hg38_data_version is not None:
+            self.application_properties.write(
+                f"exomiser.hg38.data-version={self.configurations.application_properties.hg38_data_version}\n"
+            )
+
+    def write_exomiser_hg38_cadd_snv_path(self) -> None:
+        """Write the hg38 cadd snv path to application.properties file."""
+        if (
+            self.configurations.application_properties.cadd_version is not None
+            and self.configurations.application_properties.hg38_data_version is not None
+        ):
+            self.application_properties.write(
+                "exomiser.hg38.cadd-snv-path="
+                "${exomiser.data-directory}/cadd/${cadd.version}/hg38/"
+                "whole_genome_SNVs.tsv.gz\n"
+            )
+
+    def write_exomiser_hg38_cadd_indel_path(self) -> None:
+        """Write the hg38 cadd indel path to application.properties file."""
+        if (
+            self.configurations.application_properties.cadd_version is not None
+            and self.configurations.application_properties.hg38_data_version is not None
+        ):
+            self.application_properties.write(
+                "exomiser.hg38.cadd-in-del-path="
+                "${exomiser.data-directory}/cadd/${cadd.version}/hg38/"
+                "InDels.tsv.gz\n"
+            )
+
+    def write_exomiser_hg38_remm_path(self) -> None:
+        """Write the hg38 remm path to application.properties file."""
+        if (
+            self.configurations.application_properties.remm_version is not None
+            and self.configurations.application_properties.hg38_data_version is not None
+        ):
+            self.application_properties.write(
+                "exomiser.hg38.remm-path="
+                "${exomiser.data-directory}/remm/ReMM.v${remm.version}.hg38.tsv.gz\n"
+            )
+
+    def write_exomiser_hg38_local_frequency_path(self) -> None:
+        """Write the hg38 local frequency path to application.properties file."""
+        if self.configurations.application_properties.hg38_local_frequency_path is not None:
+            self.application_properties.write(
+                f"exomiser.hg38.local-frequency-path="
+                f"${{exomiser.data-directory}}/local/"
+                f"{self.configurations.application_properties.hg38_local_frequency_path}\n"
+            )
+
+    def write_exomiser_phenotype_data_version(self) -> None:
+        """Write the phenotype data version to application.properties file."""
+        self.application_properties.write(
+            f"exomiser.phenotype.data-version={self.configurations.application_properties.phenotype_data_version}\n"
+        )
+
+    def write_hg19_white_list_path(self) -> None:
+        """Write the hg19 whitelist path to application.properties file."""
+        if self.configurations.application_properties.hg19_whitelist_path is not None:
+            self.application_properties.write(
+                f"exomiser.hg19.variant-white-list-path="
+                f"{self.configurations.application_properties.hg19_whitelist_path}\n"
+            )
+
+    def write_hg38_white_list_path(self) -> None:
+        """Write the hg38 whitelist path to application.properties file."""
+        if self.configurations.application_properties.hg38_whitelist_path is not None:
+            self.application_properties.write(
+                f"exomiser.hg38.variant-white-list-path="
+                f"{self.configurations.application_properties.hg38_whitelist_path}\n"
+            )
+
+    def write_cache_type(self):
+        """Write the cache type to application.properties file."""
+        if self.configurations.application_properties.cache_type is not None:
+            self.application_properties.write(
+                f"spring.cache.type=" f"{self.configurations.application_properties.cache_type}\n"
+            )
+
+    def write_cache_spec(self):
+        """Write the cache spec to application.properties file."""
+        if self.configurations.application_properties.cache_caffeine_spec is not None:
+            self.application_properties.write(
+                f"spring.cache.caffeine.spec=maximumSize="
+                f"{self.configurations.application_properties.cache_caffeine_spec}\n"
+            )
+
+    def write_application_properties(self) -> None:
+        """Write the application.properties file."""
+        methods = inspect.getmembers(self, predicate=inspect.ismethod)
+        for name, method in methods:
+            if name != "write_application_properties" and name != "__init__":
+                method()
+        self.application_properties.close()

pheval_exomiser/run/run.py

@@ -2,55 +2,47 @@ import os
 import subprocess
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
 
 import docker
+from packaging import version
 from pheval.utils.file_utils import all_files
 
-from pheval_exomiser.config_parser import ExomiserConfig
+from pheval_exomiser.constants import (
+    EXOMISER_CONFIG_TARGET_DIRECTORY_DOCKER,
+    EXOMISER_DATA_DIRECTORY_TARGET_DOCKER,
+    EXOMISER_YAML_TARGET_DIRECTORY_DOCKER,
+    INPUT_COMMANDS_TARGET_DIRECTORY_DOCKER,
+    PHENOPACKET_TARGET_DIRECTORY_DOCKER,
+    RAW_RESULTS_TARGET_DIRECTORY_DOCKER,
+    VCF_TARGET_DIRECTORY_DOCKER,
+)
 from pheval_exomiser.prepare.create_batch_commands import create_batch_file
-
-# def write_output_options(input_dir: Path, output_dir: Path, run: ExomiserConfigSingleRun):
-#     try:
-#         Path(input_dir.joinpath("output_options")).mkdir()
-#     except FileExistsError:
-#         pass
-#     with open(Path(input_dir).joinpath("output_options/output_options.yaml"), "w") as output_options:
-#         yaml.dump({'outputPrefix': f'{output_dir.absolute().joinpath(run.run_identifier)}_results/'}, output_options)
-#     output_options.close()
-#     return Path(input_dir).joinpath("output_options/output_options.yaml")
+from pheval_exomiser.prepare.tool_specific_configuration_options import ExomiserConfigurations
 
 
 def prepare_batch_files(
-    input_dir: Path, output_dir: Path, testdata_dir: Path, config: ExomiserConfig
+    input_dir: Path,
+    testdata_dir: Path,
+    config: ExomiserConfigurations,
+    tool_input_commands_dir: Path,
+    raw_results_dir: Path,
+    variant_analysis: bool,
 ) -> None:
     """Prepare the exomiser batch files"""
-    results_sub_output_dir = Path(output_dir).joinpath(
-        f"exomiser_{config.run.exomiser_configurations.exomiser_version.replace('.', '_')}_"
-        f"{os.path.basename(input_dir)}"
-    )
-
-    results_sub_output_dir.mkdir(parents=True, exist_ok=True)
-    print("...created sub results output directory...")
     print("...preparing batch files...")
+    vcf_dir_name = Path(testdata_dir).joinpath("vcf")
     create_batch_file(
-        environment=config.run.environment,
-        analysis=config.run.path_to_analysis_yaml,
-        phenopacket_dir=Path(testdata_dir).joinpath(
-            [
-                directory
-                for directory in os.listdir(str(testdata_dir))
-                if "phenopackets" in str(directory)
-            ][0]
-        ),
-        vcf_dir=Path(testdata_dir).joinpath(
-            [directory for directory in os.listdir(str(testdata_dir)) if "vcf" in str(directory)][0]
-        ),
-        output_dir=results_sub_output_dir,
-        batch_prefix=os.path.basename(testdata_dir),
-        max_jobs=config.run.max_jobs,
+        environment=config.environment,
+        analysis=input_dir.joinpath(config.analysis_configuration_file),
+        phenopacket_dir=Path(testdata_dir).joinpath("phenopackets"),
+        vcf_dir=vcf_dir_name if variant_analysis else None,
+        output_dir=tool_input_commands_dir,
+        batch_prefix=Path(testdata_dir).name,
+        max_jobs=config.max_jobs,
         output_options_file=None,
         output_options_dir=None,
+        results_dir=raw_results_dir,
+        variant_analysis=variant_analysis,
     )
 
 
@@ -61,257 +53,128 @@ class BasicDockerMountsForExomiser:
     phenopacket_test_data: str
     vcf_test_data: str
     exomiser_yaml: str
-    batch_file_path: str
+    tool_input_commands_path: str
     exomiser_data_dir: str
-    exomiser_application_properties: Optional[str] = None
-
-
-@dataclass
-class ExomiserConfigParameters:
-    """Exomiser configuration arguments."""
-
-    application_properties_path: Path = None
-    exomiser_phenotype_version: str = None
-    exomiser_hg19_version: str = None
-    exomiser_hg38_version: str = None
-
-
-def read_application_properties(config: ExomiserConfig) -> [str]:
-    """Return contents of Exomiser application.properties."""
-    with open(
-        config.run.exomiser_configurations.path_to_application_properties_config
-    ) as exomiser_config:
-        exomiser_config_lines = exomiser_config.readlines()
-    exomiser_config.close()
-    return exomiser_config_lines
-
-
-class EditExomiserApplicationProperties:
-    def __init__(self, config: ExomiserConfig, input_dir: Path, exomiser_config_contents: [str]):
-        self.config = config
-        self.input_dir = input_dir
-        self.exomiser_config_contents = exomiser_config_contents
-
-    def edit_data_path_for_local_run(self):
-        """Edit input data path for running locally."""
-        return [
-            line.replace(line, f"exomiser.data-directory={self.input_dir}\n")
-            if line.startswith("exomiser.data-directory=")
-            else line
-            for line in self.exomiser_config_contents
-        ]
-
-    def edit_data_path_for_docker_run(self):
-        """Edit input data path for running with docker."""
-        return [
-            line.replace(line, "exomiser.data-directory=/exomiser-data\n")
-            if line.startswith("exomiser.data-directory=")
-            else line
-            for line in self.exomiser_config_contents
-        ]
-
-    def edit_data_path(self) -> [str]:
-        """Return edited contents of application.properties."""
-        return (
-            self.edit_data_path_for_local_run()
-            if self.config.run.environment == "local"
-            else self.edit_data_path_for_docker_run()
-        )
-
-
-def write_edited_application_properties(
-    config: ExomiserConfig, input_dir: Path, exomiser_config_contents: [str]
-) -> None:
-    """Write application.properties with edited contents."""
-    with open(
-        config.run.exomiser_configurations.path_to_application_properties_config, "w"
-    ) as exomiser_config:
-        exomiser_config.writelines(
-            EditExomiserApplicationProperties(
-                config, input_dir, exomiser_config_contents
-            ).edit_data_path()
-        )
-    exomiser_config.close()
+    raw_results_dir: Path
+    exomiser_application_properties: Path
 
 
 def mount_docker(
-    input_dir: Path, testdata_dir: Path, output_dir: Path, config: ExomiserConfig
+    input_dir: Path,
+    testdata_dir: Path,
+    tool_input_commands_dir: Path,
+    raw_results_dir: Path,
+    variant_analysis: bool,
 ) -> BasicDockerMountsForExomiser:
     """Create docker mounts for paths required for running Exomiser."""
-    test_data = os.listdir(str(testdata_dir))
     phenopacket_test_data = (
-        f"{Path(testdata_dir).joinpath([sub_dir for sub_dir in test_data if 'phenopackets' in str(sub_dir)][0])}"
-        f"{os.sep}:/exomiser-testdata-phenopacket"
+        f"{Path(testdata_dir).joinpath('phenopackets')}"
+        f"{os.sep}:{PHENOPACKET_TARGET_DIRECTORY_DOCKER}"
     )
     vcf_test_data = (
-        f"{Path(testdata_dir).joinpath([sub_dir for sub_dir in test_data if 'vcf' in str(sub_dir)][0])}"
-        f"{os.sep}:/exomiser-testdata-vcf"
-    )
-    exomiser_yaml = f"{config.run.path_to_analysis_yaml.parents[0]}{os.sep}:/exomiser-yaml-template"
-    batch_file_path = str(
-        Path(output_dir).joinpath(
-            f"exomiser_{config.run.exomiser_configurations.exomiser_version.replace('.', '_')}"
-            f"_{os.path.basename(input_dir)}{os.sep}exomiser_batch_files{os.sep}:/exomiser-batch-file"
-        )
-    )
-    exomiser_data_dir = f"{input_dir}{os.sep}:/exomiser-data"
-    if config.run.exomiser_configurations.path_to_application_properties_config is None:
-        # TODO add mount for results directory to be specified in the output-options
-        return BasicDockerMountsForExomiser(
-            phenopacket_test_data=phenopacket_test_data,
-            vcf_test_data=vcf_test_data,
-            exomiser_yaml=exomiser_yaml,
-            batch_file_path=batch_file_path,
-            exomiser_data_dir=exomiser_data_dir,
-        )
-    else:
-        exomiser_config = (
-            f"{config.run.exomiser_configurations.path_to_application_properties_config.parents[0]}{os.sep}"
-            f":/exomiser-config"
-        )
-        return BasicDockerMountsForExomiser(
-            phenopacket_test_data=phenopacket_test_data,
-            vcf_test_data=vcf_test_data,
-            exomiser_yaml=exomiser_yaml,
-            batch_file_path=batch_file_path,
-            exomiser_data_dir=exomiser_data_dir,
-            exomiser_application_properties=exomiser_config,
-        )
-
-
-def add_exomiser_config_file_for_docker(config: ExomiserConfig) -> ExomiserConfigParameters:
-    """Add application.properties path to config parameters."""
-    return ExomiserConfigParameters(
-        application_properties_path=config.run.exomiser_configurations.path_to_application_properties_config.parents[
-            0
-        ]
+        (f"{Path(testdata_dir).joinpath('vcf')}" f"{os.sep}:{VCF_TARGET_DIRECTORY_DOCKER}")
+        if variant_analysis
+        else None
     )
-
-
-def add_exomiser_config_parameters_for_docker(
-    config: ExomiserConfig,
-) -> ExomiserConfigParameters:
-    """Add manual arguments required for application.properties."""
-    configs = config.run.exomiser_configurations.application_properties_arguments
-    return ExomiserConfigParameters(
-        exomiser_hg19_version=configs.exomiser_hg19_version,
-        exomiser_hg38_version=configs.exomiser_hg38_version,
-        exomiser_phenotype_version=configs.exomiser_phenotype_version,
-    )
-
-
-def exomiser_config_parameters(config: ExomiserConfig) -> ExomiserConfigParameters:
-    """Add application.properties path to config arguments if specified, otherwise add manual configurations."""
-    return (
-        add_exomiser_config_file_for_docker(config)
-        if config.run.exomiser_configurations.path_to_application_properties_config is not None
-        else add_exomiser_config_parameters_for_docker(config)
+    exomiser_yaml = f"{input_dir}:{EXOMISER_YAML_TARGET_DIRECTORY_DOCKER}"
+    batch_file_path = f"{tool_input_commands_dir}/:{INPUT_COMMANDS_TARGET_DIRECTORY_DOCKER}"
+    exomiser_data_dir = f"{input_dir}{os.sep}:{EXOMISER_DATA_DIRECTORY_TARGET_DOCKER}"
+    results_dir = f"{raw_results_dir}/:{RAW_RESULTS_TARGET_DIRECTORY_DOCKER}"
+    exomiser_config = f"{input_dir}{os.sep}" f":{EXOMISER_CONFIG_TARGET_DIRECTORY_DOCKER}"
+    return BasicDockerMountsForExomiser(
+        phenopacket_test_data=phenopacket_test_data,
+        vcf_test_data=vcf_test_data,
+        exomiser_yaml=exomiser_yaml,
+        tool_input_commands_path=batch_file_path,
+        exomiser_data_dir=exomiser_data_dir,
+        exomiser_application_properties=exomiser_config,
+        raw_results_dir=results_dir,
     )
 
 
 def run_exomiser_local(
-    input_dir: Path, testdata_dir: Path, output_dir: Path, config: ExomiserConfig
+    input_dir: Path,
+    testdata_dir: Path,
+    config: ExomiserConfigurations,
+    output_dir: Path,
+    tool_input_commands_dir: Path,
+    exomiser_version: str,
 ) -> None:
     """Run Exomiser locally."""
     print("...running exomiser...")
-    results_sub_output_dir = Path(output_dir).joinpath(
-        f"exomiser_{config.run.exomiser_configurations.exomiser_version.replace('.', '_')}"
-        f"_{os.path.basename(input_dir)}"
-    )
-    results_sub_output_dir.joinpath(f"{os.path.basename(testdata_dir)}_results").mkdir(
-        exist_ok=True, parents=True
-    )
-    write_edited_application_properties(config, input_dir, read_application_properties(config))
-    os.chdir(results_sub_output_dir.joinpath(f"{os.path.basename(testdata_dir)}_results"))
+    os.chdir(output_dir)
     batch_files = [
         file
-        for file in all_files(Path(results_sub_output_dir).joinpath("exomiser_batch_files"))
-        if file.name.startswith(os.path.basename(testdata_dir))
+        for file in all_files(tool_input_commands_dir)
+        if file.name.startswith(Path(testdata_dir).name)
     ]
     exomiser_jar_file = [
         filename
-        for filename in all_files(config.run.path_to_exomiser_software_directory)
+        for filename in all_files(input_dir.joinpath(config.exomiser_software_directory))
         if filename.name.endswith(".jar")
     ][0]
-    exomiser_jar_file_path = config.run.path_to_exomiser_software_directory.joinpath(
-        exomiser_jar_file
-    )
+    exomiser_jar_file_path = config.exomiser_software_directory.joinpath(exomiser_jar_file)
     for file in batch_files:
         subprocess.run(
             [
-                "/usr/bin/java",
+                "java",
                 "-Xmx4g",
                 "-jar",
                 exomiser_jar_file_path,
                 "--batch",
                 file,
-                f"--spring.config.location={config.run.exomiser_configurations.path_to_application_properties_config}",
+                f"--spring.config.location={Path(input_dir).joinpath('application.properties')}",
             ],
             shell=False,
         )
-    os.rename(
-        Path(results_sub_output_dir).joinpath(
-            f"{os.path.basename(testdata_dir)}_results{os.sep}results"
-        ),
-        Path(results_sub_output_dir).joinpath(
-            f"{os.path.basename(testdata_dir)}_results{os.sep}exomiser_results"
-        ),
-    )
+    if version.parse(exomiser_version) < version.parse("13.1.0"):
+        os.rename(
+            f"{output_dir}/results",
+            output_dir.joinpath("raw_results"),
+        )
 
 
-def create_docker_run_command(config: ExomiserConfig, batch_file: Path) -> [str]:
+def create_docker_run_command(batch_file: Path) -> [str]:
     """Creates docker run command."""
-    exomiser_config_params = exomiser_config_parameters(config)
-    if exomiser_config_params.application_properties_path is None:
-        return [
-            "--batch",
-            "/exomiser-batch-file/" + batch_file.name,
-            f"--exomiser.data-directory=/exomiser-data"
-            f"--exomiser.hg19.data-version={exomiser_config_params.exomiser_hg19_version}",
-            f"--exomiser.hg38.data-version={exomiser_config_params.exomiser_hg38_version}",
-            f"--exomiser.phenotype.data-version={exomiser_config_params.exomiser_phenotype_version}",
-        ]
-    else:
-        return [
-            "--batch",
-            "/exomiser-batch-file/" + batch_file.name,
-            "--spring.config.location=/exomiser-config/application.properties",
-        ]
+    return [
+        "--batch",
+        f"{INPUT_COMMANDS_TARGET_DIRECTORY_DOCKER}" + batch_file.name,
+        f"--spring.config.location={EXOMISER_CONFIG_TARGET_DIRECTORY_DOCKER}application.properties",
+    ]
 
 
 def run_exomiser_docker(
-    input_dir: Path, testdata_dir: Path, output_dir: Path, config: ExomiserConfig
+    input_dir: Path,
+    testdata_dir: Path,
+    tool_input_commands_dir: Path,
+    raw_results_dir: Path,
+    exomiser_version: str,
+    variant_analysis: bool,
 ):
     """Run Exomiser with docker."""
     print("...running exomiser...")
     client = docker.from_env()
-    results_sub_output_dir = Path(output_dir).joinpath(
-        f"exomiser_{config.run.exomiser_configurations.exomiser_version.replace('.', '_')}"
-        f"_{os.path.basename(input_dir)}"
-    )
-    results_sub_output_dir.joinpath(f"{os.path.basename(testdata_dir)}_results").mkdir(
-        exist_ok=True, parents=True
-    )
-    write_edited_application_properties(config, input_dir, read_application_properties(config))
-    os.chdir(results_sub_output_dir.joinpath(f"{os.path.basename(testdata_dir)}_results"))
     batch_files = [
         file
-        for file in all_files(Path(results_sub_output_dir).joinpath("exomiser_batch_files"))
-        if file.name.startswith(os.path.basename(testdata_dir))
+        for file in all_files(tool_input_commands_dir)
+        if file.name.startswith(Path(testdata_dir).name)
     ]
     for file in batch_files:
-        docker_command = create_docker_run_command(config, file)
-        docker_mounts = mount_docker(input_dir, testdata_dir, output_dir, config)
+        docker_command = create_docker_run_command(file)
+        docker_mounts = mount_docker(
+            input_dir, testdata_dir, tool_input_commands_dir, raw_results_dir, variant_analysis
+        )
         vol = [
             docker_mounts.vcf_test_data,
             docker_mounts.phenopacket_test_data,
             docker_mounts.exomiser_data_dir,
             docker_mounts.exomiser_yaml,
-            docker_mounts.batch_file_path,
+            docker_mounts.tool_input_commands_path,
             docker_mounts.exomiser_application_properties,
+            docker_mounts.raw_results_dir,
         ]
         container = client.containers.run(
-            f"exomiser/exomiser-cli:{config.run.exomiser_configurations.exomiser_version}",
+            f"exomiser/exomiser-cli:{exomiser_version}",
             " ".join(docker_command),
             volumes=[x for x in vol if x is not None],
             detach=True,
@@ -321,10 +184,28 @@ def run_exomiser_docker(
         break
 
 
-def run_exomiser(input_dir: Path, testdata_dir, output_dir: Path, config: ExomiserConfig):
+def run_exomiser(
+    input_dir: Path,
+    testdata_dir,
+    config: ExomiserConfigurations,
+    output_dir: Path,
+    tool_input_commands_dir: Path,
+    raw_results_dir: Path,
+    exomiser_version: str,
+    variant_analysis: bool,
+):
     """Run Exomiser with specified environment."""
-    run_exomiser_local(
-        input_dir, testdata_dir, output_dir, config
-    ) if config.run.environment == "local" else run_exomiser_docker(
-        input_dir, testdata_dir, output_dir, config
+    (
+        run_exomiser_local(
+            input_dir, testdata_dir, config, output_dir, tool_input_commands_dir, exomiser_version
+        )
+        if config.environment == "local"
+        else run_exomiser_docker(
+            input_dir,
+            testdata_dir,
+            tool_input_commands_dir,
+            raw_results_dir,
+            exomiser_version,
+            variant_analysis,
+        )
     )