phylogenie 1.0.8__py3-none-any.whl → 2.0.1__py3-none-any.whl

phylogenie/backend/remaster/generate.py

@@ -1,187 +0,0 @@
-import re
-import subprocess
-from collections.abc import Iterable
-from xml.dom import minidom
-from xml.etree.ElementTree import Element, tostring
-
-from phylogenie.backend.remaster.reactions import (
-    DEFAULT_POPULATION,
-    SAMPLE_POPULATION,
-    PunctualReaction,
-    Reaction,
-)
-from phylogenie.skyline import skyline_parameter
-
-TREE_ID = "Tree"
-
-
-def _beautify_xml(xml: bytes) -> str:
-    xml_str = minidom.parseString(xml).toprettyxml(indent="\t")
-    xml_str = re.sub(r"\n\s*\n+", "\n", xml_str)
-    xml_str = xml_str.strip()
-    return xml_str
-
-
-def _generate_config_file(
-    output_xml_file: str,
-    tree_filename: str,
-    populations: list[str],
-    init_values: list[int],
-    sample_population: str,
-    reactions: Iterable[Reaction] | None = None,
-    punctual_reactions: Iterable[PunctualReaction] | None = None,
-    trajectory_attrs: dict[str, str] | None = None,
-    n_simulations: int = 1,
-) -> None:
-    simulate = Element("simulate", {"spec": "SimulatedTree", "id": TREE_ID})
-
-    if trajectory_attrs is None:
-        trajectory_attrs = {}
-    trajectory = Element(
-        "trajectory", {"spec": "StochasticTrajectory", **trajectory_attrs}
-    )
-
-    for population, init_value in zip(populations, init_values):
-        trajectory.append(
-            Element(
-                "population",
-                {"spec": "RealParameter", "id": population, "value": str(init_value)},
-            )
-        )
-    trajectory.append(
-        Element(
-            "samplePopulation",
-            {"spec": "RealParameter", "id": sample_population, "value": "0"},
-        )
-    )
-
-    if reactions is not None:
-        for reaction in reactions:
-            if not reaction.rate:
-                continue
-            rate = skyline_parameter(reaction.rate)
-            attrs = {
-                "spec": "Reaction",
-                "rate": " ".join(map(str, rate.value)),
-                "value": reaction.value,
-            }
-            if rate.change_times:
-                attrs["changeTimes"] = " ".join(map(str, rate.change_times))
-            trajectory.append(Element("reaction", attrs))
-
-    if punctual_reactions is not None:
-        for punctual_reaction in punctual_reactions:
-            attrs = {
-                "spec": "PunctualReaction",
-                "value": punctual_reaction.value,
-                "times": " ".join(map(str, punctual_reaction.times)),
-            }
-            if punctual_reaction.p is not None:
-                attrs["p"] = " ".join(map(str, punctual_reaction.p))
-            if punctual_reaction.n is not None:
-                attrs["n"] = " ".join(map(str, punctual_reaction.n))
-            trajectory.append(Element("reaction", attrs))
-
-    simulate.append(trajectory)
-
-    logger = Element(
-        "logger", {"spec": "Logger", "mode": "tree", "fileName": tree_filename}
-    )
-    logger.append(
-        Element(
-            "log",
-            {
-                "spec": "TypedTreeLogger",
-                "tree": f"@{TREE_ID}",
-                "removeSingletonNodes": "true",
-                "noLabels": "true",
-            },
-        )
-    )
-
-    run = Element("run", {"spec": "Simulator", "nSims": str(n_simulations)})
-    run.append(simulate)
-    run.append(logger)
-
-    beast = Element(
-        "beast",
-        {
-            "version": "2.0",
-            "namespace": ":".join(
-                ["beast.base.inference", "beast.base.inference.parameter", "remaster"]
-            ),
-        },
-    )
-    beast.append(run)
-
-    with open(output_xml_file, "w") as f:
-        f.write(_beautify_xml(tostring(beast, method="xml")))
-
-
-def _postprocess_tree(input_file: str, output_file: str, attributes: list[str]) -> None:
-
-    def _replace_metadata(match: re.Match[str]) -> str:
-        metadata = match.group(0)
-        attrs: list[tuple[str, str]] = re.findall(r'(\w+)=(".*?"|[^,)\]]+)', metadata)
-        values = [v.strip('"') for k, v in attrs if k in attributes]
-        return "|" + "|".join(values)
-
-    with open(input_file, "r") as infile:
-        with open(output_file, "w") as outfile:
-            for line in infile:
-                line = line.strip()
-                if line.lower().startswith("tree"):
-                    parts = line.split("=", 1)
-                    newick = parts[1].strip()
-                    transformed_newick = re.sub(
-                        r"\[\&[^\]]*\]", _replace_metadata, newick
-                    )
-                    outfile.write(transformed_newick + "\n")
-
-
-def generate_trees(
-    tree_filename: str,
-    populations: str | list[str] = DEFAULT_POPULATION,
-    init_population: str = DEFAULT_POPULATION,
-    sample_population: str = SAMPLE_POPULATION,
-    reactions: Iterable[Reaction] | None = None,
-    punctual_reactions: Iterable[PunctualReaction] | None = None,
-    trajectory_attrs: dict[str, str] | None = None,
-    output_xml_file: str | None = None,
-    n_simulations: int = 1,
-    seed: int | None = None,
-    beast_path: str = "beast",
-) -> None:
-    if isinstance(populations, str):
-        populations = [populations]
-    init_values = [0] * len(populations)
-    init_values[populations.index(init_population)] = 1
-
-    if output_xml_file is None:
-        xml_file = f"{tree_filename}-temp.xml"
-    else:
-        xml_file = output_xml_file
-
-    temp_tree_filename = f"{tree_filename}-temp.nex"
-    _generate_config_file(
-        output_xml_file=xml_file,
-        tree_filename=temp_tree_filename,
-        populations=populations,
-        init_values=init_values,
-        sample_population=sample_population,
-        reactions=reactions,
-        punctual_reactions=punctual_reactions,
-        trajectory_attrs=trajectory_attrs,
-        n_simulations=n_simulations,
-    )
-
-    cmd = [beast_path]
-    if seed is not None:
-        cmd.extend(["-seed", str(seed)])
-    cmd.append(xml_file)
-    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-
-    _postprocess_tree(temp_tree_filename, tree_filename, ["type", "time"])
-    if output_xml_file is None:
-        subprocess.run(["rm", xml_file], check=True)
-    subprocess.run(["rm", temp_tree_filename], check=True)

