phylogenie 1.0.1__py3-none-any.whl → 1.0.2__py3-none-any.whl

phylogenie/backend/remaster/generate.py

@@ -11,7 +11,6 @@ from phylogenie.backend.remaster.reactions import (
     Reaction,
 )
 from phylogenie.skyline import skyline_parameter
-from phylogenie.utils import vectorify1D
 
 TREE_ID = "Tree"
 
@@ -75,12 +74,12 @@ def _generate_config_file(
             attrs = {
                 "spec": "PunctualReaction",
                 "value": punctual_reaction.value,
-                "times": " ".join(map(str, vectorify1D(punctual_reaction.times))),
+                "times": " ".join(map(str, punctual_reaction.times)),
             }
             if punctual_reaction.p is not None:
-                attrs["p"] = " ".join(map(str, vectorify1D(punctual_reaction.p)))
+                attrs["p"] = " ".join(map(str, punctual_reaction.p))
             if punctual_reaction.n is not None:
-                attrs["n"] = " ".join(map(str, vectorify1D(punctual_reaction.n)))
+                attrs["n"] = " ".join(map(str, punctual_reaction.n))
             trajectory.append(Element("reaction", attrs))
 
     simulate.append(trajectory)

phylogenie/backend/remaster/reactions.py

@@ -2,9 +2,9 @@ from dataclasses import dataclass
 
 import phylogenie.typings as pgt
 from phylogenie.skyline import (
-    SkylineMatrixLike,
+    SkylineMatrixCoercible,
     SkylineParameterLike,
-    SkylineVectorLike,
+    SkylineVectorCoercible,
     skyline_matrix,
     skyline_vector,
 )
@@ -21,21 +21,21 @@ class Reaction:
 
 @dataclass
 class PunctualReaction:
-    times: pgt.OneOrManyScalars
+    times: pgt.ManyScalars
     value: str
-    p: pgt.OneOrManyScalars | None = None
-    n: pgt.OneOrMany[int] | None = None
+    p: pgt.ManyScalars | None = None
+    n: pgt.Many[int] | None = None
 
 
 def get_canonical_reactions(
     populations: str | list[str] = DEFAULT_POPULATION,
     sample_population: str = SAMPLE_POPULATION,
-    birth_rates: SkylineVectorLike = 0,
-    death_rates: SkylineVectorLike = 0,
-    sampling_rates: SkylineVectorLike = 0,
-    removal_probabilities: SkylineVectorLike = 0,
-    migration_rates: SkylineMatrixLike = 0,
-    birth_rates_among_demes: SkylineMatrixLike = 0,
+    birth_rates: SkylineVectorCoercible = 0,
+    death_rates: SkylineVectorCoercible = 0,
+    sampling_rates: SkylineVectorCoercible = 0,
+    removal_probabilities: SkylineVectorCoercible = 0,
+    migration_rates: SkylineMatrixCoercible = 0,
+    birth_rates_among_demes: SkylineMatrixCoercible = 0,
 ) -> list[Reaction]:
     if isinstance(populations, str):
         populations = [populations]
@@ -84,12 +84,12 @@ def get_canonical_reactions(
 def get_epidemiological_reactions(
     populations: str | list[str] = DEFAULT_POPULATION,
     sample_population: str = SAMPLE_POPULATION,
-    reproduction_numbers: SkylineVectorLike = 0,
-    become_uninfectious_rates: SkylineVectorLike = 0,
-    sampling_proportions: SkylineVectorLike = 0,
-    removal_probabilities: SkylineVectorLike = 0,
-    migration_rates: SkylineMatrixLike = 0,
-    reproduction_numbers_among_demes: SkylineMatrixLike = 0,
+    reproduction_numbers: SkylineVectorCoercible = 0,
+    become_uninfectious_rates: SkylineVectorCoercible = 0,
+    sampling_proportions: SkylineVectorCoercible = 0,
+    removal_probabilities: SkylineVectorCoercible = 0,
+    migration_rates: SkylineMatrixCoercible = 0,
+    reproduction_numbers_among_demes: SkylineMatrixCoercible = 0,
 ) -> list[Reaction]:
     if isinstance(populations, str):
         populations = [populations]
@@ -125,12 +125,12 @@ def get_epidemiological_reactions(
 def get_FBD_reactions(
     populations: str | list[str] = DEFAULT_POPULATION,
     sample_population: str = SAMPLE_POPULATION,
-    diversification: SkylineVectorLike = 0,
-    turnover: SkylineVectorLike = 0,
-    sampling_proportions: SkylineVectorLike = 0,
-    removal_probabilities: SkylineVectorLike = 0,
-    migration_rates: SkylineMatrixLike = 0,
-    diversification_between_types: SkylineMatrixLike = 0,
+    diversification: SkylineVectorCoercible = 0,
+    turnover: SkylineVectorCoercible = 0,
+    sampling_proportions: SkylineVectorCoercible = 0,
+    removal_probabilities: SkylineVectorCoercible = 0,
+    migration_rates: SkylineMatrixCoercible = 0,
+    diversification_between_types: SkylineMatrixCoercible = 0,
 ):
     if isinstance(populations, str):
         populations = [populations]

phylogenie/backend/treesimulator.py

@@ -6,9 +6,9 @@ from treesimulator.generator import generate
 from treesimulator.mtbd_models import CTModel, Model
 
 from phylogenie.skyline import (
-    SkylineMatrixLike,
+    SkylineMatrixCoercible,
     SkylineParameterLike,
-    SkylineVectorLike,
+    SkylineVectorCoercible,
     skyline_matrix,
     skyline_parameter,
     skyline_vector,
@@ -22,10 +22,10 @@ EXPOSED_POPULATION = "E"
 @dataclass
 class TreeParams:
     populations: str | list[str] = DEFAULT_POPULATION
-    transition_rates: SkylineMatrixLike = 0
-    transmission_rates: SkylineMatrixLike = 0
-    removal_rates: SkylineVectorLike = 0
-    sampling_proportions: SkylineVectorLike = 0
+    transition_rates: SkylineMatrixCoercible = 0
+    transmission_rates: SkylineMatrixCoercible = 0
+    removal_rates: SkylineVectorCoercible = 0
+    sampling_proportions: SkylineVectorCoercible = 0
 
 
 def generate_tree(

phylogenie/core/configs.py

@@ -3,33 +3,38 @@ from phylogenie.configs import StrictBaseModel
 
 IntConfig = str | int
 ScalarConfig = str | pgt.Scalar
-OneOrManyIntsConfig = str | int | pgt.Many[IntConfig]
-OneOrManyScalarsConfig = str | pgt.Scalar | pgt.Many[ScalarConfig]
+ManyIntsConfig = str | list[IntConfig]
+ManyScalarsConfig = str | list[ScalarConfig]
+OneOrManyScalarsConfig = ScalarConfig | list[ScalarConfig]
+OneOrMany2DScalarsConfig = ScalarConfig | list[list[ScalarConfig]]
 
 
 class SkylineParameterValueModel(StrictBaseModel):
-    value: str | pgt.Many[ScalarConfig]
-    change_times: OneOrManyScalarsConfig
+    value: ManyScalarsConfig
+    change_times: ManyScalarsConfig
 
 
-SkylineParameterLikeConfig = str | pgt.Scalar | SkylineParameterValueModel
+SkylineParameterLikeConfig = ScalarConfig | SkylineParameterValueModel
 
 
 class SkylineVectorValueModel(StrictBaseModel):
-    value: str | pgt.Many[OneOrManyScalarsConfig]
-    change_times: OneOrManyScalarsConfig
+    value: str | list[OneOrManyScalarsConfig]
+    change_times: ManyScalarsConfig
 
 
+SkylineVectorCoercibleConfig = (
+    str | pgt.Scalar | list[SkylineParameterLikeConfig] | SkylineVectorValueModel
+)
 SkylineVectorLikeConfig = (
-    str | pgt.Scalar | pgt.Many[SkylineParameterLikeConfig] | SkylineVectorValueModel
+    str | list[SkylineParameterLikeConfig] | SkylineVectorValueModel
 )
 
 
 class SkylineMatrixValueModel(StrictBaseModel):
-    value: str | pgt.Many[pgt.OneOrMany2D[ScalarConfig]]
-    change_times: OneOrManyScalarsConfig
+    value: str | list[OneOrMany2DScalarsConfig]
+    change_times: ManyScalarsConfig
 
 
-SkylineMatrixLikeConfig = (
-    str | pgt.Scalar | pgt.Many[SkylineVectorLikeConfig] | SkylineMatrixValueModel
+SkylineMatrixCoercibleConfig = (
+    str | pgt.Scalar | list[SkylineVectorLikeConfig] | SkylineMatrixValueModel
 )

phylogenie/core/context/factories.py

@@ -3,18 +3,15 @@ from numpy.random import Generator
 import phylogenie.core.context.configs as cfg
 import phylogenie.typings as pgt
 from phylogenie.core.context import distributions
-from phylogenie.core.typings import Data
 
 
-def _sample_vector1D(
-    x: distributions.Scalar, N: int, rng: Generator
-) -> list[pgt.Scalar]:
+def _sample_vector1D(x: distributions.Scalar, N: int, rng: Generator) -> pgt.Vector1D:
     return [x.sample(rng) for _ in range(N)]
 
 
 def _sample_vector2D(
     x: distributions.Scalar, N: int, zero_diagonal: bool, rng: Generator
-) -> list[list[pgt.Scalar]]:
+) -> pgt.Vector2D:
     v = [_sample_vector1D(x, N, rng) for _ in range(N)]
     if zero_diagonal:
         for i in range(N):
@@ -24,12 +21,12 @@ def _sample_vector2D(
 
 def _sample_vector3D(
     x: distributions.Scalar, N: int, T: int, zero_diagonal: bool, rng: Generator
-) -> list[list[list[pgt.Scalar]]]:
+) -> pgt.Vector3D:
     return [_sample_vector2D(x, N, zero_diagonal, rng) for _ in range(T)]
 
 
-def context_factory(x: cfg.ContextConfig, rng: Generator) -> Data:
-    data: Data = {}
+def context_factory(x: cfg.ContextConfig, rng: Generator) -> pgt.Data:
+    data: pgt.Data = {}
     for key, value in x.items():
         if isinstance(value, distributions.Distribution):
             data[key] = value.sample(rng)

phylogenie/core/dataset.py

@@ -7,9 +7,9 @@ import pandas as pd
 from numpy.random import Generator, default_rng
 from tqdm import tqdm
 
+import phylogenie.typings as pgt
 from phylogenie.configs import StrictBaseModel
 from phylogenie.core.context import ContextConfig, context_factory
-from phylogenie.core.typings import Data
 
 
 class DataType(str, Enum):
@@ -27,10 +27,10 @@ class DatasetGenerator(ABC, StrictBaseModel):
     context: ContextConfig | None = None
 
     @abstractmethod
-    def _generate_one(self, filename: str, rng: Generator, data: Data) -> None: ...
+    def _generate_one(self, filename: str, rng: Generator, data: pgt.Data) -> None: ...
 
     def generate_one(
-        self, filename: str, data: Data | None = None, seed: int | None = None
+        self, filename: str, data: pgt.Data | None = None, seed: int | None = None
     ) -> None:
         data = {} if data is None else data
         self._generate_one(filename=filename, rng=default_rng(seed), data=data)

phylogenie/core/factories.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, overload
 
 import numpy as np
 
@@ -6,28 +6,32 @@ import phylogenie.core.configs as cfg
 import phylogenie.core.typeguards as ctg
 import phylogenie.typeguards as tg
 import phylogenie.typings as pgt
-from phylogenie.core.typings import Data
 from phylogenie.skyline import (
     SkylineMatrix,
-    SkylineMatrixLike,
+    SkylineMatrixCoercible,
     SkylineParameter,
     SkylineParameterLike,
     SkylineVector,
+    SkylineVectorCoercible,
     SkylineVectorLike,
 )
 
 
-def _eval_expression(expression: str, data: Data) -> Any:
+def _eval_expression(expression: str, data: pgt.Data) -> Any:
     return np.array(
         eval(
             expression,
-            {"__builtins__": __builtins__},
+            {
+                "__builtins__": __builtins__,
+                # "np": np,
+                # **{k: np.array(v) for k, v in data.items()},
+            },
             {k: np.array(v) for k, v in data.items()},
         )
     ).tolist()
 
 
-def int_factory(x: cfg.IntConfig, data: Data) -> int:
+def int_factory(x: cfg.IntConfig, data: pgt.Data) -> int:
     if isinstance(x, str):
         e = _eval_expression(x, data)
         if isinstance(e, int):
@@ -38,7 +42,7 @@ def int_factory(x: cfg.IntConfig, data: Data) -> int:
     return x
 
 
-def scalar_factory(x: cfg.ScalarConfig, data: Data) -> pgt.Scalar:
+def scalar_factory(x: cfg.ScalarConfig, data: pgt.Data) -> pgt.Scalar:
     if isinstance(x, str):
         e = _eval_expression(x, data)
         if isinstance(e, pgt.Scalar):
@@ -49,130 +53,203 @@ def scalar_factory(x: cfg.ScalarConfig, data: Data) -> pgt.Scalar:
     return x
 
 
-def one_or_many_scalars_factory(
-    x: cfg.OneOrManyScalarsConfig, data: Data
-) -> pgt.OneOrMany[pgt.Scalar]:
+def many_ints_factory(x: cfg.ManyIntsConfig, data: pgt.Data) -> pgt.Many[int]:
     if isinstance(x, str):
         e = _eval_expression(x, data)
-        if tg.is_one_or_many_scalars(e):
+        if tg.is_many_ints(e):
             return e
         raise ValueError(
-            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a scalar or a sequence of them."
+            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a sequence of integers."
         )
-    if isinstance(x, pgt.Scalar):
-        return x
-    return [scalar_factory(v, data) for v in x]
+    return [int_factory(v, data) for v in x]
 
 
-def one_or_many_ints_factory(
-    x: cfg.OneOrManyIntsConfig, data: Data
-) -> pgt.OneOrMany[int]:
+def many_scalars_factory(x: cfg.ManyScalarsConfig, data: pgt.Data) -> pgt.ManyScalars:
     if isinstance(x, str):
         e = _eval_expression(x, data)
-        if tg.is_one_or_many_ints(e):
+        if tg.is_many_scalars(e):
             return e
         raise ValueError(
-            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected an int or a sequence of them."
+            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a sequence of scalars."
         )
-    if isinstance(x, int):
-        return x
-    return [int_factory(v, data) for v in x]
+    return [scalar_factory(v, data) for v in x]
 
 
-def skyline_parameter_like_factory(
-    x: cfg.SkylineParameterLikeConfig, data: Data
-) -> SkylineParameterLike:
+def one_or_many_scalars_factory(
+    x: cfg.OneOrManyScalarsConfig, data: pgt.Data
+) -> pgt.OneOrManyScalars:
     if isinstance(x, str):
         e = _eval_expression(x, data)
-        if isinstance(e, pgt.Scalar):
+        if tg.is_one_or_many_scalars(e):
             return e
         raise ValueError(
-            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a SkylineParameterLike (e.g., a scalar)."
+            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a scalar or a sequence of them."
         )
     if isinstance(x, pgt.Scalar):
         return x
+    return many_scalars_factory(x, data)
+
+
+def skyline_parameter_like_factory(
+    x: cfg.SkylineParameterLikeConfig, data: pgt.Data
+) -> SkylineParameterLike:
+    if isinstance(x, cfg.ScalarConfig):
+        return scalar_factory(x, data)
+    return SkylineParameter(
+        value=many_scalars_factory(x.value, data),
+        change_times=many_scalars_factory(x.change_times, data),
+    )
+
+
+from typing import Literal
 
+
+@overload
+def _parse_skyline_vector_value_model(
+    x: cfg.SkylineVectorValueModel, data: pgt.Data, coercible: Literal[True]
+) -> SkylineVector | SkylineParameter: ...
+@overload
+def _parse_skyline_vector_value_model(
+    x: cfg.SkylineVectorValueModel, data: pgt.Data, coercible: Literal[False]
+) -> SkylineVector: ...
+def _parse_skyline_vector_value_model(
+    x: cfg.SkylineVectorValueModel, data: pgt.Data, coercible: bool
+) -> SkylineVector | SkylineParameter:
+    change_times = many_scalars_factory(x.change_times, data)
     if isinstance(x.value, str):
         e = _eval_expression(x.value, data)
-        if tg.is_many_scalars(e):
+        if tg.is_many_one_or_many_scalars(e):
             value = e
         else:
             raise ValueError(
-                f"Expression '{x.value}' evaluated to {e} of type {type(e)}, which is not a valid value for a SkylineParameter (expected a sequence of scalars)."
+                f"Expression '{x.value}' evaluated to {e} of type {type(e)}, which cannot be coerced to a valid value for a SkylineVector (expected a sequence composed of scalars and/or sequences of scalars)."
             )
     else:
-        value = [scalar_factory(v, data) for v in x.value]
-    return SkylineParameter(
+        value = [one_or_many_scalars_factory(v, data) for v in x.value]
+
+    if tg.is_many_scalars(value):
+        if coercible:
+            return SkylineParameter(value=value, change_times=change_times)
+        else:
+            raise ValueError(
+                f"Parsing SkylineVector value {x.value} yielded a sequence of scalars ({value}) when a nested (2D) sequence of scalars was expected."
+            )
+
+    Ns = {len(elem) for elem in value if tg.is_many(elem)}
+    if len(Ns) > 1:
+        raise ValueError(
+            f"All elements in the value of a SkylineVector config must be scalars or have the same length (got value={value} with inconsistent lengths {Ns})."
+        )
+    (N,) = Ns
+    value = [[p] * N if isinstance(p, pgt.Scalar) else p for p in value]
+
+    return SkylineVector(
         value=value,
-        change_times=one_or_many_scalars_factory(x.change_times, data),
+        change_times=change_times,
     )
 
 
-def skyline_vector_like_factory(
-    x: cfg.SkylineVectorLikeConfig, data: Data
-) -> SkylineVectorLike:
+def skyline_vector_coercible_factory(
+    x: cfg.SkylineVectorCoercibleConfig, data: pgt.Data
+) -> SkylineVectorCoercible:
     if isinstance(x, str):
         e = _eval_expression(x, data)
         if tg.is_one_or_many_scalars(e):
             return e
         raise ValueError(
-            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a SkylineVectorLike object (e.g., a scalar or a sequence of them)."
+            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a SkylineVectorCoercible object (e.g., a scalar or a sequence of them)."
         )
     if isinstance(x, pgt.Scalar):
         return x
-    if ctg.is_many_skyline_parameter_like_configs(x):
+    if ctg.is_list_of_skyline_parameter_like_configs(x):
         return [skyline_parameter_like_factory(p, data) for p in x]
 
     assert isinstance(x, cfg.SkylineVectorValueModel)
-    if isinstance(x.value, str):
-        e = _eval_expression(x.value, data)
-        if tg.is_many_one_or_many_scalars(e):
-            value = e
-        else:
-            raise ValueError(
-                f"Expression '{x.value}' evaluated to {e} of type {type(e)}, which is not a valid value for a SkylineVector (expected a sequence containing scalars and/or sequences of them)."
-            )
-    else:
-        value = [one_or_many_scalars_factory(x, data) for x in x.value]
-    return SkylineVector(
-        value=value,
-        change_times=one_or_many_scalars_factory(x.change_times, data),
-    )
+    return _parse_skyline_vector_value_model(x, data, coercible=True)
 
 
-def skyline_matrix_like_factory(
-    x: cfg.SkylineMatrixLikeConfig, data: Data
-) -> SkylineMatrixLike:
+def skyline_vector_like_factory(
+    x: cfg.SkylineVectorLikeConfig, data: pgt.Data
+) -> SkylineVectorLike:
     if isinstance(x, str):
         e = _eval_expression(x, data)
-        if tg.is_one_or_many_scalars(e) or tg.is_many_one_or_many_scalars(e):
+        if tg.is_many_scalars(e):
             return e
         raise ValueError(
-            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a SkylineMatrixLike object (e.g., a scalar, a sequence of them, or a sequence containing scalars and/or sequences of them)."
+            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a SkylineVectorLike object (e.g., a sequence of scalars)."
+        )
+    if ctg.is_list_of_skyline_parameter_like_configs(x):
+        return [skyline_parameter_like_factory(p, data) for p in x]
+
+    assert isinstance(x, cfg.SkylineVectorValueModel)
+    return _parse_skyline_vector_value_model(x, data, coercible=False)
+
+
+def one_or_many_2D_scalars_factory(
+    x: cfg.OneOrMany2DScalarsConfig, data: pgt.Data
+) -> pgt.OneOrMany2DScalars:
+    if isinstance(x, str):
+        e = _eval_expression(x, data)
+        if tg.is_one_or_many_2D_scalars(e):
+            return e
+        raise ValueError(
+            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a nested (2D) sequence of scalars."
         )
     if isinstance(x, pgt.Scalar):
         return x
-    if ctg.is_many_skyline_vector_like_configs(x):
+    return [many_scalars_factory(v, data) for v in x]
+
+
+def skyline_matrix_coercible_factory(
+    x: cfg.SkylineMatrixCoercibleConfig, data: pgt.Data
+) -> SkylineMatrixCoercible:
+    if isinstance(x, str):
+        e = _eval_expression(x, data)
+        if tg.is_one_or_many_2D_scalars(e):
+            return e
+        raise ValueError(
+            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a SkylineMatrixCoercible object (e.g., a scalar or a nested (2D) sequence of them)."
+        )
+    if isinstance(x, pgt.Scalar):
+        return x
+    if ctg.is_list_of_skyline_vector_like_configs(x):
         return [skyline_vector_like_factory(v, data) for v in x]
 
     assert isinstance(x, cfg.SkylineMatrixValueModel)
+
+    change_times = many_scalars_factory(x.change_times, data)
     if isinstance(x.value, str):
         e = _eval_expression(x.value, data)
-        if tg.is_many_one_or_many_2d_scalars(e):
+        if tg.is_many_one_or_many_2D_scalars(e):
             value = e
         else:
             raise ValueError(
-                f"Expression '{x.value}' evaluated to {e} of type {type(e)}, which is not a valid value for a SkylineMatrix (expected a sequence containing scalars and/or nested (2D) sequences of them)."
+                f"Expression '{x.value}' evaluated to {e} of type {type(e)}, which cannot be coerced to a valid value for a SkylineMatrix (expected a sequence composed of scalars and/or nested (2D) sequences of scalars)."
             )
     else:
-        value = [
-            (
-                scalar_factory(v, data)
-                if isinstance(v, cfg.ScalarConfig)
-                else [[scalar_factory(row, data) for row in m] for m in v]
-            )
-            for v in x.value
-        ]
+        value = [one_or_many_2D_scalars_factory(v, data) for v in x.value]
+
+    if tg.is_many_scalars(value):
+        return SkylineParameter(value=value, change_times=change_times)
+
+    Ns: set[int] = set()
+    for elem in value:
+        if tg.is_many_2D_scalars(elem):
+            n_rows = len(elem)
+            if any(len(row) != n_rows for row in elem):
+                raise ValueError(
+                    f"All elements in the value of a SkylineMatrix config must be scalars or square matrices (got non-square matrix: {elem})."
+                )
+            Ns.add(n_rows)
+
+    if len(Ns) > 1:
+        raise ValueError(
+            f"All elements in the value of a SkylineMatrix config must be scalars or have the same square shape (got value={value} with inconsistent lengths {Ns})."
+        )
+    (N,) = Ns
+    value = [[[p] * N] * N if isinstance(p, pgt.Scalar) else p for p in value]
+
     return SkylineMatrix(
-        value=value, change_times=one_or_many_scalars_factory(x.change_times, data)
+        value=value,
+        change_times=change_times,
     )

phylogenie/core/msas/alisim.py

@@ -3,8 +3,8 @@ from typing import Literal
 
 from numpy.random import Generator
 
+import phylogenie.typings as pgt
 from phylogenie.core.msas.base import BackendType, MSAsGenerator
-from phylogenie.core.typings import Data
 
 
 class AliSimGenerator(MSAsGenerator):
@@ -13,7 +13,7 @@ class AliSimGenerator(MSAsGenerator):
     args: dict[str, str | int | float]
 
     def _generate_one_from_tree(
-        self, filename: str, tree_file: str, rng: Generator, data: Data
+        self, filename: str, tree_file: str, rng: Generator, data: pgt.Data
     ) -> None:
         command = [
             self.iqtree_path,

phylogenie/core/msas/base.py

@@ -6,9 +6,9 @@ from typing import Literal
 
 from numpy.random import Generator
 
+import phylogenie.typings as pgt
 from phylogenie.core.dataset import DatasetGenerator, DataType
 from phylogenie.core.trees import TreesGeneratorConfig
-from phylogenie.core.typings import Data
 
 
 class BackendType(str, Enum):
@@ -22,10 +22,10 @@ class MSAsGenerator(DatasetGenerator):
 
     @abstractmethod
     def _generate_one_from_tree(
-        self, filename: str, tree_file: str, rng: Generator, data: Data
+        self, filename: str, tree_file: str, rng: Generator, data: pgt.Data
     ) -> None: ...
 
-    def _generate_one(self, filename: str, rng: Generator, data: Data) -> None:
+    def _generate_one(self, filename: str, rng: Generator, data: pgt.Data) -> None:
         if isinstance(self.trees, str):
             tree_files = os.listdir(self.trees)
             tree_file = os.path.join(self.trees, str(rng.choice(tree_files)))

phylogenie/core/trees/remaster/configs.py

@@ -8,7 +8,7 @@ class ReactionConfig(StrictBaseModel):
 
 
 class PunctualReactionConfig(StrictBaseModel):
-    times: cfg.OneOrManyScalarsConfig
+    times: cfg.ManyScalarsConfig
     value: str
-    p: cfg.OneOrManyScalarsConfig | None = None
-    n: cfg.OneOrManyIntsConfig | None = None
+    p: cfg.ManyScalarsConfig | None = None
+    n: cfg.ManyIntsConfig | None = None

phylogenie/core/trees/remaster/factories.py

@@ -1,17 +1,14 @@
 import phylogenie.core.trees.remaster.configs as cfg
+import phylogenie.typings as pgt
 from phylogenie.backend.remaster import PunctualReaction, Reaction
 from phylogenie.core.factories import (
-    one_or_many_ints_factory,
-    one_or_many_scalars_factory,
+    many_ints_factory,
+    many_scalars_factory,
     skyline_parameter_like_factory,
 )
-from phylogenie.core.typings import Data
 
 
-def reaction_factory(
-    x: cfg.ReactionConfig,
-    data: Data,
-) -> Reaction:
+def reaction_factory(x: cfg.ReactionConfig, data: pgt.Data) -> Reaction:
     return Reaction(
         rate=skyline_parameter_like_factory(x.rate, data),
         value=x.value,
@@ -19,12 +16,11 @@ def reaction_factory(
 
 
 def punctual_reaction_factory(
-    x: cfg.PunctualReactionConfig,
-    data: Data,
+    x: cfg.PunctualReactionConfig, data: pgt.Data
 ) -> PunctualReaction:
     return PunctualReaction(
-        times=one_or_many_scalars_factory(x.times, data),
+        times=many_scalars_factory(x.times, data),
         value=x.value,
-        p=None if x.p is None else one_or_many_scalars_factory(x.p, data),
-        n=None if x.n is None else one_or_many_ints_factory(x.n, data),
+        p=None if x.p is None else many_scalars_factory(x.p, data),
+        n=None if x.n is None else many_ints_factory(x.n, data),
     )