more tests

Author: dweindl

doc/modules.rst

@@ -16,6 +16,7 @@ API Reference
    petab.v1.core
    petab.v1.distributions
    petab.v1.lint
+   petab.v1.math
    petab.v1.measurements
    petab.v1.models
    petab.v1.observables

petab/v1/math/sympify.py

@@ -15,6 +15,11 @@
 def sympify_petab(expr: str | int | float) -> sp.Expr | sp.Basic:
     """Convert PEtab math expression to sympy expression.
 
+    .. note::
+
+        All symbols in the returned expression will have the `real=True`
+        assumption.
+
     Args:
         expr: PEtab math expression.
 
@@ -26,6 +31,10 @@ def sympify_petab(expr: str | int | float) -> sp.Expr | sp.Basic:
         The sympy expression corresponding to `expr`.
         Boolean values are converted to numeric values.
     """
+    if isinstance(expr, sp.Expr):
+        # TODO: check if only PEtab-compatible symbols and functions are used
+        return expr
+
     if isinstance(expr, int) or isinstance(expr, np.integer):
         return sp.Integer(expr)
     if isinstance(expr, float) or isinstance(expr, np.floating):

petab/v2/core.py

@@ -56,6 +56,14 @@ def _is_finite_or_neg_inf(v: float, info: ValidationInfo) -> float:
     return v
 
 
+def _is_finite_or_pos_inf(v: float, info: ValidationInfo) -> float:
+    if not np.isfinite(v) and v != np.inf:
+        raise ValueError(
+            f"{info.field_name} value must be finite or inf but got {v}"
+        )
+    return v
+
+
 def _not_nan(v: float, info: ValidationInfo) -> float:
     if np.isnan(v):
         raise ValueError(f"{info.field_name} value must not be nan.")
@@ -201,18 +209,24 @@ def _sympify(cls, v):
     def _placeholders(
         self, type_: Literal["observable", "noise"]
     ) -> set[sp.Symbol]:
-        # TODO: add field validator to check for 1-based consecutive numbering
-        t = f"{re.escape(type_)}Parameter"
-        o = re.escape(self.id)
-        pattern = re.compile(rf"(?:^|\W)({t}\d+_{o})(?=\W|$)")
         formula = (
             self.formula
             if type_ == "observable"
             else self.noise_formula
             if type_ == "noise"
             else None
         )
-        return {s for s in formula.free_symbols if pattern.match(str(s))}
+        if formula is None or formula.is_number:
+            return set()
+
+        if not (free_syms := formula.free_symbols):
+            return set()
+
+        # TODO: add field validator to check for 1-based consecutive numbering
+        t = f"{re.escape(type_)}Parameter"
+        o = re.escape(self.id)
+        pattern = re.compile(rf"(?:^|\W)({t}\d+_{o})(?=\W|$)")
+        return {s for s in free_syms if pattern.match(str(s))}
 
     @property
     def observable_placeholders(self) -> set[sp.Symbol]:
@@ -600,7 +614,9 @@ class Measurement(BaseModel):
     #: The experiment ID.
     experiment_id: str | None = Field(alias=C.EXPERIMENT_ID, default=None)
     #: The time point of the measurement in time units as defined in the model.
