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

pheval_exomiser/prepare/create_batch_commands.py

@@ -10,14 +10,25 @@ from pheval.prepare.custom_exceptions import MutuallyExclusiveOptionError
 from pheval.utils.file_utils import all_files, files_with_suffix, obtain_closest_file_name
 from pheval.utils.phenopacket_utils import PhenopacketUtil, phenopacket_reader
 
+from pheval_exomiser.constants import (
+    EXOMISER_YAML_TARGET_DIRECTORY_DOCKER,
+    OUTPUT_OPTIONS_TARGET_DIRECTORY_DOCKER,
+    PHENOPACKET_TARGET_DIRECTORY_DOCKER,
+    RAW_RESULTS_TARGET_DIRECTORY_DOCKER,
+    VCF_TARGET_DIRECTORY_DOCKER,
+)
+
 
 @dataclass
 class ExomiserCommandLineArguments:
     """Store command line arguments for each phenopacket to be run with Exomiser."""
 
     sample: Path
-    vcf_file: Path
-    vcf_assembly: str
+    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
     output_options_file: Optional[Path] = None
 
 
@@ -26,34 +37,28 @@ def get_all_files_from_output_opt_directory(output_options_dir: Path) -> list[Pa
     return None if output_options_dir is None else all_files(output_options_dir)
 
 
-# def edit_output_options_file_output_prefix(output_options_file: Path, phenopacket_path: Path) -> Path:
-#     with open(output_options_file) as output_options:
-#         output_opt = yaml.safe_load(output_options)
-#     output_options.close()
-#     output_opt['outputPrefix'] = output_options_file.absolute().parents[0].joinpath(phenopacket_path.stem)
-#     with open
-#     (output_options_file.absolute().parents[0].joinpath(phenopacket_path.stem + "-" + str(output_options_file.name)),
-#               'w') as correct_prefixed:
-#         yaml.dump(output_opt, correct_prefixed)
-#     correct_prefixed.close()
-#     return
-#     output_options_file.absolute().parents[0].joinpath(phenopacket_path.stem + "-" + str(output_options_file.name))
-
-
 class CommandCreator:
     """Create a command for a phenopacket."""
 
     def __init__(
         self,
+        environment: str,
         phenopacket_path: Path,
         phenopacket: Phenopacket or Family,
+        variant_analysis: bool,
         output_options_dir_files: list[Path] or None,
         output_options_file: Path or None,
+        raw_results_dir: Path or None,
+        analysis_yaml: Path or None,
     ):
+        self.environment = environment
         self.phenopacket_path = phenopacket_path
         self.phenopacket = phenopacket
+        self.variant_analysis = variant_analysis
         self.output_options_dir_files = output_options_dir_files
         self.output_options_file = output_options_file
+        self.results_dir = raw_results_dir
+        self.analysis_yaml = analysis_yaml
 
     def assign_output_options_file(self) -> Path or None:
         """Return the path of a single output option yaml if specified,
@@ -67,32 +72,75 @@ class CommandCreator:
                 else obtain_closest_file_name(self.phenopacket_path, self.output_options_dir_files)
             )
 
-    def add_command_line_arguments(self, vcf_dir: Path) -> ExomiserCommandLineArguments:
-        """Return a dataclass of all the command line arguments corresponding to phenopacket sample."""
+    def add_phenotype_only_arguments(self) -> ExomiserCommandLineArguments:
+        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)}",
+                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
+                    else None
+                ),
+                raw_results_dir=RAW_RESULTS_TARGET_DIRECTORY_DOCKER,
+            )
+        elif self.environment == "local":
+            return ExomiserCommandLineArguments(
+                sample=Path(self.phenopacket_path),
+                variant_analysis=self.variant_analysis,
+                output_options_file=output_options_file,
+                raw_results_dir=self.results_dir,
+            )
+
+    def add_variant_analysis_arguments(self, vcf_dir: Path) -> ExomiserCommandLineArguments:
         vcf_file_data = PhenopacketUtil(self.phenopacket).vcf_file_data(
             self.phenopacket_path, vcf_dir
         )
         output_options_file = self.assign_output_options_file()
-        if output_options_file is None:
+        if self.environment == "local":
             return ExomiserCommandLineArguments(
                 sample=Path(self.phenopacket_path),
                 vcf_file=Path(vcf_file_data.uri),
                 vcf_assembly=vcf_file_data.file_attributes["genomeAssembly"],
+                output_options_file=output_options_file,
+                variant_analysis=self.variant_analysis,
+                raw_results_dir=self.results_dir,
+                analysis_yaml=self.analysis_yaml,
             )
-        if output_options_file is not None:
+        elif self.environment == "docker":
             return ExomiserCommandLineArguments(
-                sample=Path(self.phenopacket_path),
-                vcf_file=Path(vcf_file_data.uri),
+                sample=f"{PHENOPACKET_TARGET_DIRECTORY_DOCKER}{Path(self.phenopacket_path.name)}",
+                vcf_file=f"{VCF_TARGET_DIRECTORY_DOCKER}{Path(vcf_file_data.uri).name}",
                 vcf_assembly=vcf_file_data.file_attributes["genomeAssembly"],
-                output_options_file=output_options_file,
+                output_options_file=(
+                    f"{OUTPUT_OPTIONS_TARGET_DIRECTORY_DOCKER}{Path(output_options_file).name}"
+                    if output_options_file is not None
+                    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}",
             )
 
+    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."""
+        return (
+            self.add_variant_analysis_arguments(vcf_dir)
+            if self.variant_analysis
+            else self.add_phenotype_only_arguments()
+        )
+
 
 def create_command_arguments(
+    environment: str,
     phenopacket_dir: Path,
+    phenotype_only: bool,
     vcf_dir: Path,
+    results_dir: Path or None,
     output_options_dir: Path or None = None,
     output_options_file: Path or None = None,
+    analysis_yaml: Path or None = None,
 ) -> list[ExomiserCommandLineArguments]:
     """Return a list of Exomiser command line arguments for a directory of phenopackets."""
     phenopacket_paths = files_with_suffix(phenopacket_dir, ".json")
@@ -100,12 +148,16 @@ def create_command_arguments(
     output_option_dir_files = get_all_files_from_output_opt_directory(output_options_dir)
     for phenopacket_path in phenopacket_paths:
         phenopacket = phenopacket_reader(phenopacket_path)
-        # output_options_file = edit_output_options_file_output_prefix(output_options_file,
-        #                                                              phenopacket_path) if output_options_file \
-        #                                                                                   is not None else None
         commands.append(
             CommandCreator(
-                phenopacket_path, phenopacket, output_option_dir_files, output_options_file
+                environment,
+                phenopacket_path,
+                phenopacket,
+                phenotype_only,
+                output_option_dir_files,
+                output_options_file,
+                results_dir,
+                analysis_yaml,
             ).add_command_line_arguments(vcf_dir)
         )
     return commands
@@ -114,92 +166,86 @@ def create_command_arguments(
 class CommandsWriter:
     """Write a command to file."""
 
-    def __init__(self, file: Path):
+    def __init__(self, file: Path, variant_analysis: bool):
         self.file = open(file, "w")
+        self.variant_analysis = variant_analysis
 
-    def write_command(
-        self, analysis_yaml: Path, command_arguments: ExomiserCommandLineArguments
-    ) -> None:
-        """Write a command out for exomiser to run."""
+    def write_basic_analysis_command(self, command_arguments: ExomiserCommandLineArguments):
+        """Write basic analysis command for Exomiser"""
         try:
             self.file.write(
                 "--analysis "
-                + str(analysis_yaml)
+                + str(command_arguments.analysis_yaml)
                 + " --sample "
                 + str(command_arguments.sample)
                 + " --vcf "
                 + str(command_arguments.vcf_file)
                 + " --assembly "
                 + command_arguments.vcf_assembly
-                + "\n"
+                + " --output-filename "
+                + f"{command_arguments.sample.stem}-exomiser"
             )
         except IOError:
             print("Error writing ", self.file)
 
-    def write_docker_command(
-        self, analysis_yaml: Path, command_arguments: ExomiserCommandLineArguments
-    ) -> None:
-        """Write a docker command out for exomiser to run."""
+    def write_results_dir(self, command_arguments: ExomiserCommandLineArguments) -> None:
+        """Write results directory for exomiser ≥13.2.0 to run."""
         try:
-            self.file.write(
-                "--analysis "
-                + str("/exomiser-yaml-template/" + Path(analysis_yaml).name)
-                + " --sample "
-                + str("/exomiser-testdata-phenopacket/" + command_arguments.sample.name)
-                + " --vcf "
-                + str("/exomiser-testdata-vcf/" + command_arguments.vcf_file.name)
-                + " --assembly "
-                + command_arguments.vcf_assembly
-                + "\n"
+            (
+                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)
 
-    def write_command_output_options(
-        self, analysis_yaml, command_arguments: ExomiserCommandLineArguments
-    ) -> None:
-        """Write a command out for exomiser to run - including output option file specified."""
+    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(
-                "--analysis "
-                + str(analysis_yaml)
-                + " --sample "
-                + str(command_arguments.sample)
-                + " --vcf "
-                + str(command_arguments.vcf_file)
-                + " --assembly "
-                + command_arguments.vcf_assembly
-                + " --output "
-                + str(command_arguments.output_options_file)
-                + "\n"
+            (
+                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)
 
-    def write_docker_command_output_options(
-        self, analysis_yaml, command_arguments: ExomiserCommandLineArguments
+    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.file.write("\n")
+
+    def write_basic_phenotype_only_command(
+        self, command_arguments: ExomiserCommandLineArguments
     ) -> None:
-        """Write a docker command out for exomiser to run - including output option file specified."""
+        """Write a phenotype-only command out for exomiser ≥13.2.0 to run."""
         try:
             self.file.write(
-                "--analysis "
-                + str("/exomiser-yaml-template/" + analysis_yaml.name)
-                + " --sample "
-                + str("/exomiser-testdata-phenopacket/" + command_arguments.sample.name)
-                + " --vcf "
-                + str("/exomiser-testdata-vcf/" + command_arguments.vcf_file.name)
-                + " --assembly "
-                + command_arguments.vcf_assembly
-                + " --output "
-                + str(
-                    "/exomiser-testdata-output-options/"
-                    + command_arguments.output_options_file.name
-                )
-                + "\n"
+                "--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"
             )
         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.file.write("\n")
+
+    def write_local_commands(self, command_arguments: ExomiserCommandLineArguments):
+        (
+            self.write_analysis_command(command_arguments)
+            if self.variant_analysis
+            else self.write_phenotype_only_command(command_arguments)
+        )
+
     def close(self) -> None:
         """Close file."""
         try:
@@ -213,64 +259,37 @@ class BatchFileWriter:
 
     def __init__(
         self,
-        analysis_yaml: Path,
         command_arguments_list: list[ExomiserCommandLineArguments],
+        variant_analysis: bool,
         output_dir: Path,
         batch_prefix: str,
     ):
-        self.analysis_yaml = analysis_yaml
         self.command_arguments_list = command_arguments_list
+        self.variant_analysis = variant_analysis
         self.output_dir = output_dir
         self.batch_prefix = batch_prefix
 
     def write_commands(self, commands_writer: CommandsWriter) -> None:
         """Write command arguments to a file."""
         for command_arguments in self.command_arguments_list:
-            commands_writer.write_command(
-                self.analysis_yaml, command_arguments
-            ) if command_arguments.output_options_file is None else commands_writer.write_command_output_options(
-                self.analysis_yaml, command_arguments
-            )
-        commands_writer.close()
-
-    def write_docker_commands(self, commands_writer: CommandsWriter) -> None:
-        """Write docker command arguments to a file."""
-        for command_arguments in self.command_arguments_list:
-            commands_writer.write_docker_command(
-                self.analysis_yaml, command_arguments
-            ) if command_arguments.output_options_file is None else commands_writer.write_docker_command_output_options(
-                self.analysis_yaml, command_arguments
-            )
+            commands_writer.write_local_commands(command_arguments)
         commands_writer.close()
 
     def write_temp_file(self) -> str:
         """Write commands out to a temporary file."""
         temp = tempfile.NamedTemporaryFile(delete=False)
-        commands_writer = CommandsWriter(Path(temp.name))
+        commands_writer = CommandsWriter(Path(temp.name), self.variant_analysis)
         self.write_commands(commands_writer)
         return temp.name
 
-    def write_docker_temp_file(self) -> str:
-        """Write docker commands out to a temporary file."""
-        temp = tempfile.NamedTemporaryFile(delete=False)
-        commands_writer = CommandsWriter(Path(temp.name))
-        self.write_docker_commands(commands_writer)
-        return temp.name
-
     def write_all_commands(self) -> None:
         """Write all commands out to a single file."""
         commands_writer = CommandsWriter(
-            Path(self.output_dir).joinpath(self.batch_prefix + "-exomiser-batch.txt")
+            Path(self.output_dir).joinpath(self.batch_prefix + "-exomiser-batch.txt"),
+            self.variant_analysis,
         )
         self.write_commands(commands_writer)
 
-    def write_all_docker_commands(self) -> None:
-        """Write all docker commands out to a single file."""
-        commands_writer = CommandsWriter(
-            Path(self.output_dir).joinpath(self.batch_prefix + "-exomiser-batch.txt")
-        )
-        self.write_docker_commands(commands_writer)
-
     def create_split_batch_files(self, max_jobs: int) -> None:
         """Split temp file into separate batch files, dependent on the number of max jobs allocated to each file."""
         temp_file_name = self.write_temp_file()
@@ -292,27 +311,6 @@ class BatchFileWriter:
         tmp_file.close()
         Path(temp_file_name).unlink()
 
-    def create_docker_split_batch_files(self, max_jobs: int) -> None:
-        """Split temp file into separate batch files, dependent on the number of max jobs allocated to each file."""
-        temp_file_name = self.write_docker_temp_file()
-        lines_per_file, f_name = max_jobs, 0
-        splitfile = None
-        with open(temp_file_name) as tmp_file:
-            for lineno, line in enumerate(tmp_file):
-                if lineno % lines_per_file == 0:
-                    f_name += 1
-                    if splitfile:
-                        splitfile.close()
-                    split_filename = Path(self.output_dir).joinpath(
-                        self.batch_prefix + "-exomiser-batch-{}.txt".format(f_name)
-                    )
-                    splitfile = open(split_filename, "w")
-                splitfile.write(line)
-            if splitfile:
-                splitfile.close()
-        tmp_file.close()
-        Path(temp_file_name).unlink()
-
 
 def create_batch_file(
     environment: str,
@@ -322,35 +320,37 @@ def create_batch_file(
     output_dir: Path,
     batch_prefix: str,
     max_jobs: int,
+    variant_analysis: bool,
+    results_dir: Path,
     output_options_dir: Path = None,
     output_options_file: Path = None,
 ) -> None:
     """Create Exomiser batch files."""
-    try:
-        Path(output_dir).joinpath("exomiser_batch_files").mkdir()
-    except FileExistsError:
-        pass
     command_arguments = create_command_arguments(
-        phenopacket_dir, vcf_dir, output_options_dir, output_options_file
+        environment,
+        phenopacket_dir,
+        variant_analysis,
+        vcf_dir,
+        results_dir,
+        output_options_dir,
+        output_options_file,
+        analysis,
     )
-    if environment == "local":
+    (
         BatchFileWriter(
-            analysis, command_arguments, output_dir.joinpath("exomiser_batch_files/"), batch_prefix
-        ).write_all_commands() if max_jobs == 0 else BatchFileWriter(
-            analysis, command_arguments, output_dir.joinpath("exomiser_batch_files/"), batch_prefix
-        ).create_split_batch_files(
-            max_jobs
-        )
-    elif environment == "docker":
-        BatchFileWriter(
-            analysis, command_arguments, output_dir.joinpath("exomiser_batch_files/"), batch_prefix
-        ).write_all_docker_commands() if max_jobs == 0 else BatchFileWriter(
-            analysis, command_arguments, output_dir.joinpath("exomiser_batch_files/"), batch_prefix
-        ).create_docker_split_batch_files(
-            max_jobs
-        )
-    else:
-        raise EnvironmentError
+            command_arguments,
+            variant_analysis,
+            output_dir,
+            batch_prefix,
+        ).write_all_commands()
+        if max_jobs == 0
+        else BatchFileWriter(
+            command_arguments,
+            variant_analysis,
+            output_dir,
+            batch_prefix,
+        ).create_split_batch_files(max_jobs)
+    )
 
 
 @click.command()
@@ -366,7 +366,7 @@ def create_batch_file(
 @click.option(
     "--analysis-yaml",
     "-a",
-    required=True,
+    required=False,
     metavar="FILE",
     type=Path,
     help="Path to the analysis .yml file.",
@@ -406,6 +406,20 @@ def create_batch_file(
     show_default=True,
     help="Number of jobs in each file.",
 )
+@click.option(
+    "--phenotype-only",
+    type=bool,
+    default=False,
+    cls=MutuallyExclusiveOptionError,
+    mutually_exclusive=["vcf_dir", "analysis_yaml"],
+    help="Run Exomiser with phenotype only preset - strongly recommended to run with versions 13.2.0 onwards.",
+)
+@click.option(
+    "--results-dir",
+    type=Path,
+    required=False,
+    help="Results directory for Exomiser results - compatible with versions 13.2.0 onwards.",
+)
 @click.option(
     "--output-options-dir",
     "-O",
@@ -432,12 +446,14 @@ def prepare_exomiser_batch(
     phenopacket_dir: Path,
     vcf_dir: Path,
     output_dir: Path,
-    batch_prefix,
-    max_jobs,
+    batch_prefix: str,
+    max_jobs: int,
+    phenotype_only: bool,
     output_options_dir: Path = None,
     output_options_file: Path = None,
 ):
     """Generate Exomiser batch files."""
+    Path(output_dir).joinpath("tool_input_commands").mkdir(exist_ok=True)
     create_batch_file(
         environment,
         analysis_yaml,
@@ -446,6 +462,7 @@ def prepare_exomiser_batch(
         output_dir,
         batch_prefix,
         max_jobs,
+        phenotype_only,
         output_options_dir,
         output_options_file,
     )

pheval_exomiser/prepare/tool_specific_configuration_options.py

@@ -0,0 +1,65 @@
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+
+class ApplicationProperties(BaseModel):
+    """
+    Class for defining the application.properties configurations.
+    Args:
+        remm_version (str): Version of the REMM database
+        cadd_version (str): Version of the CADD database
+        hg19_data_version (str): Data version of the hg19 Exomiser data
+        hg19_local_frequency_path (Path): The file name of the hg19 local frequency file
+        hg19_whitelist_path (Path): The file name of the hg19 whitelist.
+        hg38_data_version (str): Data version of the hg38 Exomiser data
+        hg38_local_frequency_path (Path): The file name of the hg38 local frequency file
+        hg38_whitelist_path (Path): The file name of the hg38 whitelist.
+        phenotype_data_version (str): Data version of the Exomiser phenotype data
+        cache_caffeine_spec (int): Cache limit
+    """
+
+    remm_version: str = Field(None)
+    cadd_version: str = Field(None)
+    hg19_data_version: str = Field(None)
+    hg19_local_frequency_path: Path = Field(None)
+    hg19_whitelist_path: Path = Field(None)
+    hg38_data_version: str = Field(None)
+    hg38_local_frequency_path: Path = Field(None)
+    hg38_whitelist_path: Path = Field(None)
+    phenotype_data_version: str = Field(None)
+    cache_type: str = Field(None)
+    cache_caffeine_spec: int = Field(None)
+
+
+class PostProcessing(BaseModel):
+    """
+    Class for defining the post-processing configurations.
+    Args:
+        score_name (str): Name of score to extract from results.
+        sort_order (str): Order to sort results
+    """
+
+    score_name: str = Field(...)
+    sort_order: str = Field(...)
+
+
+class ExomiserConfigurations(BaseModel):
+    """
+    Class for defining the Exomiser configurations in tool_specific_configurations field,
+    within the input_dir config.yaml
+    Args:
+        environment (str): Environment to run Exomiser, i.e., local/docker
+        exomiser_software_directory (Path): Directory name for Exomiser software directory
+        analysis_configuration_file (Path): The file name of the analysis configuration file located in the input_dir
+        max_jobs (int): Maximum number of jobs to run in a batch
+        application_properties (ApplicationProperties): application.properties configurations
+        post_process (PostProcessing): Post-processing configurations
+    """
+
+    environment: str = Field(...)
+    exomiser_software_directory: Path = Field(...)
+    analysis_configuration_file: Path = Field(...)
+    max_jobs: int = Field(...)
+    application_properties: ApplicationProperties = Field(...)
+    post_process: PostProcessing = Field(...)