bdms-sim 0.2.0__py3-none-any.whl

bdms/__init__.py

@@ -0,0 +1,9 @@
+__version__ = "0.2.0"
+
+from .tree import TreeNode as _TreeNode
+
+TreeNode = _TreeNode
+"""Alias for :py:class:`bdms.tree.TreeNode`."""
+
+Tree = _TreeNode
+"""Alias for :py:class:`bdms.tree.TreeNode`."""

bdms/mutators.py

@@ -0,0 +1,232 @@
+r"""Mutation effects generators.
+
+Abstract base class for defining generic mutation effect generators (i.e.
+:math:`\mathcal{p}(x\mid x')`), with arbitrary :py:class:`ete3.TreeNode` attribute
+dependence. Some concrete child classes are included.
+
+These classes are used to define mutation effects for simulations with
+:py:class:`bdms.TreeNode.evolve`.
+
+Example:
+
+    >>> import bdms
+
+    Define a discrete mutation model.
+
+    >>> mutator = bdms.mutators.DiscreteMutator(
+    ...     state_space=["a", "b", "c"],
+    ...     transition_matrix=[[0.0, 0.5, 0.5],
+    ...                        [0.5, 0.0, 0.5],
+    ...                        [0.5, 0.5, 0.0]],
+    ... )
+
+    Mutate a node.
+
+    >>> node = bdms.TreeNode(state="a")
+    >>> mutator.mutate(node, seed=0)
+    >>> node.state
+    'c'
+"""
+
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Any
+from collections.abc import Sequence, Callable, Hashable
+import numpy as np
+import scipy.stats as stats
+import ete3
+
+# NOTE: sphinx is currently unable to present this in condensed form when the
+#       sphinx_autodoc_typehints extension is enabled
+# TODO: use ArrayLike in various phenotype/time methods (current float types)
+#       once it is available in a stable release
+# from numpy.typing import ArrayLike
+from numpy.typing import NDArray
+
+
+class Mutator(ABC):
+    r"""Abstract base class for mutators that mutate a specified
+    :py:class:`ete3.TreeNode` node attribute.
+
+    Args:
+        attr: Node attribute to mutate.
+    """
+
+    def __init__(self, attr: str = "state", *args: Any, **kwargs: Any) -> None:
+        self.attr = attr
+
+    @abstractmethod
+    def mutate(
+        self,
+        node: ete3.TreeNode,
+        seed: int | np.random.Generator | None = None,
+    ) -> None:
+        r"""Mutate a :py:class:`bdms.TreeNode` object in place.
+
+        Args:
+            node: A :py:class:`bdms.TreeNode` to mutate.
+            seed: A seed to initialize the random number generation. If ``None``, then
+                  fresh, unpredictable entropy will be pulled from the OS. If an
+                  ``int``, then it will be used to derive the initial state. If a
+                  :py:class:`numpy.random.Generator`, then it will be used directly.
+        """
+
+    @abstractmethod
+    def prob(self, attr1: float, attr2: float, log: bool = False) -> float:
+        r"""Probability of mutating from ``attr1`` to ``attr2``.
+
+        Args:
+            attr1: The initial attribute value.
+            attr2: The final attribute value.
+            log: If ``True``, return the log-probability.
+
+        Returns:
+            Mutation probability (or log probability).
+        """
+
+    def __repr__(self) -> str:
+        keyval_strs = (
+            f"{key}={value}"
+            for key, value in vars(self).items()
+            if not key.startswith("_")
+        )
+        return f"{self.__class__.__name__}({', '.join(keyval_strs)})"
+
+
+class GaussianMutator(Mutator):
+    r"""Gaussian mutation effects on a specified attribute.
+
+    Args:
+        shift: Mean shift wrt current attribute value.
+        scale: Standard deviation of mutation effect.
+        attr: Node attribute to mutate.
+    """
+
+    def __init__(
+        self,
+        shift: float = 0.0,
+        scale: float = 1.0,
+        attr: str = "state",
+    ):
+        super().__init__(attr=attr)
+        self.shift = shift
+        self.scale = scale
+        self._distribution = stats.norm(loc=self.shift, scale=self.scale)
+
+    def mutate(
+        self,
+        node: ete3.TreeNode,
+        seed: int | np.random.Generator | None = None,
+    ) -> None:
+        current_state = getattr(node, self.attr)
+        Δ = self._distribution.rvs(random_state=seed)
+        setattr(node, self.attr, current_state + Δ)
+
+    def prob(self, attr1: float, attr2: float, log: bool = False) -> float:
+        Δ = np.asarray(attr2) - np.asarray(attr1)
+        if log:
+            return self._distribution.logpdf(Δ)  # type:ignore
+        return self._distribution.pdf(Δ)  # type:ignore
+
+
+class KdeMutator(Mutator):
+    r"""Gaussian kernel density estimator (KDE) for mutation effect on a specified
+    attribute.
+
+    Args:
+        data: Data to fit the KDE to.
+        attr: Node attribute to mutate.
+        bw_method: KDE bandwidth (see :py:class:`scipy.stats.gaussian_kde`).
+        weights: Weights of data points (see :py:class:`scipy.stats.gaussian_kde`).
+    """
+
+    def __init__(
+        self,
+        data: NDArray[np.float64],
+        attr: str = "state",
+        bw_method: str | float | Callable[..., float] | None = None,
+        weights: NDArray[np.float64] | None = None,
+    ):
+        super().__init__(attr=attr)
+        self._distribution = stats.gaussian_kde(data, bw_method, weights)
+
+    def mutate(
+        self,
+        node: ete3.TreeNode,
+        seed: int | np.random.Generator | None = None,
+    ) -> None:
+        current_state = getattr(node, self.attr)
+        Δ = self._distribution.resample(size=1, seed=seed)[0, 0]
+        setattr(node, self.attr, current_state + Δ)
+
+    def prob(self, attr1: float, attr2: float, log: bool = False) -> float:
+        Δ = np.asarray(attr2) - np.asarray(attr1)
+        if log:
+            return self._distribution.logpdf(Δ)
+        return self._distribution.pdf(Δ)
+
+
+class DiscreteMutator(Mutator):
+    r"""Mutations on a discrete space with a stochastic matrix.
+
+    Args:
+        state_space: hashable state values.
+        transition_matrix: Right-stochastic matrix, where column and row orders match
+                           the order of `state_space`.
+        attr: Node attribute to mutate.
+    """
+
+    def __init__(
+        self,
+        state_space: Sequence[Hashable],
+        transition_matrix: NDArray[np.float64],
+        attr: str = "state",
+    ):
+        transition_matrix = np.asarray(transition_matrix, dtype=float)
+        if not (
+            transition_matrix.ndim == 2
+            and transition_matrix.shape[0]
+            == transition_matrix.shape[1]
+            == len(state_space)
+        ):
+            raise ValueError(
+                f"Transition matrix shape {transition_matrix.shape} "
+                f"does not match state space size {state_space}"
+            )
+        if (
+            np.any(transition_matrix < 0)
+            or np.any(transition_matrix > 1)
+            or not np.allclose(transition_matrix.sum(axis=1), 1)
+        ):
+            raise ValueError(
+                f"Transition matrix {transition_matrix} is not a valid stochastic"
+                " matrix."
+            )
+
+        super().__init__(attr=attr)
+
+        self.state_space: dict[Any, int] = {
+            state: index for index, state in enumerate(state_space)
+        }
+        """Mapping from state values to their indices in the transition matrix."""
+        self.transition_matrix = transition_matrix
+
+    def mutate(
+        self,
+        node: ete3.TreeNode,
+        seed: int | np.random.Generator | None = None,
+    ) -> None:
+        rng = np.random.default_rng(seed)
+        transition_probs = self.transition_matrix[
+            self.state_space[getattr(node, self.attr)], :
+        ]
+        new_value = rng.choice(list(self.state_space.keys()), p=transition_probs)
+        setattr(node, self.attr, new_value)
+
+    def prob(self, attr1: float, attr2: float, log: bool = False) -> float:
+        result = self.transition_matrix[
+            self.state_space[attr1], self.state_space[attr2]
+        ]
+        if log:
+            result = np.log(result)
+        return result

