phylogenie 2.1.23__py3-none-any.whl → 2.1.25__py3-none-any.whl

phylogenie/__init__.py

@@ -11,7 +11,7 @@ from phylogenie.generators import (
     FBDTreeDatasetGenerator,
     TreeDatasetGeneratorConfig,
 )
-from phylogenie.io import dump_newick, load_fasta, load_newick
+from phylogenie.io import dump_newick, load_fasta, load_newick, load_nexus
 from phylogenie.msa import MSA
 from phylogenie.skyline import (
     SkylineMatrix,
@@ -100,6 +100,7 @@ __all__ = [
     "generate_trees",
     "simulate_tree",
     "dump_newick",
+    "load_nexus",
     "load_fasta",
     "load_newick",
     "MSA",

phylogenie/draw.py

@@ -1,4 +1,5 @@
 from enum import Enum
+from itertools import islice
 from typing import Any
 
 import matplotlib.colors as mcolors
@@ -25,7 +26,7 @@ def _draw_colored_tree(tree: Tree, ax: Axes, colors: Color | dict[Tree, Color])
 
     xs = (
         get_node_depth_levels(tree)
-        if any(node.branch_length is None for node in tree)
+        if any(node.branch_length is None for node in islice(tree, 1, None))
         else get_node_depths(tree)
     )
     ys: dict[Tree, float] = {node: i for i, node in enumerate(tree.get_leaves())}

phylogenie/generators/alisim.py

@@ -65,12 +65,13 @@ class AliSimDatasetGenerator(DatasetGenerator):
         while True:
             d.update(data(context, rng))
             try:
-                tree = self.trees.simulate_one(d, seed)
+                tree, metadata = self.trees.simulate_one(d, seed)
                 break
             except TimeoutError:
                 print(
                     "Tree simulation timed out, retrying with different parameters..."
                 )
+        d.update(metadata)
 
         times = get_node_depths(tree)
         for leaf in tree.get_leaves():

phylogenie/generators/configs.py

@@ -29,10 +29,6 @@ SkylineVector = str | pgt.Scalar | pgt.Many[SkylineParameter] | SkylineVectorMod
 SkylineMatrix = str | pgt.Scalar | pgt.Many[SkylineVector] | SkylineMatrixModel | None
 
 
-class Event(StrictBaseModel):
-    states: str | list[str] | None = None
-    rate: SkylineParameter
-
-
-class Mutation(Event):
+class Mutation(StrictBaseModel):
+    rate: Scalar
     rate_scalers: dict[MutationTargetType, Distribution]

phylogenie/generators/dataset.py

@@ -56,7 +56,7 @@ class DatasetGenerator(ABC, StrictBaseModel):
             for i in range(n_samples)
         )
         df = pd.DataFrame(
-            [r for r in tqdm(jobs, total=n_samples, desc=f"Generating {data_dir}...")]
+            [j for j in tqdm(jobs, f"Generating {data_dir}...", n_samples)]
         )
         df.to_csv(os.path.join(output_dir, METADATA_FILENAME), index=False)
 

phylogenie/generators/factories.py

@@ -17,6 +17,7 @@ from phylogenie.skyline import (
     SkylineVector,
     SkylineVectorCoercible,
 )
+from phylogenie.treesimulator import Mutation
 
 
 def _eval_expression(expression: str, data: dict[str, Any]) -> Any:
@@ -221,6 +222,13 @@ def distribution(x: Distribution, data: dict[str, Any]) -> Distribution:
     return Distribution(type=x.type, **args)
 
 
+def mutation(x: cfg.Mutation, data: dict[str, Any]) -> Mutation:
+    return Mutation(
+        scalar(x.rate, data),
+        {k: distribution(v, data) for k, v in x.rate_scalers.items()},
+    )
+
+
 def data(context: dict[str, Distribution] | None, rng: Generator) -> dict[str, Any]:
     if context is None:
         return {}

phylogenie/generators/trees.py

@@ -11,8 +11,8 @@ import phylogenie.generators.configs as cfg
 from phylogenie.generators.dataset import DatasetGenerator, DataType
 from phylogenie.generators.factories import (
     data,
-    distribution,
     integer,
+    mutation,
     scalar,
     skyline_matrix,
     skyline_parameter,
@@ -24,7 +24,6 @@ from phylogenie.tree import Tree
 from phylogenie.treesimulator import (
     Event,
     Feature,
-    Mutation,
     get_BD_events,
     get_BDEI_events,
     get_BDSS_events,
@@ -48,6 +47,7 @@ class ParameterizationType(str, Enum):
 
 class TreeDatasetGenerator(DatasetGenerator):
     data_type: Literal[DataType.TREES] = DataType.TREES
+    mutations: list[cfg.Mutation] | None = None
     min_tips: cfg.Integer = 1
     max_tips: cfg.Integer | None = None
     max_time: cfg.Scalar = np.inf
@@ -59,14 +59,22 @@ class TreeDatasetGenerator(DatasetGenerator):
     @abstractmethod
     def _get_events(self, data: dict[str, Any]) -> list[Event]: ...
 
-    def simulate_one(self, data: dict[str, Any], seed: int | None = None) -> Tree:
+    def simulate_one(
+        self, data: dict[str, Any], seed: int | None = None
+    ) -> tuple[Tree, dict[str, Any]]:
         init_state = (
             self.init_state
             if self.init_state is None
             else self.init_state.format(**data)
         )
+        mutations = (
+            None
+            if self.mutations is None
+            else [mutation(m, data) for m in self.mutations]
+        )
         return simulate_tree(
             events=self._get_events(data),
+            mutations=mutations,
             min_tips=integer(self.min_tips, data),
             max_tips=None if self.max_tips is None else integer(self.max_tips, data),
             max_time=scalar(self.max_time, data),
@@ -89,14 +97,14 @@ class TreeDatasetGenerator(DatasetGenerator):
         while True:
             try:
                 d.update(data(context, rng))
-                tree = self.simulate_one(d, seed)
+                tree, metadata = self.simulate_one(d, seed)
                 if self.node_features is not None:
                     set_features(tree, self.node_features)
                 dump_newick(tree, f"{filename}.nwk")
                 break
             except TimeoutError:
                 print("Simulation timed out, retrying with different parameters...")
-        return d
+        return d | metadata
 
 
 class CanonicalTreeDatasetGenerator(TreeDatasetGenerator):
@@ -147,12 +155,11 @@ class FBDTreeDatasetGenerator(TreeDatasetGenerator):
         )
 
 
-class TreeDatasetGeneratorForEpidemiology(TreeDatasetGenerator):
+class ContactTracingTreeDatasetGenerator(TreeDatasetGenerator):
     max_notified_contacts: cfg.Integer = 1
     notification_probability: cfg.SkylineParameter = 0.0
     sampling_rate_after_notification: cfg.SkylineParameter = np.inf
     samplable_states_after_notification: list[str] | None = None
-    mutations: tuple[cfg.Mutation, ...] = Field(default_factory=tuple)
 
     @abstractmethod
     def _get_base_events(self, data: dict[str, Any]) -> list[Event]: ...
@@ -171,30 +178,10 @@ class TreeDatasetGeneratorForEpidemiology(TreeDatasetGenerator):
                 ),
                 samplable_states_after_notification=self.samplable_states_after_notification,
             )
-        all_states = list({e.state for e in events})
-        for mutation in self.mutations:
-            states = mutation.states
-            if isinstance(states, str):
-                states = [states]
-            elif states is None:
-                states = all_states
-            for state in states:
-                if state not in all_states:
-                    raise ValueError(
-                        f"Mutation state '{state}' is not found in states {all_states}."
-                    )
-                rate_scalers = {
-                    t: distribution(r, data) for t, r in mutation.rate_scalers.items()
-                }
-                events.append(
-                    Mutation(
-                        state, skyline_parameter(mutation.rate, data), rate_scalers
-                    )
-                )
         return events
 
 
-class EpidemiologicalTreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
+class EpidemiologicalTreeDatasetGenerator(ContactTracingTreeDatasetGenerator):
     parameterization: Literal[ParameterizationType.EPIDEMIOLOGICAL] = (
         ParameterizationType.EPIDEMIOLOGICAL
     )
@@ -220,7 +207,7 @@ class EpidemiologicalTreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
         )
 
 
