phylogenie 1.0.3__tar.gz → 1.0.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: phylogenie
-Version: 1.0.3
+Version: 1.0.5
 Summary: Generate phylogenetic datasets with minimal setup effort
 Author: Gabriele Marino
 Author-email: gabmarino.8601@gmail.com

{phylogenie-1.0.3 → phylogenie-1.0.5}/phylogenie/core/configs.py

@@ -25,9 +25,6 @@ class SkylineVectorValueModel(StrictBaseModel):
 SkylineVectorCoercibleConfig = (
     str | pgt.Scalar | list[SkylineParameterLikeConfig] | SkylineVectorValueModel
 )
-SkylineVectorLikeConfig = (
-    str | list[SkylineParameterLikeConfig] | SkylineVectorValueModel
-)
 
 
 class SkylineMatrixValueModel(StrictBaseModel):
@@ -36,5 +33,5 @@ class SkylineMatrixValueModel(StrictBaseModel):
 
 
 SkylineMatrixCoercibleConfig = (
-    str | pgt.Scalar | list[SkylineVectorLikeConfig] | SkylineMatrixValueModel
+    str | pgt.Scalar | list[SkylineVectorCoercibleConfig] | SkylineMatrixValueModel
 )

{phylogenie-1.0.3 → phylogenie-1.0.5}/phylogenie/core/context/configs.py

@@ -1,7 +1,3 @@
-from typing import Annotated, Literal
-
-from pydantic import Field
-
 from phylogenie.configs import StrictBaseModel
 from phylogenie.core.context.distributions import (
     DistributionConfig,
@@ -11,28 +7,22 @@ from phylogenie.core.context.distributions import (
 
 class VectorModel(StrictBaseModel):
     x: ScalarDistributionConfig
-    N: int
 
 
 class Vector1DModel(VectorModel):
-    n_dim: Literal[1] = 1
+    size: int
 
 
 class Vector2DModel(VectorModel):
-    n_dim: Literal[2] = 2
+    size: tuple[int, int]
     zero_diagonal: bool = False
 
 
 class Vector3DModel(VectorModel):
-    n_dim: Literal[3] = 3
-    T: int
+    size: tuple[int, int, int]
     zero_diagonal: bool = False
 
 
 ContextConfig = dict[
-    str,
-    DistributionConfig
-    | Annotated[
-        Vector1DModel | Vector2DModel | Vector3DModel, Field(discriminator="n_dim")
-    ],
+    str, DistributionConfig | Vector1DModel | Vector2DModel | Vector3DModel
 ]

{phylogenie-1.0.3 → phylogenie-1.0.5}/phylogenie/core/context/distributions.py

@@ -77,7 +77,7 @@ class Exponential(Scalar):
     scale: float
 
     def _sample(self, rng: Generator) -> float:
-        return rng.exponential(scale=self.scale)
+        return rng.exponential(self.scale)
 
 
 class Gamma(Scalar):
@@ -86,7 +86,7 @@ class Gamma(Scalar):
     shape: float
 
     def _sample(self, rng: Generator) -> float:
-        return rng.gamma(shape=self.shape, scale=self.scale)
+        return rng.gamma(self.shape, self.scale)
 
 
 class Beta(Scalar):
@@ -95,7 +95,7 @@ class Beta(Scalar):
     beta: float
 
     def _sample(self, rng: Generator) -> float:
-        return rng.beta(a=self.alpha, b=self.beta)
+        return rng.beta(self.alpha, self.beta)
 
 
 class IntUniform(Scalar):

phylogenie-1.0.5/phylogenie/core/context/factories.py

@@ -0,0 +1,54 @@
+from numpy.random import Generator
+
+import phylogenie.core.context.configs as cfg
+import phylogenie.typings as pgt
+from phylogenie.core.context import distributions
+
+
+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,
+    size: tuple[int, int],
+    zero_diagonal: bool,
+    rng: Generator,
+) -> pgt.Vector2D:
+    n_rows, n_cols = size
+    v = [_sample_vector1D(x, n_cols, rng) for _ in range(n_rows)]
+    if zero_diagonal:
+        if n_rows != n_cols:
+            raise ValueError(
+                f"It is impossible to initialize a non-square matrix with zero the diagonal (got x={x}, size={size} and zero_diagonal=True)"
+            )
+        for i in range(n_rows):
+            v[i][i] = 0
+    return v
+
+
+def _sample_vector3D(
+    x: distributions.Scalar,
+    size: tuple[int, int, int],
+    zero_diagonal: bool,
+    rng: Generator,
+) -> pgt.Vector3D:
+    n_matrices, n_rows, n_cols = size
+    return [
+        _sample_vector2D(x, (n_rows, n_cols), zero_diagonal, rng)
+        for _ in range(n_matrices)
+    ]
+
+
+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)
+        elif isinstance(value, cfg.Vector1DModel):
+            data[key] = _sample_vector1D(value.x, value.size, rng)
+        elif isinstance(value, cfg.Vector2DModel):
+            data[key] = _sample_vector2D(value.x, value.size, value.zero_diagonal, rng)
+        else:
+            data[key] = _sample_vector3D(value.x, value.size, value.zero_diagonal, rng)
+    return data

