phylogenie 1.0.1__tar.gz → 1.0.3__tar.gz

{phylogenie-1.0.1 → phylogenie-1.0.3}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: phylogenie
-Version: 1.0.1
+Version: 1.0.3
 Summary: Generate phylogenetic datasets with minimal setup effort
-Author: gabriele-marino
+Author: Gabriele Marino
 Author-email: gabmarino.8601@gmail.com
 Requires-Python: >=3.10,<4.0
 Classifier: Programming Language :: Python :: 3

{phylogenie-1.0.1 → phylogenie-1.0.3}/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-1.0.1 → phylogenie-1.0.3}/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-1.0.1 → phylogenie-1.0.3}/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-1.0.3/phylogenie/core/configs.py

@@ -0,0 +1,40 @@
+import phylogenie.typings as pgt
+from phylogenie.configs import StrictBaseModel
+
+IntConfig = str | int
+ScalarConfig = str | pgt.Scalar
+ManyIntsConfig = str | list[IntConfig]
+ManyScalarsConfig = str | list[ScalarConfig]
+OneOrManyScalarsConfig = ScalarConfig | list[ScalarConfig]
+OneOrMany2DScalarsConfig = ScalarConfig | list[list[ScalarConfig]]
+
+
+class SkylineParameterValueModel(StrictBaseModel):
+    value: ManyScalarsConfig
+    change_times: ManyScalarsConfig
+
+
+SkylineParameterLikeConfig = ScalarConfig | SkylineParameterValueModel
+
+
+class SkylineVectorValueModel(StrictBaseModel):
+    value: str | list[OneOrManyScalarsConfig]
+    change_times: ManyScalarsConfig
+
+
+SkylineVectorCoercibleConfig = (
+    str | pgt.Scalar | list[SkylineParameterLikeConfig] | SkylineVectorValueModel
+)
+SkylineVectorLikeConfig = (
+    str | list[SkylineParameterLikeConfig] | SkylineVectorValueModel
+)
+
+
+class SkylineMatrixValueModel(StrictBaseModel):
+    value: str | list[OneOrMany2DScalarsConfig]
+    change_times: ManyScalarsConfig
+
+
+SkylineMatrixCoercibleConfig = (
+    str | pgt.Scalar | list[SkylineVectorLikeConfig] | SkylineMatrixValueModel
+)

{phylogenie-1.0.1 → phylogenie-1.0.3}/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-1.0.1 → phylogenie-1.0.3}/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-1.0.3/phylogenie/core/factories.py

@@ -0,0 +1,251 @@
+from typing import Any, Literal, overload
+
+import numpy as np
+
+import phylogenie.core.configs as cfg
+import phylogenie.core.typeguards as ctg
+import phylogenie.typeguards as tg
+import phylogenie.typings as pgt
+from phylogenie.skyline import (
+    SkylineMatrix,
+    SkylineMatrixCoercible,
+    SkylineParameter,
+    SkylineParameterLike,
+    SkylineVector,
+    SkylineVectorCoercible,
+    SkylineVectorLike,
+)
+
+
+def _eval_expression(expression: str, data: pgt.Data) -> Any:
+    return np.array(
+        eval(
+            expression,
+            {
+                "__builtins__": __builtins__,
+                "np": np,
+                **{k: np.array(v) for k, v in data.items()},
+            },
+        )
+    ).tolist()
+
+
+def int_factory(x: cfg.IntConfig, data: pgt.Data) -> int:
+    if isinstance(x, str):
+        e = _eval_expression(x, data)
+        if isinstance(e, int):
+            return e
+        raise ValueError(
+            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected an int."
+        )
+    return x
+
+
+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):
+            return e
+        raise ValueError(
+            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a scalar."
+        )
+    return x
+
+
+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_many_ints(e):
+            return e
+        raise ValueError(
+            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a sequence of integers."
+        )
+    return [int_factory(v, data) for v in x]
+
+
+def many_scalars_factory(x: cfg.ManyScalarsConfig, data: pgt.Data) -> pgt.ManyScalars:
+    if isinstance(x, str):
+        e = _eval_expression(x, data)
+        if tg.is_many_scalars(e):
+            return e
+        raise ValueError(
+            f"Expression '{x}' evaluated to {e} of type {type(e)}, expected a sequence of scalars."
+        )
+    return [scalar_factory(v, data) for v in x]
+
+
+def one_or_many_scalars_factory(
+    x: cfg.OneOrManyScalarsConfig, data: pgt.Data
+) -> pgt.OneOrManyScalars:
+    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 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),
+    )
+
+
+@overload
+def _parse_skyline_vector_value_model(
+    x: cfg.SkylineVectorValueModel, data: pgt.Data, coercible: Literal[True]
+) -> SkylineVectorCoercible: ...
+@overload
+def _parse_skyline_vector_value_model(
+    x: cfg.SkylineVectorValueModel, data: pgt.Data, coercible: Literal[False]
+) -> SkylineVectorLike: ...
+def _parse_skyline_vector_value_model(
+    x: cfg.SkylineVectorValueModel, data: pgt.Data, coercible: bool
+) -> SkylineVectorCoercible:
+    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_scalars(e):
+            value = e
+        else:
+            raise ValueError(
+                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 = [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 config {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 (config {x.value} yielded 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=change_times,
+    )
+
+
+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 SkylineVectorCoercible object (e.g., a scalar or a sequence of them)."
+        )
+    if isinstance(x, pgt.Scalar):
+        return 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)
+    return _parse_skyline_vector_value_model(x, data, coercible=True)
+
+
+def skyline_vector_like_factory(
+    x: cfg.SkylineVectorLikeConfig, data: pgt.Data
+) -> SkylineVectorLike:
+    if isinstance(x, str):
+        e = _eval_expression(x, data)
+        if tg.is_many_scalars(e):
+            return e
+        raise ValueError(
+            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
+    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):
+            value = e
+        else:
+            raise ValueError(
+                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 = [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 (config {x.value} yeilded a 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 (config {x.value} yielded 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=change_times,
+    )

{phylogenie-1.0.1 → phylogenie-1.0.3}/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-1.0.1 → phylogenie-1.0.3}/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-1.0.1 → phylogenie-1.0.3}/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-1.0.3/phylogenie/core/trees/remaster/factories.py

@@ -0,0 +1,26 @@
+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 (
+    many_ints_factory,
+    many_scalars_factory,
+    skyline_parameter_like_factory,
+)
+
+
+def reaction_factory(x: cfg.ReactionConfig, data: pgt.Data) -> Reaction:
+    return Reaction(
+        rate=skyline_parameter_like_factory(x.rate, data),
+        value=x.value,
+    )
+
+
+def punctual_reaction_factory(
+    x: cfg.PunctualReactionConfig, data: pgt.Data
+) -> PunctualReaction:
+    return PunctualReaction(
+        times=many_scalars_factory(x.times, data),
+        value=x.value,
+        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),
+    )