phylogenie 1.0.2__tar.gz → 1.0.4__tar.gz

{phylogenie-1.0.2 → phylogenie-1.0.4}/PKG-INFO

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

{phylogenie-1.0.2 → phylogenie-1.0.4}/phylogenie/core/factories.py

@@ -1,4 +1,4 @@
-from typing import Any, overload
+from typing import Any, Literal, overload
 
 import numpy as np
 
@@ -23,10 +23,9 @@ def _eval_expression(expression: str, data: pgt.Data) -> Any:
             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()},
             },
-            {k: np.array(v) for k, v in data.items()},
         )
     ).tolist()
 
@@ -101,20 +100,17 @@ def skyline_parameter_like_factory(
     )
 
 
-from typing import Literal
-
-
 @overload
 def _parse_skyline_vector_value_model(
     x: cfg.SkylineVectorValueModel, data: pgt.Data, coercible: Literal[True]
-) -> SkylineVector | SkylineParameter: ...
+) -> SkylineVectorCoercible: ...
 @overload
 def _parse_skyline_vector_value_model(
     x: cfg.SkylineVectorValueModel, data: pgt.Data, coercible: Literal[False]
-) -> SkylineVector: ...
+) -> SkylineVectorLike: ...
 def _parse_skyline_vector_value_model(
     x: cfg.SkylineVectorValueModel, data: pgt.Data, coercible: bool
-) -> SkylineVector | SkylineParameter:
+) -> SkylineVectorCoercible:
     change_times = many_scalars_factory(x.change_times, data)
     if isinstance(x.value, str):
         e = _eval_expression(x.value, data)
@@ -132,13 +128,13 @@ def _parse_skyline_vector_value_model(
             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."
+                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 (got value={value} with inconsistent lengths {Ns})."
+            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]
@@ -238,13 +234,13 @@ def skyline_matrix_coercible_factory(
             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})."
+                    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 (got value={value} with inconsistent lengths {Ns})."
+            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]

{phylogenie-1.0.2 → phylogenie-1.0.4}/phylogenie/skyline/matrix.py

@@ -80,7 +80,7 @@ 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[
@@ -97,28 +97,28 @@ class SkylineMatrix:
         )
 
     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":

{phylogenie-1.0.2 → phylogenie-1.0.4}/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,18 +42,29 @@ 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],
@@ -67,28 +78,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.2 → phylogenie-1.0.4}/phylogenie/skyline/vector.py

@@ -34,7 +34,7 @@ class SkylineVector:
         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]
@@ -77,7 +77,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 +90,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

{phylogenie-1.0.2 → phylogenie-1.0.4}/pyproject.toml

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