bdms/poisson.py

@@ -0,0 +1,305 @@
+r"""Abstract base classes for defining general Poisson point processes on
+:py:class:`bdms.TreeNode` state spaces. Several concrete child classes are included.
+
+These classes are used to define rate-driven processes---such as birth, death, and
+mutation---for simulations with :py:class:`bdms.TreeNode.evolve`.
+
+Example
+-------
+
+>>> import bdms
+
+Define a two-state process.
+
+>>> poisson_process = bdms.poisson.DiscreteProcess({"a": 1.0, "b": 2.0})
+
+Sample waiting times for each state.
+
+>>> for state in poisson_process.rates:  # doctest: +ELLIPSIS
+...     print(state, poisson_process.waiting_time_rv(state, 0.0, seed=0))
+a 0.6799...
+b 0.3399...
+"""
+
+from __future__ import annotations
+from typing import Any, Hashable, TYPE_CHECKING
+from collections.abc import Mapping, Sequence
+from abc import ABC, abstractmethod
+import scipy.integrate as integrate
+import numpy as np
+import scipy.optimize as optimize
+
+# imports that are only used for type hints
+if TYPE_CHECKING:
+    import bdms
+
+# NOTE: sphinx is currently unable to present this in condensed form when the
+#       sphinx_autodoc_typehints extension is enabled
+# TODO: use ArrayLike in various phenotype/time methods (current float types)
+#       once it is available in a stable release
+# from numpy.typing import ArrayLike
+from numpy.typing import NDArray
+
+
+class Process(ABC):
+    r"""Abstract base class for Poisson point processes on :py:class:`bdms.TreeNode`
+    attributes.
+
+    Args:
+        attr: The name of the :py:class:`bdms.TreeNode` attribute to access.
+    """
+
+    @abstractmethod
+    def __init__(self, attr: str = "state") -> None:
+        self.attr = attr
+
+    def __call__(self, node: bdms.TreeNode) -> NDArray[np.float64]:
+        r"""Call ``self`` to evaluate the Poisson intensity at a tree node.
+
+        Args:
+            node: The node whose state is accessed to evaluate the process.
+
+        Returns:
+            The Poisson intensity at the node.
+        """
+        return self.λ(getattr(node, self.attr), node.t)
+
+    # @abstractmethod
+    # def __add__(self, other: Process) -> Process:
+    #     r"""The superposition of this Poisson process with another.
+
+    #     Args:
+    #         other: A Poisson process to add.
+    #     """
+
+    # @abstractmethod
+    # def __rmul__(self, scaling: float):
+    #     r"""Multiply a Poisson process by a constant, returning a process with a
+    #     rescaled intensity measure."""
+
+    @abstractmethod
+    def λ(self, x: Hashable, t: float) -> NDArray[np.float64]:
+        r"""The Poisson intensity :math:`\lambda(x, t)` for state :math:`x` at time
+        :math:`t`.
+
+        Args:
+            x: State to evaluate Poisson intensity at.
+            t: Time to evaluate Poisson intensity at (``0.0`` corresponds to
+               the root). This only has an effect if the process is time-inhomogeneous.
+
+        Returns:
+            The Poisson intensity :math:`\lambda(x, t)`.
+        """
+
+    @abstractmethod
+    def Λ(self, x: Hashable, t: float, Δt: float) -> NDArray[np.float64]:
+        r"""Evaluate the Poisson intensity measure of state :math:`x` and time interval
+        :math:`[t, t+Δt)`, defined as.
+
+        .. math::     \Lambda(x, t, Δt) = \int_{t}^{t+Δt} \lambda(x, s)ds,
+
+        This is needed for sampling waiting times and evaluating the log probability
+        density function of waiting times.
+
+        Args:
+            x: State to evaluate Poisson intensity measure at.
+            t: Start time.
+            Δt: Time interval duration.
+
+        Returns:
+            The Poisson intensity measure :math:`\Lambda(x, t, \Delta t)`.
+        """
+
+    @abstractmethod
+    def Λ_inv(self, x: Hashable, t: float, τ: float) -> NDArray[np.float64]:
+        r"""Evaluate the inverse function wrt :math:`\Delta t` of :py:meth:`Process.Λ`,
+        :math:`\Lambda_t^{-1}(x, t, \tau)`, such that :math:`\Lambda_t^{-1}(x, t,
+        \Lambda(x, t, t+\Delta t)) = \Delta t`. This is needed for sampling waiting
+        times. Note that :math:`\Lambda_t^{-1}` is well-defined iff :math:`\lambda(x, t)
+        > 0`.
+
+        Args:
+            x: State.
+            t: Start time of the interval.
+            τ: Poisson intensity measure of the interval.
+
+        Returns:
+            The inverse Poisson intensity measure :math:`\Lambda_t^{-1}(x, t, \tau)`.
+        """
+
+    def waiting_time_rv(
+        self,
+        x: Hashable,
+        t: float,
+        rate_multiplier: float = 1.0,
+        seed: int | np.random.Generator | None = None,
+    ) -> NDArray[np.float64]:
+        r"""Sample the waiting time :math:`\Delta t` until the first event, given the
+        process on state :math:`x` starting at time :math:`t`.
+
+        Args:
+            x: State.
+            t: Time at which to start waiting.
+            rate_multiplier: A constant by which to multiply the Poisson intensity
+            seed: A seed to initialize the random number generation. If ``None``, then
+                  fresh, unpredictable entropy will be pulled from the OS. If an
+                  ``int``, then it will be used to derive the initial state. If a
+                  :py:class:`numpy.random.Generator`, then it will be used directly.
+
+        Returns:
+            Waiting time :math:`\Delta t`.
+        """
+        rng = np.random.default_rng(seed)
+        return self.Λ_inv(x, t, rng.exponential(scale=1 / rate_multiplier))
+
+    def __repr__(self) -> str:
+        keyval_strs = (
+            f"{key}={value}"
+            for key, value in vars(self).items()
+            if not key.startswith("_")
+        )
+        return f"{self.__class__.__name__}({', '.join(keyval_strs)})"
+
+
+class HomogeneousProcess(Process):
+    r"""Abstract base class for homogenous Poisson processes."""
+
+    @abstractmethod
+    def λ_homogeneous(
+        self, x: Hashable | Sequence[Hashable] | NDArray[Any]
+    ) -> NDArray[np.float64]:
+        r"""Evaluate homogeneous Poisson intensity :math:`\lambda(x)` for state
+        :math:`x`.
+
+        Args:
+            x: State to evaluate Poisson intensity at.
+
+        Returns:
+            The Poisson intensity :math:`\lambda(x)`.
+        """
+
+    # def __add__(self, other: Process) -> Process:
+
+    # def __rmul__(self, scaling: float):
+
+    def λ(self, x: Hashable, t: float) -> NDArray[np.float64]:
+        return self.λ_homogeneous(x)
+
+    def Λ(self, x: Hashable, t: float, Δt: float) -> NDArray[np.float64]:
+        return self.λ_homogeneous(x) * Δt
+
+    # @np.errstate(divide="ignore")
+    # NOTE: the above suppresses warnings, but is slow!
+    # We instead test for zero.
+    def Λ_inv(self, x: Hashable, t: float, τ: float) -> NDArray[np.float64]:
+        rate = self.λ_homogeneous(x)
+        if rate == 0:
+            return np.full_like(x, np.inf, dtype=float)
+
+        return τ / rate
+
+
+class ConstantProcess(HomogeneousProcess):
+    r"""A process with a specified constant rate (independent of state).
+
+    Args:
+        value: Constant rate.
+    """
+
+    def __init__(self, value: float = 1.0):
+        super().__init__()
+        self.value = value
+
+    def λ_homogeneous(
+        self, x: Hashable | Sequence[Hashable] | NDArray[Any]
+    ) -> NDArray[np.float64]:
+        return self.value * np.ones_like(x)
+
+
+class DiscreteProcess(HomogeneousProcess):
+    r"""A homogeneous process at each of :math:`d` states.
+
+    Args:
+        rates: Rates for each state.
+        attr: The name of the :py:class:`bdms.TreeNode` attribute to access. This
+              should take a discrete set of values.
+    """
+
+    def __init__(
+        self, rates: Mapping[Hashable, float] | Sequence[float], attr: str = "state"
+    ):
+        super().__init__(attr=attr)
+        self.rates = rates
+
+    def λ_homogeneous(
+        self, x: Hashable | Sequence[Hashable] | NDArray[Any]
+    ) -> NDArray[np.float64]:
+        if isinstance(x, Hashable):
+            return self.rates[x]  # type:ignore
+        return np.array([self.rates[xi] for xi in x])
+
+
+class InhomogeneousProcess(Process):
+    r"""Abstract base class for homogenous Poisson processes.
+
+    Default implementations of :py:meth:`Λ` and :py:meth:`Λ_inv` use quadrature and
+    root-finding, respectively.
+    You may wish to override these methods in a child clasee for better performance,
+    if analytical forms are available.
+
+    Args:
+        attr: The name of the :py:class:`bdms.TreeNode` attribute to access.
+        quad_kwargs: Quadrature convergence arguments passed to
+                     :py:func:`scipy.integrate.quad`.
+        root_kwargs: Root-finding convergence arguments passed to
+                     :py:func:`scipy.optimize.root_scalar`.
+    """
+
+    def __init__(
+        self,
+        attr: str = "state",
+        quad_kwargs: dict[str, Any] = {},
+        root_kwargs: dict[str, Any] = {},
+    ):
+        super().__init__(attr=attr)
+        self.quad_kwargs = quad_kwargs
+        self.root_kwargs = root_kwargs
+
+    @abstractmethod
+    def λ_inhomogeneous(self, x: Hashable, t: float) -> NDArray[np.float64]:
+        r"""Evaluate inhomogeneous Poisson intensity :math:`\lambda(x, t)` given state
+        :math:`x`.
+
+        Args:
+            x: Attribute value to evaluate Poisson intensity at.
+            t: Time at which to evaluate Poisson intensity.
+
+        Returns:
+            The Poisson intensity :math:`\lambda(x, t)`.
+        """
+
+    def λ(self, x: Hashable, t: float) -> NDArray[np.float64]:
+        return self.λ_inhomogeneous(x, t)
+
+    def Λ(self, x: Hashable, t: float, Δt: float) -> NDArray[np.float64]:
+        return integrate.quad(lambda Δt: self.λ(x, t + Δt), 0, Δt, **self.quad_kwargs)[
+            0
+        ]
+
+    def Λ_inv(self, x: Hashable, t: float, τ: float) -> NDArray[np.float64]:
+        # NOTE: we log transform to ensure non-negative values
+        def f(logΔt: float):
+            return self.Λ(x, t, np.exp(logΔt)) - τ
+
+        def fprime(logΔt: float):
+            return self.λ(x, t + np.exp(logΔt)) * np.exp(logΔt)
+
+        sol = optimize.root_scalar(
+            f=f,
+            fprime=fprime,
+            x0=np.log(τ / self.λ(x, t)),  # initial guess based on rate at time t
+            **self.root_kwargs,
+        )
+        if not sol.converged:
+            raise RuntimeError(f"Root-finding failed to converge:\n{sol}")
+        return np.exp(sol.root)