-    time: float = Field(alias=C.TIME)
+    time: Annotated[float, AfterValidator(_is_finite_or_pos_inf)] = Field(
+        alias=C.TIME
+    )
     #: The measurement value.
     measurement: Annotated[float, AfterValidator(_not_nan)] = Field(
         alias=C.MEASUREMENT

petab/v2/problem.py

@@ -203,10 +203,10 @@ def get_path(filename):
 
         if yaml.is_composite_problem(yaml_config):
             raise ValueError(
-                "petab.Problem.from_yaml() can only be used for "
+                "petab.v2.Problem.from_yaml() can only be used for "
                 "yaml files comprising a single model. "
                 "Consider using "
-                "petab.CompositeProblem.from_yaml() instead."
+                "petab.v2.CompositeProblem.from_yaml() instead."
             )
         config = ProblemConfig(
             **yaml_config, base_path=base_path, filepath=yaml_file
@@ -350,13 +350,13 @@ def from_dfs(
     def from_combine(filename: Path | str) -> Problem:
         """Read PEtab COMBINE archive (http://co.mbine.org/documents/archive).
 
-        See also :py:func:`petab.create_combine_archive`.
+        See also :py:func:`petab.v2.create_combine_archive`.
 
         Arguments:
             filename: Path to the PEtab-COMBINE archive
 
         Returns:
-            A :py:class:`petab.Problem` instance.
+            A :py:class:`petab.v2.Problem` instance.
         """
         # function-level import, because module-level import interfered with
         # other SWIG interfaces
@@ -882,7 +882,7 @@ def add_condition(
             id_: The condition id
             name: The condition name
             kwargs: Entities to be added to the condition table in the form
-                `target_id=(value_type, target_value)`.
+                `target_id=target_value`.
         """
         if not kwargs:
             raise ValueError("Cannot add condition without any changes")
@@ -1132,19 +1132,25 @@ class ExtensionConfig(BaseModel):
 class ProblemConfig(BaseModel):
     """The PEtab problem configuration."""
 
+    #: The path to the PEtab problem configuration.
     filepath: str | AnyUrl | None = Field(
         None,
         description="The path to the PEtab problem configuration.",
         exclude=True,
     )
+    #: The base path to resolve relative paths.
     base_path: str | AnyUrl | None = Field(
         None,
         description="The base path to resolve relative paths.",
         exclude=True,
     )
+    #: The PEtab format version.
     format_version: str = "2.0.0"
+    #: The path to the parameter file, relative to ``base_path``.
     parameter_file: str | AnyUrl | None = None
+    #: The list of problems in the configuration.
     problems: list[SubProblem] = []
+    #: Extensiions used by the problem.
     extensions: list[ExtensionConfig] = []
 
     def to_yaml(self, filename: str | Path):

tests/v1/math/test_math.py

@@ -74,6 +74,11 @@ def test_ids():
     """Test symbols in expressions."""
     assert sympify_petab("bla * 2") == 2.0 * sp.Symbol("bla", real=True)
 
+    # test that sympy expressions that are invalid in PEtab raise an error
+    # TODO: handle these cases after
+    #   https://github.com/PEtab-dev/libpetab-python/pull/364
+    # sympify_petab(sp.Symbol("föö"))
+
 
 def test_syntax_error():
     """Test exceptions upon syntax errors."""

tests/v2/test_core.py

@@ -1,16 +1,12 @@
 import tempfile
 from pathlib import Path
 
+import pytest
 import sympy as sp
+from pydantic import ValidationError
+from sympy.abc import x, y
 
-from petab.v2.core import (
-    Change,
-    Condition,
-    ConditionsTable,
-    Experiment,
-    ExperimentPeriod,
-    ObservablesTable,
-)
+from petab.v2.core import *
 from petab.v2.petab1to2 import petab1to2
 
 example_dir_fujita = Path(__file__).parents[2] / "doc/example/example_Fujita"
@@ -73,3 +69,116 @@ def test_conditions_table_add_changes():
     conditions_table += c2
 
     assert conditions_table.conditions == [c1, c2]
+
+
+def test_measurments():
+    Measurement(
+        observable_id="obs1", time=1, experiment_id="exp1", measurement=1
+    )
+    Measurement(
+        observable_id="obs1", time="1", experiment_id="exp1", measurement="1"
+    )
+    Measurement(
+        observable_id="obs1", time="inf", experiment_id="exp1", measurement="1"
+    )
+
+    Measurement(
+        observable_id="obs1",
+        time=1,
+        experiment_id="exp1",
+        measurement=1,
+        observable_parameters=["p1"],
+        noise_parameters=["n1"],
+    )
+
+    Measurement(
+        observable_id="obs1",
+        time=1,
+        experiment_id="exp1",
+        measurement=1,
+        observable_parameters=[1],
+        noise_parameters=[2],
+    )
+
+    Measurement(
+        observable_id="obs1",
+        time=1,
+        experiment_id="exp1",
+        measurement=1,
+        observable_parameters=[sp.sympify("x ** y")],
+        noise_parameters=[sp.sympify("x ** y")],
+    )
+
+    assert (
+        Measurement(
+            observable_id="obs1",
+            time=1,
+            experiment_id="exp1",
+            measurement=1,
+            non_petab=1,
+        ).non_petab
+        == 1
+    )
+
+    with pytest.raises(ValidationError, match="got -inf"):
+        Measurement(
+            observable_id="obs1",
+            time="-inf",
+            experiment_id="exp1",
+            measurement=1,
+        )
+
+    with pytest.raises(ValidationError, match="Invalid ID"):
+        Measurement(
+            observable_id="1_obs", time=1, experiment_id="exp1", measurement=1
+        )
+
+    with pytest.raises(ValidationError, match="Invalid ID"):
+        Measurement(
+            observable_id="obs", time=1, experiment_id=" exp1", measurement=1
+        )
+
+
+def test_observable():
+    Observable(id="obs1", formula=x + y)
+    Observable(id="obs1", formula="x + y", noise_formula="x + y")
+    Observable(id="obs1", formula=1, noise_formula=2)
+    Observable(
+        id="obs1",
+        formula="x + y",
+        noise_formula="x + y",
+        observable_parameters=["p1"],
+        noise_parameters=["n1"],
+    )
+    Observable(
+        id="obs1",
+        formula=sp.sympify("x + y"),
+        noise_formula=sp.sympify("x + y"),
+        observable_parameters=[sp.Symbol("p1")],
+        noise_parameters=[sp.Symbol("n1")],
+    )
+    assert Observable(id="obs1", formula="x + y", non_petab=1).non_petab == 1
+
+    o = Observable(id="obs1", formula=x + y)
+    assert o.observable_placeholders == set()
+    assert o.noise_placeholders == set()
+
+    o = Observable(
+        id="obs1",
+        formula="observableParameter1_obs1",
+        noise_formula="noiseParameter1_obs1",
+    )
+    assert o.observable_placeholders == {
+        sp.Symbol("observableParameter1_obs1", real=True),
+    }
+    assert o.noise_placeholders == {
+        sp.Symbol("noiseParameter1_obs1", real=True)
+    }
+
+    # TODO: this should raise an error
+    #   (numbering is not consecutive / not starting from 1)
+    # TODO: clarify if observableParameter0_obs1 would be allowed
+    #  as regular parameter
+    #
+    # with pytest.raises(ValidationError):
+    #  Observable(id="obs1", formula="observableParameter2_obs1")