phylogenie 2.0.13__py3-none-any.whl → 2.1.0__py3-none-any.whl

phylogenie/__init__.py

@@ -8,9 +8,6 @@ from phylogenie.generators import (
     DatasetGeneratorConfig,
     EpidemiologicalTreeDatasetGenerator,
     FBDTreeDatasetGenerator,
-    SkylineMatrixModel,
-    SkylineParameterModel,
-    SkylineVectorModel,
     TreeDatasetGeneratorConfig,
 )
 from phylogenie.io import load_fasta, load_newick
@@ -30,6 +27,7 @@ from phylogenie.skyline import (
 from phylogenie.tree import Tree
 from phylogenie.treesimulator import (
     Event,
+    generate_trees,
     get_BD_events,
     get_BDEI_events,
     get_BDSS_events,
@@ -51,16 +49,13 @@ __all__ = [
     "FBDTreeDatasetGenerator",
     "SkylineMatrix",
     "SkylineMatrixCoercible",
-    "SkylineMatrixModel",
     "skyline_matrix",
     "SkylineParameter",
     "SkylineParameterLike",
-    "SkylineParameterModel",
     "skyline_parameter",
     "SkylineVector",
     "SkylineVectorCoercible",
     "SkylineVectorLike",
-    "SkylineVectorModel",
     "skyline_vector",
     "Tree",
     "TreeDatasetGeneratorConfig",
@@ -71,6 +66,7 @@ __all__ = [
     "get_canonical_events",
     "get_epidemiological_events",
     "get_FBD_events",
+    "generate_trees",
     "simulate_tree",
     "load_fasta",
     "load_newick",

phylogenie/generators/__init__.py

@@ -3,11 +3,6 @@ from typing import Annotated
 from pydantic import Field
 
 from phylogenie.generators.alisim import AliSimDatasetGenerator
-from phylogenie.generators.configs import (
-    SkylineMatrixModel,
-    SkylineParameterModel,
-    SkylineVectorModel,
-)
 from phylogenie.generators.dataset import DatasetGenerator
 from phylogenie.generators.trees import (
     BDEITreeDatasetGenerator,
@@ -34,7 +29,4 @@ __all__ = [
     "BDTreeDatasetGenerator",
     "BDEITreeDatasetGenerator",
     "BDSSTreeDatasetGenerator",
-    "SkylineMatrixModel",
-    "SkylineParameterModel",
-    "SkylineVectorModel",
 ]

phylogenie/generators/dataset.py

@@ -11,6 +11,7 @@ from numpy.random import Generator, default_rng
 from tqdm import tqdm
 
 import phylogenie.generators.configs as cfg
+from phylogenie.generators.factories import eval_expression
 
 
 class DataType(str, Enum):
@@ -56,18 +57,23 @@ class DatasetGenerator(ABC, cfg.StrictBaseModel):
         if self.context is not None:
             for d, (k, v) in product(data, self.context.items()):
                 args = v.model_extra if v.model_extra is not None else {}
+                for arg_name, arg_value in args.items():
+                    if isinstance(arg_value, str):
+                        args[arg_name] = eval_expression(arg_value, d)
                 d[k] = np.array(getattr(rng, v.type)(**args)).tolist()
             df = pd.DataFrame([{"file_id": str(i), **d} for i, d in enumerate(data)])
             df.to_csv(os.path.join(output_dir, METADATA_FILENAME), index=False)
 
-        joblib.Parallel(n_jobs=self.n_jobs)(
+        jobs = joblib.Parallel(n_jobs=self.n_jobs, return_as="generator_unordered")(
             joblib.delayed(self.generate_one)(
                 filename=os.path.join(data_dir, str(i)),
                 data=data[i],
                 seed=int(rng.integers(2**32)),
             )
-            for i in tqdm(range(n_samples), desc=f"Generating {data_dir}...")
+            for i in range(n_samples)
         )
+        for _ in tqdm(jobs, total=n_samples, desc=f"Generating {data_dir}..."):
+            pass
 
     def generate(self) -> None:
         rng = default_rng(self.seed)

phylogenie/generators/factories.py

@@ -16,7 +16,7 @@ from phylogenie.skyline import (
 )
 
 
-def _eval_expression(expression: str, data: dict[str, Any]) -> Any:
+def eval_expression(expression: str, data: dict[str, Any]) -> Any:
     return np.array(
         eval(
             expression,
@@ -31,7 +31,7 @@ def _eval_expression(expression: str, data: dict[str, Any]) -> Any:
 
 def integer(x: cfg.Integer, data: dict[str, Any]) -> int:
     if isinstance(x, str):
-        e = _eval_expression(x, data)
+        e = eval_expression(x, data)
         if isinstance(e, int):
             return e
         raise ValueError(
@@ -42,7 +42,7 @@ def integer(x: cfg.Integer, data: dict[str, Any]) -> int:
 
 def scalar(x: cfg.Scalar, data: dict[str, Any]) -> pgt.Scalar:
     if isinstance(x, str):
-        e = _eval_expression(x, data)
+        e = eval_expression(x, data)
         if isinstance(e, pgt.Scalar):
             return e
         raise ValueError(
@@ -53,7 +53,7 @@ def scalar(x: cfg.Scalar, data: dict[str, Any]) -> pgt.Scalar:
 
 def many_scalars(x: cfg.ManyScalars, data: dict[str, Any]) -> pgt.ManyScalars:
     if isinstance(x, str):
-        e = _eval_expression(x, data)
+        e = eval_expression(x, data)
         if tg.is_many_scalars(e):
             return e
         raise ValueError(
@@ -66,7 +66,7 @@ def one_or_many_scalars(
     x: cfg.OneOrManyScalars, data: dict[str, Any]
 ) -> pgt.OneOrManyScalars:
     if isinstance(x, str):
-        e = _eval_expression(x, data)
+        e = eval_expression(x, data)
         if tg.is_one_or_many_scalars(e):
             return e
         raise ValueError(
@@ -92,7 +92,7 @@ def skyline_vector(
     x: cfg.SkylineVector, data: dict[str, Any]
 ) -> SkylineVectorCoercible:
     if isinstance(x, str):
-        e = _eval_expression(x, data)
+        e = eval_expression(x, data)
         if tg.is_one_or_many_scalars(e):
             return e
         raise ValueError(
@@ -107,7 +107,7 @@ def skyline_vector(
 
     change_times = many_scalars(x.change_times, data)
     if isinstance(x.value, str):
-        e = _eval_expression(x.value, data)
+        e = eval_expression(x.value, data)
         if tg.is_many_one_or_many_scalars(e):
             value = e
         else:
@@ -135,7 +135,7 @@ def one_or_many_2D_scalars(
     x: cfg.OneOrMany2DScalars, data: dict[str, Any]
 ) -> pgt.OneOrMany2DScalars:
     if isinstance(x, str):
-        e = _eval_expression(x, data)
+        e = eval_expression(x, data)
         if tg.is_one_or_many_2D_scalars(e):
             return e
         raise ValueError(
@@ -153,7 +153,7 @@ def skyline_matrix(
         return None
 
     if isinstance(x, str):
-        e = _eval_expression(x, data)
+        e = eval_expression(x, data)
         if tg.is_one_or_many_2D_scalars(e):
             return e
         raise ValueError(
@@ -168,7 +168,7 @@ def skyline_matrix(
 
     change_times = many_scalars(x.change_times, data)
     if isinstance(x.value, str):
-        e = _eval_expression(x.value, data)
+        e = eval_expression(x.value, data)
         if tg.is_many_one_or_many_2D_scalars(e):
             value = e
         else:

phylogenie/generators/trees.py

@@ -23,6 +23,7 @@ from phylogenie.treesimulator import (
     get_BDEI_events,
     get_BDSS_events,
     get_canonical_events,
+    get_contact_tracing_events,
     get_epidemiological_events,
     get_FBD_events,
     simulate_tree,
@@ -41,16 +42,14 @@ class ParameterizationType(str, Enum):
 class TreeDatasetGenerator(DatasetGenerator):
     data_type: Literal[DataType.TREES] = DataType.TREES
     min_tips: cfg.Integer = 1
-    max_tips: cfg.Integer | None = None
+    max_tips: cfg.Integer = 2**32
     max_time: cfg.Scalar = np.inf
     init_state: str | None = None
     sampling_probability_at_present: cfg.Scalar = 0.0
     max_tries: int | None = None
-    notification_probability: cfg.Scalar = 0.0
-    max_notified_contacts: cfg.Integer = 1
-    samplable_states_after_notification: list[str] | None = None
-    sampling_rate_after_notification: cfg.SkylineParameter = np.inf
-    contacts_removal_probability: cfg.SkylineParameter = 1
+
+    @abstractmethod
+    def _get_events(self, data: dict[str, Any]) -> list[Event]: ...
 
     def simulate_one(self, rng: Generator, data: dict[str, Any]) -> Tree | None:
         events = self._get_events(data)
@@ -59,34 +58,19 @@ class TreeDatasetGenerator(DatasetGenerator):
             if self.init_state is None
             else self.init_state.format(**data)
         )
-        max_tips = (
-            self.max_tips if self.max_tips is None else integer(self.max_tips, data)
-        )
         return simulate_tree(
             events=events,
             min_tips=integer(self.min_tips, data),
-            max_tips=max_tips,
+            max_tips=integer(self.max_tips, data),
             max_time=scalar(self.max_time, data),
             init_state=init_state,
             sampling_probability_at_present=scalar(
                 self.sampling_probability_at_present, data
             ),
-            notification_probability=scalar(self.notification_probability, data),
-            max_notified_contacts=integer(self.max_notified_contacts, data),
-            samplable_states_after_notification=self.samplable_states_after_notification,
-            sampling_rate_after_notification=skyline_parameter(
-                self.sampling_rate_after_notification, data
-            ),
-            contacts_removal_probability=skyline_parameter(
-                self.contacts_removal_probability, data
-            ),
             max_tries=self.max_tries,
             seed=int(rng.integers(2**32)),
         )
 
-    @abstractmethod
-    def _get_events(self, data: dict[str, Any]) -> list[Event]: ...
-
     def _generate_one(
         self, filename: str, rng: Generator, data: dict[str, Any]
     ) -> None:
@@ -101,9 +85,9 @@ class CanonicalTreeDatasetGenerator(TreeDatasetGenerator):
     )
     states: list[str]
     sampling_rates: cfg.SkylineVector
+    remove_after_sampling: bool
     birth_rates: cfg.SkylineVector = 0
     death_rates: cfg.SkylineVector = 0
-    removal_probabilities: cfg.SkylineVector = 0
     migration_rates: cfg.SkylineMatrix = None
     birth_rates_among_states: cfg.SkylineMatrix = None
 
@@ -111,9 +95,9 @@ class CanonicalTreeDatasetGenerator(TreeDatasetGenerator):
         return get_canonical_events(
             states=self.states,
             sampling_rates=skyline_vector(self.sampling_rates, data),
+            remove_after_sampling=self.remove_after_sampling,
             birth_rates=skyline_vector(self.birth_rates, data),
             death_rates=skyline_vector(self.death_rates, data),
-            removal_probabilities=skyline_vector(self.removal_probabilities, data),
             migration_rates=skyline_matrix(self.migration_rates, data),
             birth_rates_among_states=skyline_matrix(
                 self.birth_rates_among_states, data
@@ -121,19 +105,66 @@ class CanonicalTreeDatasetGenerator(TreeDatasetGenerator):
         )
 
 
-class EpidemiologicalTreeDatasetGenerator(TreeDatasetGenerator):
+class FBDTreeDatasetGenerator(TreeDatasetGenerator):
+    parameterization: Literal[ParameterizationType.FBD] = ParameterizationType.FBD
+    states: list[str]
+    sampling_proportions: cfg.SkylineVector
+    diversification: cfg.SkylineVector = 0
+    turnover: cfg.SkylineVector = 0
+    migration_rates: cfg.SkylineMatrix = None
+    diversification_between_states: cfg.SkylineMatrix = None
+
+    def _get_events(self, data: dict[str, Any]) -> list[Event]:
+        return get_FBD_events(
+            states=self.states,
+            diversification=skyline_vector(self.diversification, data),
+            turnover=skyline_vector(self.turnover, data),
+            sampling_proportions=skyline_vector(self.sampling_proportions, data),
+            migration_rates=skyline_matrix(self.migration_rates, data),
+            diversification_between_states=skyline_matrix(
+                self.diversification_between_states, data
+            ),
+        )
+
+
+class TreeDatasetGeneratorWithContactTracing(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
+
+    @abstractmethod
+    def _get_base_events(self, data: dict[str, Any]) -> list[Event]: ...
+
+    def _get_events(self, data: dict[str, Any]) -> list[Event]:
+        events = self._get_base_events(data)
+        if self.notification_probability:
+            events = get_contact_tracing_events(
+                events=events,
+                max_notified_contacts=integer(self.max_notified_contacts, data),
+                notification_probability=skyline_parameter(
+                    self.notification_probability, data
+                ),
+                sampling_rate_after_notification=skyline_parameter(
+                    self.sampling_rate_after_notification, data
+                ),
+                samplable_states_after_notification=self.samplable_states_after_notification,
+            )
+        return events
+
+
+class EpidemiologicalTreeDatasetGenerator(TreeDatasetGeneratorWithContactTracing):
     parameterization: Literal[ParameterizationType.EPIDEMIOLOGICAL] = (
         ParameterizationType.EPIDEMIOLOGICAL
     )
     states: list[str]
+    sampling_proportions: cfg.SkylineVector
     reproduction_numbers: cfg.SkylineVector = 0
     become_uninfectious_rates: cfg.SkylineVector = 0
-    sampling_proportions: cfg.SkylineVector = 1
-    removal_probabilities: cfg.SkylineVector = 1
     migration_rates: cfg.SkylineMatrix = None
     reproduction_numbers_among_states: cfg.SkylineMatrix = None
 
-    def _get_events(self, data: dict[str, Any]) -> list[Event]:
+    def _get_base_events(self, data: dict[str, Any]) -> list[Event]:
         return get_epidemiological_events(
             states=self.states,
             reproduction_numbers=skyline_vector(self.reproduction_numbers, data),
@@ -141,7 +172,6 @@ class EpidemiologicalTreeDatasetGenerator(TreeDatasetGenerator):
                 self.become_uninfectious_rates, data
             ),
             sampling_proportions=skyline_vector(self.sampling_proportions, data),
-            removal_probabilities=skyline_vector(self.removal_probabilities, data),
             migration_rates=skyline_matrix(self.migration_rates, data),
             reproduction_numbers_among_states=skyline_matrix(
                 self.reproduction_numbers_among_states, data
@@ -149,37 +179,13 @@ class EpidemiologicalTreeDatasetGenerator(TreeDatasetGenerator):
         )
 
 
-class FBDTreeDatasetGenerator(TreeDatasetGenerator):
-    parameterization: Literal[ParameterizationType.FBD] = ParameterizationType.FBD
-    states: list[str]
-    diversification: cfg.SkylineVector = 0
-    turnover: cfg.SkylineVector = 0
-    sampling_proportions: cfg.SkylineVector = 1
-    removal_probabilities: cfg.SkylineVector = 0
-    migration_rates: cfg.SkylineMatrix = None
-    diversification_between_types: cfg.SkylineMatrix = None
-
-    def _get_events(self, data: dict[str, Any]) -> list[Event]:
-        return get_FBD_events(
-            states=self.states,
-            diversification=skyline_vector(self.diversification, data),
-            turnover=skyline_vector(self.turnover, data),
-            sampling_proportions=skyline_vector(self.sampling_proportions, data),
-            removal_probabilities=skyline_vector(self.removal_probabilities, data),
-            migration_rates=skyline_matrix(self.migration_rates, data),
-            diversification_between_types=skyline_matrix(
-                self.diversification_between_types, data
-            ),
-        )
-
-
-class BDTreeDatasetGenerator(TreeDatasetGenerator):
+class BDTreeDatasetGenerator(TreeDatasetGeneratorWithContactTracing):
     parameterization: Literal[ParameterizationType.BD] = ParameterizationType.BD
     reproduction_number: cfg.SkylineParameter
     infectious_period: cfg.SkylineParameter
     sampling_proportion: cfg.SkylineParameter = 1
 
-    def _get_events(self, data: dict[str, Any]) -> list[Event]:
+    def _get_base_events(self, data: dict[str, Any]) -> list[Event]:
         return get_BD_events(
             reproduction_number=skyline_parameter(self.reproduction_number, data),
             infectious_period=skyline_parameter(self.infectious_period, data),
@@ -187,14 +193,14 @@ class BDTreeDatasetGenerator(TreeDatasetGenerator):
         )
 
 
-class BDEITreeDatasetGenerator(TreeDatasetGenerator):
+class BDEITreeDatasetGenerator(TreeDatasetGeneratorWithContactTracing):
     parameterization: Literal[ParameterizationType.BDEI] = ParameterizationType.BDEI
     reproduction_number: cfg.SkylineParameter
     infectious_period: cfg.SkylineParameter
     incubation_period: cfg.SkylineParameter
     sampling_proportion: cfg.SkylineParameter = 1
 
-    def _get_events(self, data: dict[str, Any]) -> list[Event]:
+    def _get_base_events(self, data: dict[str, Any]) -> list[Event]:
         return get_BDEI_events(
             reproduction_number=skyline_parameter(self.reproduction_number, data),
             infectious_period=skyline_parameter(self.infectious_period, data),
@@ -203,7 +209,7 @@ class BDEITreeDatasetGenerator(TreeDatasetGenerator):
         )
 
 
-class BDSSTreeDatasetGenerator(TreeDatasetGenerator):
+class BDSSTreeDatasetGenerator(TreeDatasetGeneratorWithContactTracing):
     parameterization: Literal[ParameterizationType.BDSS] = ParameterizationType.BDSS
     reproduction_number: cfg.SkylineParameter
     infectious_period: cfg.SkylineParameter
@@ -211,7 +217,7 @@ class BDSSTreeDatasetGenerator(TreeDatasetGenerator):
     superspreaders_proportion: cfg.SkylineParameter
     sampling_proportion: cfg.SkylineParameter = 1
 
-    def _get_events(self, data: dict[str, Any]) -> list[Event]:
+    def _get_base_events(self, data: dict[str, Any]) -> list[Event]:
         return get_BDSS_events(
             reproduction_number=skyline_parameter(self.reproduction_number, data),
             infectious_period=skyline_parameter(self.infectious_period, data),

phylogenie/io.py

@@ -66,9 +66,12 @@ def _to_newick(tree: Tree) -> str:
     return newick
 
 
-def dump_newick(tree: Tree, filepath: str) -> None:
+def dump_newick(trees: Tree | list[Tree], filepath: str) -> None:
+    if isinstance(trees, Tree):
+        trees = [trees]
     with open(filepath, "w") as file:
-        file.write(_to_newick(tree) + ";")
+        for t in trees:
+            file.write(_to_newick(t) + ";\n")
 
 
 def load_fasta(

phylogenie/treesimulator/__init__.py

@@ -8,7 +8,7 @@ from phylogenie.treesimulator.events import (
     get_epidemiological_events,
     get_FBD_events,
 )
-from phylogenie.treesimulator.gillespie import simulate_tree
+from phylogenie.treesimulator.gillespie import generate_trees, simulate_tree
 
 __all__ = [
     "Event",
@@ -19,5 +19,6 @@ __all__ = [
     "get_contact_tracing_events",
     "get_epidemiological_events",
     "get_FBD_events",
+    "generate_trees",
     "simulate_tree",
 ]

phylogenie/treesimulator/events.py

@@ -3,6 +3,7 @@ from collections.abc import Sequence
 from dataclasses import dataclass
 
 import numpy as np
+from numpy.random import Generator
 
 from phylogenie.skyline import (
     SkylineMatrixCoercible,
@@ -13,11 +14,20 @@ from phylogenie.skyline import (
     skyline_parameter,
     skyline_vector,
 )
-from phylogenie.treesimulator.model import Model, get_CT_state
+from phylogenie.treesimulator.model import Model
 
 INFECTIOUS_STATE = "I"
 EXPOSED_STATE = "E"
 SUPERSPREADER_STATE = "S"
+CT_POSTFIX = "-CT"
+
+
+def _get_CT_state(state: str) -> str:
+    return f"{state}{CT_POSTFIX}"
+
+
+def _is_CT_state(state: str) -> bool:
+    return state.endswith(CT_POSTFIX)
 
 
 @dataclass
@@ -25,6 +35,9 @@ class Event(ABC):
     rate: SkylineParameter
     state: str
 
+    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)
@@ -33,48 +46,65 @@ class Event(ABC):
         return rate * n_individuals
 
     @abstractmethod
-    def apply(self, model: Model, time: float) -> None: ...
+    def apply(self, model: Model, time: float, rng: Generator) -> None: ...
 
 
 @dataclass
-class BirthEvent(Event):
+class Birth(Event):
     child_state: str
 
-    def apply(self, model: Model, time: float) -> None:
-        individual = model.get_random_individual(self.state)
+    def apply(self, model: Model, time: float, rng: Generator) -> None:
+        individual = self.draw_individual(model, rng)
         model.birth_from(individual, self.child_state, time)
 
 
-class DeathEvent(Event):
-    def apply(self, model: Model, time: float) -> None:
-        individual = model.get_random_individual(self.state)
+class Death(Event):
+    def apply(self, model: Model, time: float, rng: Generator) -> None:
+        individual = self.draw_individual(model, rng)
         model.remove(individual, time)
 
 
 @dataclass
-class MigrationEvent(Event):
+class Migration(Event):
     target_state: str
 
-    def apply(self, model: Model, time: float) -> None:
-        individual = model.get_random_individual(self.state)
+    def apply(self, model: Model, time: float, rng: Generator) -> None:
+        individual = self.draw_individual(model, rng)
         model.migrate(individual, self.target_state, time)
 
 
 @dataclass
-class SamplingEvent(Event):
-    removal_probability: SkylineParameter
+class Sampling(Event):
+    removal: bool
+
+    def apply(self, model: Model, time: float, rng: Generator) -> None:
+        individual = self.draw_individual(model, rng)
+        model.sample(individual, time, self.removal)
 
-    def apply(self, model: Model, time: float) -> None:
-        individual = model.get_random_individual(self.state)
-        model.sample(individual, time, self.removal_probability.get_value_at_time(time))
+
+@dataclass
+class SamplingWithContactTracing(Event):
+    max_notified_contacts: int
+    notification_probability: SkylineParameter
+
+    def apply(self, model: Model, time: float, rng: Generator) -> None:
+        individual = self.draw_individual(model, rng)
+        model.sample(individual, time, True)
+        population = model.get_population()
+        for contact in model.get_lineage(individual)[-self.max_notified_contacts :]:
+            if contact in population:
+                state = model.get_state(contact)
+                p = self.notification_probability.get_value_at_time(time)
+                if not _is_CT_state(state) and rng.random() < p:
+                    model.migrate(contact, _get_CT_state(state), time)
 
 
 def get_canonical_events(
     states: Sequence[str],
     sampling_rates: SkylineVectorCoercible,
+    remove_after_sampling: bool,
     birth_rates: SkylineVectorCoercible = 0,
     death_rates: SkylineVectorCoercible = 0,
-    removal_probabilities: SkylineVectorCoercible = 0,
     migration_rates: SkylineMatrixCoercible | None = None,
     birth_rates_among_states: SkylineMatrixCoercible | None = None,
 ) -> list[Event]:
@@ -83,102 +113,94 @@ def get_canonical_events(
     birth_rates = skyline_vector(birth_rates, N)
     death_rates = skyline_vector(death_rates, N)
     sampling_rates = skyline_vector(sampling_rates, N)
-    removal_probabilities = skyline_vector(removal_probabilities, N)
 
     events: list[Event] = []
     for i, state in enumerate(states):
-        events.append(BirthEvent(birth_rates[i], state, state))
-        events.append(DeathEvent(death_rates[i], state))
-        events.append(SamplingEvent(sampling_rates[i], state, removal_probabilities[i]))
+        events.append(Birth(birth_rates[i], state, state))
+        events.append(Death(death_rates[i], state))
+        events.append(Sampling(sampling_rates[i], state, remove_after_sampling))
 
     if migration_rates is not None:
         migration_rates = skyline_matrix(migration_rates, N, N - 1)
         for i, state in enumerate(states):
             for j, other_state in enumerate([s for s in states if s != state]):
-                events.append(MigrationEvent(migration_rates[i, j], state, other_state))
+                events.append(Migration(migration_rates[i, j], state, other_state))
 
     if birth_rates_among_states is not None:
         birth_rates_among_states = skyline_matrix(birth_rates_among_states, N, N - 1)
         for i, state in enumerate(states):
             for j, other_state in enumerate([s for s in states if s != state]):
-                events.append(
-                    BirthEvent(birth_rates_among_states[i, j], state, other_state)
-                )
+                events.append(Birth(birth_rates_among_states[i, j], state, other_state))
 
     return [event for event in events if event.rate]
 
 
-def get_epidemiological_events(
+def get_FBD_events(
     states: Sequence[str],
     sampling_proportions: SkylineVectorCoercible = 1,
-    reproduction_numbers: SkylineVectorCoercible = 0,
-    become_uninfectious_rates: SkylineVectorCoercible = 0,
-    removal_probabilities: SkylineVectorCoercible = 1,
+    diversification: SkylineVectorCoercible = 0,
+    turnover: SkylineVectorCoercible = 0,
     migration_rates: SkylineMatrixCoercible | None = None,
-    reproduction_numbers_among_states: SkylineMatrixCoercible | None = None,
+    diversification_between_states: SkylineMatrixCoercible | None = None,
 ) -> list[Event]:
     N = len(states)
 
-    reproduction_numbers = skyline_vector(reproduction_numbers, N)
-    become_uninfectious_rates = skyline_vector(become_uninfectious_rates, N)
+    diversification = skyline_vector(diversification, N)
+    turnover = skyline_vector(turnover, N)
     sampling_proportions = skyline_vector(sampling_proportions, N)
-    removal_probabilities = skyline_vector(removal_probabilities, N)
 
-    birth_rates = reproduction_numbers * become_uninfectious_rates
-    sampling_rates = become_uninfectious_rates * sampling_proportions
-    death_rates = become_uninfectious_rates - removal_probabilities * sampling_rates
+    birth_rates = diversification / (1 - turnover)
+    death_rates = turnover * birth_rates
+    sampling_rates = sampling_proportions * death_rates
     birth_rates_among_states = (
-        (
-            skyline_matrix(reproduction_numbers_among_states, N, N - 1)
-            * become_uninfectious_rates
-        )
-        if reproduction_numbers_among_states is not None
+        (skyline_matrix(diversification_between_states, N, N - 1) + death_rates)
+        if diversification_between_states is not None
         else None
     )
 
     return get_canonical_events(
         states=states,
+        sampling_rates=sampling_rates,
+        remove_after_sampling=False,
         birth_rates=birth_rates,
         death_rates=death_rates,
-        sampling_rates=sampling_rates,
-        removal_probabilities=removal_probabilities,
         migration_rates=migration_rates,
         birth_rates_among_states=birth_rates_among_states,
     )
 
 
-def get_FBD_events(
+def get_epidemiological_events(
     states: Sequence[str],
-    diversification: SkylineVectorCoercible = 0,
-    turnover: SkylineVectorCoercible = 0,
     sampling_proportions: SkylineVectorCoercible = 1,
-    removal_probabilities: SkylineVectorCoercible = 0,
+    reproduction_numbers: SkylineVectorCoercible = 0,
+    become_uninfectious_rates: SkylineVectorCoercible = 0,
     migration_rates: SkylineMatrixCoercible | None = None,
-    diversification_between_types: SkylineMatrixCoercible | None = None,
+    reproduction_numbers_among_states: SkylineMatrixCoercible | None = None,
 ) -> list[Event]:
     N = len(states)
 
-    diversification = skyline_vector(diversification, N)
-    turnover = skyline_vector(turnover, N)
+    reproduction_numbers = skyline_vector(reproduction_numbers, N)
+    become_uninfectious_rates = skyline_vector(become_uninfectious_rates, N)
     sampling_proportions = skyline_vector(sampling_proportions, N)
-    removal_probabilities = skyline_vector(removal_probabilities, N)
 
-    birth_rates = diversification / (1 - turnover)
-    death_rates = turnover * birth_rates
-    sampling_rates_dividend = 1 - removal_probabilities * sampling_proportions
-    sampling_rates = sampling_proportions * death_rates / sampling_rates_dividend
+    birth_rates = reproduction_numbers * become_uninfectious_rates
+    sampling_rates = become_uninfectious_rates * sampling_proportions
+    death_rates = become_uninfectious_rates - sampling_rates
     birth_rates_among_states = (
-        (skyline_matrix(diversification_between_types, N, N - 1) + death_rates)
-        if diversification_between_types is not None
+        (
+            skyline_matrix(reproduction_numbers_among_states, N, N - 1)
+            * become_uninfectious_rates
+        )
+        if reproduction_numbers_among_states is not None
         else None
     )
 
     return get_canonical_events(
         states=states,
+        sampling_rates=sampling_rates,
+        remove_after_sampling=True,
         birth_rates=birth_rates,
         death_rates=death_rates,
-        sampling_rates=sampling_rates,
-        removal_probabilities=removal_probabilities,
         migration_rates=migration_rates,
         birth_rates_among_states=birth_rates_among_states,
     )
@@ -236,35 +258,51 @@ def get_BDSS_events(
 
 def get_contact_tracing_events(
     events: Sequence[Event],
-    samplable_states_after_notification: Sequence[str] | None = None,
+    max_notified_contacts: int = 1,
+    notification_probability: SkylineParameterLike = 1,
     sampling_rate_after_notification: SkylineParameterLike = np.inf,
-    contacts_removal_probability: SkylineParameterLike = 1,
+    samplable_states_after_notification: Sequence[str] | None = None,
 ) -> list[Event]:
-    ct_events = list(events)
+    ct_events = [e for e in events if not isinstance(e, Sampling)]
+
     for event in events:
-        if isinstance(event, MigrationEvent):
+        if isinstance(event, Migration):
             ct_events.append(
-                MigrationEvent(
+                Migration(
                     event.rate,
-                    get_CT_state(event.state),
-                    get_CT_state(event.target_state),
+                    _get_CT_state(event.state),
+                    _get_CT_state(event.target_state),
                 )
             )
-        elif isinstance(event, BirthEvent):
+        elif isinstance(event, Birth):
             ct_events.append(
-                BirthEvent(event.rate, get_CT_state(event.state), event.child_state)
+                Birth(event.rate, _get_CT_state(event.state), event.child_state)
+            )
+        elif isinstance(event, Sampling):
+            if not event.removal:
+                raise ValueError(
+                    "Contact tracing requires removal to be set for all sampling events."
+                )
+            ct_events.append(
+                SamplingWithContactTracing(
+                    event.rate,
+                    event.state,
+                    max_notified_contacts,
+                    skyline_parameter(notification_probability),
+                )
             )
 
     for state in (
         samplable_states_after_notification
         if samplable_states_after_notification is not None
-        else [e.state for e in events]
+        else {e.state for e in events}
     ):
         ct_events.append(
-            SamplingEvent(
+            SamplingWithContactTracing(
                 skyline_parameter(sampling_rate_after_notification),
-                get_CT_state(state),
-                skyline_parameter(contacts_removal_probability),
+                _get_CT_state(state),
+                max_notified_contacts,
+                skyline_parameter(notification_probability),
             )
         )
 

phylogenie/treesimulator/gillespie.py

@@ -1,84 +1,128 @@
+import os
 from collections.abc import Sequence
 
+import joblib
 import numpy as np
 from numpy.random import default_rng
+from tqdm import tqdm
 
-from phylogenie.skyline import SkylineParameterLike
+from phylogenie.io import dump_newick
 from phylogenie.tree import Tree
-from phylogenie.treesimulator.events import Event, get_contact_tracing_events
+from phylogenie.treesimulator.events import Event
 from phylogenie.treesimulator.model import Model
 
 
 def simulate_tree(
     events: Sequence[Event],
     min_tips: int = 1,
-    max_tips: int | None = None,
+    max_tips: int = 2**32,
     max_time: float = np.inf,
     init_state: str | None = None,
     sampling_probability_at_present: float = 0.0,
-    notification_probability: float = 0,
-    max_notified_contacts: int = 1,
-    samplable_states_after_notification: Sequence[str] | None = None,
-    sampling_rate_after_notification: SkylineParameterLike = np.inf,
-    contacts_removal_probability: SkylineParameterLike = 1,
     max_tries: int | None = None,
     seed: int | None = None,
 ) -> Tree | None:
-    rng = default_rng(seed)
-
-    if max_tips is None and max_time == np.inf:
-        raise ValueError("Either max_tips or max_time must be specified.")
+    if max_time == np.inf and max_tips == 2**32:
+        raise ValueError("Either max_time or max_tips must be specified.")
 
-    root_states = list({e.state for e in events})
+    if max_time == np.inf and sampling_probability_at_present:
+        raise ValueError(
+            "sampling_probability_at_present cannot be set when max_time is infinite."
+        )
 
-    if notification_probability:
-        events = get_contact_tracing_events(
-            events,
-            samplable_states_after_notification,
-            sampling_rate_after_notification,
-            contacts_removal_probability,
+    states = {e.state for e in events}
+    if init_state is None and len(states) > 1:
+        raise ValueError(
+            "Init state must be provided for models with more than one state."
         )
+    elif init_state is None:
+        (init_state,) = states
+    elif init_state not in states:
+        raise ValueError(f"Init state {init_state} not found in event states: {states}")
 
+    rng = default_rng(seed)
     n_tries = 0
     while max_tries is None or n_tries < max_tries:
-        root_state = init_state if init_state is not None else rng.choice(root_states)
-        model = Model(root_state, max_notified_contacts, notification_probability, rng)
+        model = Model(init_state)
         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
-        n_tips = None if max_tips is None else rng.integers(min_tips, max_tips + 1)
 
-        while current_time < max_time and (n_tips is None or model.n_sampled < n_tips):
+        target_n_tips = rng.integers(min_tips, max_tips) if max_time == np.inf else None
+        while current_time < max_time:
             rates = [e.get_propensity(model, current_time) for e in events]
 
             instantaneous_events = [e for e, r in zip(events, rates) if r == np.inf]
             if instantaneous_events:
                 event = instantaneous_events[rng.integers(len(instantaneous_events))]
-                event.apply(model, current_time)
+                event.apply(model, current_time, rng)
                 continue
 
-            if not any(rates):
-                break
-
-            current_time += rng.exponential(1 / sum(rates))
-            if current_time >= max_time:
+            if (
+                not any(rates)
+                or model.n_sampled > max_tips
+                or target_n_tips is not None
+                and model.n_sampled >= target_n_tips
+            ):
                 break
 
-            if current_time >= next_change_time:
+            time_step = rng.exponential(1 / sum(rates))
+            if current_time + time_step >= next_change_time:
                 current_time = next_change_time
                 next_change_time = change_times.pop(0) if change_times else np.inf
                 continue
+            if current_time + time_step >= max_time:
+                current_time = max_time
+                break
+            current_time += time_step
 
             event_idx = np.searchsorted(np.cumsum(rates) / sum(rates), rng.random())
-            events[int(event_idx)].apply(model, current_time)
+            events[int(event_idx)].apply(model, current_time, rng)
 
         for individual in model.get_population():
             if rng.random() < sampling_probability_at_present:
-                model.sample(individual, current_time, 1)
+                model.sample(individual, current_time, True)
 
-        if model.n_sampled >= min_tips and (
-            max_tips is None or model.n_sampled <= max_tips
-        ):
+        if min_tips <= model.n_sampled <= max_tips:
             return model.get_sampled_tree()
-
         n_tries += 1
+
+    print("WARNING: Maximum number of tries reached, returning None.")
+
+
+def generate_trees(
+    output_dir: str,
+    n_trees: int,
+    events: Sequence[Event],
+    min_tips: int = 1,
+    max_tips: int = 2**32,
+    max_time: float = np.inf,
+    init_state: str | None = None,
+    sampling_probability_at_present: float = 0.0,
+    max_tries: int | None = None,
+    seed: int | None = None,
+    n_jobs: int = -1,
+) -> None:
+    if os.path.exists(output_dir):
+        raise FileExistsError(f"Output directory {output_dir} already exists")
+    os.mkdir(output_dir)
+
+    rng = default_rng(seed)
+    jobs = joblib.Parallel(n_jobs=n_jobs, return_as="generator_unordered")(
+        joblib.delayed(simulate_tree)(
+            events=events,
+            min_tips=min_tips,
+            max_tips=max_tips,
+            max_time=max_time,
+            init_state=init_state,
+            sampling_probability_at_present=sampling_probability_at_present,
+            max_tries=max_tries,
+            seed=int(rng.integers(2**32)),
+        )
+        for _ in range(n_trees)
+    )
+    for i, tree in tqdm(
+        enumerate(jobs), total=n_trees, desc=f"Generating trees in {output_dir}..."
+    ):
+        if tree is not None:
+            dump_newick(tree, os.path.join(output_dir, f"{i}.nwk"))

phylogenie/treesimulator/model.py

@@ -1,51 +1,25 @@
 from collections import defaultdict
-from dataclasses import dataclass, field
-from typing import ClassVar
-
-from numpy.random import Generator, default_rng
+from dataclasses import dataclass
 
 from phylogenie.tree import Tree
 
-CT_POSTFIX = "-CT"
-
-
-def get_CT_state(state: str) -> str:
-    return f"{state}{CT_POSTFIX}"
-
-
-def is_CT_state(state: str) -> bool:
-    return state.endswith(CT_POSTFIX)
-
 
 @dataclass
 class Individual:
+    id: int
     node: Tree
     state: str
-    id: int = field(init=False)
-    _id_counter: ClassVar[int] = 0
-
-    def __post_init__(self):
-        Individual._id_counter += 1
-        self.id = Individual._id_counter
 
 
 class Model:
-    def __init__(
-        self,
-        init_state: str,
-        max_notified_contacts: int = 1,
-        notification_probability: float = 0,
-        rng: int | Generator | None = None,
-    ):
+    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._contacts: dict[int, list[Individual]] = defaultdict(list)
+        self._lineages: dict[int, list[Individual]] = defaultdict(list)
         self._sampled: set[str] = set()
         self._tree = self._get_new_individual(init_state).node
-        self._max_notified_contacts = max_notified_contacts
-        self._notification_probability = notification_probability
-        self._rng = rng if isinstance(rng, Generator) else default_rng(rng)
 
     @property
     def n_sampled(self) -> int:
@@ -56,7 +30,10 @@ class Model:
         return Tree(f"{self._next_node_id}|{state}")
 
     def _get_new_individual(self, state: str) -> Individual:
-        individual = Individual(self._get_new_node(state), state)
+        self._next_individual_id += 1
+        individual = Individual(
+            self._next_individual_id, self._get_new_node(state), state
+        )
         self._population[individual.id] = individual
         self._states[state].add(individual.id)
         return individual
@@ -93,12 +70,12 @@ class Model:
         new_individual = self._get_new_individual(state)
         individual.node.add_child(new_individual.node)
         self._stem(individual, time)
-        self._contacts[id].append(new_individual)
-        self._contacts[new_individual.id].append(individual)
+        self._lineages[id].append(new_individual)
+        self._lineages[new_individual.id].append(individual)
 
-    def sample(self, id: int, time: float, removal_probability: float) -> None:
+    def sample(self, id: int, time: float, removal: bool) -> None:
         individual = self._population[id]
-        if self._rng.random() < removal_probability:
+        if removal:
             self._sampled.add(individual.node.id)
             self.remove(id, time)
         else:
@@ -108,13 +85,11 @@ class Model:
             individual.node.add_child(sample_node)
             self._stem(individual, time)
 
-        for contact in self._contacts[id][-self._max_notified_contacts :]:
-            if (
-                contact.id in self._population
-                and not is_CT_state(contact.state)
-                and self._rng.random() < self._notification_probability
-            ):
-                self.migrate(contact.id, get_CT_state(contact.state), time)
+    def get_lineage(self, id: int) -> list[int]:
+        return [individual.id for individual in self._lineages[id]]
+
+    def get_state(self, id: int) -> str:
+        return self._population[id].state
 
     def get_sampled_tree(self) -> Tree:
         tree = self._tree.copy()
@@ -140,13 +115,10 @@ class Model:
     def get_full_tree(self) -> Tree:
         return self._tree.copy()
 
-    def get_random_individual(self, state: str | None = None) -> int:
+    def get_population(self, state: str | None = None) -> list[int]:
         if state is None:
-            return self._rng.choice(list(self._population))
-        return self._rng.choice(list(self._states[state]))
-
-    def get_population(self) -> list[int]:
-        return list(self._population)
+            return list(self._population)
+        return list(self._states[state])
 
     def count_individuals(self, state: str | None = None) -> int:
         if state is None:

{phylogenie-2.0.13.dist-info → phylogenie-2.1.0.dist-info}/METADATA

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

phylogenie-2.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+phylogenie/__init__.py,sha256=sv8sfqkbarYgeaCFGiGMtV_fTUPuXEyJS_I3W9mlIto,1801
+phylogenie/generators/__init__.py,sha256=zsOxy28-9j9alOQLIgrOAFfmM58NNHO_NEtW-KXQXAY,888
+phylogenie/generators/alisim.py,sha256=dDqlSwLDbRE2u5SZlsq1mArobTBtuk0aeXY3m1N-bWA,2374
+phylogenie/generators/configs.py,sha256=4jSBUZiFo2GacXWed5dy7lUEkaOWZkZG-KY9vHfhqGU,993
+phylogenie/generators/dataset.py,sha256=UTsf8u868_8K6aMwIpLZrIfSY7s9skXlLUqQBuetiNQ,2954
+phylogenie/generators/factories.py,sha256=Y7cTsIblyV9T7ZhYvyQ5Wd7JcCpMG1dkEF8jJ1iQxN8,6928
+phylogenie/generators/trees.py,sha256=R5ZlZ-UNy2euPBt2P3lyit4txC3xweLrPPA1FI6m5PQ,9210
+phylogenie/generators/typeguards.py,sha256=yj4VkhOaUXJ2OrY-6zhOeY9C4yKIQxjZtk2d-vIxttQ,828
+phylogenie/io.py,sha256=d1xF6rwER6KpnA5OrFgDn7Ow-YymvxA7OXX7hi_nfB4,2951
+phylogenie/main.py,sha256=vtvSpQxBNlYABoFQ25czl-l3fIr4QRo3svWVd-jcArw,1170
+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=dk8Sj1tqyGOunVO2crtIqb0LH-ws-PXqA8SuNcYfVHI,1738
+phylogenie/treesimulator/__init__.py,sha256=DGn_sRDwL4OY1x1fT36kh4ghhwqSGt_8FnrV_TcQCjs,563
+phylogenie/treesimulator/events.py,sha256=xV64Y_oH9tsAFVVJEGW6-VgiOcX-xNPR_niTxTmpARo,10583
+phylogenie/treesimulator/gillespie.py,sha256=q5t0jfZWRqoyoiXiImMmo8fXqo7Cw1ea-OS_8aCD6Mc,4491
+phylogenie/treesimulator/model.py,sha256=Zl82nlbuq0htrLZV7x5LAB-thuN4lzbDv5pDSrG3oM8,4595
+phylogenie/typeguards.py,sha256=JtqmbEWJZBRHbWgCvcl6nrWm3VcBfzRbklbTBYHItn0,1325
+phylogenie/typings.py,sha256=O1X6lGKTjJ2YJz3ApQ-rYb_tEJNUIcHdUIeYlSM4s5o,500
+phylogenie-2.1.0.dist-info/LICENSE.txt,sha256=NUrDqElK-eD3I0WqC004CJsy6cs0JgsAoebDv_42-pw,1071
+phylogenie-2.1.0.dist-info/METADATA,sha256=5_QZd6c3rvlHwhRC-TT6bqcNG6gZDJJGLuNWVUorzlg,5472
+phylogenie-2.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+phylogenie-2.1.0.dist-info/entry_points.txt,sha256=Rt6_usN0FkBX1ZfiqCirjMN9FKOgFLG8rydcQ8kugeE,51
+phylogenie-2.1.0.dist-info/RECORD,,

phylogenie-2.0.13.dist-info/RECORD

@@ -1,28 +0,0 @@
-phylogenie/__init__.py,sha256=4BytT42_M1K6T3W9eqHQCrKc6g0Lh5LTQxP8dGIJTsk,1915
-phylogenie/generators/__init__.py,sha256=VCpuvmOoY_N6p1h_Q0peYgGIIUIFLsvZT3T7vbHG6w0,1090
-phylogenie/generators/alisim.py,sha256=dDqlSwLDbRE2u5SZlsq1mArobTBtuk0aeXY3m1N-bWA,2374
-phylogenie/generators/configs.py,sha256=4jSBUZiFo2GacXWed5dy7lUEkaOWZkZG-KY9vHfhqGU,993
-phylogenie/generators/dataset.py,sha256=hbkN5McM4BKY7D0hLNaxdoAGsLHac6O-D4sgnZ0wFX4,2618
-phylogenie/generators/factories.py,sha256=0ckeAsKnPy69Vbdoi1rIyf6zRcqamz9VfSi0mAiTzds,6938
-phylogenie/generators/trees.py,sha256=jukaVXGcPGzDBEYMGJ1MKqWt4XbAB5EEfuHXDpwKTqM,9173
-phylogenie/generators/typeguards.py,sha256=yj4VkhOaUXJ2OrY-6zhOeY9C4yKIQxjZtk2d-vIxttQ,828
-phylogenie/io.py,sha256=ZXlofnSh7FX5UJiP0svRHrTraMSNgKa1GiAv0bMz7jU,2854
-phylogenie/main.py,sha256=vtvSpQxBNlYABoFQ25czl-l3fIr4QRo3svWVd-jcArw,1170
-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=dk8Sj1tqyGOunVO2crtIqb0LH-ws-PXqA8SuNcYfVHI,1738
-phylogenie/treesimulator/__init__.py,sha256=INPU9LrPdUmt3dYGzWDRoRKrPR9xENcHu44pJVUbyNA,525
-phylogenie/treesimulator/events.py,sha256=X3_0U9qqMpYgh6-7TwQEnlUipANkHz6QTCXlm-qXFQk,9524
-phylogenie/treesimulator/gillespie.py,sha256=4uMt_-Rr3cRXWGKC8veBIB-uqtKtN-dLbAHKjAi_5Mo,3182
-phylogenie/treesimulator/model.py,sha256=XpzAicmg2O6K0Trk5YolH-B_HJZxoSauF2wZOMqp-Iw,5559
-phylogenie/typeguards.py,sha256=JtqmbEWJZBRHbWgCvcl6nrWm3VcBfzRbklbTBYHItn0,1325
-phylogenie/typings.py,sha256=O1X6lGKTjJ2YJz3ApQ-rYb_tEJNUIcHdUIeYlSM4s5o,500
-phylogenie-2.0.13.dist-info/LICENSE.txt,sha256=NUrDqElK-eD3I0WqC004CJsy6cs0JgsAoebDv_42-pw,1071
-phylogenie-2.0.13.dist-info/METADATA,sha256=XkYNiu3IYt516JJ8dw-iIo9zonC8LFiB_ZVGhNyw-eY,5473
-phylogenie-2.0.13.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-phylogenie-2.0.13.dist-info/entry_points.txt,sha256=Rt6_usN0FkBX1ZfiqCirjMN9FKOgFLG8rydcQ8kugeE,51
-phylogenie-2.0.13.dist-info/RECORD,,