phylogenie/backend/remaster/reactions.py

@@ -1,165 +0,0 @@
-from dataclasses import dataclass
-
-import phylogenie.typings as pgt
-from phylogenie.skyline import (
-    SkylineMatrixCoercible,
-    SkylineParameterLike,
-    SkylineVectorCoercible,
-    skyline_matrix,
-    skyline_vector,
-)
-
-SAMPLE_POPULATION = "sample"
-DEFAULT_POPULATION = "X"
-
-
-@dataclass
-class Reaction:
-    rate: SkylineParameterLike
-    value: str
-
-
-@dataclass
-class PunctualReaction:
-    times: pgt.ManyScalars
-    value: str
-    p: pgt.ManyScalars | None = None
-    n: pgt.Many[int] | None = None
-
-
-def get_canonical_reactions(
-    populations: str | list[str] = DEFAULT_POPULATION,
-    sample_population: str = SAMPLE_POPULATION,
-    birth_rates: SkylineVectorCoercible = 0,
-    death_rates: SkylineVectorCoercible = 0,
-    sampling_rates: SkylineVectorCoercible = 0,
-    removal_probabilities: SkylineVectorCoercible = 0,
-    migration_rates: SkylineMatrixCoercible = 0,
-    birth_rates_among_demes: SkylineMatrixCoercible = 0,
-) -> list[Reaction]:
-    if isinstance(populations, str):
-        populations = [populations]
-    N = len(populations)
-
-    birth_rates = skyline_vector(birth_rates, N=N)
-    death_rates = skyline_vector(death_rates, N=N)
-    sampling_rates = skyline_vector(sampling_rates, N=N)
-    removal_probabilities = skyline_vector(removal_probabilities, N=N)
-    migration_rates = skyline_matrix(migration_rates, N=N, zero_diagonal=True)
-    birth_rates_among_demes = skyline_matrix(
-        birth_rates_among_demes, N=N, zero_diagonal=True
-    )
-
-    reactions: list[Reaction] = []
-    for i, population in enumerate(populations):
-        reactions.append(Reaction(birth_rates[i], f"{population} -> 2{population}"))
-        reactions.append(Reaction(death_rates[i], f"{population} -> 0"))
-        reactions.append(
-            Reaction(
-                sampling_rates[i] * removal_probabilities[i],
-                f"{population} -> {sample_population}",
-            )
-        )
-        reactions.append(
-            Reaction(
-                sampling_rates[i] * (1 - removal_probabilities[i]),
-                f"{population} -> {population} + {sample_population}",
-            )
-        )
-        for j, other_population in enumerate(populations):
-            if i == j:
-                continue
-            reactions.append(
-                Reaction(migration_rates[i][j], f"{population} -> {other_population}")
-            )
-            reactions.append(
-                Reaction(
-                    birth_rates_among_demes[i][j],
-                    f"{population} -> {population} + {other_population}",
-                )
-            )
-    return reactions
-
-
-def get_epidemiological_reactions(
-    populations: str | list[str] = DEFAULT_POPULATION,
-    sample_population: str = SAMPLE_POPULATION,
-    reproduction_numbers: SkylineVectorCoercible = 0,
-    become_uninfectious_rates: SkylineVectorCoercible = 0,
-    sampling_proportions: SkylineVectorCoercible = 0,
-    removal_probabilities: SkylineVectorCoercible = 0,
-    migration_rates: SkylineMatrixCoercible = 0,
-    reproduction_numbers_among_demes: SkylineMatrixCoercible = 0,
-) -> list[Reaction]:
-    if isinstance(populations, str):
-        populations = [populations]
-    N = len(populations)
-
-    reproduction_numbers = skyline_vector(reproduction_numbers, N=N)
-    become_uninfectious_rates = skyline_vector(become_uninfectious_rates, N=N)
-    sampling_proportions = skyline_vector(sampling_proportions, N=N)
-    removal_probabilities = skyline_vector(removal_probabilities, N=N)
-    reproduction_numbers_among_demes = skyline_matrix(
-        reproduction_numbers_among_demes, N=N, zero_diagonal=True
-    )
-
-    birth_rates = reproduction_numbers * become_uninfectious_rates
-    birth_rates_among_demes = (
-        reproduction_numbers_among_demes * become_uninfectious_rates
-    )
-    sampling_rates = become_uninfectious_rates * sampling_proportions
-    death_rates = become_uninfectious_rates - removal_probabilities * sampling_rates
-
-    return get_canonical_reactions(
-        populations=populations,
-        sample_population=sample_population,
-        birth_rates=birth_rates,
-        death_rates=death_rates,
-        sampling_rates=sampling_rates,
-        removal_probabilities=removal_probabilities,
-        migration_rates=migration_rates,
-        birth_rates_among_demes=birth_rates_among_demes,
-    )
-
-
-def get_FBD_reactions(
-    populations: str | list[str] = DEFAULT_POPULATION,
-    sample_population: str = SAMPLE_POPULATION,
-    diversification: SkylineVectorCoercible = 0,
-    turnover: SkylineVectorCoercible = 0,
-    sampling_proportions: SkylineVectorCoercible = 0,
-    removal_probabilities: SkylineVectorCoercible = 0,
-    migration_rates: SkylineMatrixCoercible = 0,
-    diversification_between_types: SkylineMatrixCoercible = 0,
-):
-    if isinstance(populations, str):
-        populations = [populations]
-    N = len(populations)
-
-    diversification = skyline_vector(diversification, N=N)
-    turnover = skyline_vector(turnover, N=N)
-    sampling_proportions = skyline_vector(sampling_proportions, N=N)
-    removal_probabilities = skyline_vector(removal_probabilities, N=N)
-    diversification_between_types = skyline_matrix(
-        diversification_between_types, N=N, zero_diagonal=True
-    )
-
-    birth_rates = diversification / (1 - turnover)
-    death_rates = turnover * birth_rates
-    sampling_rates = (
-        sampling_proportions
-        * death_rates
-        / (1 - removal_probabilities * sampling_proportions)
-    )
-    birth_rates_among_demes = diversification_between_types + death_rates
-
-    return get_canonical_reactions(
-        populations=populations,
-        sample_population=sample_population,
-        birth_rates=birth_rates,
-        death_rates=death_rates,
-        sampling_rates=sampling_rates,
-        removal_probabilities=removal_probabilities,
-        migration_rates=migration_rates,
-        birth_rates_among_demes=birth_rates_among_demes,
-    )

