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

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

@@ -1,106 +1,69 @@
-from abc import ABC, abstractmethod
-from collections.abc import Sequence
-from dataclasses import dataclass
-
-import numpy as np
 from numpy.random import Generator
 
 from phylogenie.skyline import (
     SkylineMatrixCoercible,
-    SkylineParameter,
     SkylineParameterLike,
     SkylineVectorCoercible,
     skyline_matrix,
-    skyline_parameter,
     skyline_vector,
 )
-from phylogenie.treesimulator.model import Model
+from phylogenie.treesimulator.model import Event, 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
-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)
-        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: ...
-
-
-@dataclass
 class Birth(Event):
-    child_state: str
+    def __init__(self, state: str, rate: SkylineParameterLike, child_state: str):
+        super().__init__(state, rate)
+        self.child_state = child_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)
 
+    def __repr__(self) -> str:
+        return f"Birth(state={self.state}, rate={self.rate}, child_state={self.child_state})"
+
 
 class Death(Event):
     def apply(self, model: Model, time: float, rng: Generator) -> None:
         individual = self.draw_individual(model, rng)
         model.remove(individual, time)
 
+    def __repr__(self) -> str:
+        return f"Death(state={self.state}, rate={self.rate})"
+
 
-@dataclass
 class Migration(Event):
-    target_state: str
+    def __init__(self, state: str, rate: SkylineParameterLike, target_state: str):
+        super().__init__(state, rate)
+        self.target_state = target_state
 
     def apply(self, model: Model, time: float, rng: Generator) -> None:
         individual = self.draw_individual(model, rng)
         model.migrate(individual, self.target_state, time)
 
+    def __repr__(self) -> str:
+        return f"Migration(state={self.state}, rate={self.rate}, target_state={self.target_state})"
+
 
-@dataclass
 class Sampling(Event):
-    removal: bool
+    def __init__(self, state: str, rate: SkylineParameterLike, removal: bool):
+        super().__init__(state, rate)
+        self.removal = removal
 
     def apply(self, model: Model, time: float, rng: Generator) -> None:
         individual = self.draw_individual(model, rng)
         model.sample(individual, time, self.removal)
 
