Add petab-compatible sympy string-printer

Add a sympy Printer to stringify sympy expressions in a petab-compatible way.
For example, we need to avoid `str(sympy.sympify("x^2"))` -> `'x**2'`.

Closes #362.

Author: dweindl

petab/v1/math/__init__.py

@@ -1,3 +1,4 @@
 """Functions for parsing and evaluating mathematical expressions."""
 
+from .printer import PetabStrPrinter, petab_math_str  # noqa: F401
 from .sympify import sympify_petab  # noqa: F401

petab/v1/math/printer.py

@@ -0,0 +1,86 @@
+"""A PEtab-compatible sympy string-printer."""
+
+from itertools import chain, islice
+
+import sympy as sp
+from sympy.printing.str import StrPrinter
+
+
+class PetabStrPrinter(StrPrinter):
+    """A PEtab-compatible sympy string-printer."""
+
+    #: Mapping of sympy functions to PEtab functions
+    func_map = {
+        "asin": "arcsin",
+        "acos": "arccos",
+        "atan": "arctan",
+        "acot": "arccot",
+        "asec": "arcsec",
+        "acsc": "arccsc",
+        "asinh": "arcsinh",
+        "acosh": "arccosh",
+        "atanh": "arctanh",
+        "acoth": "arccoth",
+        "asech": "arcsech",
+        "acsch": "arccsch",
+        "Abs": "abs",
+    }
+
+    def _print_BooleanTrue(self, expr):
+        return "true"
+
+    def _print_BooleanFalse(self, expr):
+        return "false"
+
+    def _print_Pow(self, expr: sp.Pow):
+        """Custom printing for the power operator"""
+        base, exp = expr.as_base_exp()
+        return f"{self._print(base)} ^ {self._print(exp)}"
+
+    def _print_Infinity(self, expr):
+        """Custom printing for infinity"""
+        return "inf"
+
+    def _print_NegativeInfinity(self, expr):
+        """Custom printing for negative infinity"""
+        return "-inf"
+
+    def _print_Function(self, expr):
+        """Custom printing for specific functions"""
+
+        if expr.func.__name__ == "Piecewise":
+            return self._print_Piecewise(expr)
+
+        if func := self.func_map.get(expr.func.__name__):
+            return f"{func}({', '.join(map(self._print, expr.args))})"
+
+        return super()._print_Function(expr)
+
+    def _print_Piecewise(self, expr):
+        """Custom printing for Piecewise function"""
+        # merge the tuples and drop the final `True` condition
+        str_args = map(
+            self._print,
+            islice(chain.from_iterable(expr.args), len(expr.args) - 1),
+        )
+        return f"piecewise({', '.join(str_args)})"
+
+    def _print_Min(self, expr):
+        """Custom printing for Min function"""
+        return f"min({', '.join(map(self._print, expr.args))})"
+
+    def _print_Max(self, expr):
+        """Custom printing for Max function"""
+        return f"max({', '.join(map(self._print, expr.args))})"
+
+
+def petab_math_str(expr: sp.Expr) -> str:
+    """Convert a sympy expression to a PEtab-compatible math expression string.
+
+    :example:
+    >>> expr = sp.sympify("x**2 + sin(y)")
+    >>> petab_math_str(expr)
+    'x ^ 2 + sin(y)'
+    """
+
+    return PetabStrPrinter().doprint(expr)

petab/v1/math/sympify.py

@@ -52,10 +52,17 @@ def sympify_petab(expr: str | int | float) -> sp.Expr | sp.Basic:
     visitor = MathVisitorSympy()
     expr = visitor.visit(tree)
     expr = bool2num(expr)
-    # check for `False`, we'll accept both `True` and `None`
-    if expr.is_extended_real is False:
-        raise ValueError(f"Expression {expr} is not real-valued.")
-
+    try:
+        # check for `False`, we'll accept both `True` and `None`
+        if expr.is_extended_real is False:
+            raise ValueError(f"Expression {expr} is not real-valued.")
+    except AttributeError as e:
+        # work-around for `sp.sec(0, evaluate=False).is_extended_real` error
+        if str(e) not in (
+            "'One' object has no attribute '_eval_is_extended_real'",
+            "'Float' object has no attribute '_eval_is_extended_real'",
+        ):
+            raise
     return expr
 
 

tests/v1/math/test_math.py

@@ -6,9 +6,9 @@
 import sympy as sp
 import yaml
 from sympy.abc import _clash
-from sympy.logic.boolalg import Boolean
+from sympy.logic.boolalg import Boolean, BooleanFalse, BooleanTrue
 
-from petab.math import sympify_petab
+from petab.math import petab_math_str, sympify_petab
 
 
 def test_sympify_numpy():
@@ -23,6 +23,9 @@ def test_parse_simple():
     assert float(sympify_petab("1 + 2 * (3 + 4)")) == 15
     assert float(sympify_petab("1 + 2 * (3 + 4) / 2")) == 8
 
+def test_printer():
+    assert petab_math_str(BooleanTrue()) == "true"
+    assert petab_math_str(BooleanFalse()) == "false"
 
 def read_cases():
     """Read test cases from YAML file in the petab_test_suite package."""
@@ -55,20 +58,27 @@ def read_cases():
 @pytest.mark.parametrize("expr_str, expected", read_cases())
 def test_parse_cases(expr_str, expected):
     """Test PEtab math expressions for the PEtab test suite."""
-    result = sympify_petab(expr_str)
-    if isinstance(result, Boolean):
-        assert result == expected
+    sym_expr = sympify_petab(expr_str)
+    if isinstance(sym_expr, Boolean):
+        assert sym_expr == expected
     else:
         try:
-            result = float(result.evalf())
+            result = float(sym_expr.evalf())
             assert np.isclose(result, expected), (
                 f"{expr_str}: Expected {expected}, got {result}"
             )
         except TypeError:
-            assert result == expected, (
+            assert sym_expr == expected, (
                 f"{expr_str}: Expected {expected}, got {result}"
             )
 
+    # test parsing, printing, and parsing again
+    resympified = sympify_petab(petab_math_str(sym_expr))
+    if sym_expr.is_number:
+        assert np.isclose(float(resympified), float(sym_expr))
+    else:
+        assert resympified.equals(sym_expr), (sym_expr, resympified)
+
 
 def test_ids():
     """Test symbols in expressions."""