-class BDTreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
+class BDTreeDatasetGenerator(ContactTracingTreeDatasetGenerator):
     parameterization: Literal[ParameterizationType.BD] = ParameterizationType.BD
     reproduction_number: cfg.SkylineParameter
     infectious_period: cfg.SkylineParameter
@@ -234,7 +221,7 @@ class BDTreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
         )
 
 
-class BDEITreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
+class BDEITreeDatasetGenerator(ContactTracingTreeDatasetGenerator):
     parameterization: Literal[ParameterizationType.BDEI] = ParameterizationType.BDEI
     reproduction_number: cfg.SkylineParameter
     infectious_period: cfg.SkylineParameter
@@ -250,7 +237,7 @@ class BDEITreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
         )
 
 
-class BDSSTreeDatasetGenerator(TreeDatasetGeneratorForEpidemiology):
+class BDSSTreeDatasetGenerator(ContactTracingTreeDatasetGenerator):
     parameterization: Literal[ParameterizationType.BDSS] = ParameterizationType.BDSS
     reproduction_number: cfg.SkylineParameter
     infectious_period: cfg.SkylineParameter

phylogenie/io/__init__.py

@@ -0,0 +1,5 @@
+from phylogenie.io.fasta import load_fasta
+from phylogenie.io.newick import dump_newick, load_newick
+from phylogenie.io.nexus import load_nexus
+
+__all__ = ["load_fasta", "load_newick", "dump_newick", "load_nexus"]

phylogenie/io/fasta.py

@@ -0,0 +1,25 @@
+from typing import Callable
+
+from phylogenie.msa import MSA, Sequence
+
+
+def load_fasta(
+    fasta_file: str, extract_time_from_id: Callable[[str], float] | None = None
+) -> MSA:
+    sequences: list[Sequence] = []
+    with open(fasta_file, "r") as f:
+        for line in f:
+            if not line.startswith(">"):
+                raise ValueError(f"Invalid FASTA format: expected '>', got '{line[0]}'")
+            id = line[1:].strip()
+            time = None
+            if extract_time_from_id is not None:
+                time = extract_time_from_id(id)
+            elif "|" in id:
+                try:
+                    time = float(id.split("|")[-1])
+                except ValueError:
+                    pass
+            chars = next(f).strip()
+            sequences.append(Sequence(id, chars, time))
+    return MSA(sequences)

phylogenie/{io.py → io/newick.py}

@@ -1,17 +1,17 @@
 import re
-from typing import Callable
 
-from phylogenie.msa import MSA, Sequence
 from phylogenie.tree import Tree
 
 
-def _parse_newick(newick: str) -> Tree:
+def parse_newick(newick: str, translations: dict[str, str] | None = None) -> Tree:
     newick = newick.strip()
+    newick = re.sub(r"^\[\&[^\]]*\]", "", newick).strip()
+
     stack: list[list[Tree]] = []
     current_children: list[Tree] = []
     current_nodes: list[Tree] = []
     i = 0
-    while i < len(newick):
+    while True:
 
         def _read_chars(stoppers: list[str]) -> str:
             nonlocal i
@@ -29,7 +29,10 @@ def _parse_newick(newick: str) -> Tree:
             i += 1
             continue
 
-        current_node = Tree(_read_chars(["[", ":", ",", ")", ";"]))
+        name = _read_chars([":", "[", ",", ")", ";"])
+        if translations is not None and name in translations:
+            name = translations[name]
+        current_node = Tree(name)
 
         if newick[i] == "[":
             i += 1
@@ -62,17 +65,15 @@ def _parse_newick(newick: str) -> Tree:
 
         i += 1
 
-    raise ValueError("Newick string should end with ';'")
-
 
 def load_newick(filepath: str) -> Tree | list[Tree]:
     with open(filepath, "r") as file:
-        trees = [_parse_newick(newick) for newick in file]
+        trees = [parse_newick(newick) for newick in file]
     return trees[0] if len(trees) == 1 else trees
 
 
-def _to_newick(tree: Tree) -> str:
-    children_newick = ",".join([_to_newick(child) for child in tree.children])
+def to_newick(tree: Tree) -> str:
+    children_newick = ",".join([to_newick(child) for child in tree.children])
     newick = tree.name
     if tree.features:
         reprs = {k: repr(v).replace("'", '"') for k, v in tree.features.items()}
@@ -99,26 +100,4 @@ def dump_newick(trees: Tree | list[Tree], filepath: str) -> None:
         trees = [trees]
     with open(filepath, "w") as file:
         for t in trees:
-            file.write(_to_newick(t) + ";\n")
-
-
-def load_fasta(
-    fasta_file: str, extract_time_from_id: Callable[[str], float] | None = None
-) -> MSA:
-    sequences: list[Sequence] = []
-    with open(fasta_file, "r") as f:
-        for line in f:
-            if not line.startswith(">"):
-                raise ValueError(f"Invalid FASTA format: expected '>', got '{line[0]}'")
-            id = line[1:].strip()
-            time = None
-            if extract_time_from_id is not None:
-                time = extract_time_from_id(id)
-            elif "|" in id:
-                try:
-                    time = float(id.split("|")[-1])
-                except ValueError:
-                    pass
-            chars = next(f).strip()
-            sequences.append(Sequence(id, chars, time))
-    return MSA(sequences)
+            file.write(to_newick(t) + ";\n")

phylogenie/io/nexus.py

@@ -0,0 +1,43 @@
+import re
+from collections.abc import Iterator
+
+from phylogenie.io.newick import parse_newick
+from phylogenie.tree import Tree
+
+
+def _parse_translate_block(lines: Iterator[str]) -> dict[str, str]:
+    translations: dict[str, str] = {}
+    for line in lines:
+        match = re.match(r"\s*(\d+)\s+['\"]?([^'\",;]+)['\"]?", line)
+        if match is None:
+            if ";" in line:
+                return translations
+            else:
+                raise ValueError(f"Invalid translate line: {line.strip()}")
+        translations[match.group(1)] = match.group(2)
+    raise ValueError("Translate block not terminated with ';'")
+
+
+def _parse_trees_block(lines: Iterator[str]) -> dict[str, Tree]:
+    trees: dict[str, Tree] = {}
+    translations = {}
+    for line in lines:
+        line = line.strip()
+        if line.upper() == "TRANSLATE":
+            translations = _parse_translate_block(lines)
+        elif line.upper() == "END;":
+            return trees
+        else:
+            match = re.match(r"^TREE\s*\*?\s+(\S+)\s*=\s*(.+)$", line, re.IGNORECASE)
+            if match is None:
+                raise ValueError(f"Invalid tree line. Expected 'TREE name = newick'")
+            trees[match.group(1)] = parse_newick(match.group(2), translations)
+    return trees
+
+
+def load_nexus(nexus_file: str) -> dict[str, Tree]:
+    with open(nexus_file, "r") as f:
+        for line in f:
+            if line.strip().upper() == "BEGIN TREES;":
+                return _parse_trees_block(f)
+    raise ValueError("No TREES block found in the NEXUS file.")

phylogenie/skyline/matrix.py

@@ -33,7 +33,7 @@ class SkylineMatrix:
     ):
         if params is not None and value is None and change_times is None:
             if is_many_skyline_vectors_like(params):