bdms/tree.py

@@ -0,0 +1,646 @@
+r"""Birth-death-mutation-sampling (BDMS) process simulation.
+
+Example:
+
+    >>> import bdms
+
+    Initialize a tree with a single root node.
+
+    >>> tree = bdms.Tree()
+    >>> print(tree)
+    <BLANKLINE>
+    --0
+
+    Evolve the tree for a one time unit with default parameters.
+
+    >>> tree.evolve(1.0, seed=0)
+    >>> print(tree)
+    <BLANKLINE>
+          /-2
+         |
+    -- /-|      /-6
+         |   /-|
+          \-|   \-7
+            |
+             \-5
+"""
+
+from __future__ import annotations
+import ete3
+from ete3.coretype.tree import TreeError as ete_TreeError
+from bdms import mutators, poisson, utils
+import numpy as np
+from typing import Any, Literal, Hashable
+from collections.abc import Mapping, Iterator, Generator
+import itertools
+from collections import defaultdict
+import copy
+import math
+
+
+class TreeError(ete_TreeError):
+    pass
+
+
+class TreeNode(ete3.Tree):
+    r"""A tree generated by a BDMS process. Subclasses :py:class:`ete3.TreeNode`.
+
+    Args:
+        t: Time of this node.
+        state: State of this node.
+        state_attr: Name of the node attribute to store the state in.
+        kwargs: Keyword arguments passed to :py:class:`ete3.TreeNode` initializer.
+    """
+
+    _BIRTH_EVENT = "birth"
+    _DEATH_EVENT = "death"
+    _MUTATION_EVENT = "mutation"
+    _SURVIVAL_EVENT = "survival"
+    _SAMPLING_EVENT = "sampling"
+
+    _OFFSPRING_NUMBER = 2
+
+    _name_generator: Iterator[int] = itertools.count()
+
+    _mutation_face = ete3.AttrFace(
+        "n_mutations",
+        fsize=6,
+        ftype="Arial",
+        fgcolor="black",
+    )
+
+    def __init__(
+        self,
+        t: float = 0,
+        state: Hashable = None,
+        state_attr: str = "state",
+        **kwargs: Any,
+    ) -> None:
+        if "dist" not in kwargs:
+            kwargs["dist"] = 0
+        if "name" not in kwargs:
+            TreeNode._name_generator = itertools.count()
+            self.name: int = next(self._name_generator)
+            kwargs["name"] = self.name
+        super().__init__(**kwargs)
+        self.t: float = t
+        """Time of the node."""
+        self.state_attr: str = state_attr
+        """Name of the node attribute to store the state in."""
+        setattr(self, state_attr, state)
+        self.event: str | None = None
+        """Event at this node."""
+        self.n_mutations: int = 0
+        """Number of mutations on the branch above this node (zero unless the tree has
+        been pruned above this node, removing mutation event nodes)."""
+        self._sampled: bool = False
+        """Whether sampling has been run on this tree.
+
+        (Not whether the node has been sampled as part of this sampling process).
+        """
+        self._pruned: bool = False
+        """Whether pruning has been run on this tree."""
+        self._mutations_removed: bool = False
+        """Whether unifurcating mutation event nodes have been removed from this
+        tree."""
+
+    def _birth_outcome(
+        self, birth_mutations: bool, mutator: mutators.Mutator, rng: np.random.Generator
+    ) -> Generator[TreeNode, None, None]:
+        r"""Generate the outcome of a birth event at this node.
+
+        Args:
+            birth_mutations: Flag to indicate whether mutations should occur at birth.
+            mutator: Generator of mutation effects if ``birth_mutations=True``.
+            rng: Random number generator.
+
+        Yields:
+            The child nodes, or mutated grandchild nodes if ``birth_mutations=True``.
+        """
+        assert self.event == self._BIRTH_EVENT
+        for _ in range(self._OFFSPRING_NUMBER):
+            child = TreeNode(
+                t=self.t,
+                dist=0,
+                name=next(self._name_generator),
+            )
+            setattr(child, mutator.attr, copy.copy(getattr(self, mutator.attr)))
+            if birth_mutations:
+                child.event = self._MUTATION_EVENT
+                mutator.mutate(child, seed=rng)
+                grandchild = TreeNode(
+                    t=child.t,
+                    dist=0,
+                    name=next(self._name_generator),
+                )
+                setattr(
+                    grandchild, mutator.attr, copy.copy(getattr(child, mutator.attr))
+                )
+                child.add_child(grandchild)
+                yield grandchild
+            else:
+                yield child
+            self.add_child(child)
+
+    def _mutation_outcome(
+        self, mutator: mutators.Mutator, rng: np.random.Generator
+    ) -> Generator[TreeNode, None, None]:
+        r"""Generate the outcome of a mutation event at this node.
+
+        Args:
+            mutator: Generator of mutation effects.
+            rng: Random number generator.
+
+        Yields:
+            The mutated child node.
+        """
+        assert self.event == self._MUTATION_EVENT
+        mutator.mutate(self, seed=rng)
+        child = TreeNode(
+            t=self.t,
+            dist=0,
+            name=next(self._name_generator),
+        )
+        setattr(child, mutator.attr, copy.copy(getattr(self, mutator.attr)))
+        self.add_child(child)
+        yield child
+
+    def evolve(
+        self,
+        t: float,
+        birth_process: poisson.Process = poisson.ConstantProcess(1),
+        death_process: poisson.Process = poisson.ConstantProcess(0),
+        mutation_process: poisson.Process = poisson.ConstantProcess(0),
+        mutator: mutators.Mutator = mutators.DiscreteMutator((None,), np.array([[1]])),
+        birth_mutations: bool = False,
+        min_survivors: int = 1,
+        capacity: int = 1000,
+        capacity_method: Literal["birth", "death", "hard"] | None = None,
+        init_population: int = 1,
+        seed: int | np.random.Generator | None = None,
+        verbose: bool = False,
+    ) -> None:
+        r"""Evolve for time :math:`\Delta t`.
+
+        Args:
+            t: Evolve for a duration of :math:`t` time units.
+            birth_process: Birth process function.
+            death_process: Death process function.
+            mutation_process: Mutation process function.
+            mutator: Generator of mutation effects at mutation events
+                     (and on offspring of birth events if ``birth_mutations=True``).
+            birth_mutations: Flag to indicate whether mutations should occur at birth.
+            min_survivors: Minimum number of survivors. If the simulation finishes with
+                           fewer than this number of survivors, then a
+                           :py:class:`TreeError` is raised.
+            capacity: Population carrying capacity.
+            capacity_method: Method to enforce population carrying capacity. If
+                             ``None``, then a :py:class:`TreeError` is raised if
+                             the population exceeds the carrying capacity.
+                             If ``"birth"``, then the birth rate is logistically
+                             modulated such that the process is critical when the
+                             population is at carrying capacity.
+                             If ``"death"``, then the death rate is logistically
+                             modulated such that the process is critical when the
+                             population is at carrying capacity.
+                             If ``"hard"``, then a random individual is chosen to
+                             die whenever a birth event results in carrying capacity
+                             being exceeded.
+            init_population: Initial population size.
+            seed: A seed to initialize the random number generation.
+                  If ``None``, then fresh, unpredictable entropy will be pulled from
+                  the OS.
+                  If an ``int``, then it will be used to derive the initial state.
+                  If a :py:class:`numpy.random.Generator`, then it will be used
+                  directly.
+            verbose: Flag to indicate whether to print progress information.
+
+        Raises:
+            TreeError: If the tree is not a root node, or if the tree has already
+                       evolved, or if the number of survivors is less than
+                       ``min_survivors``, or if the population exceeds ``capacity``
+                       with ``capacity_method=None``.
+            ValueError: If ``init_population`` is greater than ``capacity`` or if
+                        the event processes refer to different node attributes.
+        """
+        if not self.is_root():
+            raise TreeError("Cannot evolve a non-root node")
+        if self.children:
+            raise TreeError(
+                "tree has already evolved at node "
+                f"{self.name} with {len(self.children)} descendant lineages"
+            )
+        if init_population > capacity:
+            raise ValueError(f"{init_population=} must be less than {capacity=}")
+        if birth_process.attr != death_process.attr != mutation_process.attr:
+            raise ValueError(
+                f"Event processes must refer to the same node attribute. Got: "
+                f"{birth_process.attr=}, {death_process.attr=}, "
+                f"{mutation_process.attr=}"
+            )
+        state_attr = birth_process.attr
+        if not hasattr(self, state_attr):
+            raise ValueError(
+                f"node {self.name} does not have attribute {state_attr} "
+                "required by mutator"
+            )
+        # NOTE: this may go later when we revise how mutators work
+        if mutator.attr != state_attr:
+            raise ValueError(
+                f"mutator attribute {mutator.attr} does not match state attribute "
+                f"{state_attr}"
+            )
+
+        rng = np.random.default_rng(seed)
+
+        if verbose:
+
+            def print_progress(current_time: float, n_nodes_active: int):
+                print(f"t={current_time:.3f}, n={n_nodes_active}", end="   \r")
+
+        else:
+
+            def print_progress(current_time: float, n_nodes_active: int):
+                pass
+
+        current_time = self.t
+        end_time = self.t + t
+        processes = {
+            self._BIRTH_EVENT: birth_process,
+            self._DEATH_EVENT: death_process,
+            self._MUTATION_EVENT: mutation_process,
+        }
+
+        # initialize population
+        names_nodes_all: dict[int, TreeNode] = dict()
+        names_active = utils.RandomizedSet()
+        state_names_active: defaultdict[str, utils.RandomizedSet] = defaultdict(
+            utils.RandomizedSet
+        )
+        total_birth_rate = 0.0
+        total_death_rate = 0.0
+        for _ in range(init_population):
+            start_node = TreeNode(
+                t=self.t,
+                dist=0,
+                name=next(self._name_generator),
+            )
+            setattr(start_node, state_attr, copy.copy(getattr(self, state_attr)))
+            self.add_child(start_node)
+            names_nodes_all[start_node.name] = start_node
+            names_active.add(start_node.name)
+            state_names_active[getattr(start_node, state_attr)].add(start_node.name)
+            total_birth_rate += birth_process(start_node)
+            total_death_rate += death_process(start_node)
+
+        # initialize rate multipliers, which are used to modulate
+        # rates in accordance with the carrying capacity
+        rate_multipliers: dict[str, float] = {
+            self._BIRTH_EVENT: 1.0,
+            self._DEATH_EVENT: 1.0,
+            self._MUTATION_EVENT: 1.0,
+        }
+        while len(names_active) > 0:
+            if capacity_method == "birth":
+                rate_multipliers[self._BIRTH_EVENT] = (  # type:ignore
+                    total_death_rate / total_birth_rate
+                ) ** (len(names_active) / capacity)
+            elif capacity_method == "death":
+                rate_multipliers[self._DEATH_EVENT] = (  # type:ignore
+                    total_birth_rate / total_death_rate
+                ) ** (len(names_active) / capacity)
+            elif capacity_method == "hard":
+                if len(names_active) > capacity:
+                    node_to_die_name: int = names_active.choice(rng)
+                    node_to_die = names_nodes_all[node_to_die_name]
+                    assert node_to_die.up is not None
+                    node_to_die.dist = current_time - node_to_die.up.t
+                    node_to_die.event = self._DEATH_EVENT
+                    node_to_die.t = current_time
+                    names_active.remove(node_to_die_name)
+                    state_names_active[getattr(node_to_die, state_attr)].remove(
+                        node_to_die.name
+                    )
+                    total_birth_rate -= birth_process(node_to_die)
+                    total_death_rate -= death_process(node_to_die)
+            elif capacity_method is None:
+                if len(names_active) > capacity:
+                    self._aborted_evolve_cleanup()
+                    if verbose:
+                        print()
+                    raise TreeError(f"{capacity=} exceeded at time={current_time}")
+            else:
+                raise ValueError(f"{capacity_method=} not recognized")
+            waiting_time, event, state = min(
+                (
+                    processes[event].waiting_time_rv(
+                        state,
+                        current_time,
+                        rate_multiplier=rate_multipliers[event]
+                        * len(state_names_active[state]),
+                        seed=rng,
+                    ),
+                    event,
+                    state,
+                )
+                for event in processes
+                for state in state_names_active
+                if len(state_names_active[state]) > 0
+            )
+            Δt = float(np.minimum(waiting_time, end_time - current_time))
+            current_time += Δt
+            if current_time < end_time:
+                event_node_name = state_names_active[state].choice(rng)
+                event_node = names_nodes_all[event_node_name]
+                event_node.t = current_time
+                assert event_node.up is not None
+                event_node.dist = current_time - event_node.up.t
+                event_node.event = event
+                names_active.remove(event_node_name)
+                state_names_active[getattr(event_node, state_attr)].remove(
+                    event_node.name
+                )
+                total_birth_rate -= birth_process(event_node)
+                total_death_rate -= death_process(event_node)
+                if event_node.event == self._DEATH_EVENT:
+                    new_nodes = ()
+                elif event_node.event == self._BIRTH_EVENT:
+                    new_nodes = event_node._birth_outcome(birth_mutations, mutator, rng)
+                elif event_node.event == self._MUTATION_EVENT:
+                    new_nodes = event_node._mutation_outcome(mutator, rng)
+                else:
+                    raise ValueError(f"invalid event {event_node.event}")
+                for new_node in new_nodes:
+                    names_nodes_all[new_node.name] = new_node
+                    names_active.add(new_node.name)
+                    state_names_active[getattr(new_node, state_attr)].add(new_node.name)
+                    total_birth_rate += birth_process(new_node)
+                    total_death_rate += death_process(new_node)
+                print_progress(float(current_time), len(names_active))
+            else:
+                # deal with possible loss of significance
+                if current_time > end_time:
+                    # NOTE: math.isclose is much faster than np.isclose
+                    assert math.isclose(
+                        current_time, end_time
+                    ), f"{current_time=}, {end_time=}"
+                    current_time = end_time
+                print_progress(float(current_time), len(names_active))
+                for node_name in reversed(names_active):
+                    node = names_nodes_all[node_name]
+                    node.t = current_time
+                    assert node.up is not None
+                    node.dist = current_time - node.up.t
+                    node.event = self._SURVIVAL_EVENT
+                    names_active.remove(node_name)
+                    state_names_active[getattr(node, state_attr)].remove(node.name)
+                assert len(names_active) == 0
+                assert not any(
+                    len(state_names_active[state]) > 0 for state in state_names_active
+                )
+        if verbose:
+            print()
+        n_survivors = sum(leaf.event == self._SURVIVAL_EVENT for leaf in self)
+        if n_survivors < min_survivors:
+            self._aborted_evolve_cleanup()
+            raise TreeError(
+                f"number of survivors {n_survivors} is less than {min_survivors=}"
+            )
+
+    def _aborted_evolve_cleanup(self) -> None:
+        """Remove any children added to the root node during an aborted evolution
+        attempt, and reset the node name generator."""
+        for child in self.children.copy():
+            child.detach()
+            del child
+        TreeNode._name_generator = itertools.count(start=self.name + 1)
+
+    def sample_survivors(
+        self,
+        n: int | None = None,
+        p: float | None = 1.0,
+        seed: int | np.random.Generator | None = None,
+    ) -> None:
+        """Choose :math:`n` survivor leaves from the tree, or each survivor leaf with
+        probability :math:`p`, to mark as sampled (via the event attribute).
+
+        Args:
+            n: Number of leaves to sample.
+            p: Probability of sampling a leaf.
+            seed: A seed to initialize the random number generation. If ``None``, then
+                  fresh, unpredictable entropy will be pulled from the OS. If an
+                  ``int``, then it will be used to derive the initial state. If a
+                  :py:class:`numpy.random.Generator`, then it will be used directly.
+
+        Raises:
+            ValueError: If the tree has already been sampled below this node, or if
+                        neither ``n`` nor ``p`` is specified.
+        """
+        if self._sampled:
+            raise ValueError(f"tree has already been sampled below node {self.name}")
+        rng = np.random.default_rng(seed)
+        surviving_leaves: list[TreeNode] = [
+            leaf for leaf in self if leaf.event == self._SURVIVAL_EVENT
+        ]
+        if n is not None:
+            for leaf in rng.choice(
+                surviving_leaves, size=n, replace=False  # type:ignore
+            ):
+                leaf.event = self._SAMPLING_EVENT
+        elif p is not None:
+            for leaf in surviving_leaves:
+                if rng.choice(range(2), p=(1 - p, p)):
+                    leaf.event = self._SAMPLING_EVENT
+        else:
+            raise ValueError("must specify either n or p")
+        for node in self.traverse():  # type:ignore
+            node._sampled = True
+
+    # NOTE: this could be generalized to take an ordered array-valued t,
+    #       and made efficient via ordered traversal
+    def slice(self, t: float, attr: str = "x") -> list[Any]:
+        r"""
+        Args:
+            t: Slice the tree at time :math:`t`.
+            attr: Attribute to extract from slice.
+
+        Returns:
+            List of attribute ``attr`` values at time :math:`t` for all lineages alive
+            at that time.
+
+        Raises:
+            ValueError: If the tree has not evolved or has already been pruned below
+                        this node, or if the tree has not been sampled below this node,
+                        or if ``t`` is before the root time or after the tree end time.
+        """
+        if self._pruned:
+            raise ValueError("Cannot slice a pruned tree")
+        if not self.children:
+            raise ValueError("Cannot slice an unevolved tree")
+        if t < self.t:
+            raise ValueError(f"Cannot slice at time {t} before root time {self.t}")
+        tree_end_time = max(node.t for node in self)
+        if t > tree_end_time:
+            raise ValueError(
+                f"cannot slice at time {t} after tree end time {tree_end_time}"
+            )
+
+        if self.t == t:
+            return [getattr(self, attr)]
+
+        def is_leaf_fn(node: TreeNode):
+            assert node.up is not None
+            return node.t >= t and node.up.t < t
+
+        return [
+            (getattr(node, attr) if node.t == t else getattr(node.up, attr))
+            for node in self.iter_leaves(is_leaf_fn=is_leaf_fn)
+        ]
+
+    def prune_unsampled(self) -> None:
+        r"""Prune the tree to the subtree subtending the sampled leaves, removing
+        unobserved subtrees.
+
+        Raises:
+            ValueError: If the tree has not been sampled below this node, or if the
+                        tree has already been pruned below this node.
+            TreeError: If no leaves were sampled.
+        """
+        if self._pruned:
+            raise ValueError(f"tree has already been pruned below node {self.name}")
+        if not self._sampled:
+            raise ValueError(f"tree has not been sampled below node {self.name}")
+
+        event_cache: dict[TreeNode, set[str]] = self.get_cached_content(
+            store_attr="event"
+        )
+        if self._SAMPLING_EVENT not in event_cache[self]:
+            raise TreeError("cannot prune because no leaves were sampled")
+
+        def is_leaf_fn(node: TreeNode):
+            return self._SAMPLING_EVENT not in event_cache[node]
+
+        for node in self.iter_leaves(is_leaf_fn=is_leaf_fn):
+            parent = node.up
+            assert parent is not None
+            parent.remove_child(node)
+            assert parent.event == self._BIRTH_EVENT or parent.is_root()
+            parent.delete(
+                prevent_nondicotomic=False,
+                preserve_branch_length=True,
+            )
+        for node in self.traverse():  # type:ignore
+            node._pruned = True
+
+    def remove_mutation_events(self) -> None:
+        r"""Remove unifurcating mutation event nodes, preserving branch length, and
+        annotate mutation counts in child node ``n_mutations`` attribute.
+
+        Raises:
+            ValueError: If the tree has not been pruned below this node with
+                        :py:meth:`prune`.
+        """
+        if not self._pruned:
+            raise ValueError(f"tree has not been pruned below node {self.name}")
+        for node in self.traverse(strategy="postorder"):  # type:ignore
+            if node.event == self._MUTATION_EVENT:
+                assert len(node.children) == 1
+                node.children[0].n_mutations += 1
+                node.delete(
+                    prevent_nondicotomic=False,
+                    preserve_branch_length=True,
+                )
+        for node in self.traverse():  # type:ignore
+            node._mutations_removed = True
+
+    def render(  # type:ignore
+        self,
+        file_name: str,
+        color_by: str | None = "state",
+        color_map: Mapping[Any, str] | None = None,
+        mode: Literal["c", "r"] = "r",
+        scale: float | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        r"""A thin wrapper around :py:meth:`ete3.TreeNode.render` that adds some custom
+        decoration and a color bar. See also ETE's tree rendering `tutorial`_ and linked
+        API docs pages there.
+
+        .. _tutorial: http://etetoolkit.org/docs/latest/tutorial/tutorial_drawing.html
+
+        If tree is not pruned (or is pruned without removing mutation events), then
+        branches are colored according to the attribute specified by ``color_by``,
+        extinct lineages are indicated as dotted branches, unsampled non-extint
+        lineages are indicated as solid branches, and sampled lineages are indicated
+        as thick solid branches. Sampled leaves are indicated with a circle.
+
+        If tree is pruned without retaining mutation events, then nodes are colored
+        according to the attribute specified by ``color_by``, branches are annotated
+        above with branch length (in black text) and below with number of mutations
+        (in green text).
+
+        Args:
+            file_name: Filename to save the rendered tree to. Use ``"%%inline"`` to
+                      render inline in a notebook.
+            color_by: If not ``None``, color tree by this numerical node attribute.
+            color_map: mapping from node attribute values to color names or hex codes.
+            mode: ``"c"`` for circular tree, ``"r"`` for rectangular tree.
+            scale: Scale branch lengths by this factor (ignored if a ``tree_style`` is
+                   passed in ``kwargs``). If ``None``, then the scale is chosen
+                   automatically.
+            kwargs: Keyword arguments to pass to :py:meth:`ete3.TreeNode.render`.
+
+        Returns:
+            The return value of :py:meth:`ete3.TreeNode.render`.
+        """
+        if "tree_style" not in kwargs:
+            kwargs["tree_style"] = ete3.TreeStyle()
+            kwargs["tree_style"].show_leaf_name = False
+            kwargs["tree_style"].show_scale = False
+            kwargs["tree_style"].rotation = 90
+            kwargs["tree_style"].mode = mode
+            kwargs["tree_style"].scale = scale  # type:ignore
+
+        event_cache: dict[TreeNode, set[str]] = self.get_cached_content(
+            store_attr="event", leaves_only=False
+        )
+        if (not self._pruned) or (not self._mutations_removed):
+            for node in self.traverse():  # type:ignore
+                nstyle = ete3.NodeStyle()
+                if (
+                    self._SURVIVAL_EVENT not in event_cache[node]
+                    and self._SAMPLING_EVENT not in event_cache[node]
+                ):
+                    nstyle["hz_line_type"] = 1
+                    nstyle["vt_line_type"] = 1
+                    nstyle["hz_line_width"] = 0
+                    nstyle["vt_line_width"] = 0
+                elif self._SAMPLING_EVENT not in event_cache[node]:
+                    nstyle["hz_line_width"] = 1
+                    nstyle["vt_line_width"] = 1
+                else:
+                    nstyle["hz_line_width"] = 2
+                    nstyle["vt_line_width"] = 2
+                if color_map is not None:
+                    assert color_by is not None
+                    nstyle["vt_line_color"] = color_map[getattr(node, color_by)]
+                    if not node.is_root():
+                        assert node.up is not None
+                        nstyle["hz_line_color"] = color_map[getattr(node.up, color_by)]
+                    nstyle["fgcolor"] = color_map[getattr(node, color_by)]
+                if node.event == self._SAMPLING_EVENT:
+                    nstyle["size"] = 2
+                else:
+                    nstyle["size"] = 0
+                node.set_style(nstyle)
+        else:
+            for node in self.traverse():  # type:ignore
+                nstyle = ete3.NodeStyle()
+                if color_map is not None:
+                    assert color_by is not None
+                    nstyle["fgcolor"] = color_map[getattr(node, color_by)]
+                if not node.is_root() and not getattr(node.faces, "branch-bottom"):
+                    node.add_face(self._mutation_face, 0, position="branch-bottom")
+                node.set_style(nstyle)
+
+        return super().render(file_name, **kwargs)

bdms/utils.py

@@ -0,0 +1,129 @@
+r"""Miscellaneous utilities needed by the rest of the package."""
+
+from __future__ import annotations
+from typing import Any, Hashable, Iterable
+import numpy as np
+
+
+class RandomizedSet:
+    r"""A set-like data structure that supports random sampling with constant time
+    complexity.
+
+    Example:
+
+        >>> import bdms
+
+        Initialize with any iterable of hashable items.
+
+        >>> rs = bdms.utils.RandomizedSet("abc")
+        >>> rs
+        RandomizedSet('a', 'b', 'c')
+        >>> len(rs)
+        3
+
+        Add an item.
+
+        >>> rs.add('d')
+        >>> rs
+        RandomizedSet('a', 'b', 'c', 'd')
+        >>> len(rs)
+        4
+
+        Choose a random item.
+
+        >>> rs.choice(seed=0)
+        'd'
+
+        Remove an item.
+
+        >>> rs.remove('a')
+        >>> rs
+        RandomizedSet('d', 'b', 'c')
+
+        Iterate over the items.
+
+        >>> for item in rs:
+        ...     print(item)
+        d
+        b
+        c
+
+        Reverse iterate over the items.
+
+        >>> for item in reversed(rs):
+        ...     print(item)
+        c
+        b
+        d
+
+    Args:
+        items: Items to initialize the set with.
+    """
+
+    def __init__(self, items: Iterable[Hashable] = ()):
+        self._item_to_idx: dict[Any, int] = {}
+        self._idx_to_item: list[Any] = []
+        for item in items:
+            self.add(item)
+
+    def add(self, item: Hashable):
+        r"""Add an item to the set.
+
+        Args:
+            item: The item to add.
+        """
+        if item in self._item_to_idx:
+            return
+        self._item_to_idx[item] = len(self._idx_to_item)
+        self._idx_to_item.append(item)
+
+    def remove(self, item: Hashable):
+        r"""Remove an item from the set.
+
+        Args:
+            item: The item to remove.
+
+        Raises:
+            KeyError: If the item is not in the set.
+        """
+        if item not in self._item_to_idx:
+            raise KeyError(item)
+        # Swap the element with the last element
+        last_item = self._idx_to_item[len(self) - 1]
+        del_idx = self._item_to_idx[item]
+        self._item_to_idx[last_item] = del_idx
+        self._idx_to_item[del_idx] = last_item
+        # Remove the last element
+        del self._item_to_idx[item]
+        del self._idx_to_item[-1]
+
+    def choice(self, seed: int | np.random.Generator | None = None) -> Any:
+        r"""Randomly sample an item from the set.
+
+        Args:
+            seed: A seed to initialize the random number generation.
+                  If ``None``, then fresh, unpredictable entropy will be pulled from
+                  the OS.
+                  If an ``int``, then it will be used to derive the initial state.
+                  If a :py:class:`numpy.random.Generator`, then it will be used
+                  directly.
+
+        Returns:
+            The sampled item.
+        """
+        rng = np.random.default_rng(seed)
+        return self._idx_to_item[rng.choice(len(self))]
+
+    def __len__(self) -> int:
+        return len(self._idx_to_item)
+
+    def __iter__(self):
+        for idx in range(len(self)):
+            yield self._idx_to_item[idx]
+
+    def __reversed__(self):
+        for idx in reversed(range(len(self))):
+            yield self._idx_to_item[idx]
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({', '.join(map(repr, self))})"

bdms_sim-0.2.0.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: bdms-sim
+Version: 0.2.0
+Summary: Tree simulator for birth-death-mutation-sampling (BDMS) processes
+Project-URL: Homepage, https://github.com/WSDeWitt/BDMS
+Project-URL: Bug Tracker, https://github.com/WSDeWitt/BDMS/issues
+Project-URL: Documentation, https://wsdewitt.github.io/BDMS
+Author-email: Thanasi Bakis <abakis@uci.edu>, Michael Celentano <mcelentano@berkeley.edu>, William DeWitt <wsdewitt@gmail.com>, Frederick Matsen <ematsen@gmail.com>, Volodymyr Minin <yss@berkeley.edu>, Sebastian Prillo <sprillo@berkeley.edu>, Duncan Ralph <dkralph@gmail.com>, Yoonseo Song <ysong07@cs.washington.edu>, Yun Song <yss@berkeley.edu>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: ete3
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pyqt5
+Requires-Dist: scipy
+Description-Content-Type: text/markdown
+
+[![build and test](https://github.com/WSDeWitt/BDMS/actions/workflows/build-and-test.yml/badge.svg)](https://github.com/WSDeWitt/BDMS/actions/workflows/build-and-test.yml)
+[![docs build and deploy](https://github.com/WSDeWitt/BDMS/actions/workflows/docs-build-and-deploy.yml/badge.svg)](https://github.com/WSDeWitt/BDMS/actions/workflows/docs-build-and-deploy.yml)
+
+# BDMS
+Tree simulator for birth-death-mutation-sampling (BDMS) processes
+
+Documentation: https://wsdewitt.github.io/BDMS

bdms_sim-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+bdms/__init__.py,sha256=EwSpi9WqG-wLhsBVM3eLUgxru4xW9gRVZvuxH28TXHE,199
+bdms/mutators.py,sha256=ZQT-sDVQU3GdveiAoHr2r8KVg8XQS38_dkes03lhZEE,7531
+bdms/poisson.py,sha256=5DOmdnU-xe4MyrdSk-Sw_AnIyW0RTPbMIQNhfC_6404,10283
+bdms/tree.py,sha256=zxtP5TGbcWiedTinFWeWit6vfOwdlS9-GOmmCoRy21Y,27342
+bdms/utils.py,sha256=fQ0-GkuyyAmNUDmYFh9m6ea9LQGhwR61PL-YBfj3BlQ,3338
+bdms_sim-0.2.0.dist-info/METADATA,sha256=G4EgQTux33IfdsP3muQv_7yG6rywl0pR-_mGnAnc-GM,1484
+bdms_sim-0.2.0.dist-info/WHEEL,sha256=mRYSEL3Ih6g5a_CVMIcwiF__0Ae4_gLYh01YFNwiq1k,87
+bdms_sim-0.2.0.dist-info/licenses/LICENSE,sha256=dwM9ik7qVMz2cdFxgoc9J3LbygD9AuBUch32nUAQEO8,1071
+bdms_sim-0.2.0.dist-info/RECORD,,

bdms_sim-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.21.0
+Root-Is-Purelib: true
+Tag: py3-none-any

bdms_sim-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 William DeWitt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.