phylogenie 2.1.26__tar.gz → 3.1.5__tar.gz

{phylogenie-2.1.26 → phylogenie-3.1.5}/PKG-INFO

@@ -1,21 +1,17 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: phylogenie
-Version: 2.1.26
+Version: 3.1.5
 Summary: Generate phylogenetic datasets with minimal setup effort
-Author: Gabriele Marino
-Author-email: gabmarino.8601@gmail.com
-Requires-Python: >=3.10,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: joblib (>=1.4.2,<2.0.0)
-Requires-Dist: matplotlib (>=3.10.6,<4.0.0)
-Requires-Dist: pandas (>=2.2.2,<3.0.0)
-Requires-Dist: pydantic (>=2.11.5,<3.0.0)
-Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
-Requires-Dist: tqdm (>=4.66.4,<5.0.0)
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: joblib>=1.5.2
+Requires-Dist: matplotlib>=3.10.7
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: pydantic>=2.12.3
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: tqdm>=4.67.1
+Dynamic: license-file
 
 <p align="center">
 <img src="https://raw.githubusercontent.com/gabriele-marino/phylogenie/main/logo.png" style="width:100%; height:auto;"/>
@@ -103,4 +99,3 @@ This project is licensed under [MIT License](https://raw.githubusercontent.com/g
 For questions, bug reports, or feature requests, please, consider opening an [issue on GitHub](https://github.com/gabriele-marino/phylogenie/issues), or [contact me directly](mailto:gabmarino.8601@email.com).
 
 If you need help with the configuration files, feel free to reach out —  I am always very available and happy to assist!
-

phylogenie-3.1.5/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "phylogenie"
+version = "3.1.5"
+description = "Generate phylogenetic datasets with minimal setup effort"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "joblib>=1.5.2",
+    "matplotlib>=3.10.7",
+    "pandas>=2.3.3",
+    "pydantic>=2.12.3",
+    "pyyaml>=6.0.3",
+    "tqdm>=4.67.1",
+]
+
+[dependency-groups]
+dev = [
+    "joblib-stubs>=1.5.2.0.20250831",
+    "pandas-stubs>=2.3.2.250926",
+    "pyright>=1.1.407",
+    "pytest>=8.4.2",
+]
+
+[tool.pyright]
+typeCheckingMode = "strict"
+
+[project.scripts]
+phylogenie = "phylogenie.main:main"
+
+[build-system]
+requires = ["setuptools>=42"]
+build-backend = "setuptools.build_meta"

phylogenie-3.1.5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{phylogenie-2.1.26 → phylogenie-3.1.5/src}/phylogenie/__init__.py

@@ -11,7 +11,7 @@ from phylogenie.generators import (
     FBDTreeDatasetGenerator,
     TreeDatasetGeneratorConfig,
 )
-from phylogenie.io import dump_newick, load_fasta, load_newick, load_nexus
+from phylogenie.io import load_fasta
 from phylogenie.msa import MSA
 from phylogenie.skyline import (
     SkylineMatrix,
@@ -25,41 +25,47 @@ from phylogenie.skyline import (
     skyline_parameter,
     skyline_vector,
 )
-from phylogenie.tree import Tree
 from phylogenie.treesimulator import (
     Birth,
     BirthWithContactTracing,
     Death,
     Event,
     EventType,
+    Feature,
     Migration,
     Mutation,
     Sampling,
     SamplingWithContactTracing,
+    Tree,
+    compute_mean_leaf_pairwise_distance,
+    compute_sackin_index,
+    dump_newick,
     generate_trees,
     get_BD_events,
     get_BDEI_events,
     get_BDSS_events,
     get_canonical_events,
     get_contact_tracing_events,
+    get_distance,
     get_epidemiological_events,
     get_FBD_events,
-    simulate_tree,
-)
-from phylogenie.utils import (
-    compute_colless_index,
-    compute_mean_leaf_pairwise_distance,
-    compute_sackin_index,
-    get_distance,
     get_mrca,
+    get_mutation_id,
     get_node_depth_levels,
     get_node_depths,
     get_node_height_levels,
     get_node_heights,
     get_node_leaf_counts,
+    get_node_state,
+    load_newick,
+    load_nexus,
+    set_features,
+    simulate_tree,
 )
 
 __all__ = [
+    "Coloring",
+    "draw_tree",
     "AliSimDatasetGenerator",
     "BDEITreeDatasetGenerator",
     "BDSSTreeDatasetGenerator",
@@ -69,51 +75,52 @@ __all__ = [
     "DatasetGeneratorConfig",
     "EpidemiologicalTreeDatasetGenerator",
     "FBDTreeDatasetGenerator",
+    "TreeDatasetGeneratorConfig",
+    "load_fasta",
+    "MSA",
     "SkylineMatrix",
     "SkylineMatrixCoercible",
-    "skyline_matrix",
     "SkylineParameter",
     "SkylineParameterLike",
-    "skyline_parameter",
     "SkylineVector",
     "SkylineVectorCoercible",
     "SkylineVectorLike",
+    "skyline_matrix",
+    "skyline_parameter",
     "skyline_vector",
-    "Tree",
-    "TreeDatasetGeneratorConfig",
     "Birth",
     "BirthWithContactTracing",
     "Death",
     "Event",
     "EventType",
+    "Feature",
     "Migration",
     "Mutation",
     "Sampling",
     "SamplingWithContactTracing",
+    "Tree",
+    "compute_mean_leaf_pairwise_distance",
+    "compute_sackin_index",
+    "dump_newick",
+    "generate_trees",
     "get_BD_events",
     "get_BDEI_events",
     "get_BDSS_events",
     "get_canonical_events",
     "get_contact_tracing_events",
+    "get_distance",
     "get_epidemiological_events",
     "get_FBD_events",
-    "generate_trees",
-    "simulate_tree",
-    "dump_newick",
-    "load_nexus",
-    "load_fasta",
-    "load_newick",
-    "MSA",
-    "Coloring",
-    "draw_tree",
-    "compute_colless_index",
-    "compute_mean_leaf_pairwise_distance",
-    "compute_sackin_index",
-    "get_distance",
     "get_mrca",
-    "get_node_depths",
+    "get_mutation_id",
     "get_node_depth_levels",
-    "get_node_heights",
+    "get_node_depths",
     "get_node_height_levels",
+    "get_node_heights",
     "get_node_leaf_counts",
+    "get_node_state",
+    "load_newick",
+    "load_nexus",
+    "set_features",
+    "simulate_tree",
 ]

{phylogenie-2.1.26 → phylogenie-3.1.5/src}/phylogenie/draw.py

@@ -1,15 +1,14 @@
 from enum import Enum
-from itertools import islice
-from typing import Any
+from typing import Any, Callable
 
 import matplotlib.colors as mcolors
 import matplotlib.patches as mpatches
 import matplotlib.pyplot as plt
 from matplotlib.axes import Axes
+from matplotlib.colors import Colormap
 from mpl_toolkits.axes_grid1.inset_locator import inset_axes  # pyright: ignore
 
-from phylogenie.tree import Tree
-from phylogenie.utils import get_node_depth_levels, get_node_depths
+from phylogenie.treesimulator import Tree, get_node_depth_levels, get_node_depths
 
 
 class Coloring(str, Enum):
@@ -20,13 +19,18 @@ class Coloring(str, Enum):
 Color = str | tuple[float, float, float] | tuple[float, float, float, float]
 
 
-def _draw_colored_tree(tree: Tree, ax: Axes, colors: Color | dict[Tree, Color]) -> Axes:
+def draw_colored_tree(
+    tree: Tree, ax: Axes | None = None, colors: Color | dict[Tree, Color] = "black"
+) -> Axes:
+    if ax is None:
+        ax = plt.gca()
+
     if not isinstance(colors, dict):
         colors = {node: colors for node in tree}
 
     xs = (
         get_node_depth_levels(tree)
-        if any(node.branch_length is None for node in islice(tree, 1, None))
+        if any(node.branch_length is None for node in tree.iter_descendants())
         else get_node_depths(tree)
     )
     ys: dict[Tree, float] = {node: i for i, node in enumerate(tree.get_leaves())}
@@ -34,14 +38,14 @@ def _draw_colored_tree(tree: Tree, ax: Axes, colors: Color | dict[Tree, Color])
         if node.is_internal():
             ys[node] = sum(ys[child] for child in node.children) / len(node.children)
 
+    if tree.branch_length is not None:
+        ax.hlines(y=ys[tree], xmin=0, xmax=xs[tree], color=colors[tree])  # pyright: ignore
     for node in tree:
         x1, y1 = xs[node], ys[node]
-        if node.parent is None:
-            ax.hlines(y=y1, xmin=0, xmax=x1, color=colors[node])  # pyright: ignore
-            continue
-        x0, y0 = xs[node.parent], ys[node.parent]
-        ax.vlines(x=x0, ymin=y0, ymax=y1, color=colors[node])  # pyright: ignore
-        ax.hlines(y=y1, xmin=x0, xmax=x1, color=colors[node])  # pyright: ignore
+        for child in node.children:
+            x2, y2 = xs[child], ys[child]
+            ax.hlines(y=y2, xmin=x1, xmax=x2, color=colors[child])  # pyright: ignore
+            ax.vlines(x=x1, ymin=y1, ymax=y2, color=colors[child])  # pyright: ignore
 
     ax.set_yticks([])  # pyright: ignore
     return ax
@@ -50,13 +54,14 @@ def _draw_colored_tree(tree: Tree, ax: Axes, colors: Color | dict[Tree, Color])
 def draw_tree(
     tree: Tree,
     ax: Axes | None = None,
-    color_by: str | None = None,
+    color_by: str | dict[str, Any] | None = None,
     coloring: str | Coloring | None = None,
     default_color: Color = "black",
-    cmap: str | None = None,
+    colormap: str | Colormap | None = None,
     vmin: float | None = None,
     vmax: float | None = None,
     show_legend: bool = True,
+    labels: dict[Any, Any] | None = None,
     legend_kwargs: dict[str, Any] | None = None,
     show_hist: bool = True,
     hist_kwargs: dict[str, Any] | None = None,
@@ -66,62 +71,62 @@ def draw_tree(
         ax = plt.gca()
 
     if color_by is None:
-        return _draw_colored_tree(tree, ax, colors=default_color)
+        return draw_colored_tree(tree, ax, colors=default_color)
 
-    features = [node.get(color_by) for node in tree if color_by in node.features]
+    if isinstance(color_by, str):
+        features = {node: node[color_by] for node in tree if color_by in node.metadata}
+    else:
+        features = {node: color_by[node.name] for node in tree if node.name in color_by}
+    values = list(features.values())
 
     if coloring is None:
         coloring = (
             Coloring.CONTINUOUS
-            if any(isinstance(f, float) for f in features)
+            if any(isinstance(f, float) for f in values)
             else Coloring.DISCRETE
         )
+    if colormap is None:
+        colormap = "tab20" if coloring == Coloring.DISCRETE else "viridis"
+    if isinstance(colormap, str):
+        colormap = plt.get_cmap(colormap)
+
+    def _get_colors(feature_map: Callable[[Any], Color]) -> dict[Tree, Color]:
+        return {
+            node: feature_map(features[node]) if node in features else default_color
+            for node in tree
+        }
 
     if coloring == Coloring.DISCRETE:
-        if any(isinstance(f, float) for f in features):
+        if any(isinstance(f, float) for f in values):
             raise ValueError(
                 "Discrete coloring selected but feature values are not all categorical."
             )
-
-        colormap = plt.get_cmap("tab20" if cmap is None else cmap)
         feature_colors = {
-            f: mcolors.to_hex(colormap(i)) for i, f in enumerate(set(features))
-        }
-        colors = {
-            node: (
-                feature_colors[node.get(color_by)]
-                if color_by in node.features
-                else default_color
-            )
-            for node in tree
+            f: mcolors.to_hex(colormap(i)) for i, f in enumerate(set(values))
         }
+        colors = _get_colors(lambda f: feature_colors[f])
 
         if show_legend:
             legend_handles = [
-                mpatches.Patch(color=feature_colors[f], label=str(f))
+                mpatches.Patch(
+                    color=feature_colors[f],
+                    label=str(f) if labels is None else labels[f],
+                )
                 for f in feature_colors
             ]
-            if any(color_by not in node.features for node in tree):
+            if any(color_by not in node.metadata for node in tree):
                 legend_handles.append(mpatches.Patch(color=default_color, label="NA"))
             if legend_kwargs is None:
                 legend_kwargs = {}
             ax.legend(handles=legend_handles, **legend_kwargs)  # pyright: ignore
 
-        return _draw_colored_tree(tree, ax, colors)
+        return draw_colored_tree(tree, ax, colors)
 
     if coloring == Coloring.CONTINUOUS:
-        vmin = min(features) if vmin is None else vmin
-        vmax = max(features) if vmax is None else vmax
+        vmin = min(values) if vmin is None else vmin
+        vmax = max(values) if vmax is None else vmax
         norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
-        colormap = plt.get_cmap("viridis" if cmap is None else cmap)
-        colors = {
-            node: (
-                colormap(norm(float(node.get(color_by))))
-                if color_by in node.features
-                else default_color
-            )
-            for node in tree
-        }
+        colors = _get_colors(lambda f: colormap(norm(float(f))))
 
         if show_hist:
             default_hist_axes_kwargs = {"width": "25%", "height": "25%"}
@@ -130,19 +135,17 @@ def draw_tree(
             hist_ax = inset_axes(ax, **default_hist_axes_kwargs)  # pyright: ignore
 
             hist_kwargs = {} if hist_kwargs is None else hist_kwargs
-            _, bins, patches = hist_ax.hist(features, **hist_kwargs)  # pyright: ignore
+            _, bins, patches = hist_ax.hist(values, **hist_kwargs)  # pyright: ignore
 
-            for patch, b0, b1 in zip(  # pyright: ignore
-                patches, bins[:-1], bins[1:]  # pyright: ignore
-            ):
+            for patch, b0, b1 in zip(patches, bins[:-1], bins[1:]):  # pyright: ignore
                 midpoint = (b0 + b1) / 2  # pyright: ignore
                 patch.set_facecolor(colormap(norm(midpoint)))  # pyright: ignore
-            return _draw_colored_tree(tree, ax, colors), hist_ax  # pyright: ignore
+            return draw_colored_tree(tree, ax, colors), hist_ax  # pyright: ignore
 
         else:
             sm = plt.cm.ScalarMappable(cmap=colormap, norm=norm)
             ax.get_figure().colorbar(sm, ax=ax)  # pyright: ignore
-            return _draw_colored_tree(tree, ax, colors)
+            return draw_colored_tree(tree, ax, colors)
 
     raise ValueError(
         f"Unknown coloring method: {coloring}. Choices are {list(Coloring)}."

{phylogenie-2.1.26 → phylogenie-3.1.5/src}/phylogenie/generators/alisim.py

@@ -8,8 +8,7 @@ from numpy.random import Generator, default_rng
 from phylogenie.generators.dataset import DatasetGenerator, DataType
 from phylogenie.generators.factories import data, string
 from phylogenie.generators.trees import TreeDatasetGeneratorConfig
-from phylogenie.io import dump_newick
-from phylogenie.utils import get_node_depths
+from phylogenie.treesimulator import dump_newick, get_node_depths
 
 MSAS_DIRNAME = "MSAs"
 TREES_DIRNAME = "trees"
@@ -60,26 +59,26 @@ class AliSimDatasetGenerator(DatasetGenerator):
             tree_filename = f"{filename}.temp-tree"
             msa_filename = filename
 
-        d: dict[str, Any] = {"file_id": Path(msa_filename).stem}
+        md: dict[str, Any] = {"file_id": Path(msa_filename).stem}
         rng = default_rng(seed)
         while True:
-            d.update(data(context, rng))
+            md.update(data(context, rng))
             try:
-                tree, metadata = self.trees.simulate_one(d, seed)
+                tree, metadata = self.trees.simulate_one(md, seed)
                 break
             except TimeoutError:
                 print(
                     "Tree simulation timed out, retrying with different parameters..."
                 )
-        d.update(metadata)
+        md.update(metadata)
 
         times = get_node_depths(tree)
         for leaf in tree.get_leaves():
             leaf.name += f"|{times[leaf]}"
         dump_newick(tree, f"{tree_filename}.nwk")
 
-        self._generate_one_from_tree(msa_filename, f"{tree_filename}.nwk", rng, d)
+        self._generate_one_from_tree(msa_filename, f"{tree_filename}.nwk", rng, md)
         if not self.keep_trees:
             os.remove(f"{tree_filename}.nwk")
 
-        return d
+        return md

{phylogenie-2.1.26 → phylogenie-3.1.5/src}/phylogenie/generators/configs.py

@@ -1,7 +1,29 @@
+from typing import Any
+
+from numpy.random import Generator
+from pydantic import BaseModel, ConfigDict
+
 import phylogenie.typings as pgt
-from phylogenie.models import Distribution, StrictBaseModel
 from phylogenie.treesimulator import EventType
 
+
+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
+
+    def __call__(self, rng: Generator) -> Any:
+        return getattr(rng, self.type)(**self.args)
+
+
 Integer = str | int
 Scalar = str | pgt.Scalar
 ManyScalars = str | pgt.Many[Scalar]

{phylogenie-2.1.26 → phylogenie-3.1.5/src}/phylogenie/generators/dataset.py

@@ -8,7 +8,7 @@ import pandas as pd
 from numpy.random import Generator, default_rng
 from tqdm import tqdm
 
-from phylogenie.models import Distribution, StrictBaseModel
+from phylogenie.generators.configs import Distribution, StrictBaseModel
 
 
 class DataType(str, Enum):

{phylogenie-2.1.26 → phylogenie-3.1.5/src}/phylogenie/generators/factories.py

@@ -1,5 +1,5 @@
 import re
-from typing import Any
+from typing import Any, Callable
 
 import numpy as np
 from numpy.random import Generator
@@ -8,7 +8,6 @@ import phylogenie.generators.configs as cfg
 import phylogenie.generators.typeguards as ctg
 import phylogenie.typeguards as tg
 import phylogenie.typings as pgt
-from phylogenie.models import Distribution
 from phylogenie.skyline import (
     SkylineMatrix,
     SkylineMatrixCoercible,
@@ -17,18 +16,14 @@ from phylogenie.skyline import (
     SkylineVector,
     SkylineVectorCoercible,
 )
-from phylogenie.treesimulator import Mutation
+from phylogenie.treesimulator import EventType, Mutation
 
 
 def _eval_expression(expression: str, data: dict[str, Any]) -> Any:
     return np.array(
         eval(
             expression,
-            {
-                "__builtins__": __builtins__,
-                "np": np,
-                **{k: np.array(v) for k, v in data.items()},
-            },
+            {"np": np, **{k: np.array(v) for k, v in data.items()}},
         )
     ).tolist()
 
@@ -214,33 +209,40 @@ def skyline_matrix(
     return SkylineMatrix(value=value, change_times=change_times)
 
 
-def distribution(x: Distribution, data: dict[str, Any]) -> Distribution:
+def distribution(x: cfg.Distribution, data: dict[str, Any]) -> cfg.Distribution:
     args = x.args
     for arg_name, arg_value in args.items():
         if isinstance(arg_value, str):
             args[arg_name] = _eval_expression(arg_value, data)
-    return Distribution(type=x.type, **args)
+    return cfg.Distribution(type=x.type, **args)
 
 
 def mutations(
-    x: list[cfg.Mutation], data: dict[str, Any], states: set[str]
+    x: list[cfg.Mutation],
+    data: dict[str, Any],
+    states: set[str],
+    rates_to_log: list[EventType] | None,
+    rng: Generator,
 ) -> list[Mutation]:
     mutations: list[Mutation] = []
     for m in x:
         rate = skyline_parameter(m.rate, data)
-        rate_scalers = {k: distribution(v, data) for k, v in m.rate_scalers.items()}
+        rate_scalers: dict[EventType, Callable[[], float]] = {
+            k: lambda: distribution(v, data)(rng) for k, v in m.rate_scalers.items()
+        }
         if m.state is None:
-            mutations.extend(Mutation(s, rate, rate_scalers) for s in states)
+            mutations.extend(
+                Mutation(s, rate, rate_scalers, rates_to_log) for s in states
+            )
         else:
-            mutations.append(Mutation(m.state, rate, rate_scalers))
+            mutations.append(Mutation(m.state, rate, rate_scalers, rates_to_log))
     return mutations
 
 
-def data(context: dict[str, Distribution] | None, rng: Generator) -> dict[str, Any]:
+def data(context: dict[str, cfg.Distribution] | None, rng: Generator) -> dict[str, Any]:
     if context is None:
         return {}
     data: dict[str, Any] = {}
     for k, v in context.items():
-        dist = distribution(v, data)
-        data[k] = np.array(getattr(rng, dist.type)(**dist.args)).tolist()
+        data[k] = np.array(distribution(v, data)(rng)).tolist()
     return data

{phylogenie-2.1.26 → phylogenie-3.1.5/src}/phylogenie/generators/trees.py

@@ -1,13 +1,14 @@
 from abc import abstractmethod
 from enum import Enum
 from pathlib import Path
-from typing import Annotated, Any, Literal
+from typing import Annotated, Any, Callable, Literal
 
 import numpy as np
 from numpy.random import default_rng
 from pydantic import Field
 
 import phylogenie.generators.configs as cfg
+from phylogenie.generators.configs import Distribution
 from phylogenie.generators.dataset import DatasetGenerator, DataType
 from phylogenie.generators.factories import (
     data,
@@ -18,12 +19,12 @@ from phylogenie.generators.factories import (
     skyline_parameter,
     skyline_vector,
 )
-from phylogenie.io import dump_newick
-from phylogenie.models import Distribution
-from phylogenie.tree import Tree
 from phylogenie.treesimulator import (
     Event,
+    EventType,
     Feature,
+    Tree,
+    dump_newick,
     get_BD_events,
     get_BDEI_events,
     get_BDSS_events,
@@ -48,13 +49,14 @@ class ParameterizationType(str, Enum):
 class TreeDatasetGenerator(DatasetGenerator):
     data_type: Literal[DataType.TREES] = DataType.TREES
     mutations: list[cfg.Mutation] = Field(default_factory=lambda: [])
-    min_tips: cfg.Integer = 1
-    max_tips: cfg.Integer | None = None
+    rates_to_log: list[EventType] | None = None
+    n_tips: cfg.Integer | None = None
     max_time: cfg.Scalar = np.inf
     init_state: str | None = None
     sampling_probability_at_present: cfg.Scalar = 0.0
     timeout: float = np.inf
     node_features: list[Feature] | None = None
+    acceptance_criterion: str | None = None
 
     @abstractmethod
     def _get_events(self, data: dict[str, Any]) -> list[Event]: ...
@@ -67,11 +69,21 @@ class TreeDatasetGenerator(DatasetGenerator):
             if self.init_state is None
             else self.init_state.format(**data)
         )
-        states = {e.state for e in self._get_events(data)}
+        events = self._get_events(data)
+        states = {e.state for e in events}
+        events += mutations(
+            self.mutations, data, states, self.rates_to_log, default_rng(seed)
+        )
+        acceptance_criterion: None | Callable[[Tree], bool] = (
+            None
+            if self.acceptance_criterion is None
+            else lambda tree: eval(
+                self.acceptance_criterion, {}, {"tree": tree}  # pyright: ignore
+            )
+        )
         return simulate_tree(
-            events=self._get_events(data) + mutations(self.mutations, data, states),
-            min_tips=integer(self.min_tips, data),
-            max_tips=None if self.max_tips is None else integer(self.max_tips, data),
+            events=events,
+            n_tips=None if self.n_tips is None else integer(self.n_tips, data),
             max_time=scalar(self.max_time, data),
             init_state=init_state,
             sampling_probability_at_present=scalar(
@@ -79,6 +91,7 @@ class TreeDatasetGenerator(DatasetGenerator):
             ),
             seed=seed,
             timeout=self.timeout,
+            acceptance_criterion=acceptance_criterion,
         )
 
     def generate_one(
@@ -153,7 +166,7 @@ class FBDTreeDatasetGenerator(TreeDatasetGenerator):
 class ContactTracingTreeDatasetGenerator(TreeDatasetGenerator):
     max_notified_contacts: cfg.Integer = 1
     notification_probability: cfg.SkylineParameter = 0.0
-    sampling_rate_after_notification: cfg.SkylineParameter = np.inf
+    sampling_rate_after_notification: cfg.SkylineParameter = 2**32
     samplable_states_after_notification: list[str] | None = None
 
     @abstractmethod

phylogenie-3.1.5/src/phylogenie/io/__init__.py

@@ -0,0 +1,3 @@
+from phylogenie.io.fasta import load_fasta
+
+__all__ = ["load_fasta"]