-
-@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 __repr__(self) -> str:
+        return f"Sampling(state={self.state}, rate={self.rate}, removal={self.removal})"
 
 
 def get_canonical_events(
-    states: Sequence[str],
+    states: list[str],
     sampling_rates: SkylineVectorCoercible,
     remove_after_sampling: bool,
     birth_rates: SkylineVectorCoercible = 0,
@@ -116,27 +79,27 @@ def get_canonical_events(
 
     events: list[Event] = []
     for i, state in enumerate(states):
-        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))
+        events.append(Birth(state, birth_rates[i], state))
+        events.append(Death(state, death_rates[i]))
+        events.append(Sampling(state, sampling_rates[i], 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(Migration(migration_rates[i, j], state, other_state))
+                events.append(Migration(state, migration_rates[i, j], 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(Birth(birth_rates_among_states[i, j], state, other_state))
+                events.append(Birth(state, birth_rates_among_states[i, j], other_state))
 
     return [event for event in events if event.rate]
 
 
 def get_FBD_events(
-    states: Sequence[str],
+    states: list[str],
     sampling_proportions: SkylineVectorCoercible = 1,
     diversification: SkylineVectorCoercible = 0,
     turnover: SkylineVectorCoercible = 0,
@@ -170,7 +133,7 @@ def get_FBD_events(
 
 
 def get_epidemiological_events(
-    states: Sequence[str],
+    states: list[str],
     sampling_proportions: SkylineVectorCoercible = 1,
     reproduction_numbers: SkylineVectorCoercible = 0,
     become_uninfectious_rates: SkylineVectorCoercible = 0,
@@ -254,56 +217,3 @@ def get_BDSS_events(
         become_uninfectious_rates=1 / infectious_period,
         sampling_proportions=sampling_proportion,
     )
-
-
-def get_contact_tracing_events(
-    events: Sequence[Event],
-    max_notified_contacts: int = 1,
-    notification_probability: SkylineParameterLike = 1,
-    sampling_rate_after_notification: SkylineParameterLike = np.inf,
-    samplable_states_after_notification: Sequence[str] | None = None,
-) -> list[Event]:
-    ct_events = [e for e in events if not isinstance(e, Sampling)]
-
-    for event in events:
-        if isinstance(event, Migration):
-            ct_events.append(
-                Migration(
-                    event.rate,
-                    _get_CT_state(event.state),
-                    _get_CT_state(event.target_state),
-                )
-            )
-        elif isinstance(event, Birth):
-            ct_events.append(
-                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}
-    ):
-        ct_events.append(
-            SamplingWithContactTracing(
-                skyline_parameter(sampling_rate_after_notification),
-                _get_CT_state(state),
-                max_notified_contacts,
-                skyline_parameter(notification_probability),
-            )
-        )
-
-    return ct_events

phylogenie/treesimulator/events/mutations.py

@@ -0,0 +1,105 @@
+from copy import deepcopy
+from enum import Enum
+from typing import Type
+
+from numpy.random import Generator
+
+from phylogenie.skyline import SkylineParameterLike
+from phylogenie.treesimulator.events.contact_tracing import (
+    BirthWithContactTracing,
+    SamplingWithContactTracing,
+)
+from phylogenie.treesimulator.events.core import (
+    Birth,
+    Death,
+    Event,
+    Migration,
+    Sampling,
+)
+from phylogenie.treesimulator.model import Model
+from phylogenie.utils import Distribution
+
+MUTATION_PREFIX = "MUT-"
+MUTATIONS_KEY = "MUTATIONS"
+
+
+def _get_mutation(state: str) -> str | None:
+    return state.split(".")[0] if state.startswith(MUTATION_PREFIX) else None
+
+
+def _get_mutated_state(mutation_id: int, state: str) -> str:
+    if state.startswith(MUTATION_PREFIX):
+        state = state.split(".")[1]
+    return f"{MUTATION_PREFIX}{mutation_id}.{state}"
+
+
+class TargetType(str, Enum):
+    BIRTH = "birth"
+    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)
+        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]
+
+        individual = self.draw_individual(model, rng)
+        model.migrate(individual, _get_mutated_state(mutation_id, self.state), time)
+
+        rate_scalers = {
+            target_type: getattr(rng, rate_scaler.type)(**rate_scaler.args)
+            for target_type, rate_scaler in self.rate_scalers.items()
+        }
+
+        for event in [
+            deepcopy(e)
+            for e in model.events
+            if _get_mutation(self.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
+            ):
+                raise ValueError(
+                    f"Mutation not defined 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)
+
+    def __repr__(self) -> str:
+        return f"Mutation(state={self.state}, rate={self.rate}, rate_scalers={self.rate_scalers})"
+
+
+TARGETS: dict[TargetType, tuple[Type[Event], ...]] = {
+    TargetType.BIRTH: (Birth, BirthWithContactTracing),
+    TargetType.DEATH: (Death,),
+    TargetType.MIGRATION: (Migration,),
+    TargetType.SAMPLING: (Sampling, SamplingWithContactTracing),
+    TargetType.MUTATION: (Mutation,),
+}

phylogenie/treesimulator/gillespie.py

@@ -8,21 +8,21 @@ from tqdm import tqdm
 
 from phylogenie.io import dump_newick
 from phylogenie.tree import Tree
-from phylogenie.treesimulator.events import Event
-from phylogenie.treesimulator.model import Model
+from phylogenie.treesimulator.model import Event, Model
+
+MAX_TIPS = 2**32
 
 
 def simulate_tree(
     events: Sequence[Event],
     min_tips: int = 1,
-    max_tips: int = 2**32,
+    max_tips: int = MAX_TIPS,
     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,
 ) -> Tree | None:
-    if max_time == np.inf and max_tips == 2**32:
+    if max_time == np.inf and max_tips == MAX_TIPS:
         raise ValueError("Either max_time or max_tips must be specified.")
 
     if max_time == np.inf and sampling_probability_at_present:
@@ -30,7 +30,7 @@ def simulate_tree(
             "sampling_probability_at_present cannot be set when max_time is infinite."
         )
 
-    states = {e.state for e in events}
+    states = {e.state for e in events if e.state}
     if init_state is None and len(states) > 1:
         raise ValueError(
             "Init state must be provided for models with more than one state."
@@ -41,15 +41,15 @@ def simulate_tree(
         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:
-        model = Model(init_state)
+    while True:
+        model = Model(init_state, 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
 
         target_n_tips = rng.integers(min_tips, max_tips) if max_time == np.inf else None
         while current_time < max_time:
+            events = model.events
             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]
@@ -85,21 +85,17 @@ def simulate_tree(
 
         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],
+    events: list[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:
@@ -116,7 +112,6 @@ def generate_trees(
             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)

phylogenie/treesimulator/model.py

@@ -1,9 +1,35 @@
+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
 
 
+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: ...
+
+
 @dataclass
 class Individual:
     id: int
@@ -12,19 +38,27 @@ class Individual:
 
 
 class Model:
-    def __init__(self, init_state: str):
+    def __init__(self, init_state: str, events: Sequence[Event]):
         self._next_node_id = 0
         self._next_individual_id = 0
         self._population: dict[int, Individual] = {}
         self._states: dict[str, set[int]] = defaultdict(set)
-        self._lineages: dict[int, list[Individual]] = defaultdict(list)
         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
         return Tree(f"{self._next_node_id}|{state}")
@@ -54,9 +88,8 @@ class Model:
     def remove(self, id: int, time: float) -> None:
         individual = self._population[id]
         self._set_branch_length(individual.node, time)
-        state = individual.state
         self._population.pop(id)
-        self._states[state].remove(id)
+        self._states[individual.state].remove(id)
 
     def migrate(self, id: int, state: str, time: float) -> None:
         individual = self._population[id]
@@ -65,13 +98,12 @@ class Model:
         self._states[state].add(id)
         self._stem(individual, time)
 
-    def birth_from(self, id: int, state: str, time: float) -> None:
+    def birth_from(self, id: int, state: str, time: float) -> int:
         individual = self._population[id]
         new_individual = self._get_new_individual(state)
         individual.node.add_child(new_individual.node)
         self._stem(individual, time)
-        self._lineages[id].append(new_individual)
-        self._lineages[new_individual.id].append(individual)
+        return new_individual.id
 
     def sample(self, id: int, time: float, removal: bool) -> None:
         individual = self._population[id]
@@ -85,9 +117,6 @@ class Model:
             individual.node.add_child(sample_node)
             self._stem(individual, 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
 
@@ -98,29 +127,28 @@ class Model:
                 if node.parent is None:
                     raise ValueError("No samples in the tree.")
                 else:
-                    node.parent.children.remove(node)
+                    node.parent.remove_child(node)
             elif len(node.children) == 1:
                 (child,) = node.children
-                child.parent = node.parent
+                child.set_parent(node.parent)
                 assert child.branch_length is not None
                 assert node.branch_length is not None
                 child.branch_length += node.branch_length
                 if node.parent is None:
                     return child
                 else:
-                    node.parent.children.append(child)
-                    node.parent.children.remove(node)
+                    node.parent.remove_child(node)
         return tree
 
     def get_full_tree(self) -> Tree:
         return self._tree.copy()
 
-    def get_population(self, state: str | None = None) -> list[int]:
-        if state is None:
+    def get_population(self, states: str | None = None) -> list[int]:
+        if states is None:
             return list(self._population)
-        return list(self._states[state])
+        return list(self._states[states])
 
-    def count_individuals(self, state: str | None = None) -> int:
-        if state is None:
+    def count_individuals(self, states: str | None = None) -> int:
+        if states is None:
             return len(self._population)
-        return len(self._states[state])
+        return len(self._states[states])

phylogenie/typings.py

@@ -16,6 +16,5 @@ Many2DScalars = Many2D[Scalar]
 Many3DScalars = Many3D[Scalar]
 
 Vector1D = list[Scalar]
-IntVector1D = list[int]
 Vector2D = list[Vector1D]
 Vector3D = list[Vector2D]

phylogenie/utils.py

@@ -0,0 +1,17 @@
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class StrictBaseModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+
+class Distribution(BaseModel):
+    type: str
+    model_config = ConfigDict(extra="allow")
+
+    @property
+    def args(self) -> dict[str, Any]:
+        assert self.model_extra is not None
+        return self.model_extra

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: phylogenie
-Version: 2.1.0
+Version: 2.1.2
 Summary: Generate phylogenetic datasets with minimal setup effort
 Author: Gabriele Marino
 Author-email: gabmarino.8601@gmail.com
@@ -24,7 +24,6 @@ Description-Content-Type: text/markdown
 
 [![AliSim](https://img.shields.io/badge/Powered%20by-AliSim-orange?style=flat-square)](https://iqtree.github.io/doc/AliSim)
 [![PyPI version](https://img.shields.io/pypi/v/phylogenie)](https://pypi.org/project/phylogenie/)
-[![PyPI downloads](https://shields.io/pypi/dm/phylogenie)](https://pypi.org/project/phylogenie/)
 
 Phylogenie is a [Python](https://www.python.org/) package designed to easily simulate phylogenetic datasets—such as trees and multiple sequence alignments (MSAs)—with minimal setup effort. Simply specify the distributions from which your parameters should be sampled, and Phylogenie will handle the rest!
 

phylogenie-2.1.2.dist-info/RECORD

@@ -0,0 +1,32 @@
+phylogenie/__init__.py,sha256=T2mRLsYtoLlWt8GlxrrUnfXJ9XVioq7hTvVq3uJpwQI,2215
+phylogenie/generators/__init__.py,sha256=zsOxy28-9j9alOQLIgrOAFfmM58NNHO_NEtW-KXQXAY,888
+phylogenie/generators/alisim.py,sha256=dDqlSwLDbRE2u5SZlsq1mArobTBtuk0aeXY3m1N-bWA,2374
+phylogenie/generators/configs.py,sha256=AiiFS6rpH9BPwDKCkT4SVrRzfLFFrwRCJM4CRj0Srdk,1072
+phylogenie/generators/dataset.py,sha256=wYtb5fxjrM0bD9KVDlgZPpiR4ACezdKKfsmsXyc4__0,2755
+phylogenie/generators/factories.py,sha256=14p1wvJtjdXgM4mPqV9vX34HYcKpemx9TPfemvoB5Wo,7265
+phylogenie/generators/trees.py,sha256=EEj5KPuu7FSOoti_gGTmgWgiX68rEKFh57Hp6BDw8po,10049
+phylogenie/generators/typeguards.py,sha256=yj4VkhOaUXJ2OrY-6zhOeY9C4yKIQxjZtk2d-vIxttQ,828
+phylogenie/io.py,sha256=y7nQIvLgCvqELsXFKfm1GgKJO_saoQ-7zQpE3Kvajzc,3509
+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=Cum74mTdmgfGXk25dnvUngr4zDYRyWFq5zThBh0QFog,2677
+phylogenie/treesimulator/__init__.py,sha256=XG_xwETKWgDmCihqNUFCcMHtFg4WvZu5qbqWn9Dndt8,879
+phylogenie/treesimulator/events/__init__.py,sha256=UGfvXOVJ_ZAkk_8sBPihjmxciiaEnXZEPFIY53sttWI,940
+phylogenie/treesimulator/events/contact_tracing.py,sha256=_nJ85yhgGkeruQgMHvGpDYoyhheBf8M4LgZWiWdi5dY,4801
+phylogenie/treesimulator/events/core.py,sha256=JokGmieAv2xEX7KsjBWZr05jHN1jB-XZbpxe9gwdbDA,7953
+phylogenie/treesimulator/events/mutations.py,sha256=xkXUIppbLIWZqKwVf-hi7d-_pS42TG2EPVfJA_grxBg,3443
+phylogenie/treesimulator/gillespie.py,sha256=TMDNKBkFwVyAEhBlbwxCTA61GuGwP-42HxpsAVXiU0s,4275
+phylogenie/treesimulator/model.py,sha256=0Im6cFTlpMlJrSP4pTTKtvLT9qrQWV8MSTesAsBxT8g,5422
+phylogenie/typeguards.py,sha256=JtqmbEWJZBRHbWgCvcl6nrWm3VcBfzRbklbTBYHItn0,1325
+phylogenie/typings.py,sha256=GknvAFXyiaWeeYJ8Lk5d6E2VHT-xW6ONEojYbtJYiB8,476
+phylogenie/utils.py,sha256=pCg9ob0RpLUHwM49x4knKxL4FNPr3-EU_6zMXsvxtAg,370
+phylogenie-2.1.2.dist-info/LICENSE.txt,sha256=NUrDqElK-eD3I0WqC004CJsy6cs0JgsAoebDv_42-pw,1071
+phylogenie-2.1.2.dist-info/METADATA,sha256=RoxXfMaPI6auRdjONAE8HfcfhZjHX0hTmx_oJlrzaws,5375
+phylogenie-2.1.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+phylogenie-2.1.2.dist-info/entry_points.txt,sha256=Rt6_usN0FkBX1ZfiqCirjMN9FKOgFLG8rydcQ8kugeE,51
+phylogenie-2.1.2.dist-info/RECORD,,

phylogenie-2.1.0.dist-info/RECORD

@@ -1,28 +0,0 @@
-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,,