phylogenie/backend/treesimulator.py

@@ -1,163 +0,0 @@
-from dataclasses import dataclass
-
-import numpy as np
-from treesimulator import STATE, save_forest
-from treesimulator.generator import generate
-from treesimulator.mtbd_models import CTModel, Model
-
-from phylogenie.skyline import (
-    SkylineMatrixCoercible,
-    SkylineParameterLike,
-    SkylineVectorCoercible,
-    skyline_matrix,
-    skyline_parameter,
-    skyline_vector,
-)
-
-DEFAULT_POPULATION = "X"
-INFECTIOUS_POPULATION = "I"
-EXPOSED_POPULATION = "E"
-SUPERSPREADER_POPULATION = "S"
-
-
-@dataclass
-class TreeParams:
-    populations: str | list[str]
-    transmission_rates: SkylineMatrixCoercible
-    removal_rates: SkylineVectorCoercible
-    sampling_proportions: SkylineVectorCoercible
-    transition_rates: SkylineMatrixCoercible = 0
-
-
-def generate_tree(
-    output_file: str,
-    params: TreeParams,
-    min_tips: int,
-    max_tips: int,
-    T: float = np.inf,
-    state_frequencies: list[float] | None = None,
-    notification_probability: SkylineParameterLike = 0,
-    notification_sampling_rate: SkylineParameterLike = np.inf,
-    allow_irremovable_states: bool = False,
-    max_notified_contacts: int = 1,
-    root_state: str | None = None,
-    random_seed: int | None = None,
-) -> None:
-    populations = params.populations
-    if isinstance(populations, str):
-        populations = [populations]
-    N = len(populations)
-
-    transition_rates = skyline_matrix(params.transition_rates, N=N, zero_diagonal=True)
-    transmission_rates = skyline_matrix(params.transmission_rates, N=N)
-    removal_rates = skyline_vector(params.removal_rates, N=N)
-    sampling_proportions = skyline_vector(params.sampling_proportions, N=N)
-
-    change_times = sorted(
-        set(
-            [
-                *transition_rates.change_times,
-                *transmission_rates.change_times,
-                *removal_rates.change_times,
-                *sampling_proportions.change_times,
-            ]
-        )
-    )
-
-    models = [
-        Model(
-            states=populations,
-            transition_rates=transition_rates.get_value_at_time(t),
-            transmission_rates=transmission_rates.get_value_at_time(t),
-            removal_rates=removal_rates.get_value_at_time(t),
-            ps=sampling_proportions.get_value_at_time(t),
-        )
-        for t in [0, *change_times]
-    ]
-
-    if notification_probability:
-        notification_sampling_rate = skyline_parameter(notification_sampling_rate)
-        notification_probability = skyline_parameter(notification_probability)
-        models = [
-            CTModel(
-                model,
-                phi=notification_sampling_rate.get_value_at_time(t),
-                upsilon=notification_probability.get_value_at_time(t),
-                allow_irremovable_states=allow_irremovable_states,
-            )
-            for t, model in zip([0, *change_times], models)
-        ]
-
-    [tree], _, _ = generate(
-        models,
-        min_tips=min_tips,
-        max_tips=max_tips,
-        T=T,
-        skyline_times=change_times,
-        state_frequencies=state_frequencies,
-        max_notified_contacts=max_notified_contacts,
-        root_state=root_state,
-        random_seed=random_seed,
-    )
-    for i, leaf in enumerate(tree.iter_leaves()):
-        state: str = getattr(leaf, STATE)
-        delattr(leaf, STATE)
-        date = tree.get_distance(leaf)
-        leaf.name = f"{i}|{state}|{date}"
-    save_forest([tree], output_file)
-
-
-def get_BD_params(
-    reproduction_number: SkylineParameterLike,
-    infectious_period: SkylineParameterLike,
-    sampling_proportion: SkylineParameterLike,
-) -> TreeParams:
-    transmission_rate = reproduction_number / infectious_period
-    removal_rate = 1 / infectious_period
-    return TreeParams(
-        populations=INFECTIOUS_POPULATION,
-        transmission_rates=transmission_rate,
-        removal_rates=removal_rate,
-        sampling_proportions=sampling_proportion,
-    )
-
-
-def get_BDEI_params(
-    reproduction_number: SkylineParameterLike,
-    infectious_period: SkylineParameterLike,
-    incubation_period: SkylineParameterLike,
-    sampling_proportion: SkylineParameterLike,
-) -> TreeParams:
-    transmission_rates = [[0, 0], [reproduction_number / infectious_period, 0]]
-    transition_rates = [[0, 1 / incubation_period], [0, 0]]
-    removal_rates = [0, 1 / infectious_period]
-    sampling_proportions = [0, sampling_proportion]
-    return TreeParams(
-        populations=[EXPOSED_POPULATION, INFECTIOUS_POPULATION],
-        transition_rates=transition_rates,
-        transmission_rates=transmission_rates,
-        removal_rates=removal_rates,
-        sampling_proportions=sampling_proportions,
-    )
-
-
-def get_BDSS_params(
-    reproduction_number: SkylineParameterLike,
-    infectious_period: SkylineParameterLike,
-    superspreading_ratio: SkylineParameterLike,
-    superspreaders_proportion: SkylineParameterLike,
-    sampling_proportion: SkylineParameterLike,
-) -> TreeParams:
-    gamma = 1 / infectious_period
-    f_SS = superspreaders_proportion
-    r_SS = superspreading_ratio
-    lambda_IS = reproduction_number * gamma * f_SS / (1 + r_SS * f_SS - f_SS)
-    lambda_SI = (reproduction_number * gamma - r_SS * lambda_IS) * r_SS
-    lambda_SS = r_SS * lambda_IS
-    lambda_II = lambda_SI / r_SS
-    return TreeParams(
-        populations=[INFECTIOUS_POPULATION, SUPERSPREADER_POPULATION],
-        transmission_rates=[[lambda_II, lambda_IS], [lambda_SI, lambda_SS]],
-        removal_rates=gamma,
-        sampling_proportions=sampling_proportion,
-    )

