pheval 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

pheval/post_processing/phenopacket_truth_set.py

@@ -1,5 +1,4 @@
 from pathlib import Path
-from typing import List
 
 import polars as pl
 
@@ -56,7 +55,7 @@ class PhenopacketTruthSet:
         phenopacket = phenopacket_reader(phenopacket_path)
         return PhenopacketUtil(phenopacket)
 
-    def _get_causative_genes(self, phenopacket_name: str) -> List[ProbandCausativeGene]:
+    def _get_causative_genes(self, phenopacket_name: str) -> list[ProbandCausativeGene]:
         """
         Get the causative genes for a given phenopacket.
         Args:
@@ -67,7 +66,7 @@ class PhenopacketTruthSet:
         phenopacket_util = self._get_phenopacket_util(phenopacket_name)
         return phenopacket_util.diagnosed_genes()
 
-    def _get_causative_variants(self, phenopacket_name: str) -> List[GenomicVariant]:
+    def _get_causative_variants(self, phenopacket_name: str) -> list[GenomicVariant]:
         """
         Get the causative variants for a given phenopacket.
         Args:
@@ -78,7 +77,7 @@ class PhenopacketTruthSet:
         phenopacket_util = self._get_phenopacket_util(phenopacket_name)
         return phenopacket_util.diagnosed_variants()
 
-    def _get_causative_diseases(self, phenopacket_name: str) -> List[ProbandDisease]:
+    def _get_causative_diseases(self, phenopacket_name: str) -> list[ProbandDisease]:
         """
         Get the diseases for a given phenopacket.
         Args:
@@ -133,11 +132,7 @@ class PhenopacketTruthSet:
             )
             .with_columns(pl.col("rank").cast(pl.Int64))
             .select(classified_results.columns)
-            .vstack(
-                classified_results.filter(
-                    ~pl.col("gene_symbol").is_in(ranked_results["gene_symbol"])
-                )
-            )
+            .vstack(classified_results.filter(~pl.col("gene_symbol").is_in(ranked_results["gene_symbol"])))
         )
 
     def classified_variant(self, result_name: str) -> pl.DataFrame:
@@ -181,11 +176,7 @@ class PhenopacketTruthSet:
             ranked_results.with_columns(
                 [
                     pl.struct(["chrom", "start", "end", "ref", "alt"])
-                    .is_in(
-                        classified_results.select(
-                            pl.struct(["chrom", "start", "end", "ref", "alt"])
-                        ).to_series()
-                    )
+                    .is_in(classified_results.select(pl.struct(["chrom", "start", "end", "ref", "alt"])).to_series())
                     .alias("true_positive")
                 ]
             )
@@ -194,17 +185,13 @@ class PhenopacketTruthSet:
             .vstack(
                 classified_results.filter(
                     ~pl.struct(["chrom", "start", "end", "ref", "alt"]).is_in(
-                        ranked_results.select(
-                            pl.struct(["chrom", "start", "end", "ref", "alt"])
-                        ).to_series()
+                        ranked_results.select(pl.struct(["chrom", "start", "end", "ref", "alt"])).to_series()
                     )
                 )
             )
         )
 
-    def classified_disease(
-        self, result_name: str, mondo_mapping_table: pl.DataFrame
-    ) -> pl.DataFrame:
+    def classified_disease(self, result_name: str, mondo_mapping_table: pl.DataFrame) -> pl.DataFrame:
         """
         Classify disease results for a given phenopacket.
         Args:
@@ -225,9 +212,7 @@ class PhenopacketTruthSet:
                 pl.lit(0).cast(pl.Int64).alias("rank"),
                 pl.lit(True).alias("true_positive"),
                 pl.col("disease_identifier")
-                .map_elements(
-                    lambda x: map_disease_id(x, mondo_mapping_table), return_dtype=pl.Utf8
-                )
+                .map_elements(lambda x: map_disease_id(x, mondo_mapping_table), return_dtype=pl.Utf8)
                 .alias("mondo_identifier"),
             ]
         )
