pheval 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

pheval/prepare/create_noisy_phenopackets.py

@@ -0,0 +1,173 @@
+import random
+from pathlib import Path
+
+from oaklib.implementations.pronto.pronto_implementation import ProntoImplementation
+from oaklib.resource import OntologyResource
+from phenopackets import Family, OntologyClass, Phenopacket, PhenotypicFeature
+
+from pheval.utils.file_utils import files_with_suffix
+from pheval.utils.phenopacket_utils import (
+    PhenopacketRebuilder,
+    PhenopacketUtil,
+    phenopacket_reader,
+    write_phenopacket,
+)
+
+
+def load_ontology():
+    """Loads human phenotype ontology."""
+    resource = OntologyResource(slug="hp.obo", local=False)
+    return ProntoImplementation(resource)
+
+
+class HpoRandomiser:
+    """Randomises phenopacket phenotypic features."""
+
+    def __init__(self, hpo_ontology, scramble_factor: float):
+        self.hpo_ontology = hpo_ontology
+        self.phenotypic_abnormalities = set(hpo_ontology.roots(predicates=["HP:0000118"]))
+        self.scramble_factor = scramble_factor
+
+    def scramble_factor_proportions(self, phenotypic_features: list[PhenotypicFeature]):
+        """Calculate proportion of scrambled hpo terms from scramble factor."""
+        if len(phenotypic_features) == 1:
+            return 1
+        else:
+            return int(round(len(phenotypic_features) * self.scramble_factor, 0))
+
+    def retrieve_hpo_term(self, hpo_id: str) -> PhenotypicFeature:
+        """Retrieves term for hpo id."""
+        rels = self.hpo_ontology.entity_alias_map(hpo_id)
+        hpo_term = "".join(rels[(list(rels.keys())[0])])
+        return PhenotypicFeature(type=OntologyClass(id=hpo_id, label=hpo_term))
+
+    @staticmethod
+    def retain_real_patient_terms(
+        phenotypic_features: list[PhenotypicFeature],
+        number_of_scrambled_terms: int,
+    ) -> list[PhenotypicFeature]:
+        """Returns a list of the maximum number of real patient HPO terms."""
+        if len(phenotypic_features) > 1:
+            number_of_real_id = len(phenotypic_features) - number_of_scrambled_terms
+        else:
+            number_of_real_id = 1
+        return random.sample(phenotypic_features, number_of_real_id)
+
+    def convert_patient_terms_to_parent(
+        self,
+        phenotypic_features: list[PhenotypicFeature],
+        retained_phenotypic_features: list[PhenotypicFeature],
+        number_of_scrambled_terms: int,
+    ) -> list[PhenotypicFeature]:
+        """Returns a list of the HPO terms that have been converted to a parent term."""
+        remaining_hpo = [i for i in phenotypic_features if i not in retained_phenotypic_features]
+        if len(remaining_hpo) == 0:
+            number_of_scrambled_terms = 0
+        hpo_terms_to_be_changed = list(random.sample(remaining_hpo, number_of_scrambled_terms))
+        parent_terms = []
+        for term in hpo_terms_to_be_changed:
+            try:
+                parent_terms.append(
+                    self.retrieve_hpo_term(
+                        self.hpo_ontology.hierararchical_parents(term.type.id)[0]
+                    )
+                )
+            except IndexError:
+                obsolete_term = self.hpo_ontology.entity_metadata_map(term.type.id)
+                updated_term = list(obsolete_term.values())[0][0]
+                parent_terms.append(
+                    self.retrieve_hpo_term(
+                        self.hpo_ontology.hierararchical_parents(updated_term)[0]
+                    )
+                )
+        return parent_terms
+
+    def create_random_hpo_terms(self, number_of_scrambled_terms: int) -> list[PhenotypicFeature]:
+        """Returns a list of random HPO 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]:
+        """Returns a list of randomised HPO terms."""
+        number_of_scrambled_terms = self.scramble_factor_proportions(phenotypic_features)
+        retained_patient_terms = self.retain_real_patient_terms(
+            phenotypic_features, number_of_scrambled_terms
+        )
+        return (
+            retained_patient_terms
+            + self.convert_patient_terms_to_parent(
+                phenotypic_features, retained_patient_terms, number_of_scrambled_terms
+            )
+            + self.create_random_hpo_terms(number_of_scrambled_terms)
+        )
+
+
+def add_noise_to_phenotypic_profile(
+    hpo_randomiser: HpoRandomiser,
+    phenopacket: Phenopacket or Family,
+) -> Phenopacket or Family:
+    """Randomises the phenotypic profile of a phenopacket."""
+    # phenopacket_util = PhenopacketUtil(phenopacket)
+    # phenotypic_features = phenopacket_util.observed_phenotypic_features()
+    phenotypic_features = PhenopacketUtil(phenopacket).observed_phenotypic_features()
+    random_phenotypes = hpo_randomiser.randomise_hpo_terms(phenotypic_features)
+    randomised_phenopacket = PhenopacketRebuilder(phenopacket).add_randomised_hpo(random_phenotypes)
+    return randomised_phenopacket
+
+
+def create_scrambled_phenopacket(
+    output_dir: Path, phenopacket_path: Path, scramble_factor: float
+) -> None:
+    """Creates a scrambled phenopacket."""
+    try:
+        output_dir.mkdir()
+    except FileExistsError:
+        pass
+    ontology = load_ontology()
+    hpo_randomiser = HpoRandomiser(ontology, scramble_factor)
+    phenopacket = phenopacket_reader(phenopacket_path)
+    created_noisy_phenopacket = add_noise_to_phenotypic_profile(
+        hpo_randomiser,
+        phenopacket,
+    )
+    write_phenopacket(
+        created_noisy_phenopacket,
+        output_dir.joinpath(phenopacket_path.name),
+    )
+
+
+def create_scrambled_phenopackets(
+    output_dir: Path, phenopacket_dir: Path, scramble_factor: float
+) -> None:
+    """Creates scrambled phenopackets."""
+    try:
+        output_dir.mkdir()
+    except FileExistsError:
+        pass
+    ontology = load_ontology()
+    hpo_randomiser = HpoRandomiser(ontology, scramble_factor)
+    phenopacket_files = files_with_suffix(phenopacket_dir, ".json")
+    for phenopacket_path in phenopacket_files:
+        phenopacket = phenopacket_reader(phenopacket_path)
+        created_noisy_phenopacket = add_noise_to_phenotypic_profile(hpo_randomiser, phenopacket)
+        write_phenopacket(
+            created_noisy_phenopacket,
+            output_dir.joinpath(
+                phenopacket_path.name,
+            ),
+        )
+
+
+def scramble_phenopackets(
+    output_dir: Path, phenopacket_path: Path, phenopacket_dir: Path, scramble_factor: float
+) -> None:
+    """Create scrambled phenopackets from either a single phenopacket or directory of phenopackets."""
+    if phenopacket_path is not None:
+        create_scrambled_phenopacket(output_dir, phenopacket_path, scramble_factor)
+    elif phenopacket_dir is not None:
+        create_scrambled_phenopackets(output_dir, phenopacket_dir, scramble_factor)

pheval/prepare/create_spiked_vcf.py

@@ -0,0 +1,366 @@
+#!/usr/bin/python
+import gzip
+import logging
+import re
+import secrets
+import urllib.parse
+from copy import copy
+from dataclasses import dataclass
+from pathlib import Path
+
+from phenopackets import Family, File, Phenopacket
+
+from pheval.utils.phenopacket_utils import (
+    IncompatibleGenomeAssemblyError,
+    PhenopacketRebuilder,
+    PhenopacketUtil,
+    ProbandCausativeVariant,
+    phenopacket_reader,
+    write_phenopacket,
+)
+
+from .custom_exceptions import InputError
+from ..utils.file_utils import all_files, files_with_suffix, is_gzipped
+
+info_log = logging.getLogger("info")
+
+genome_assemblies = {
+    "GRCh38": {
+        "1": 248956422,
+        "2": 242193529,
+        "3": 198295559,
+        "4": 190214555,
+        "5": 181538259,
+        "6": 170805979,
+        "7": 159345973,
+        "8": 145138636,
+        "9": 138394717,
+        "10": 133797422,
+        "11": 135086622,
+        "12": 133275309,
+        "13": 114364328,
+        "14": 107043718,
+        "15": 101991189,
+        "16": 90338345,
+        "17": 83257441,
+        "18": 80373285,
+        "19": 58617616,
+        "20": 64444167,
+        "21": 46709983,
+        "22": 50818468,
+    },
+    "GRCh37": {
+        "1": 249250621,
+        "2": 243199373,
+        "3": 198022430,
+        "4": 191154276,
+        "5": 180915260,
+        "6": 171115067,
+        "7": 159138663,
+        "8": 146364022,
+        "9": 141213431,
+        "10": 135534747,
+        "11": 135006516,
+        "12": 133851895,
+        "13": 115169878,
+        "14": 107349540,
+        "15": 102531392,
+        "16": 90354753,
+        "17": 81195210,
+        "18": 78077248,
+        "19": 59128983,
+        "20": 63025520,
+        "21": 48129895,
+        "22": 51304566,
+    },
+}
+
+
+@dataclass
+class VcfHeader:
+    """Data obtained from VCF header"""
+
+    sample_id: str
+    assembly: str
+    chr_status: bool
+
+
+class VcfPicker:
+    """Chooses a VCF file from random for a directory if provided, otherwise selects the single template."""
+
+    def __init__(self, template_vcf: Path or None, vcf_dir: Path or None):
+        self.template_vcf = template_vcf
+        self.vcf_dir = vcf_dir
+
+    def pick_file_from_dir(self) -> Path:
+        """Selects a file from a directory at random."""
+        return secrets.choice(all_files(self.vcf_dir))
+
+    def pick_file(self) -> Path:
+        """Selects a VCF file from random when given a directory, if not, template vcf is assigned."""
+        return self.pick_file_from_dir() if self.vcf_dir is not None else self.template_vcf
+
+
+def read_vcf(vcf_file: Path) -> list[str]:
+    """Reads the contents of a VCF file into memory - handles both uncompressed and gzipped."""
+    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.close()
+    return vcf_contents
+
+
+class VcfHeaderParser:
+    """Parses the header of a VCF file."""
+
+    def __init__(self, vcf_contents: list[str]):
+        self.vcf_contents = vcf_contents
+
+    def parse_assembly(self) -> tuple[str, bool]:
+        """Parses the genome assembly and format of vcf_records."""
+        vcf_assembly = {}
+        chr_status = False
+        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]
+                )
+                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],
+                )
+                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]
+        return assembly, chr_status
+
+    def parse_sample_id(self) -> str:
+        """Parses the sample ID of the VCF."""
+        for line in self.vcf_contents:
+            if line.startswith("#CHROM"):
+                return line.split("\t")[9].rstrip()
+
+    def parse_vcf_header(self) -> VcfHeader:
+        """Parses the header of the VCF."""
+        assembly, chr_status = self.parse_assembly()
+        sample_id = self.parse_sample_id()
+        return VcfHeader(sample_id, assembly, chr_status)
+
+
+def check_variant_assembly(
+    proband_causative_variants: list[ProbandCausativeVariant],
+    vcf_header: VcfHeader,
+    phenopacket_path: Path,
+):
+    """Checks the assembly of the variant assembly against the VCF."""
+    compatible_genome_assembly = {"GRCh37", "hg19", "GRCh38", "hg38"}
+    phenopacket_assembly = list({variant.assembly for variant in proband_causative_variants})
+    if len(phenopacket_assembly) > 1:
+        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] != vcf_header.assembly:
+        raise IncompatibleGenomeAssemblyError(
+            assembly=phenopacket_assembly, phenopacket=phenopacket_path
+        )
+
+
+class VcfSpiker:
+    """Spikes proband variants into template VCF file contents."""
+
+    def __init__(
+        self,
+        vcf_contents: list[str],
+        proband_causative_variants: list[ProbandCausativeVariant],
+        vcf_header: VcfHeader,
+    ):
+        self.vcf_contents = vcf_contents
+        self.proband_causative_variants = proband_causative_variants
+        self.vcf_header = vcf_header
+
+    def construct_variant_entry(self, proband_variant_data: ProbandCausativeVariant) -> list[str]:
+        """Constructs variant entries."""
+        genotype_codes = {
+            "hemizygous": "0/1",
+            "homozygous": "1/1",
+            "heterozygous": "0/1",
+            "compound heterozygous": "0/1",
+        }
+        if self.vcf_header.chr_status is True and "chr" not in proband_variant_data.variant.chrom:
+            proband_variant_data.variant.chrom = "chr" + proband_variant_data.variant.chrom
+        return [
+            proband_variant_data.variant.chrom,
+            str(proband_variant_data.variant.pos),
+            ".",
+            proband_variant_data.variant.ref,
+            f"<{proband_variant_data.variant.alt}>"
+            if proband_variant_data.variant.ref == "N"
+            else proband_variant_data.variant.alt,
+            "100",
+            "PASS",
+            proband_variant_data.info
+            if proband_variant_data.info is not None
+            else "SPIKED_VARIANT_" + proband_variant_data.genotype.upper(),
+            "GT",
+            genotype_codes[proband_variant_data.genotype.lower()] + "\n",
+        ]
+
+    def construct_vcf_records(self):
+        """Inserts spiked variant into correct position within VCF."""
+        updated_vcf_records = copy(self.vcf_contents)
+        for variant in self.proband_causative_variants:
+            variant = self.construct_variant_entry(variant)
+            variant_entry_position = [
+                i
+                for i, val in enumerate(updated_vcf_records)
+                if val.split("\t")[0] == variant[0] and int(val.split("\t")[1]) < int(variant[1])
+            ][-1] + 1
+            updated_vcf_records.insert(variant_entry_position, "\t".join(variant))
+        return updated_vcf_records
+
+    def construct_header(self, updated_vcf_records) -> list[str]:
+        """Constructs the header of the VCF."""
+        updated_vcf_file = []
+        for line in updated_vcf_records:
+            text = line.replace(
+                self.vcf_header.sample_id,
+                self.proband_causative_variants[0].proband_id,
+            )
+            updated_vcf_file.append(text)
+        return updated_vcf_file
+
+    def construct_vcf(self) -> list[str]:
+        """Constructs the entire spiked VCF."""
+        return self.construct_header(self.construct_vcf_records())
+
+
+class VcfWriter:
+    def __init__(
+        self,
+        vcf_contents: list[str],
+        spiked_vcf_file_path: Path,
+    ):
+        self.vcf_contents = vcf_contents
+        self.spiked_vcf_file_path = spiked_vcf_file_path
+
+    def write_gzip(self) -> None:
+        """Writes gzipped vcf file."""
+        encoded_contents = [line.encode() for line in self.vcf_contents]
+        with gzip.open(self.spiked_vcf_file_path, "wb") as f:
+            for line in encoded_contents:
+                f.write(line)
+        f.close()
+
+    def write_uncompressed(self) -> None:
+        """Writes an uncompressed vcf file."""
+        with open(self.spiked_vcf_file_path, "w") as file:
+            file.writelines(self.vcf_contents)
+        file.close()
+
+    def write_vcf_file(self) -> None:
+        """Writes spiked vcf file."""
+        self.write_gzip() if is_gzipped(self.spiked_vcf_file_path) else self.write_uncompressed()
+
+
+def spike_vcf_contents(
+    phenopacket: Phenopacket or Family,
+    phenopacket_path: Path,
+    chosen_template_vcf: Path,
+) -> tuple[str, list[str]]:
+    """Spikes VCF records with variants."""
+    # this is a separate function to a click command as it will fail if annotated with click annotations
+    # and referenced from another click command
+    phenopacket_causative_variants = PhenopacketUtil(phenopacket).causative_variants()
+    vcf_contents = read_vcf(chosen_template_vcf)
+    vcf_header = VcfHeaderParser(vcf_contents).parse_vcf_header()
+    check_variant_assembly(phenopacket_causative_variants, vcf_header, phenopacket_path)
+    return (
+        vcf_header.assembly,
+        VcfSpiker(vcf_contents, phenopacket_causative_variants, vcf_header).construct_vcf(),
+    )
+
+
+def generate_spiked_vcf_file(
+    output_dir: Path,
+    phenopacket: Phenopacket or Family,
+    phenopacket_path: Path,
+    chosen_template_vcf: Path,
+) -> File:
+    """Writes spiked vcf contents to a new file."""
+    try:
+        output_dir.mkdir()
+        info_log.info(f" Created a directory {output_dir}")
+    except FileExistsError:
+        pass
+    vcf_assembly, spiked_vcf = spike_vcf_contents(
+        phenopacket, phenopacket_path, chosen_template_vcf
+    )
+    spiked_vcf_path = (
+        output_dir.joinpath(phenopacket_path.name.replace(".json", ".vcf.gz"))
+        if is_gzipped(chosen_template_vcf)
+        else output_dir.joinpath(phenopacket_path.name.replace(".json", ".vcf"))
+    )
+    VcfWriter(spiked_vcf, spiked_vcf_path).write_vcf_file()
+    return File(
+        uri=urllib.parse.unquote(spiked_vcf_path.as_uri()),
+        file_attributes={"fileFormat": "vcf", "genomeAssembly": vcf_assembly},
+    )
+
+
+def create_spiked_vcf(
+    output_dir: Path, phenopacket_path: Path, template_vcf_path: Path, vcf_dir: Path
+):
+    """Creates a spiked vcf for a phenopacket."""
+    if template_vcf_path is None and vcf_dir is None:
+        raise InputError("Either a template_vcf or vcf_dir must be specified")
+    vcf_file_path = VcfPicker(template_vcf_path, vcf_dir).pick_file()
+    phenopacket = phenopacket_reader(phenopacket_path)
+    spiked_vcf_file_message = generate_spiked_vcf_file(
+        output_dir, phenopacket, phenopacket_path, vcf_file_path
+    )
+    updated_phenopacket = PhenopacketRebuilder(phenopacket).add_spiked_vcf_path(
+        spiked_vcf_file_message
+    )
+    write_phenopacket(updated_phenopacket, phenopacket_path)
+
+
+def create_spiked_vcfs(
+    output_dir: Path, phenopacket_dir: Path, template_vcf_path: Path, vcf_dir: Path
+):
+    """Creates spiked vcfs for phenopackets."""
+    if template_vcf_path is None and vcf_dir is None:
+        raise InputError("Either a template_vcf or vcf_dir must be specified")
+    for phenopacket_path in files_with_suffix(phenopacket_dir, ".json"):
+        vcf_file_path = VcfPicker(template_vcf_path, vcf_dir).pick_file()
+        phenopacket = phenopacket_reader(phenopacket_path)
+        spiked_vcf_file_message = generate_spiked_vcf_file(
+            output_dir, phenopacket, phenopacket_path, vcf_file_path
+        )
+        updated_phenopacket = PhenopacketRebuilder(phenopacket).add_spiked_vcf_path(
+            spiked_vcf_file_message
+        )
+        write_phenopacket(updated_phenopacket, phenopacket_path)
+    # or made a lambda one-liner for maximum wtf...
+    # [spike_vcf(path, output_dir, template_vcf, vcf_dir) for path in phenopacket_dir.iterdir() if path.suffix ==
+    # ".json"]
+
+
+def spike_vcfs(
+    output_dir: Path,
+    phenopacket_path: Path,
+    phenopacket_dir: Path,
+    template_vcf_path: Path,
+    vcf_dir: Path,
+):
+    """Create spiked VCF from either a phenopacket or a phenopacket directory."""
+    if phenopacket_path is not None:
+        create_spiked_vcf(output_dir, phenopacket_path, template_vcf_path, vcf_dir)
+    elif phenopacket_dir is not None:
+        create_spiked_vcfs(output_dir, phenopacket_dir, template_vcf_path, vcf_dir)

pheval/prepare/custom_exceptions.py

@@ -0,0 +1,47 @@
+from click import Option, UsageError
+
+
+class InputError(Exception):
+    """Exception raised for missing required inputs."""
+
+    def __init__(self, file, message="Missing required input"):
+        self.file: str = file
+        self.message: str = message
+        super().__init__(self.message)
+
+    def __str__(self):
+        return f"{self.message} -> {self.file} "
+
+
+class MutuallyExclusiveOptionError(Option):
+    """Exception raised for when"""
+
+    def __init__(self, *args, **kwargs):
+        self.mutually_exclusive = set(kwargs.pop("mutually_exclusive", []))
+        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)
+
+    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))
+            )
+
+        return super(MutuallyExclusiveOptionError, self).handle_parse_result(ctx, opts, args)
+
+
+class IncorrectFileFormatError(Exception):
+    def __init__(self, file, expectation, message="Incorrect File Type"):
+        self.file: str = file
+        self.expectation: str = expectation
+        self.message: str = message
+        super().__init__(self.message)
+
+    def __str__(self):
+        return f"{self.message} -> {self.file} (expected {self.expectation})"

pheval/prepare/update_phenopacket.py

@@ -0,0 +1,53 @@
+from collections import defaultdict
+from pathlib import Path
+
+from pheval.utils.file_utils import all_files
+from pheval.utils.phenopacket_utils import (
+    GeneIdentifierUpdater,
+    PhenopacketRebuilder,
+    PhenopacketUtil,
+    create_hgnc_dict,
+    phenopacket_reader,
+    write_phenopacket,
+)
+
+
+def update_outdated_gene_context(
+    phenopacket_path: Path, gene_identifier: str, hgnc_data: defaultdict
+):
+    """Updates the gene context of the phenopacket."""
+    phenopacket = phenopacket_reader(phenopacket_path)
+    interpretations = PhenopacketUtil(phenopacket).interpretations()
+    updated_interpretations = GeneIdentifierUpdater(
+        hgnc_data=hgnc_data, gene_identifier=gene_identifier
+    ).update_genomic_interpretations_gene_identifier(interpretations)
+
+    return PhenopacketRebuilder(phenopacket).update_interpretations(updated_interpretations)
+
+
+def create_updated_phenopacket(gene_identifier: str, phenopacket_path: Path, output_dir: Path):
+    """Updates the gene context within the interpretations for a phenopacket."""
+    hgnc_data = create_hgnc_dict()
+    updated_phenopacket = update_outdated_gene_context(phenopacket_path, gene_identifier, hgnc_data)
+    write_phenopacket(updated_phenopacket, output_dir.joinpath(phenopacket_path.name))
+
+
+def create_updated_phenopackets(gene_identifier: str, phenopacket_dir: Path, output_dir: Path):
+    """Updates the gene context within the interpretations for phenopackets."""
+    hgnc_data = create_hgnc_dict()
+    for phenopacket_path in all_files(phenopacket_dir):
+        updated_phenopacket = update_outdated_gene_context(
+            phenopacket_path, gene_identifier, hgnc_data
+        )
+        write_phenopacket(updated_phenopacket, output_dir.joinpath(phenopacket_path.name))
+
+
+def update_phenopackets(
+    gene_identifier: str, phenopacket_path: Path, phenopacket_dir: Path, output_dir: Path
+):
+    """Update the gene identifiers in either a single phenopacket or a directory of phenopackets."""
+    output_dir.mkdir(exist_ok=True)
+    if phenopacket_path is not None:
+        create_updated_phenopacket(gene_identifier, phenopacket_path, output_dir)
+    elif phenopacket_dir is not None:
+        create_updated_phenopackets(gene_identifier, phenopacket_dir, output_dir)

pheval/resources/alternate_ouputs/CADA_results.txt

@@ -0,0 +1,11 @@
+rank    gene_id gene_name       score
+1       Entrez:368      ABCC6   84.62940470377605
+2       Entrez:5167     ENPP1   69.57813326517741
+3       Entrez:54790    TET2    57.23555533091227
+4       Entrez:64132    XYLT2   57.030126889546715
+5       Entrez:3949     LDLR    55.80375734965006
+6       Entrez:64240    ABCG5   53.74869124094645
+7       Entrez:348      APOE    53.691530545552574
+8       Entrez:462      SERPINC1        51.44988568623861
+9       Entrez:255738   PCSK9   50.51583385467529
+10      Entrez:2162     F13A1   50.0550905863444

pheval/resources/alternate_ouputs/DeepPVP_results.txt

@@ -0,0 +1,22 @@
+Chr	Start	Ref	Alt	GT	Gene	CADD	GWAVA	DANN	Sim_Score	Prediction_Score
+10	100177428	C	A	1/1	HPS1	46	0.436666666666666667	0.9972185359365543	0.9648632774654027	0.9213319434699428
+6	32489940	G	T,C	1/1	.	.	0.41	.	.	0.5740168850055932
+6	32489940	G	T,C	1/1	.	.	0.41	.	.	0.5740168850055932
+9	136328657	T	C,G	1/1	.	.	0.41	.	.	0.5740168850055932
+10	113940329	T	C,G	1/1	.	.	0.4066666666666667	.	.	0.5740168850055932
+19	42132273	C	T,A	1/1	.	.	0.41	.	.	0.5740168850055932
+14	21467913	T	G,A	1/1	.	.	0.42333333333333334	.	.	0.5735853467091718
+1	16354590	A	T,G	1/1	.	.	0.41333333333333333	.	.	0.5718396449188846
+12	52681925	A	C,T	1/1	.	.	0.38000000000000006	.	.	0.5711489183536179
+7	34192762	G	C,A	1/1	.	.	0.37666666666666665	.	.	0.5708847601387523
+11	125830970	A	T,G	1/1	.	.	0.3766666666666667	.	.	0.5708847601387523
+11	125830970	A	T,G	1/1	.	.	0.3766666666666667	.	.	0.5708847601387523
+7	156469133	C	G,T	1/1	.	.	0.4666666666666666	.	.	0.5692571159111212
+11	57155288	T	C,A	1/1	.	.	0.4666666666666666	.	.	0.5692571159111212
+2	130832444	C	A,T	1/1	.	.	0.3833333333333333	.	.	0.5689482176042727
+7	106508978	A	G,C	1/1	.	.	0.38333333333333336	.	.	0.5689482176042727
+10	61552692	G	T,C	1/1	.	.	0.3833333333333333	.	.	0.5689482176042727
+5	141336264	G	T,A	1/1	.	.	0.47666666666666674	.	.	0.5686996214945524
+5	141336264	G	T,A	1/1	.	.	0.47666666666666674	.	.	0.5686996214945524
+19	52004795	G	T,C	1/1	.	.	0.4633333333333334	.	.	0.5680430668280317
+11	75572808	G	A	1/1	UVRAG	29.8	0.6566666666666666	0.99870875812720883	.	0.5678185751935081