{phylogenie-1.0.3 → phylogenie-1.0.5}/phylogenie/core/factories.py

@@ -1,4 +1,4 @@
-from typing import Any, Literal, overload
+from typing import Any
 
 import numpy as np
 
@@ -13,7 +13,6 @@ from phylogenie.skyline import (
     SkylineParameterLike,
     SkylineVector,
     SkylineVectorCoercible,
-    SkylineVectorLike,
 )
 
 
@@ -100,17 +99,23 @@ def skyline_parameter_like_factory(
     )
 
 
-@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
+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)
+
     change_times = many_scalars_factory(x.change_times, data)
     if isinstance(x.value, str):
         e = _eval_expression(x.value, data)
@@ -124,12 +129,7 @@ def _parse_skyline_vector_value_model(
         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."
-            )
+        return SkylineParameter(value=value, change_times=change_times)
 
     Ns = {len(elem) for elem in value if tg.is_many(elem)}
     if len(Ns) > 1:
@@ -139,46 +139,7 @@ def _parse_skyline_vector_value_model(
     (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)
+    return SkylineVector(value=value, change_times=change_times)
 
 
 def one_or_many_2D_scalars_factory(
@@ -208,8 +169,8 @@ def skyline_matrix_coercible_factory(
         )
     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]
+    if ctg.is_list_of_skyline_vector_coercible_configs(x):
+        return [skyline_vector_coercible_factory(v, data) for v in x]
 
     assert isinstance(x, cfg.SkylineMatrixValueModel)
 
@@ -245,7 +206,4 @@ def skyline_matrix_coercible_factory(
     (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,
-    )
+    return SkylineMatrix(value=value, change_times=change_times)

phylogenie-1.0.5/phylogenie/core/msas/base.py

@@ -0,0 +1,34 @@
+import os
+from abc import abstractmethod
+from enum import Enum
+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
+
+
+class BackendType(str, Enum):
+    ALISIM = "alisim"
+
+
+class MSAsGenerator(DatasetGenerator):
+    data_type: Literal[DataType.MSAS] = DataType.MSAS
+    trees: TreesGeneratorConfig
+
+    @abstractmethod
+    def _generate_one_from_tree(
+        self, filename: str, tree_file: str, rng: Generator, data: pgt.Data
+    ) -> None: ...
+
+    def _generate_one(self, filename: str, rng: Generator, data: pgt.Data) -> None:
+        tree_filename = f"{filename}.temp-tree"
+        self.trees.generate_one(
+            filename=tree_filename, data=data, seed=int(rng.integers(0, 2**32 - 1))
+        )
+        self._generate_one_from_tree(
+            filename=filename, tree_file=f"{tree_filename}.nwk", rng=rng, data=data
+        )
+        os.remove(f"{tree_filename}.nwk")

{phylogenie-1.0.3 → phylogenie-1.0.5}/phylogenie/core/trees/remaster/generator.py

@@ -67,9 +67,6 @@ class ReMASTERGenerator(TreesGenerator):
             beast_path=self.beast_path,
         )
 
-    def _generate_one(self, filename: str, rng: Generator, data: pgt.Data) -> None:
-        self._generate_one_from_extra_reactions(filename, rng, data, reactions=[])
-
 
 class CanonicalReMASTERGenerator(ReMASTERGenerator):
     parameterization: Literal[ParameterizationType.CANONICAL] = (

{phylogenie-1.0.3 → phylogenie-1.0.5}/phylogenie/core/trees/treesimulator.py

@@ -25,7 +25,7 @@ from phylogenie.core.trees.base import BackendType, TreesGenerator
 
 
 class ParameterizationType(str, Enum):
-    CANONICAL = "canonical"
+    MTBD = "MTBD"
     BD = "BD"
     BDEI = "BDEI"
 
@@ -70,10 +70,8 @@ class TreeSimulatorGenerator(TreesGenerator):
         )
 
 
-class CanonicalTreeSimulatorGenerator(TreeSimulatorGenerator):
-    parameterization: Literal[ParameterizationType.CANONICAL] = (
-        ParameterizationType.CANONICAL
-    )
+class MTBDTreeSimulatorGenerator(TreeSimulatorGenerator):
+    parameterization: Literal[ParameterizationType.MTBD] = ParameterizationType.MTBD
     populations: str | list[str] = DEFAULT_POPULATION
     transition_rates: cfg.SkylineMatrixCoercibleConfig = 0
     transmission_rates: cfg.SkylineMatrixCoercibleConfig = 0
@@ -158,8 +156,6 @@ class BDEITreeSimulatorGenerator(TreeSimulatorGenerator):
 
 
 TreeSimulatorGeneratorConfig = Annotated[
-    CanonicalTreeSimulatorGenerator
-    | BDTreeSimulatorGenerator
-    | BDEITreeSimulatorGenerator,
+    MTBDTreeSimulatorGenerator | BDTreeSimulatorGenerator | BDEITreeSimulatorGenerator,
     Field(discriminator="parameterization"),
 ]

{phylogenie-1.0.3 → phylogenie-1.0.5}/phylogenie/core/typeguards.py

@@ -1,6 +1,7 @@
 from typing import TypeGuard
 
 import phylogenie.core.configs as cfg
+import phylogenie.typings as pgt
 
 
 def is_list(x: object) -> TypeGuard[list[object]]:
@@ -17,11 +18,15 @@ def is_list_of_skyline_parameter_like_configs(
     return is_list(x) and all(isinstance(v, cfg.SkylineParameterLikeConfig) for v in x)
 
 
-def is_list_of_skyline_vector_like_configs(
+def is_skyline_vector_coercible_config(
     x: object,
-) -> TypeGuard[list[cfg.SkylineVectorLikeConfig]]:
-    return is_list(x) and all(
-        isinstance(v, str | cfg.SkylineVectorValueModel)
-        or is_list_of_skyline_parameter_like_configs(v)
-        for v in x
-    )
+) -> TypeGuard[cfg.SkylineVectorCoercibleConfig]:
+    return isinstance(
+        x, str | pgt.Scalar | cfg.SkylineVectorValueModel
+    ) or is_list_of_skyline_parameter_like_configs(x)
+
+
+def is_list_of_skyline_vector_coercible_configs(
+    x: object,
+) -> TypeGuard[list[cfg.SkylineVectorCoercibleConfig]]:
+    return is_list(x) and all(is_skyline_vector_coercible_config(v) for v in x)

{phylogenie-1.0.3 → phylogenie-1.0.5}/phylogenie/skyline/matrix.py

@@ -1,28 +1,24 @@
 from collections.abc import Callable, Iterator
-from typing import TypeGuard, Union
+from typing import TypeGuard, Union, overload
 
 import phylogenie.typeguards as tg
 import phylogenie.typings as pgt
-from phylogenie.skyline.parameter import (
-    SkylineParameter,
-    SkylineParameterLike,
-    is_skyline_parameter_like,
-    skyline_parameter,
-)
+from phylogenie.skyline.parameter import SkylineParameter, is_skyline_parameter_like
 from phylogenie.skyline.vector import (
     SkylineVector,
+    SkylineVectorCoercible,
     SkylineVectorLike,
     SkylineVectorOperand,
+    is_many_skyline_vectors_coercible,
     is_many_skyline_vectors_like,
+    is_skyline_vector_coercible,
     is_skyline_vector_like,
     is_skyline_vector_operand,
     skyline_vector,
 )
 
 SkylineMatrixOperand = Union[SkylineVectorOperand, "SkylineMatrix"]
-SkylineMatrixCoercible = Union[
-    SkylineParameterLike, pgt.Many[SkylineVectorLike], "SkylineMatrix"
-]
+SkylineMatrixCoercible = Union[pgt.OneOrMany[SkylineVectorCoercible], "SkylineMatrix"]
 
 
 def is_skyline_matrix_operand(x: object) -> TypeGuard[SkylineMatrixOperand]:
@@ -43,7 +39,7 @@ class SkylineMatrix:
                 raise TypeError(
                     f"It is impossible to create a SkylineMatrix from `params` {params} of type {type(params)}. Please provide a sequence composed of SkylineVectorLike objects (a SkylineVectorLike object can either be a SkylineVector or a sequence of scalars and/or SkylineParameters)."
                 )
-        elif value is not None and change_times is not None:
+        elif params is None and value is not None and change_times is not None:
             if tg.is_many_3D_scalars(value):
                 matrix_lengths = {len(matrix) for matrix in value}
                 if any(ml != len(value[0]) for ml in matrix_lengths):
@@ -80,45 +76,49 @@ class SkylineMatrix:
     def get_value_at_time(self, time: pgt.Scalar) -> pgt.Vector2D:
         return [param.get_value_at_time(time) for param in self.params]
 
-    def operate(
+    def _operate(
         self,
         other: SkylineMatrixOperand,
         func: Callable[
             [SkylineVector, SkylineVector | SkylineParameter], SkylineVector
         ],
     ) -> "SkylineMatrix":
-        if not is_skyline_matrix_operand(other):
-            return NotImplemented
         if is_skyline_vector_operand(other):
             other = skyline_vector(other, N=self.N)
-        assert isinstance(other, SkylineVector | SkylineMatrix)
+        elif isinstance(other, SkylineMatrix):
+            if other.N != self.N:
+                raise ValueError(
+                    f"Expected a SkylineMatrix with the same size as self (N={self.N}), but got {other} with N={other.N}."
+                )
+        else:
+            return NotImplemented
         return SkylineMatrix(
             [func(p1, p2) for p1, p2 in zip(self.params, other.params)]
         )
 
     def __add__(self, operand: SkylineMatrixOperand) -> "SkylineMatrix":
-        return self.operate(operand, lambda x, y: x + y)
+        return self._operate(operand, lambda x, y: x + y)
 
     def __radd__(self, operand: SkylineVectorOperand) -> "SkylineMatrix":
-        return self.operate(operand, lambda x, y: y + x)
+        return self._operate(operand, lambda x, y: y + x)
 
     def __sub__(self, operand: SkylineMatrixOperand) -> "SkylineMatrix":
-        return self.operate(operand, lambda x, y: x - y)
+        return self._operate(operand, lambda x, y: x - y)
 
     def __rsub__(self, operand: SkylineVectorOperand) -> "SkylineMatrix":
-        return self.operate(operand, lambda x, y: y - x)
+        return self._operate(operand, lambda x, y: y - x)
 
     def __mul__(self, operand: SkylineMatrixOperand) -> "SkylineMatrix":
-        return self.operate(operand, lambda x, y: x * y)
+        return self._operate(operand, lambda x, y: x * y)
 
     def __rmul__(self, operand: SkylineVectorOperand) -> "SkylineMatrix":
-        return self.operate(operand, lambda x, y: y * x)
+        return self._operate(operand, lambda x, y: y * x)
 
     def __truediv__(self, operand: SkylineMatrixOperand) -> "SkylineMatrix":
-        return self.operate(operand, lambda x, y: x / y)
+        return self._operate(operand, lambda x, y: x / y)
 
     def __rtruediv__(self, operand: SkylineVectorOperand) -> "SkylineMatrix":
-        return self.operate(operand, lambda x, y: y / x)
+        return self._operate(operand, lambda x, y: y / x)
 
     @property
     def T(self) -> "SkylineMatrix":
@@ -139,7 +139,13 @@ class SkylineMatrix:
     def __len__(self) -> int:
         return self.N
 
-    def __getitem__(self, item: int) -> "SkylineVector":
+    @overload
+    def __getitem__(self, item: int) -> SkylineVector: ...
+    @overload
+    def __getitem__(self, item: slice) -> list[SkylineVector]: ...
+    def __getitem__(
+        self, item: int | slice
+    ) -> Union[SkylineVector, list[SkylineVector]]:
         return self.params[item]
 
     def __setitem__(self, item: int, value: SkylineVectorLike) -> None:
@@ -153,20 +159,36 @@ class SkylineMatrix:
 def skyline_matrix(
     x: SkylineMatrixCoercible, N: int, zero_diagonal: bool = False
 ) -> SkylineMatrix:
-    if is_skyline_parameter_like(x):
-        x = SkylineMatrix([[skyline_parameter(x)] * N] * N)
+    if N <= 0:
+        raise ValueError(
+            f"N must be a positive integer for SkylineMatrix construction (got N={N})."
+        )
+    if is_skyline_vector_coercible(x):
+        x = SkylineMatrix([[p] * N for p in skyline_vector(x, N)])
         if zero_diagonal:
             for i in range(N):
                 x[i][i] = 0
         return x
-    elif is_many_skyline_vectors_like(x):
-        x = SkylineMatrix(x)
+    elif is_many_skyline_vectors_coercible(x):
+        x = SkylineMatrix(
+            [
+                [
+                    (
+                        0
+                        if i == j and is_skyline_parameter_like(v) and zero_diagonal
+                        else p
+                    )
+                    for j, p in enumerate(skyline_vector(v, N))
+                ]
+                for i, v in enumerate(x)
+            ]
+        )
     if not isinstance(x, SkylineMatrix):
         raise TypeError(
             f"It is impossible to coerce {x} of type {type(x)} into a SkylineMatrix. Please provide either:\n"
             "- a SkylineMatrix,\n"
-            "- a SkylineParameterLike object (i.e., a scalar or a SkylineParameter),\n"
-            "- a sequence of SkylineVectorLike objects (a SkylineVectorLike object can be a SkylineVector or a sequence of SkylineParameterLike objects)."
+            "- a SkylineVectorCoercible object (i.e., a scalar, a SkylineParameter, a SkylineVector, or a sequence of scalars and/or SkylineParameters),\n"
+            "- a sequence of SkylineVectorCoercible objects."
         )
 
     if x.N != N:

{phylogenie-1.0.3 → phylogenie-1.0.5}/phylogenie/skyline/parameter.py

@@ -23,7 +23,7 @@ class SkylineParameter:
         self,
         value: pgt.OneOrManyScalars,
         change_times: pgt.ManyScalars | None = None,
-    ) -> None:
+    ):
         if isinstance(value, pgt.Scalar):
             value = [value]
         elif not tg.is_many_scalars(value):
@@ -42,23 +42,37 @@ class SkylineParameter:
             raise ValueError(
                 f"`value` must have exactly one more element than `change_times` (got value={value} of length {len(value)} and change_times={change_times} of length {len(change_times)})."
             )
+        if any(t1 >= t2 for t1, t2 in zip(change_times, change_times[1:])):
+            raise ValueError(
+                f"`change_times` must be sorted in strictly increasing order "
+                f"(got change_times={change_times})."
+            )
+        if any(t < 0 for t in change_times):
+            raise ValueError(
+                f"`change_times` must be non-negative (got change_times={change_times})."
+            )
 
         self.value = [value[0]]
         self.change_times: list[pgt.Scalar] = []
         for i in range(1, len(value)):
             if value[i] != value[i - 1]:
                 self.value.append(value[i])
-                self.value.append(change_times[i - 1])
+                self.change_times.append(change_times[i - 1])
 
     def get_value_at_time(self, t: pgt.Scalar) -> pgt.Scalar:
+        if t < 0:
+            raise ValueError(f"Time cannot be negative (got t={t}).")
         return self.value[bisect_right(self.change_times, t)]
 
-    def operate(
+    def _operate(
         self,
         other: SkylineParameterLike,
         f: Callable[[pgt.Scalar, pgt.Scalar], pgt.Scalar],
     ) -> "SkylineParameter":
-        other = skyline_parameter(other)
+        if is_skyline_parameter_like(other):
+            other = skyline_parameter(other)
+        else:
+            return NotImplemented
         change_times = sorted(set(self.change_times + other.change_times))
         value = [
             f(self.get_value_at_time(t), other.get_value_at_time(t))
@@ -67,28 +81,28 @@ class SkylineParameter:
         return SkylineParameter(value, change_times)
 
     def __add__(self, other: SkylineParameterLike) -> "SkylineParameter":
-        return self.operate(other, lambda x, y: x + y)
+        return self._operate(other, lambda x, y: x + y)
 
     def __radd__(self, other: pgt.Scalar) -> "SkylineParameter":
-        return self.operate(other, lambda x, y: y + x)
+        return self._operate(other, lambda x, y: y + x)
 
     def __sub__(self, other: SkylineParameterLike) -> "SkylineParameter":
-        return self.operate(other, lambda x, y: x - y)
+        return self._operate(other, lambda x, y: x - y)
 
     def __rsub__(self, other: pgt.Scalar) -> "SkylineParameter":
-        return self.operate(other, lambda x, y: y - x)
+        return self._operate(other, lambda x, y: y - x)
 
     def __mul__(self, other: SkylineParameterLike) -> "SkylineParameter":
-        return self.operate(other, lambda x, y: x * y)
+        return self._operate(other, lambda x, y: x * y)
 
     def __rmul__(self, other: pgt.Scalar) -> "SkylineParameter":
-        return self.operate(other, lambda x, y: y * x)
+        return self._operate(other, lambda x, y: y * x)
 
     def __truediv__(self, other: SkylineParameterLike) -> "SkylineParameter":
-        return self.operate(other, lambda x, y: x / y)
+        return self._operate(other, lambda x, y: x / y)
 
     def __rtruediv__(self, other: pgt.Scalar) -> "SkylineParameter":
-        return self.operate(other, lambda x, y: y / x)
+        return self._operate(other, lambda x, y: y / x)
 
     def __bool__(self) -> bool:
         return any(self.value)

{phylogenie-1.0.3 → phylogenie-1.0.5}/phylogenie/skyline/vector.py

@@ -1,5 +1,5 @@
 from collections.abc import Callable, Iterator
-from typing import TypeGuard, Union
+from typing import TypeGuard, Union, overload
 
 import phylogenie.typeguards as tg
 import phylogenie.typings as pgt
@@ -24,17 +24,29 @@ def is_skyline_vector_like(x: object) -> TypeGuard[SkylineVectorLike]:
     return isinstance(x, SkylineVector) or is_many_skyline_parameters_like(x)
 
 
+def is_skyline_vector_coercible(
+    x: object,
+) -> TypeGuard[SkylineVectorCoercible]:
+    return is_skyline_parameter_like(x) or is_skyline_vector_like(x)
+
+
 def is_many_skyline_vectors_like(x: object) -> TypeGuard[pgt.Many[SkylineVectorLike]]:
     return tg.is_many(x) and all(is_skyline_vector_like(v) for v in x)
 
 
+def is_many_skyline_vectors_coercible(
+    x: object,
+) -> TypeGuard[pgt.Many[SkylineVectorCoercible]]:
+    return tg.is_many(x) and all(is_skyline_vector_coercible(v) for v in x)
+
+
 class SkylineVector:
     def __init__(
         self,
         params: pgt.Many[SkylineParameterLike] | None = None,
         value: pgt.Many2DScalars | None = None,
         change_times: pgt.ManyScalars | None = None,
-    ) -> None:
+    ):
         if params is not None and value is None and change_times is None:
             if is_many_skyline_parameters_like(params):
                 self.params = [skyline_parameter(param) for param in params]
@@ -42,7 +54,7 @@ class SkylineVector:
                 raise TypeError(
                     f"It is impossible to create a SkylineVector from `params` {params} of type {type(params)}. Please provide a sequence of SkylineParameterLike objects (a SkylineParameterLike object can either be a SkylineParameter or a scalar)."
                 )
-        elif value is not None and change_times is not None:
+        elif params is None and value is not None and change_times is not None:
             if tg.is_many_2D_scalars(value):
                 vector_lengths = {len(vector) for vector in value}
                 if any(vl != len(value[0]) for vl in vector_lengths):
@@ -77,7 +89,7 @@ class SkylineVector:
     def get_value_at_time(self, t: pgt.Scalar) -> pgt.Vector1D:
         return [param.get_value_at_time(t) for param in self.params]
 
-    def operate(
+    def _operate(
         self,
         other: SkylineVectorOperand,
         func: Callable[[SkylineParameter, SkylineParameter], SkylineParameter],
@@ -90,28 +102,28 @@ class SkylineVector:
         )
 
     def __add__(self, operand: SkylineVectorOperand) -> "SkylineVector":
-        return self.operate(operand, lambda x, y: x + y)
+        return self._operate(operand, lambda x, y: x + y)
 
     def __radd__(self, operand: SkylineParameterLike) -> "SkylineVector":
-        return self.operate(operand, lambda x, y: y + x)
+        return self._operate(operand, lambda x, y: y + x)
 
     def __sub__(self, operand: SkylineVectorOperand) -> "SkylineVector":
-        return self.operate(operand, lambda x, y: x - y)
+        return self._operate(operand, lambda x, y: x - y)
 
     def __rsub__(self, operand: SkylineParameterLike) -> "SkylineVector":
-        return self.operate(operand, lambda x, y: y - x)
+        return self._operate(operand, lambda x, y: y - x)
 
     def __mul__(self, operand: SkylineVectorOperand) -> "SkylineVector":
-        return self.operate(operand, lambda x, y: x * y)
+        return self._operate(operand, lambda x, y: x * y)
 
     def __rmul__(self, operand: SkylineParameterLike) -> "SkylineVector":
-        return self.operate(operand, lambda x, y: y * x)
+        return self._operate(operand, lambda x, y: y * x)
 
     def __truediv__(self, operand: SkylineVectorOperand) -> "SkylineVector":
-        return self.operate(operand, lambda x, y: x / y)
+        return self._operate(operand, lambda x, y: x / y)
 
     def __rtruediv__(self, operand: SkylineParameterLike) -> "SkylineVector":
-        return self.operate(operand, lambda x, y: y / x)
+        return self._operate(operand, lambda x, y: y / x)
 
     def __len__(self) -> int:
         return self.N
@@ -128,7 +140,13 @@ class SkylineVector:
     def __iter__(self) -> Iterator[SkylineParameter]:
         return iter(self.params)
 
-    def __getitem__(self, item: int) -> "SkylineParameter":
+    @overload
+    def __getitem__(self, item: int) -> SkylineParameter: ...
+    @overload
+    def __getitem__(self, item: slice) -> list[SkylineParameter]: ...
+    def __getitem__(
+        self, item: int | slice
+    ) -> Union[SkylineParameter, list[SkylineParameter]]:
         return self.params[item]
 
     def __setitem__(self, item: int, value: SkylineParameterLike) -> None:
@@ -140,6 +158,10 @@ class SkylineVector:
 
 
 def skyline_vector(x: SkylineVectorCoercible, N: int) -> SkylineVector:
+    if N <= 0:
+        raise ValueError(
+            f"N must be a positive integer for SkylineVector construction (got N={N})."
+        )
     if is_skyline_parameter_like(x):
         return SkylineVector([skyline_parameter(x)] * N)
     elif is_many_skyline_parameters_like(x):

{phylogenie-1.0.3 → phylogenie-1.0.5}/phylogenie/typings.py

@@ -21,3 +21,4 @@ Vector2D = list[Vector1D]
 Vector3D = list[Vector2D]
 
 Data = dict[str, str | Scalar | Vector1D | Vector2D | Vector3D]
+Size = int | tuple[int, int] | tuple[int, int, int]

{phylogenie-1.0.3 → phylogenie-1.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "phylogenie"
-version = "1.0.3"
+version = "1.0.5"
 description = "Generate phylogenetic datasets with minimal setup effort"
 authors = ["Gabriele Marino <gabmarino.8601@gmail.com>"]
 readme = "README.md"

phylogenie-1.0.3/phylogenie/core/context/factories.py

@@ -1,41 +0,0 @@
-from numpy.random import Generator
-
-import phylogenie.core.context.configs as cfg
-import phylogenie.typings as pgt
-from phylogenie.core.context import distributions
-
-
-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
-) -> pgt.Vector2D:
-    v = [_sample_vector1D(x, N, rng) for _ in range(N)]
-    if zero_diagonal:
-        for i in range(N):
-            v[i][i] = 0
-    return v
-
-
-def _sample_vector3D(
-    x: distributions.Scalar, N: int, T: int, zero_diagonal: bool, rng: Generator
-) -> pgt.Vector3D:
-    return [_sample_vector2D(x, N, zero_diagonal, rng) for _ in range(T)]
-
-
-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)
-        elif isinstance(value, cfg.Vector1DModel):
-            data[key] = _sample_vector1D(value.x, value.N, rng)
-        elif isinstance(value, cfg.Vector2DModel):
-            data[key] = _sample_vector2D(value.x, value.N, value.zero_diagonal, rng)
-        else:
-            data[key] = _sample_vector3D(
-                value.x, value.N, value.T, value.zero_diagonal, rng
-            )
-    return data

phylogenie-1.0.3/phylogenie/core/msas/base.py

@@ -1,51 +0,0 @@
-import os
-from abc import abstractmethod
-from enum import Enum
-from pathlib import Path
-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
-
-
-class BackendType(str, Enum):
-    ALISIM = "alisim"
-
-
-class MSAsGenerator(DatasetGenerator):
-    data_type: Literal[DataType.MSAS] = DataType.MSAS
-    trees: str | TreesGeneratorConfig
-    output_trees_dir: str | None = None
-
-    @abstractmethod
-    def _generate_one_from_tree(
-        self, filename: str, tree_file: str, rng: Generator, data: pgt.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)))
-            self._generate_one_from_tree(
-                filename=filename, tree_file=tree_file, rng=rng, data=data
-            )
-        elif isinstance(self.output_trees_dir, str):
-            os.makedirs(self.output_trees_dir, exist_ok=True)
-            self._generate_one_from_tree(
-                filename=filename,
-                tree_file=os.path.join(self.output_trees_dir, f"{Path(filename).stem}"),
-                rng=rng,
-                data=data,
-            )
-        else:
-            tree_filename = f"{filename}.temp-tree"
-            self.trees.generate_one(
-                filename=tree_filename, data=data, seed=int(rng.integers(0, 2**32 - 1))
-            )
-            self._generate_one_from_tree(
-                filename=filename, tree_file=f"{tree_filename}.nwk", rng=rng, data=data
-            )
-            os.remove(f"{tree_filename}.nwk")