@@ -260,15 +245,9 @@ class PhenopacketTruthSet:
         )
         return (
             ranked_results.with_columns(
-                (
-                    pl.col("disease_identifier").is_in(classified_results["disease_identifier"])
-                ).alias("true_positive")
+                (pl.col("mondo_identifier").is_in(classified_results["mondo_identifier"])).alias("true_positive")
             )
             .with_columns(pl.col("rank").cast(pl.Int64))
             .select(classified_results.columns)
-            .vstack(
-                classified_results.filter(
-                    ~pl.col("disease_identifier").is_in(ranked_results["disease_identifier"])
-                )
-            )
+            .vstack(classified_results.filter(~pl.col("mondo_identifier").is_in(ranked_results["mondo_identifier"])))
         )

pheval/post_processing/post_processing.py

@@ -1,6 +1,6 @@
+from collections.abc import Callable
 from enum import Enum
 from pathlib import Path
-from typing import Callable, Tuple
 
 import polars as pl
 
@@ -57,7 +57,7 @@ def _rank_results(results: pl.DataFrame, sort_order: SortOrder) -> pl.DataFrame:
         results = (
             results.sort("score", descending=sort_descending)
             .with_columns(
-                pl.struct(["score"] + group_by)
+                pl.struct(["score"] + group_by)  # noqa
                 .rank(method="dense", descending=sort_descending)
                 .cast(pl.Int32)
                 .alias("min_rank")
@@ -89,9 +89,7 @@ def _write_gene_result(ranked_results: pl.DataFrame, output_file: Path) -> None:
         ranked_results ([PhEvalResult]): List of ranked PhEval gene results.
         output_file (Path): Path to the output file.
     """
-    gene_output = ranked_results.select(
-        ["rank", "score", "gene_symbol", "gene_identifier", "true_positive"]
-    )
+    gene_output = ranked_results.select(["rank", "score", "gene_symbol", "gene_identifier", "true_positive"])
     _write_results_file(output_file, gene_output)
 
 
@@ -127,15 +125,11 @@ def _write_disease_result(ranked_results: pl.DataFrame, output_file: Path) -> No
         ranked_results ([PhEvalResult]): List of ranked PhEval disease results.
         output_file (Path): Path to the output file.
     """
-    disease_output = ranked_results.select(
-        ["rank", "score", "disease_identifier", "mondo_identifier", "true_positive"]
-    )
+    disease_output = ranked_results.select(["rank", "score", "disease_identifier", "mondo_identifier", "true_positive"])
     _write_results_file(output_file, disease_output)
 
 
-def _get_result_type(
-    result_type: ResultType, phenopacket_truth_set: PhenopacketTruthSet
-) -> Tuple[Callable, Callable]:
+def _get_result_type(result_type: ResultType, phenopacket_truth_set: PhenopacketTruthSet) -> tuple[Callable, Callable]:
     """
     Get the methods for extracting the entity and writing the result for a given result type.
     Args:
@@ -156,9 +150,7 @@ def _get_result_type(
             )
 
 
-def create_empty_pheval_result(
-    phenopacket_dir: Path, output_dir: Path, result_type: ResultType
-) -> None:
+def create_empty_pheval_result(phenopacket_dir: Path, output_dir: Path, result_type: ResultType) -> None:
     """
     Create an empty PhEval result for a given result type (gene, variant, or disease).
 
@@ -176,10 +168,7 @@ def create_empty_pheval_result(
     """
     if result_type in executed_results:
         return
-    logger.info(
-        f"Writing classified results for {len(all_files(phenopacket_dir))} "
-        f"phenopackets to {output_dir}"
-    )
+    logger.info(f"Writing classified results for {len(all_files(phenopacket_dir))} phenopackets to {output_dir}")
     executed_results.add(result_type)
     phenopacket_truth_set = PhenopacketTruthSet(phenopacket_dir)
     classify_method, write_method = _get_result_type(result_type, phenopacket_truth_set)
@@ -209,13 +198,9 @@ def generate_gene_result(
         phenopacket_dir (Path): Path to the Phenopacket directory
     """
     output_file = output_dir.joinpath(f"pheval_gene_results/{result_path.stem}-gene_result.parquet")
-    create_empty_pheval_result(
-        phenopacket_dir, output_dir.joinpath("pheval_gene_results"), ResultType.GENE
-    )
+    create_empty_pheval_result(phenopacket_dir, output_dir.joinpath("pheval_gene_results"), ResultType.GENE)
     ranked_results = _rank_results(results, sort_order)
-    classified_results = PhenopacketTruthSet(phenopacket_dir).merge_gene_results(
-        ranked_results, output_file
-    )
+    classified_results = PhenopacketTruthSet(phenopacket_dir).merge_gene_results(ranked_results, output_file)
     _write_gene_result(classified_results, output_file)
 
 
@@ -236,9 +221,7 @@ def generate_variant_result(
         result_path (Path): Path to the tool-specific result file.
         phenopacket_dir (Path): Path to the Phenopacket directory
     """
-    output_file = output_dir.joinpath(
-        f"pheval_variant_results/{result_path.stem}-variant_result.parquet"
-    )
+    output_file = output_dir.joinpath(f"pheval_variant_results/{result_path.stem}-variant_result.parquet")
     create_empty_pheval_result(
         phenopacket_dir,
         output_dir.joinpath("pheval_variant_results"),
@@ -247,9 +230,7 @@ def generate_variant_result(
     ranked_results = _rank_results(results, sort_order).with_columns(
         pl.concat_str(["chrom", "start", "ref", "alt"], separator="-").alias("variant_id")
     )
-    classified_results = PhenopacketTruthSet(phenopacket_dir).merge_variant_results(
-        ranked_results, output_file
-    )
+    classified_results = PhenopacketTruthSet(phenopacket_dir).merge_variant_results(ranked_results, output_file)
     _write_variant_result(classified_results, output_file)
 
 
@@ -270,9 +251,7 @@ def generate_disease_result(
         result_path (Path): Path to the tool-specific result file.
         phenopacket_dir (Path): Path to the Phenopacket directory
     """
-    output_file = output_dir.joinpath(
-        f"pheval_disease_results/{result_path.stem}-disease_result.parquet"
-    )
+    output_file = output_dir.joinpath(f"pheval_disease_results/{result_path.stem}-disease_result.parquet")
     create_empty_pheval_result(
         phenopacket_dir,
         output_dir.joinpath("pheval_disease_results"),

pheval/post_processing/validate_result_format.py

@@ -1,6 +1,6 @@
+from collections.abc import Callable
 from enum import Enum
 from functools import wraps
-from typing import Callable
 
 import polars as pl
 
@@ -63,9 +63,7 @@ class ResultSchema(Enum):
                 raise ValueError(f"Missing required column: {col_name}")
 
             if results.schema[col_name] != expected_type:
-                raise TypeError(
-                    f"Column '{col_name}' has type {results.schema[col_name]}, expected {expected_type}"
-                )
+                raise TypeError(f"Column '{col_name}' has type {results.schema[col_name]}, expected {expected_type}")
 
         return True
 

pheval/prepare/create_noisy_phenopackets.py

@@ -1,7 +1,6 @@
 import random
 import time
 from pathlib import Path
-from typing import List, Union
 
 from oaklib.implementations.pronto.pronto_implementation import ProntoImplementation
 from oaklib.resource import OntologyResource
@@ -19,7 +18,7 @@ from pheval.utils.phenopacket_utils import (
 logger = get_logger()
 
 
-def load_ontology(local_cached_ontology: Path = None) -> ProntoImplementation:
+def load_ontology(local_cached_ontology: Path | None = None) -> ProntoImplementation:
     """
     Load the Human Phenotype Ontology (HPO).
     Args:
@@ -78,14 +77,14 @@ class HpoRandomiser:
             PhenotypicFeature: The PhenotypicFeature object representing the retrieved HPO term.
         """
         rels = self.hpo_ontology.entity_alias_map(hpo_id)
-        hpo_term = "".join(rels[(list(rels.keys())[0])])
+        hpo_term = "".join(rels[next(iter(rels))])
         return PhenotypicFeature(type=OntologyClass(id=hpo_id, label=hpo_term))
 
     @staticmethod
     def retain_real_patient_terms(
-        phenotypic_features: List[PhenotypicFeature],
+        phenotypic_features: list[PhenotypicFeature],
         number_of_scrambled_terms: int,
-    ) -> List[PhenotypicFeature]:
+    ) -> list[PhenotypicFeature]:
         """
         Return a list of real patient HPO terms, retaining a specific number of non-scrambled terms.
 
@@ -104,10 +103,10 @@ class HpoRandomiser:
 
     def convert_patient_terms_to_parent(
         self,
-        phenotypic_features: List[PhenotypicFeature],
-        retained_phenotypic_features: List[PhenotypicFeature],
+        phenotypic_features: list[PhenotypicFeature],
+        retained_phenotypic_features: list[PhenotypicFeature],
         number_of_scrambled_terms: int,
-    ) -> List[PhenotypicFeature]:
+    ) -> list[PhenotypicFeature]:
         """
         Convert a subset of patient HPO terms to their respective parent terms.
 
@@ -133,7 +132,7 @@ class HpoRandomiser:
         for term in hpo_terms_to_be_changed:
             if self.hpo_ontology.label(term.type.id).startswith("obsolete"):
                 obsolete_term = self.hpo_ontology.entity_metadata_map(term.type.id)
-                updated_term = list(obsolete_term.values())[0][0]
+                updated_term = next(iter(obsolete_term.values()))[0]
                 parents = self.hpo_ontology.hierarchical_parents(updated_term)
             else:
                 parents = self.hpo_ontology.hierarchical_parents(term.type.id)
@@ -143,7 +142,7 @@ class HpoRandomiser:
                 parent_terms.append(self.retrieve_hpo_term(random.choice(parents)))
         return parent_terms
 
-    def create_random_hpo_terms(self, number_of_scrambled_terms: int) -> List[PhenotypicFeature]:
+    def create_random_hpo_terms(self, number_of_scrambled_terms: int) -> list[PhenotypicFeature]:
         """
         Generate a list of random HPO terms.
 
@@ -153,15 +152,13 @@ class HpoRandomiser:
         Returns:
             List[PhenotypicFeature]: A list of randomly selected HPO terms.
         """
-        random_ids = list(
-            random.sample(sorted(self.phenotypic_abnormalities), number_of_scrambled_terms)
-        )
+        random_ids = list(random.sample(sorted(self.phenotypic_abnormalities), number_of_scrambled_terms))
         return [self.retrieve_hpo_term(random_id) for random_id in random_ids]
 
     def randomise_hpo_terms(
         self,
-        phenotypic_features: List[PhenotypicFeature],
-    ) -> List[PhenotypicFeature]:
+        phenotypic_features: list[PhenotypicFeature],
+    ) -> list[PhenotypicFeature]:
         """
         Randomise the provided phenotypic features by combining retained, parent-converted, and random HPO terms.
 
@@ -181,9 +178,7 @@ class HpoRandomiser:
             of randomised HPO terms to be used in the phenotypic features.
         """
         number_of_scrambled_terms = self.scramble_factor_proportions(phenotypic_features)
-        retained_patient_terms = self.retain_real_patient_terms(
-            phenotypic_features, number_of_scrambled_terms
-        )
+        retained_patient_terms = self.retain_real_patient_terms(phenotypic_features, number_of_scrambled_terms)
         return (
             retained_patient_terms
             + self.convert_patient_terms_to_parent(
@@ -194,8 +189,8 @@ class HpoRandomiser:
 
     def add_noise_to_phenotypic_profile(
         self,
-        phenopacket: Union[Phenopacket, Family],
-    ) -> Union[Phenopacket, Family]:
+        phenopacket: Phenopacket | Family,
+    ) -> Phenopacket | Family:
         """
         Randomise the phenotypic profile of a Phenopacket or Family.
 
@@ -207,9 +202,7 @@ class HpoRandomiser:
         """
         phenotypic_features = PhenopacketUtil(phenopacket).observed_phenotypic_features()
         random_phenotypes = self.randomise_hpo_terms(phenotypic_features)
-        randomised_phenopacket = PhenopacketRebuilder(phenopacket).add_randomised_hpo(
-            random_phenotypes
-        )
+        randomised_phenopacket = PhenopacketRebuilder(phenopacket).add_randomised_hpo(random_phenotypes)
         return randomised_phenopacket
 
     def create_scrambled_phenopacket(
@@ -283,13 +276,9 @@ def scramble_phenopackets(
     ontology = load_ontology(local_cached_ontology)
     if phenopacket_path is not None:
         logger.info(f"Scrambling {phenopacket_path}.")
-        HpoRandomiser(ontology, scramble_factor).create_scrambled_phenopacket(
-            output_dir, phenopacket_path
-        )
+        HpoRandomiser(ontology, scramble_factor).create_scrambled_phenopacket(output_dir, phenopacket_path)
     elif phenopacket_dir is not None:
-        logger.info(
-            f"Scrambling {len(all_files(phenopacket_dir))} phenopackets in {phenopacket_dir}."
-        )
+        logger.info(f"Scrambling {len(all_files(phenopacket_dir))} phenopackets in {phenopacket_dir}.")
         HpoRandomiser(ontology, scramble_factor).create_scrambled_phenopackets(
             output_dir,
             phenopacket_dir,

pheval/prepare/create_spiked_vcf.py

@@ -6,7 +6,6 @@ import urllib.parse
 from copy import copy
 from dataclasses import dataclass
 from pathlib import Path
-from typing import List, Union
 
 from phenopackets import Family, File, Phenopacket
 
@@ -90,7 +89,7 @@ class VcfHeader:
     chr_status: bool
 
 
-def read_vcf(vcf_file: Path) -> List[str]:
+def read_vcf(vcf_file: Path) -> list[str]:
     """
     Read the contents of a VCF file into memory, handling both uncompressed and gzipped files.
 
@@ -102,9 +101,7 @@ def read_vcf(vcf_file: Path) -> List[str]:
     """
     open_fn = gzip.open if is_gzipped(vcf_file) else open
     vcf = open_fn(vcf_file)
-    vcf_contents = (
-        [line.decode() for line in vcf.readlines()] if is_gzipped(vcf_file) else vcf.readlines()
-    )
+    vcf_contents = [line.decode() for line in vcf.readlines()] if is_gzipped(vcf_file) else vcf.readlines()
     vcf.close()
     return vcf_contents
 
@@ -133,20 +130,14 @@ class VcfHeaderParser:
         for line in self.vcf_contents:
             if line.startswith("##contig=<ID"):
                 tokens = line.split(",")
-                chromosome = re.sub(
-                    r"^.*?ID=", "", [token for token in tokens if "ID=" in token][0]
-                )
+                chromosome = re.sub(r"^.*?ID=", "", next(token for token in tokens if "ID=" in token))
                 if "chr" in chromosome:
                     chr_status = True
                     chromosome = chromosome.replace("chr", "")
-                contig_length = re.sub(
-                    "[^0-9]+",
-                    "",
-                    [token for token in tokens if "length=" in token][0],
-                )
+                contig_length = re.sub("[^0-9]+", "", next(token for token in tokens if "length=" in token))
                 vcf_assembly[chromosome] = int(contig_length)
                 vcf_assembly = {i: vcf_assembly[i] for i in vcf_assembly if i.isdigit()}
-        assembly = [k for k, v in genome_assemblies.items() if v == vcf_assembly][0]
+        assembly = next(k for k, v in genome_assemblies.items() if v == vcf_assembly)
         return assembly, chr_status
 
     def parse_sample_id(self) -> str:
@@ -184,7 +175,7 @@ class VcfFile:
     """
 
     vcf_file_name: str = None
-    vcf_contents: List[str] = None
+    vcf_contents: list[str] = None
     vcf_header: VcfHeader = None
 
     @staticmethod
@@ -205,7 +196,7 @@ class VcfFile:
 
 def select_vcf_template(
     phenopacket_path: Path,
-    proband_causative_variants: List[ProbandCausativeVariant],
+    proband_causative_variants: list[ProbandCausativeVariant],
     hg19_vcf_info: VcfFile,
     hg38_vcf_info: VcfFile,
     hg19_vcf_dir: Path,
@@ -241,9 +232,7 @@ def select_vcf_template(
         else:
             raise InputError("Must specify hg38 template VCF!")
     else:
-        raise IncompatibleGenomeAssemblyError(
-            proband_causative_variants[0].assembly, phenopacket_path
-        )
+        raise IncompatibleGenomeAssemblyError(proband_causative_variants[0].assembly, phenopacket_path)
 
 
 def check_variant_assembly(
@@ -269,16 +258,10 @@ def check_variant_assembly(
         raise ValueError("Too many genome assemblies!")
     if phenopacket_assembly[0] not in compatible_genome_assembly:
         raise IncompatibleGenomeAssemblyError(phenopacket_assembly, phenopacket_path)
-    if (
-        phenopacket_assembly[0] in {"hg19", "GRCh37"}
-        and vcf_header.assembly not in {"hg19", "GRCh37"}
-    ) or (
-        phenopacket_assembly[0] in {"hg38", "GRCh38"}
-        and vcf_header.assembly not in {"hg38", "GRCh38"}
+    if (phenopacket_assembly[0] in {"hg19", "GRCh37"} and vcf_header.assembly not in {"hg19", "GRCh37"}) or (
+        phenopacket_assembly[0] in {"hg38", "GRCh38"} and vcf_header.assembly not in {"hg38", "GRCh38"}
     ):
-        raise IncompatibleGenomeAssemblyError(
-            assembly=phenopacket_assembly, phenopacket=phenopacket_path
-        )
+        raise IncompatibleGenomeAssemblyError(assembly=phenopacket_assembly, phenopacket=phenopacket_path)
 
 
 class VcfSpiker:
@@ -302,7 +285,7 @@ class VcfSpiker:
         self.proband_causative_variants = proband_causative_variants
         self.vcf_header = vcf_header
 
-    def construct_variant_entry(self, proband_variant_data: ProbandCausativeVariant) -> List[str]:
+    def construct_variant_entry(self, proband_variant_data: ProbandCausativeVariant) -> list[str]:
         """
         Construct variant entries.
 
@@ -337,7 +320,7 @@ class VcfSpiker:
             genotype_codes[proband_variant_data.genotype.lower()] + "\n",
         ]
 
-    def construct_vcf_records(self, template_vcf_name: str) -> List[str]:
+    def construct_vcf_records(self, template_vcf_name: str) -> list[str]:
         """
         Construct updated VCF records by inserting spiked variants into the correct positions within the VCF.
 
@@ -353,8 +336,7 @@ class VcfSpiker:
             matching_indices = [
                 i
                 for i, val in enumerate(updated_vcf_records)
-                if val.split("\t")[0] == variant_entry[0]
-                and int(val.split("\t")[1]) < int(variant_entry[1])
+                if val.split("\t")[0] == variant_entry[0] and int(val.split("\t")[1]) < int(variant_entry[1])
             ]
             if matching_indices:
                 logger.info(
@@ -372,7 +354,7 @@ class VcfSpiker:
             updated_vcf_records.insert(variant_entry_position, "\t".join(variant_entry))
         return updated_vcf_records
 
-    def construct_header(self, updated_vcf_records: List[str]) -> List[str]:
+    def construct_header(self, updated_vcf_records: list[str]) -> list[str]:
         """
         Construct the header of the VCF.
 
@@ -394,7 +376,7 @@ class VcfSpiker:
             updated_vcf_file.append(text)
         return updated_vcf_file
 
-    def construct_vcf(self, template_vcf_name: str) -> List[str]:
+    def construct_vcf(self, template_vcf_name: str) -> list[str]:
         """
         Construct the entire spiked VCF file by incorporating the spiked variants into the VCF.
 
@@ -412,7 +394,7 @@ class VcfWriter:
 
     def __init__(
         self,
-        vcf_contents: List[str],
+        vcf_contents: list[str],
         spiked_vcf_file_path: Path,
     ):
         """
@@ -454,13 +436,13 @@ class VcfWriter:
 
 
 def spike_vcf_contents(
-    phenopacket: Union[Phenopacket, Family],
+    phenopacket: Phenopacket | Family,
     phenopacket_path: Path,
     hg19_vcf_info: VcfFile,
     hg38_vcf_info: VcfFile,
     hg19_vcf_dir: Path,
     hg38_vcf_dir: Path,
-) -> tuple[str, List[str]]:
+) -> tuple[str, list[str]]:
     """
     Spike VCF records with variants obtained from a Phenopacket or Family.
 
@@ -486,9 +468,7 @@ def spike_vcf_contents(
         hg19_vcf_dir,
         hg38_vcf_dir,
     )
-    check_variant_assembly(
-        phenopacket_causative_variants, chosen_template_vcf.vcf_header, phenopacket_path
-    )
+    check_variant_assembly(phenopacket_causative_variants, chosen_template_vcf.vcf_header, phenopacket_path)
     return (
         chosen_template_vcf.vcf_header.assembly,
         VcfSpiker(
@@ -501,7 +481,7 @@ def spike_vcf_contents(
 
 def generate_spiked_vcf_file(
     output_dir: Path,
-    phenopacket: Union[Phenopacket, Family],
+    phenopacket: Phenopacket | Family,
     phenopacket_path: Path,
     hg19_vcf_info: VcfFile,
     hg38_vcf_info: VcfFile,
@@ -566,9 +546,7 @@ def spike_and_update_phenopacket(
         hg19_vcf_dir,
         hg38_vcf_dir,
     )
-    updated_phenopacket = PhenopacketRebuilder(phenopacket).add_spiked_vcf_path(
-        spiked_vcf_file_message
-    )
+    updated_phenopacket = PhenopacketRebuilder(phenopacket).add_spiked_vcf_path(spiked_vcf_file_message)
     write_phenopacket(updated_phenopacket, phenopacket_path)
 
 
@@ -598,9 +576,7 @@ def create_spiked_vcf(
         raise InputError("Either a hg19 template vcf or hg38 template vcf must be specified")
     hg19_vcf_info = VcfFile.populate_fields(hg19_template_vcf) if hg19_template_vcf else None
     hg38_vcf_info = VcfFile.populate_fields(hg38_template_vcf) if hg38_template_vcf else None
-    spike_and_update_phenopacket(
-        hg19_vcf_info, hg38_vcf_info, hg19_vcf_dir, hg38_vcf_dir, output_dir, phenopacket_path
-    )
+    spike_and_update_phenopacket(hg19_vcf_info, hg38_vcf_info, hg19_vcf_dir, hg38_vcf_dir, output_dir, phenopacket_path)
 
 
 def create_spiked_vcfs(
@@ -625,12 +601,7 @@ def create_spiked_vcfs(
     Raises:
         InputError: If both hg19_template_vcf and hg38_template_vcf are None.
     """
-    if (
-        hg19_template_vcf is None
-        and hg38_template_vcf is None
-        and hg19_vcf_dir is None
-        and hg38_vcf_dir is None
-    ):
+    if hg19_template_vcf is None and hg38_template_vcf is None and hg19_vcf_dir is None and hg38_vcf_dir is None:
         raise InputError("Need to specify a VCF!")
     hg19_vcf_info = VcfFile.populate_fields(hg19_template_vcf) if hg19_template_vcf else None
     hg38_vcf_info = VcfFile.populate_fields(hg38_template_vcf) if hg38_template_vcf else None
@@ -677,9 +648,7 @@ def spike_vcfs(
             hg38_vcf_dir,
         )
     elif phenopacket_dir is not None:
-        logger.info(
-            f"Spiking variants from {len(all_files(phenopacket_dir))} phenopackets in {phenopacket_dir}."
-        )
+        logger.info(f"Spiking variants from {len(all_files(phenopacket_dir))} phenopackets in {phenopacket_dir}.")
         create_spiked_vcfs(
             output_dir,
             phenopacket_dir,

pheval/prepare/custom_exceptions.py

@@ -21,19 +21,18 @@ class MutuallyExclusiveOptionError(Option):
         help_ = kwargs.get("help", "")
         if self.mutually_exclusive:
             ex_str = ", ".join(self.mutually_exclusive)
-            kwargs["help"] = help_ + (
-                " NOTE: This argument is mutually exclusive with " " arguments: [" + ex_str + "]."
-            )
-        super(MutuallyExclusiveOptionError, self).__init__(*args, **kwargs)
+            kwargs["help"] = help_ + (" NOTE: This argument is mutually exclusive with  arguments: [" + ex_str + "].")
+        super().__init__(*args, **kwargs)
 
     def handle_parse_result(self, ctx, opts, args):
         if self.mutually_exclusive.intersection(opts) and self.name in opts:
             raise UsageError(
-                "Illegal usage: `{}` is mutually exclusive with "
-                "arguments `{}`.".format(self.name, ", ".join(self.mutually_exclusive))
+                "Illegal usage: `{}` is mutually exclusive with arguments `{}`.".format(
+                    self.name, ", ".join(self.mutually_exclusive)
+                )
             )
 
-        return super(MutuallyExclusiveOptionError, self).handle_parse_result(ctx, opts, args)
+        return super().handle_parse_result(ctx, opts, args)
 
 
 class IncorrectFileFormatError(Exception):