-                self.params = [
+                self._params = [
                     p if isinstance(p, SkylineVector) else SkylineVector(p)
                     for p in params
                 ]
@@ -41,7 +41,7 @@ class SkylineMatrix:
                 raise TypeError(
                     f"It is impossible to create a SkylineMatrix from `params` {params} of type {type(params)}. Please provide a sequence composed of SkylineVectorLike objects (a SkylineVectorLike object can either be a SkylineVector or a sequence of scalars and/or SkylineParameters)."
                 )
-            lengths = {len(p) for p in self.params}
+            lengths = {len(p) for p in self._params}
             if len(lengths) > 1:
                 raise ValueError(
                     f"All `params` must have the same length to create a SkylineMatrix (got params={params} with lengths {lengths})."
@@ -57,7 +57,7 @@ class SkylineMatrix:
                 raise TypeError(
                     f"It is impossible to create a SkylineMatrix from `value` {value} of type {type(value)}. Please provide a nested (3D) sequence of scalar values."
                 )
-            self.params = [
+            self._params = [
                 SkylineVector(
                     value=[matrix[i] for matrix in value], change_times=change_times
                 )
@@ -68,6 +68,10 @@ class SkylineMatrix:
                 "Either `params` or both `value` and `change_times` must be provided to create a SkylineMatrix."
             )
 
+    @property
+    def params(self) -> tuple[SkylineVector, ...]:
+        return tuple(self._params)
+
     @property
     def n_rows(self) -> int:
         return len(self.params)
@@ -82,14 +86,14 @@ class SkylineMatrix:
 
     @property
     def change_times(self) -> pgt.Vector1D:
-        return sorted(set([t for row in self.params for t in row.change_times]))
+        return tuple(sorted(set([t for row in self.params for t in row.change_times])))
 
     @property
     def value(self) -> pgt.Vector3D:
-        return [self.get_value_at_time(t) for t in (0, *self.change_times)]
+        return tuple(self.get_value_at_time(t) for t in (0, *self.change_times))
 
     def get_value_at_time(self, time: pgt.Scalar) -> pgt.Vector2D:
-        return [param.get_value_at_time(time) for param in self.params]
+        return tuple(param.get_value_at_time(time) for param in self.params)
 
     def _operate(
         self,
@@ -185,7 +189,7 @@ class SkylineMatrix:
             raise TypeError(
                 f"It is impossible to set item of SkylineMatrix to value {value} of type {type(value)}. Please provide a SkylineVectorLike object (i.e., a SkylineVector or a sequence of scalars and/or SkylineParameters)."
             )
-        self.params[item] = skyline_vector(value, self.n_cols)
+        self._params[item] = skyline_vector(value, self.n_cols)
 
 
 def skyline_matrix(

phylogenie/skyline/parameter.py

@@ -52,12 +52,20 @@ class SkylineParameter:
                 f"`change_times` must be non-negative (got change_times={change_times})."
             )
 
-        self.value = [value[0]]
-        self.change_times: list[pgt.Scalar] = []
+        self._value = [value[0]]
+        self._change_times: list[pgt.Scalar] = []
         for i in range(1, len(value)):
             if value[i] != value[i - 1]:
-                self.value.append(value[i])
-                self.change_times.append(change_times[i - 1])
+                self._value.append(value[i])
+                self._change_times.append(change_times[i - 1])
+
+    @property
+    def value(self) -> pgt.Vector1D:
+        return tuple(self._value)
+
+    @property
+    def change_times(self) -> pgt.Vector1D:
+        return tuple(self._change_times)
 
     def get_value_at_time(self, t: pgt.Scalar) -> pgt.Scalar:
         if t < 0:

phylogenie/skyline/vector.py

@@ -47,7 +47,7 @@ class SkylineVector:
     ):
         if params is not None and value is None and change_times is None:
             if is_many_skyline_parameters_like(params):
-                self.params = [skyline_parameter(param) for param in params]
+                self._params = [skyline_parameter(param) for param in params]
             else:
                 raise TypeError(
                     f"It is impossible to create a SkylineVector from `params` {params} of type {type(params)}. Please provide a sequence of SkylineParameterLike objects (a SkylineParameterLike object can either be a SkylineParameter or a scalar)."
@@ -63,7 +63,7 @@ class SkylineVector:
                 raise TypeError(
                     f"It is impossible to create a SkylineVector from `value` {value} of type {type(value)}. Please provide a nested (2D) sequence of scalar values."
                 )
-            self.params = [
+            self._params = [
                 SkylineParameter([vector[i] for vector in value], change_times)
                 for i in range(len(value[0]))
             ]
@@ -72,20 +72,26 @@ class SkylineVector:
                 "Either `params` or both `value` and `change_times` must be provided to create a SkylineVector."
             )
 
+    @property
+    def params(self) -> tuple[SkylineParameter, ...]:
+        return tuple(self._params)
+
     @property
     def change_times(self) -> pgt.Vector1D:
-        return sorted(set(t for param in self.params for t in param.change_times))
+        return tuple(
+            sorted(set(t for param in self.params for t in param.change_times))
+        )
 
     @property
     def value(self) -> pgt.Vector2D:
-        return [self.get_value_at_time(t) for t in (0, *self.change_times)]
+        return tuple(self.get_value_at_time(t) for t in (0, *self.change_times))
 
     @property
     def N(self) -> int:
         return len(self.params)
 
     def get_value_at_time(self, t: pgt.Scalar) -> pgt.Vector1D:
-        return [param.get_value_at_time(t) for param in self.params]
+        return tuple(param.get_value_at_time(t) for param in self.params)
 
     def _operate(
         self,
@@ -154,7 +160,7 @@ class SkylineVector:
             raise TypeError(
                 f"It is impossible to set item {item} of SkylineVector with value {value} of type {type(value)}. Please provide a SkylineParameterLike object (i.e., a scalar or a SkylineParameter)."
             )
-        self.params[item] = skyline_parameter(value)
+        self._params[item] = skyline_parameter(value)
 
 
 def skyline_vector(x: SkylineVectorCoercible, N: int) -> SkylineVector:

phylogenie/treesimulator/__init__.py

@@ -4,8 +4,6 @@ from phylogenie.treesimulator.events import (
     Death,
     Event,
     Migration,
-    Mutation,
-    MutationTargetType,
     Sampling,
     SamplingWithContactTracing,
     get_BD_events,
@@ -15,11 +13,13 @@ from phylogenie.treesimulator.events import (
     get_contact_tracing_events,
     get_epidemiological_events,
     get_FBD_events,
-    get_mutation_id,
 )
 from phylogenie.treesimulator.features import Feature, set_features
 from phylogenie.treesimulator.gillespie import generate_trees, simulate_tree
 from phylogenie.treesimulator.model import get_node_state
+from phylogenie.treesimulator.mutations import Mutation
+from phylogenie.treesimulator.mutations import TargetType as MutationTargetType
+from phylogenie.treesimulator.mutations import get_mutation_id
 
 __all__ = [
     "Birth",

phylogenie/treesimulator/events/__init__.py

@@ -1,3 +1,4 @@
+from phylogenie.treesimulator.events.base import Event
 from phylogenie.treesimulator.events.contact_tracing import (
     BirthWithContactTracing,
     SamplingWithContactTracing,
@@ -6,7 +7,6 @@ from phylogenie.treesimulator.events.contact_tracing import (
 from phylogenie.treesimulator.events.core import (
     Birth,
     Death,
-    Event,
     Migration,
     Sampling,
     get_BD_events,
@@ -16,9 +16,6 @@ from phylogenie.treesimulator.events.core import (
     get_epidemiological_events,
     get_FBD_events,
 )
-from phylogenie.treesimulator.events.mutations import Mutation
-from phylogenie.treesimulator.events.mutations import TargetType as MutationTargetType
-from phylogenie.treesimulator.events.mutations import get_mutation_id
 
 __all__ = [
     "Birth",
@@ -26,10 +23,8 @@ __all__ = [
     "Death",
     "Event",
     "Migration",
-    "Mutation",
     "Sampling",
     "SamplingWithContactTracing",
-    "MutationTargetType",
     "get_BD_events",
     "get_BDEI_events",
     "get_BDSS_events",
@@ -37,5 +32,4 @@ __all__ = [
     "get_contact_tracing_events",
     "get_epidemiological_events",
     "get_FBD_events",
-    "get_mutation_id",
 ]

phylogenie/treesimulator/events/base.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+
+import numpy as np
+from numpy.random import Generator
+
+from phylogenie.skyline import SkylineParameterLike, skyline_parameter
+from phylogenie.treesimulator.model import Model
+
+
+class Event(ABC):
+    def __init__(self, state: str, rate: SkylineParameterLike):
+        self.state = state
+        self.rate = skyline_parameter(rate)
+
+    def draw_individual(self, model: Model, rng: Generator) -> int:
+        return rng.choice(model.get_population(self.state))
+
+    def get_propensity(self, model: Model, time: float) -> float:
+        n_individuals = model.count_individuals(self.state)
+        rate = self.rate.get_value_at_time(time)
+        if rate == np.inf and not n_individuals:
+            return 0
+        return rate * n_individuals
+
+    @abstractmethod
+    def apply(self, model: Model, time: float, rng: Generator) -> None: ...

phylogenie/treesimulator/events/contact_tracing.py

@@ -5,8 +5,9 @@ import numpy as np
 from numpy.random import Generator
 
 from phylogenie.skyline import SkylineParameterLike, skyline_parameter
+from phylogenie.treesimulator.events.base import Event
 from phylogenie.treesimulator.events.core import Birth, Death, Migration, Sampling
-from phylogenie.treesimulator.model import Event, Model
+from phylogenie.treesimulator.model import Model
 
 CT_POSTFIX = "-CT"
 CONTACTS_KEY = "CONTACTS"

phylogenie/treesimulator/events/core.py

@@ -7,7 +7,8 @@ from phylogenie.skyline import (
     skyline_matrix,
     skyline_vector,
 )
-from phylogenie.treesimulator.model import Event, Model
+from phylogenie.treesimulator.events.base import Event
+from phylogenie.treesimulator.model import Model
 
 INFECTIOUS_STATE = "I"
 EXPOSED_STATE = "E"

phylogenie/treesimulator/features.py

@@ -2,8 +2,8 @@ from collections.abc import Iterable
 from enum import Enum
 
 from phylogenie.tree import Tree
-from phylogenie.treesimulator.events import get_mutation_id
 from phylogenie.treesimulator.model import get_node_state
+from phylogenie.treesimulator.mutations import get_mutation_id
 from phylogenie.utils import (
     get_node_depth_levels,
     get_node_depths,

phylogenie/treesimulator/gillespie.py

@@ -1,20 +1,25 @@
 import os
 import time
 from collections.abc import Iterable, Sequence
+from typing import Any
 
 import joblib
 import numpy as np
+import pandas as pd
 from numpy.random import default_rng
 from tqdm import tqdm
 
 from phylogenie.io import dump_newick
 from phylogenie.tree import Tree
+from phylogenie.treesimulator.events import Event
 from phylogenie.treesimulator.features import Feature, set_features
-from phylogenie.treesimulator.model import Event, Model
+from phylogenie.treesimulator.model import Model
+from phylogenie.treesimulator.mutations import Mutation
 
 
 def simulate_tree(
     events: Sequence[Event],
+    mutations: Sequence[Mutation] | None = None,
     min_tips: int = 1,
     max_tips: int | None = None,
     max_time: float = np.inf,
@@ -22,10 +27,7 @@ def simulate_tree(
     sampling_probability_at_present: float = 0.0,
     seed: int | None = None,
     timeout: float = np.inf,
-) -> Tree:
-    if max_time == np.inf and max_tips is None:
-        raise ValueError("Either max_time or max_tips must be specified.")
-
+) -> tuple[Tree, dict[str, Any]]:
     if max_time == np.inf and sampling_probability_at_present:
         raise ValueError(
             "sampling_probability_at_present cannot be set when max_time is infinite."
@@ -41,15 +43,22 @@ def simulate_tree(
     elif init_state not in states:
         raise ValueError(f"Init state {init_state} not found in event states: {states}")
 
+    if mutations is None:
+        mutations = []
+
     rng = default_rng(seed)
     start_clock = time.perf_counter()
     while True:
-        model = Model(init_state, events)
+        model = Model(init_state)
+        metadata: dict[str, Any] = {}
+        run_events = list(events)
         current_time = 0.0
         change_times = sorted(set(t for e in events for t in e.rate.change_times))
         next_change_time = change_times.pop(0) if change_times else np.inf
+
         if max_time == np.inf:
-            assert max_tips is not None
+            if max_tips is None:
+                raise ValueError("Either max_time or max_tips must be specified.")
             target_n_tips = rng.integers(min_tips, max_tips + 1)
         else:
             target_n_tips = None
@@ -58,10 +67,9 @@ def simulate_tree(
             if time.perf_counter() - start_clock > timeout:
                 raise TimeoutError("Simulation timed out.")
 
-            events = model.events
-            rates = [e.get_propensity(model, current_time) for e in events]
+            rates = [e.get_propensity(model, current_time) for e in run_events]
 
-            instantaneous_events = [e for e, r in zip(events, rates) if r == np.inf]
+            instantaneous_events = [e for e, r in zip(run_events, rates) if r == np.inf]
             if instantaneous_events:
                 event = instantaneous_events[rng.integers(len(instantaneous_events))]
                 event.apply(model, current_time, rng)
@@ -76,6 +84,7 @@ def simulate_tree(
             ):
                 break
 
+            rates.extend(m.rate for m in mutations)
             time_step = rng.exponential(1 / sum(rates))
             if current_time + time_step >= next_change_time:
                 current_time = next_change_time
@@ -86,8 +95,13 @@ def simulate_tree(
                 break
             current_time += time_step
 
-            event_idx = np.searchsorted(np.cumsum(rates) / sum(rates), rng.random())
-            events[int(event_idx)].apply(model, current_time, rng)
+            targets = run_events + list(mutations)
+            target_idx = np.searchsorted(np.cumsum(rates) / sum(rates), rng.random())
+            target = targets[int(target_idx)]
+            if isinstance(target, Event):
+                target.apply(model, current_time, rng)
+            else:
+                metadata.update(target.apply(model, run_events, current_time, rng))
 
         for individual in model.get_population():
             if rng.random() < sampling_probability_at_present:
@@ -96,7 +110,7 @@ def simulate_tree(
         if min_tips <= model.n_sampled and (
             max_tips is None or model.n_sampled <= max_tips
         ):
-            return model.get_sampled_tree()
+            return (model.get_sampled_tree(), metadata)
 
 
 def generate_trees(
@@ -112,11 +126,11 @@ def generate_trees(
     seed: int | None = None,
     n_jobs: int = -1,
     timeout: float = np.inf,
-) -> None:
-    def _simulate_tree(seed: int) -> Tree:
+) -> pd.DataFrame:
+    def _simulate_tree(seed: int) -> tuple[Tree, dict[str, Any]]:
         while True:
             try:
-                tree = simulate_tree(
+                tree, metadata = simulate_tree(
                     events=events,
                     min_tips=min_tips,
                     max_tips=max_tips,
@@ -128,7 +142,7 @@ def generate_trees(
                 )
                 if node_features is not None:
                     set_features(tree, node_features)
-                return tree
+                return (tree, metadata)
             except TimeoutError:
                 print("Simulation timed out, retrying with a different seed...")
             seed += 1
@@ -142,7 +156,11 @@ def generate_trees(
         joblib.delayed(_simulate_tree)(seed=int(rng.integers(2**32)))
         for _ in range(n_trees)
     )
-    for i, tree in tqdm(
+
+    df: list[dict[str, Any]] = []
+    for i, (tree, metadata) in tqdm(
         enumerate(jobs), total=n_trees, desc=f"Generating trees in {output_dir}..."
     ):
+        df.append({"file_id": i} | metadata)
         dump_newick(tree, os.path.join(output_dir, f"{i}.nwk"))
+    return pd.DataFrame(df)

phylogenie/treesimulator/model.py

@@ -1,13 +1,7 @@
-from abc import ABC, abstractmethod
 from collections import defaultdict
-from collections.abc import Sequence
 from dataclasses import dataclass
 from typing import Any
 
-import numpy as np
-from numpy.random import Generator
-
-from phylogenie.skyline import SkylineParameterLike, skyline_parameter
 from phylogenie.tree import Tree
 
 
@@ -18,25 +12,6 @@ class Individual:
     state: str
 
 
-class Event(ABC):
-    def __init__(self, state: str, rate: SkylineParameterLike):
-        self.state = state
-        self.rate = skyline_parameter(rate)
-
-    def draw_individual(self, model: "Model", rng: Generator) -> int:
-        return rng.choice(model.get_population(self.state))
-
-    def get_propensity(self, model: "Model", time: float) -> float:
-        n_individuals = model.count_individuals(self.state)
-        rate = self.rate.get_value_at_time(time)
-        if rate == np.inf and not n_individuals:
-            return 0
-        return rate * n_individuals
-
-    @abstractmethod
-    def apply(self, model: "Model", time: float, rng: Generator) -> None: ...
-
-
 def _get_node_name(node_id: int, state: str) -> str:
     return f"{node_id}|{state}"
 
@@ -51,27 +26,19 @@ def get_node_state(node_name: str) -> str:
 
 
 class Model:
-    def __init__(self, init_state: str, events: Sequence[Event]):
+    def __init__(self, init_state: str):
         self._next_node_id = 0
         self._next_individual_id = 0
         self._population: dict[int, Individual] = {}
         self._states: dict[str, set[int]] = defaultdict(set)
         self._sampled: set[str] = set()
         self._tree = self._get_new_individual(init_state).node
-        self._events = list(events)
         self.context: dict[str, Any] = {}
 
     @property
     def n_sampled(self) -> int:
         return len(self._sampled)
 
-    @property
-    def events(self) -> tuple[Event, ...]:
-        return tuple(self._events)
-
-    def add_event(self, event: Event) -> None:
-        self._events.append(event)
-
     def _get_new_node(self, state: str) -> Tree:
         self._next_node_id += 1
         node = Tree(_get_node_name(self._next_node_id, state))

phylogenie/treesimulator/{events/mutations.py → mutations.py}

@@ -1,12 +1,11 @@
 import re
 from copy import deepcopy
 from enum import Enum
-from typing import Type
+from typing import Any, Type
 
 from numpy.random import Generator
 
 from phylogenie.models import Distribution
-from phylogenie.skyline import SkylineParameterLike
 from phylogenie.treesimulator.events.contact_tracing import (
     BirthWithContactTracing,
     SamplingWithContactTracing,
@@ -21,7 +20,7 @@ from phylogenie.treesimulator.events.core import (
 from phylogenie.treesimulator.model import Model
 
 MUTATION_PREFIX = "MUT-"
-MUTATIONS_KEY = "MUTATIONS"
+NEXT_MUTATION_ID = "NEXT_MUTATION_ID"
 
 
 def _get_mutation(state: str) -> str | None:
@@ -46,68 +45,68 @@ class TargetType(str, Enum):
     DEATH = "death"
     MIGRATION = "migration"
     SAMPLING = "sampling"
-    MUTATION = "mutation"
 
 
-class Mutation(Event):
-    def __init__(
-        self,
-        state: str,
-        rate: SkylineParameterLike,
-        rate_scalers: dict[TargetType, Distribution],
-    ):
-        super().__init__(state, rate)
+EVENT_TARGET_TYPES: dict[Type[Event], TargetType] = {
+    Birth: TargetType.BIRTH,
+    BirthWithContactTracing: TargetType.BIRTH,
+    Death: TargetType.DEATH,
+    Migration: TargetType.MIGRATION,
+    Sampling: TargetType.SAMPLING,
+    SamplingWithContactTracing: TargetType.SAMPLING,
+}
+
+
+class Mutation:
+    def __init__(self, rate: float, rate_scalers: dict[TargetType, Distribution]):
+        self.rate = rate
         self.rate_scalers = rate_scalers
 
-    def apply(self, model: Model, time: float, rng: Generator) -> None:
-        if MUTATIONS_KEY not in model.context:
-            model.context[MUTATIONS_KEY] = 0
-        model.context[MUTATIONS_KEY] += 1
-        mutation_id = model.context[MUTATIONS_KEY]
+    def apply(
+        self, model: Model, events: list[Event], time: float, rng: Generator
+    ) -> dict[str, Any]:
+        if NEXT_MUTATION_ID not in model.context:
+            model.context[NEXT_MUTATION_ID] = 0
+        model.context[NEXT_MUTATION_ID] += 1
+        mutation_id = model.context[NEXT_MUTATION_ID]
 
-        individual = self.draw_individual(model, rng)
-        model.migrate(individual, _get_mutated_state(mutation_id, self.state), time)
+        individual = rng.choice(model.get_population())
+        state = model.get_state(individual)
+        model.migrate(individual, _get_mutated_state(mutation_id, state), time)
 
-        rate_scalers = {
+        rate_scalers: dict[TargetType, float] = {
             target_type: getattr(rng, rate_scaler.type)(**rate_scaler.args)
             for target_type, rate_scaler in self.rate_scalers.items()
         }
 
+        metadata: dict[str, Any] = {}
         for event in [
             deepcopy(e)
-            for e in model.events
-            if _get_mutation(self.state) == _get_mutation(e.state)
+            for e in events
+            if _get_mutation(state) == _get_mutation(e.state)
         ]:
             event.state = _get_mutated_state(mutation_id, event.state)
             if isinstance(event, Birth | BirthWithContactTracing):
                 event.child_state = _get_mutated_state(mutation_id, event.child_state)
             elif isinstance(event, Migration):
                 event.target_state = _get_mutated_state(mutation_id, event.target_state)
-            elif not isinstance(
-                event, Mutation | Death | Sampling | SamplingWithContactTracing
-            ):
+            elif not isinstance(event, Death | Sampling | SamplingWithContactTracing):
                 raise ValueError(
-                    f"Mutation not defined for event of type {type(event)}."
+                    f"Mutation not implemented for event of type {type(event)}."
                 )
 
-            for target_type, rate_scaler in rate_scalers.items():
-                if target_type not in TARGETS:
-                    raise ValueError(
-                        f"Unsupported target type {target_type} for mutation."
-                    )
-                if isinstance(event, TARGETS[target_type]):
-                    event.rate *= rate_scaler
-
-            model.add_event(event)
+            target_type = EVENT_TARGET_TYPES[type(event)]
+            if target_type in rate_scalers:
+                event.rate *= rate_scalers[target_type]
+                metadata[f"{MUTATION_PREFIX}{mutation_id}.{target_type}.rate.value"] = (
+                    event.rate.value[0]
+                    if len(event.rate.value) == 1
+                    else list(event.rate.value)
+                )
 
-    def __repr__(self) -> str:
-        return f"Mutation(state={self.state}, rate={self.rate})"
+            events.append(event)
 
+        return metadata
 
-TARGETS: dict[TargetType, tuple[Type[Event], ...]] = {
-    TargetType.BIRTH: (Birth, BirthWithContactTracing),
-    TargetType.DEATH: (Death,),
-    TargetType.MIGRATION: (Migration,),
-    TargetType.SAMPLING: (Sampling, SamplingWithContactTracing),
-    TargetType.MUTATION: (Mutation,),
-}
+    def __repr__(self) -> str:
+        return f"Mutation(rate={self.rate}, rate_scalers={self.rate_scalers})"

phylogenie/typings.py

@@ -15,6 +15,6 @@ OneOrMany2DScalars = OneOrMany2D[Scalar]
 Many2DScalars = Many2D[Scalar]
 Many3DScalars = Many3D[Scalar]
 
-Vector1D = list[Scalar]
-Vector2D = list[Vector1D]
-Vector3D = list[Vector2D]
+Vector1D = tuple[Scalar, ...]
+Vector2D = tuple[Vector1D, ...]
+Vector3D = tuple[Vector2D, ...]

{phylogenie-2.1.23.dist-info → phylogenie-2.1.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: phylogenie
-Version: 2.1.23
+Version: 2.1.25
 Summary: Generate phylogenetic datasets with minimal setup effort
 Author: Gabriele Marino
 Author-email: gabmarino.8601@gmail.com

phylogenie-2.1.25.dist-info/RECORD

@@ -0,0 +1,39 @@
+phylogenie/__init__.py,sha256=KV83hJ153WAwCIWEPWXtSsqdI_ncojxiXzt1X_lC7SU,2879
+phylogenie/draw.py,sha256=37eQDK8TKmL8bxSzXvi7jNvrR7ulj7MByR5MA1FtyyE,5317
+phylogenie/generators/__init__.py,sha256=zsOxy28-9j9alOQLIgrOAFfmM58NNHO_NEtW-KXQXAY,888
+phylogenie/generators/alisim.py,sha256=1YQLpOG_Bpn9YqExQqEu-wz1MDGCbpPmTdhrBb6TbWc,2820
+phylogenie/generators/configs.py,sha256=Xp8kk8sDy3EzKSgfdsVuMep1zEvdVX6U86yFgn6MS1I,999
+phylogenie/generators/dataset.py,sha256=kY92diePr2IjiLejHLixJoYRc-2LpM-GBt3wkX9SYvA,2109
+phylogenie/generators/factories.py,sha256=A-r33L5eYe2Shc-o7y6RHe8GoAcTTQw61249_lzC1BY,8123
+phylogenie/generators/trees.py,sha256=HrrSxpejURs2DXrV5PBm3OuD9RgSbSu_YBI_ukWbEcA,10119
+phylogenie/generators/typeguards.py,sha256=yj4VkhOaUXJ2OrY-6zhOeY9C4yKIQxjZtk2d-vIxttQ,828
+phylogenie/io/__init__.py,sha256=gtRYtDdZSTlWCj3I4vmMJSAs93jdz5RySkCakD3sxlQ,214
+phylogenie/io/fasta.py,sha256=IWtNb_RQLR6kvS0G826wB9SodkCGfugddoUHx78Yrec,837
+phylogenie/io/newick.py,sha256=vw0fafh1LL0SXQifIIa1TQ7g5KgTCIAX6vzq-bUOrKE,3396
+phylogenie/io/nexus.py,sha256=IKbV8lJ_Q053iYJ7JzVQPCUqSkSfmiRpUchFTrLHZuE,1551
+phylogenie/main.py,sha256=vtvSpQxBNlYABoFQ25czl-l3fIr4QRo3svWVd-jcArw,1170
+phylogenie/models.py,sha256=pCg9ob0RpLUHwM49x4knKxL4FNPr3-EU_6zMXsvxtAg,370
+phylogenie/msa.py,sha256=JDGyZUsAq6-m-SQjoCDjAkAZIxfgyl_PDIhdYn5HOow,2064
+phylogenie/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+phylogenie/skyline/__init__.py,sha256=7pF4CUb4ZCLzNYJNhOjpuTOLTRhlK7L6ugfccNqjIGo,620
+phylogenie/skyline/matrix.py,sha256=v4SitY7VbXprqlqQckjWTzW5hwRmCyIF595R6IJMxWw,9268
+phylogenie/skyline/parameter.py,sha256=TVqkqirGXNN-VP8hnIJACPkOxUan6LkGa5o_JcPfwbY,4834
+phylogenie/skyline/vector.py,sha256=60jtp7PieiEaEH0Tp6zNjNKjyzpN_nT5uwBUXbgeATk,7261
+phylogenie/tree.py,sha256=P1uM6s32TsODpvNJQIPMix9oj39vGSw_wsHYp2wmy5U,5246
+phylogenie/treesimulator/__init__.py,sha256=5UF2S3Evos0-7GJVSQxx6SICaKxcrmU7o1T8JS_cMKk,1246
+phylogenie/treesimulator/events/__init__.py,sha256=5ncG2JMh7RcSgG5BPR012UujxoTrczD0YCv-khSGSHM,792
+phylogenie/treesimulator/events/base.py,sha256=ruyje6lOgBVcsxzqLcEkvjX8TetvHk2xXqTCSz4apKM,875
+phylogenie/treesimulator/events/contact_tracing.py,sha256=bFu00rj5t1ToTuTwzFOqdttodyBAQ9VqUbZpAbvTMSg,4849
+phylogenie/treesimulator/events/core.py,sha256=rALA4LVXsWbtRn0R-SOoAD9w9zDLxmzwzGcQetTVtWU,7997
+phylogenie/treesimulator/features.py,sha256=wWD1aLs4qpFmw7GZpGolhfk7Ym6v9g-cIv2c717cLKU,1359
+phylogenie/treesimulator/gillespie.py,sha256=Xj-ntrhPVH6vMuAe7-Q7x1gA5Zr6xoYoeVLnZQKfcRU,6005
+phylogenie/treesimulator/model.py,sha256=lhDwmBFQ8Qh8qVGZPgED0vehtPC3DE7_CgCV_8rPB-A,4641
+phylogenie/treesimulator/mutations.py,sha256=Wv0qJqjGAMNTYftiCCaSXfZQA6pj8pSrmrOLyTI86ko,3635
+phylogenie/typeguards.py,sha256=JtqmbEWJZBRHbWgCvcl6nrWm3VcBfzRbklbTBYHItn0,1325
+phylogenie/typings.py,sha256=p694PBe_tk25A6N8vGGWxuqoDtt3nHFUsIYJrwR_76Y,494
+phylogenie/utils.py,sha256=ehVk_2kvjW8Q_EyM2kxBPHYiK-KlPmZQx7JeVN6Fh-E,5419
+phylogenie-2.1.25.dist-info/LICENSE.txt,sha256=NUrDqElK-eD3I0WqC004CJsy6cs0JgsAoebDv_42-pw,1071
+phylogenie-2.1.25.dist-info/METADATA,sha256=smzOlX4LSGx_MzMBneW1humdTaUL8FG-TekNtKS1AtE,5477
+phylogenie-2.1.25.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+phylogenie-2.1.25.dist-info/entry_points.txt,sha256=Rt6_usN0FkBX1ZfiqCirjMN9FKOgFLG8rydcQ8kugeE,51
+phylogenie-2.1.25.dist-info/RECORD,,

phylogenie-2.1.23.dist-info/RECORD

@@ -1,35 +0,0 @@
-phylogenie/__init__.py,sha256=8ulA-U7-WnBLNsqRYqPOPrJG8X4ZzyEU02oaDbR_Hxs,2849
-phylogenie/draw.py,sha256=WCjr_HCn-wCuxwkDhHA9Ijl1Sm6av6FBLkyR0MK2bVM,5271
-phylogenie/generators/__init__.py,sha256=zsOxy28-9j9alOQLIgrOAFfmM58NNHO_NEtW-KXQXAY,888
-phylogenie/generators/alisim.py,sha256=0aCLuGInifWgAvfh7zARWSKF4EMw3TjlPXMLSECui0k,2783
-phylogenie/generators/configs.py,sha256=WFoeKpgj9ZQIom7BKqwpgXbriiQGg3jFBMLoD8KButk,1073
-phylogenie/generators/dataset.py,sha256=pPwW9yxm9fkU0PPllFq8EsPlqau8tth-4OatbA_hEHo,2120
-phylogenie/generators/factories.py,sha256=TuVFQWRjq33Hewjw_Lp8tQ0l_IPtqYDyQCNJhtiHpw8,7882
-phylogenie/generators/trees.py,sha256=6tHS013RNRyIsObeYq2Kx9it7Yc0TgiMkeAHbskHzAM,10748
-phylogenie/generators/typeguards.py,sha256=yj4VkhOaUXJ2OrY-6zhOeY9C4yKIQxjZtk2d-vIxttQ,828
-phylogenie/io.py,sha256=vUG2yVtoV98tNHut46uSuB3VPj6s64VDhUp1EaSk0o0,4084
-phylogenie/main.py,sha256=vtvSpQxBNlYABoFQ25czl-l3fIr4QRo3svWVd-jcArw,1170
-phylogenie/models.py,sha256=pCg9ob0RpLUHwM49x4knKxL4FNPr3-EU_6zMXsvxtAg,370
-phylogenie/msa.py,sha256=JDGyZUsAq6-m-SQjoCDjAkAZIxfgyl_PDIhdYn5HOow,2064
-phylogenie/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-phylogenie/skyline/__init__.py,sha256=7pF4CUb4ZCLzNYJNhOjpuTOLTRhlK7L6ugfccNqjIGo,620
-phylogenie/skyline/matrix.py,sha256=Gl8OgKjtieG0NwPYiPimKI36gefV8fm_OeorjdXxPTs,9146
-phylogenie/skyline/parameter.py,sha256=EM9qlPt0JhMBy3TbztM0dj24BaGNEy8KWKdTObDKhbI,4644
-phylogenie/skyline/vector.py,sha256=bJP7_FNX_Klt6wXqsyfj0KX3VNj6-dIhzCKSJuQcOV0,7115
-phylogenie/tree.py,sha256=P1uM6s32TsODpvNJQIPMix9oj39vGSw_wsHYp2wmy5U,5246
-phylogenie/treesimulator/__init__.py,sha256=yqS2vtYMhdWSXc9RAnX1dd4zAqSQweMLyVKTnJLfGTU,1106
-phylogenie/treesimulator/events/__init__.py,sha256=6zSgZ0MEUMvTK4yPlSolJnRWzCARLS-jYreTzh45mQo,1033
-phylogenie/treesimulator/events/contact_tracing.py,sha256=_nJ85yhgGkeruQgMHvGpDYoyhheBf8M4LgZWiWdi5dY,4801
-phylogenie/treesimulator/events/core.py,sha256=RF7oHzAjkU675PnczaVc66d9gNrHBL-IhmVHtcy7MKE,7949
-phylogenie/treesimulator/events/mutations.py,sha256=erEvgfiv_X3G_DwK9Hqu-fAR8otupfwq66cp5tRZamM,3591
-phylogenie/treesimulator/features.py,sha256=Wj1rjbOAHHE9XqhrLND2GMgqTB_4M9MdAD5OWoUoatc,1356
-phylogenie/treesimulator/gillespie.py,sha256=LZHB2Ko147E78LoUCtN_BN7NYO1xhMYRy5PUZbN93c0,5283
-phylogenie/treesimulator/model.py,sha256=Nyg6R8XmMwZMSw1-dII81sU9uU7tDe-NMs8v1qKE4_M,5746
-phylogenie/typeguards.py,sha256=JtqmbEWJZBRHbWgCvcl6nrWm3VcBfzRbklbTBYHItn0,1325
-phylogenie/typings.py,sha256=GknvAFXyiaWeeYJ8Lk5d6E2VHT-xW6ONEojYbtJYiB8,476
-phylogenie/utils.py,sha256=ehVk_2kvjW8Q_EyM2kxBPHYiK-KlPmZQx7JeVN6Fh-E,5419
-phylogenie-2.1.23.dist-info/LICENSE.txt,sha256=NUrDqElK-eD3I0WqC004CJsy6cs0JgsAoebDv_42-pw,1071
-phylogenie-2.1.23.dist-info/METADATA,sha256=ym-NHK9hkvBR4kH_KGCnLnckV_iEzvFk0fdMzrkVudQ,5477
-phylogenie-2.1.23.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-phylogenie-2.1.23.dist-info/entry_points.txt,sha256=Rt6_usN0FkBX1ZfiqCirjMN9FKOgFLG8rydcQ8kugeE,51
-phylogenie-2.1.23.dist-info/RECORD,,