phylogenie/configs.py

@@ -1,5 +0,0 @@
-from pydantic import BaseModel, ConfigDict
-
-
-class StrictBaseModel(BaseModel):
-    model_config = ConfigDict(extra="forbid")

phylogenie/core/__init__.py

@@ -1,14 +0,0 @@
-from typing import Annotated
-
-from pydantic import Field
-
-from phylogenie.core.dataset import DatasetGenerator
-from phylogenie.core.msas import MSAsGeneratorConfig
-from phylogenie.core.trees import TreesGeneratorConfig
-
-DatasetGeneratorConfig = Annotated[
-    TreesGeneratorConfig | MSAsGeneratorConfig,
-    Field(discriminator="data_type"),
-]
-
-__all__ = ["DatasetGeneratorConfig", "DatasetGenerator"]

phylogenie/core/configs.py

@@ -1,37 +0,0 @@
-import phylogenie.typings as pgt
-from phylogenie.configs import StrictBaseModel
-
-IntConfig = str | int
-ScalarConfig = str | pgt.Scalar
-ManyIntsConfig = str | list[IntConfig]
-ManyScalarsConfig = str | list[ScalarConfig]
-OneOrManyScalarsConfig = ScalarConfig | list[ScalarConfig]
-OneOrMany2DScalarsConfig = ScalarConfig | list[list[ScalarConfig]]
-
-
-class SkylineParameterValueModel(StrictBaseModel):
-    value: ManyScalarsConfig
-    change_times: ManyScalarsConfig
-
-
-SkylineParameterLikeConfig = ScalarConfig | SkylineParameterValueModel
-
-
-class SkylineVectorValueModel(StrictBaseModel):
-    value: str | list[OneOrManyScalarsConfig]
-    change_times: ManyScalarsConfig
-
-
-SkylineVectorCoercibleConfig = (
-    str | pgt.Scalar | list[SkylineParameterLikeConfig] | SkylineVectorValueModel
-)
-
-
-class SkylineMatrixValueModel(StrictBaseModel):
-    value: str | list[OneOrMany2DScalarsConfig]
-    change_times: ManyScalarsConfig
-
-
-SkylineMatrixCoercibleConfig = (
-    str | pgt.Scalar | list[SkylineVectorCoercibleConfig] | SkylineMatrixValueModel
-)

phylogenie/core/context/__init__.py

@@ -1,4 +0,0 @@
-from phylogenie.core.context.configs import ContextConfig
-from phylogenie.core.context.factories import context_factory
-
-__all__ = ["ContextConfig", "context_factory"]

phylogenie/core/context/configs.py

@@ -1,28 +0,0 @@
-from phylogenie.configs import StrictBaseModel
-from phylogenie.core.context.distributions import (
-    DistributionConfig,
-    ScalarDistributionConfig,
-)
-
-
-class VectorModel(StrictBaseModel):
-    x: ScalarDistributionConfig
-
-
-class Vector1DModel(VectorModel):
-    size: int
-
-
-class Vector2DModel(VectorModel):
-    size: tuple[int, int]
-    zero_diagonal: bool = False
-
-
-class Vector3DModel(VectorModel):
-    size: tuple[int, int, int]
-    zero_diagonal: bool = False
-
-
-ContextConfig = dict[
-    str, DistributionConfig | Vector1DModel | Vector2DModel | Vector3DModel
-]