gotranx 0.2.2__tar.gz → 0.2.3__tar.gz

{gotranx-0.2.2 → gotranx-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gotranx
-Version: 0.2.2
+Version: 0.2.3
 Summary: A declarative language describing ordinary differential equations
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT
@@ -23,6 +23,7 @@ Requires-Dist: rich-click
 Requires-Dist: structlog
 Requires-Dist: sympy
 Requires-Dist: typer
+Requires-Dist: myokit
 Requires-Dist: graphlib-backport; python_version < "3.9"
 Requires-Dist: typing_extensions; python_version < "3.9"
 Provides-Extra: dev

{gotranx-0.2.2 → gotranx-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gotranx"
-version = "0.2.2"
+version = "0.2.3"
 description = "A declarative language describing ordinary differential equations"
 authors = [{name = "Henrik Finsberg", email = "henriknf@simula.no"}]
 license = {text = "MIT"}
@@ -29,6 +29,7 @@ dependencies = [
     "structlog",
     "sympy",
     "typer",
+    "myokit",
     'graphlib-backport;python_version < "3.9"',
     'typing_extensions;python_version < "3.9"',
 ]
@@ -91,13 +92,6 @@ omit = ["src/gotranx/__main__.py", "src/gotranx/templates/__init__.py"]
 
 
 [tool.ruff]
-# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default.
-select = ["E", "F"]
-ignore = ["E402", "E741", "E743", "E731"]
-
-# Allow autofix for all enabled rules (when `--fix`) is provided.
-fixable = ["A", "B", "C", "D", "E", "F"]
-unfixable = []
 
 # Exclude a variety of commonly ignored directories.
 exclude = [
@@ -126,13 +120,23 @@ exclude = [
 # Same as Black.
 line-length = 100
 
+# Assume Python 3.10.
+target-version = "py310"
+
+[tool.ruff.lint]
+# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default.
+select = ["E", "F"]
+ignore = ["E402", "E741", "E743", "E731"]
+
+# Allow autofix for all enabled rules (when `--fix`) is provided.
+fixable = ["A", "B", "C", "D", "E", "F"]
+unfixable = []
+
 # Allow unused variables when underscore-prefixed.
 dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 
-# Assume Python 3.10.
-target-version = "py310"
 
-[tool.ruff.mccabe]
+[tool.ruff.lint.mccabe]
 # Unlike Flake8, default to a complexity level of 10.
 max-complexity = 10
 
@@ -145,7 +149,7 @@ tag = true
 sign_tags = false
 tag_name = "v{new_version}"
 tag_message = "Bump version: {current_version} → {new_version}"
-current_version = "0.2.2"
+current_version = "0.2.3"
 
 
 [[tool.bumpversion.files]]

{gotranx-0.2.2 → gotranx-0.2.3}/src/gotranx/__init__.py

@@ -13,7 +13,7 @@ from . import units
 from . import sympytools
 from . import schemes
 from . import templates
-from . import cellml
+from . import myokit
 from .load import load_ode
 from .ode import ODE
 from .ode_component import Component
@@ -47,5 +47,5 @@ __all__ = [
     "sympytools",
     "schemes",
     "templates",
-    "cellml",
+    "myokit",
 ]

{gotranx-0.2.2 → gotranx-0.2.3}/src/gotranx/atoms.py

@@ -8,6 +8,7 @@ from structlog import get_logger
 
 from .expressions import build_expression
 from .units import ureg
+from . import exceptions
 
 logger = get_logger()
 
@@ -52,7 +53,7 @@ class Atom:
     """Base class for atoms"""
 
     name: str = attr.ib()
-    value: float | Expression | sp.core.Number = attr.ib()
+    value: float | Expression | sp.core.Number | None = attr.ib()
     components: tuple[str, ...] = attr.ib(default=("",))
     description: str | None = attr.ib(None)
     symbol: sp.Symbol = attr.ib(None)
@@ -132,10 +133,12 @@ class Expression:
 class Assignment(Atom):
     """Assignments are object of the form `name = value`."""
 
-    value: Expression = attr.ib()
+    value: Expression | None = attr.ib()
     expr: sp.Expr = attr.ib(sp.S.Zero)
 
     def resolve_expression(self, symbols: dict[str, sp.Symbol]) -> Assignment:
+        if self.value is None:
+            raise exceptions.ResolveExpressionError(name=self.name)
         expr = self.value.resolve(symbols)
         return type(self)(
             name=self.name,
@@ -201,6 +204,8 @@ class StateDerivative(Assignment):
     state: State = attr.ib()
 
     def resolve_expression(self, symbols: dict[str, sp.Symbol]) -> Assignment:
+        if self.value is None:
+            raise exceptions.ResolveExpressionError(name=self.name)
         expr = self.value.resolve(symbols)
         return StateDerivative(
             name=self.name,

{gotranx-0.2.2 → gotranx-0.2.3}/src/gotranx/cli/cellml2ode.py

@@ -3,7 +3,7 @@ from pathlib import Path
 import logging
 import structlog
 
-from ..cellml import cellml_to_gotran
+from ..myokit import cellml_to_gotran
 
 logger = structlog.get_logger()
 
@@ -20,7 +20,7 @@ def main(
     assert fname.suffix == ".cellml", f"File {fname} must be a cellml file"
     assert fname.exists(), f"File {fname} does not exist"
     logger.info(f"Converting {fname} to gotran ode file")
-    code = cellml_to_gotran(fname)
+    ode = cellml_to_gotran(fname)
     out = fname.with_suffix(".ode") if outname is None else Path(outname)
-    out.write_text(code)
+    ode.save(out)
     logger.info(f"Wrote {out}")

gotranx-0.2.3/src/gotranx/codegen/__init__.py

@@ -0,0 +1,26 @@
+from . import base
+from . import c
+from . import python
+from . import ode
+
+from .c import CCodeGenerator, GotranCCodePrinter
+from .python import PythonCodeGenerator, GotranPythonCodePrinter
+from .base import CodeGenerator, Func, RHSArgument, SchemeArgument
+from .ode import GotranODECodePrinter, BaseGotranODECodePrinter
+
+__all__ = [
+    "base",
+    "c",
+    "CCodeGenerator",
+    "CodeGenerator",
+    "Func",
+    "RHSArgument",
+    "SchemeArgument",
+    "python",
+    "PythonCodeGenerator",
+    "GotranPythonCodePrinter",
+    "ode",
+    "GotranODECodePrinter",
+    "BaseGotranODECodePrinter",
+    "GotranCCodePrinter",
+]

{gotranx-0.2.2 → gotranx-0.2.3}/src/gotranx/codegen/base.py

@@ -87,8 +87,7 @@ def _print_Piecewise(
 
     exprs = [printer._print(arg.expr) for arg in expr.args]
     conds = [print_cond(arg.cond) for arg in expr.args]
-    assert len(exprs) == 2
-    assert len(conds) == 2
+
     return tuple(conds), tuple(exprs)
 
 

{gotranx-0.2.2 → gotranx-0.2.3}/src/gotranx/codegen/c.py

@@ -21,14 +21,27 @@ class GotranCCodePrinter(C99CodePrinter):
         return self._print(str(float(flt)))
 
     def _print_Piecewise(self, expr):
-        fst, snd = expr.args
-        if isinstance(fst[0], Assignment):
-            value = (
-                f"{super()._print(fst[0].args[0])} = "
-                f"({super()._print(fst[1])}) ? "
-                f"{super()._print(fst[0].args[1])} : "
-                f"{super()._print(snd[0].args[1])};"
-            )
+        if isinstance(expr.args[0][0], Assignment):
+            result = []
+            lhs = super()._print(expr.args[0][0].lhs)
+            result.append(f"{super()._print(lhs)} = ")
+            all_lsh_equal = True
+            for arg in expr.args:
+                result.append(f"({super()._print(arg[1])}) ? ")
+                result.append(f"{super()._print(arg[0].rhs)}")
+                result.append(" : ")
+                all_lsh_equal = all_lsh_equal and super()._print(arg[0].lhs) == lhs
+
+            assert all_lsh_equal, "All assignments in Piecewise must have the same lhs"
+
+            if super()._print(arg[1]) == "true":
+                result = result[:-3]
+                result.append(f"{super()._print(arg[0].rhs)}")
+            else:
+                raise ValueError("Last condition in Piecewise must be True")
+
+            result.append(";")
+            value = "".join(result)
         else:
             value = bool_to_int(super()._print_Piecewise(expr))
 

gotranx-0.2.2/src/gotranx/save.py → gotranx-0.2.3/src/gotranx/codegen/ode.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from pathlib import Path
 from typing import TypeVar, Callable
 from functools import reduce
-
+from sympy.printing.str import StrPrinter
 from structlog import get_logger
 
-from . import atoms
-from .ode import ODE
-from .codegen.python import PythonCodeGenerator
+from .. import atoms
+from ..ode import ODE
+from .base import _print_Piecewise
 
 T = TypeVar("T")
 logger = get_logger()
@@ -25,16 +24,74 @@ def break_comment_at_80(acc, x):
         return acc + " " + x
 
 
-class GotranODECodePrinter(PythonCodeGenerator):
+class BaseGotranODECodePrinter(StrPrinter):
+    def _print_Relational(self, expr):
+        # v = super()._print_Relational(expr)
+        lhs = self._print(expr.lhs)
+        rhs = self._print(expr.rhs)
+
+        relop2str = {
+            "<": "Lt",
+            "<=": "Le",
+            ">": "Gt",
+            ">=": "Ge",
+            "==": "Eq",
+            "!=": "Ne",
+        }
+        relop = relop2str[expr.rel_op]
+        print(expr, f"{relop}({lhs}, {rhs})")
+        return f"{relop}({lhs}, {rhs})"
+
+    def _print_Or(self, expr):
+        return f"Or({', '.join(self._print(a) for a in expr.args)})"
+
+    def _print_And(self, expr):
+        return f"And({', '.join(self._print(a) for a in expr.args)})"
+
+    def _print_BooleanFalse(self, expr):
+        return "0"
+
+    def _print_BooleanTrue(self, expr):
+        return "1"
+
+    def _print_Piecewise(self, expr):
+        conds, exprs = _print_Piecewise(self, expr)
+
+        result = []
+
+        for c, e in zip(conds, exprs):
+            result.append("Conditional(")
+            result.append(f"{c}")
+            result.append(", ")
+            result.append(f"{e}")
+            result.append(", ")
+
+        if c == "1":
+            result = result[:-6]
+            result.append(f", {e}")
+        else:
+            raise ValueError("Last condition in Piecewise must be True")
+
+        result.append(")" * (len(conds) - 1))
+        return "".join(result)
+
+
+class GotranODECodePrinter(BaseGotranODECodePrinter):
+    def __init__(self, ode: ODE, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.ode = ode
+
     def print_comments(self) -> str:
         if len(self.ode.comments) == 0:
             return ""
-        text = "# "
+        text = ""
 
         for comment in self.ode.comments:
             text += reduce(break_comment_at_80, comment.text.split(" "))
 
-        text += "\n\n"
+        if len(text) > 0:
+            text = "# " + "\n# ".join(text.strip().split("\n"))
+            text += "\n\n"
         return text
 
     def print_states(self) -> str:
@@ -45,7 +102,7 @@ class GotranODECodePrinter(PythonCodeGenerator):
         text = ""
         for components, states in d.items():
             text += start_odeblock("states", names=components) + "\n"
-            text += ", ".join([print_ScalarParam(s, doprint=self.printer.doprint) for s in states])
+            text += ", ".join([print_ScalarParam(s, doprint=self.doprint) for s in states])
             text += "\n)\n\n"
         return text
 
@@ -57,9 +114,7 @@ class GotranODECodePrinter(PythonCodeGenerator):
         text = ""
         for components, parameters in d.items():
             text += start_odeblock("parameters", names=components) + "\n"
-            text += ",\n".join(
-                [print_ScalarParam(p, doprint=self.printer.doprint) for p in parameters]
-            )
+            text += ",\n".join([print_ScalarParam(p, doprint=self.doprint) for p in parameters])
             text += "\n)\n\n"
 
         return text
@@ -72,14 +127,11 @@ class GotranODECodePrinter(PythonCodeGenerator):
         text = ""
         for components, intermediates in d.items():
             text += start_odeblock("expressions", names=components, is_expression=True) + "\n"
-            text += "\n".join([print_assignment(i) for i in intermediates])
+            text += "\n".join([print_assignment(i, doprint=self.doprint) for i in intermediates])
             text += "\n\n"
 
         return text
 
-    def format(self, code: str) -> str:
-        return self._formatter(code)
-
 
 def start_odeblock(case: str, names: tuple[str, ...] = (), is_expression: bool = False):
     if len(names) == 0 or (len(names) == 1 and names[0] == ""):
@@ -118,21 +170,8 @@ def print_ScalarParam(p: atoms.Atom, doprint: Callable[[str], str]) -> str:
     return ret
 
 
-def print_assignment(a: atoms.Assignment) -> str:
-    s = f"{a.name} = {a.expr}"
-    if a.unit_str is not None:
+def print_assignment(a: atoms.Assignment, doprint: Callable[[str], str]) -> str:
+    s = f"{a.name} = {doprint(a.expr)}"
+    if a.unit_str is not None and a.unit_str != "1":
         s += f" # {a.unit_str}"
     return s
-
-
-def write_ODE_to_ode_file(ode: ODE, path: Path) -> None:
-    # Just make sure it is a Path object
-    printer = GotranODECodePrinter(ode)
-    path = Path(path)
-    text = ""
-    text += printer.print_comments()
-    text += printer.print_states()
-    text += printer.print_parameters()
-    text += printer.print_assignments()
-    path.write_text(text)
-    logger.info(f"Wrote {path}")

{gotranx-0.2.2 → gotranx-0.2.3}/src/gotranx/codegen/python.py

@@ -30,20 +30,49 @@ class GotranPythonCodePrinter(PythonCodePrinter):
         return self._print(str(float(flt)))
 
     def _print_Piecewise(self, expr):
-        fst, snd = expr.args
-        if isinstance(fst[0], Assignment):
-            value = (
-                f"{super()._print(fst[0].lhs)} = "
-                f"numpy.where({super()._print(fst[1])}, "
-                f"{super()._print(fst[0].rhs)}, "
-                f"{super()._print(snd[0].rhs)})"
-            )
+        result = []
+
+        if isinstance(expr.args[0][0], Assignment):
+            lhs = super()._print(expr.args[0][0].lhs)
+            result.append(f"{super()._print(lhs)} = ")
+            all_lsh_equal = True
+            for arg in expr.args:
+                result.append("numpy.where(")
+                result.append(f"{super()._print(arg[1])}")
+                result.append(", ")
+                result.append(f"{super()._print(arg[0].rhs)}")
+                result.append(", ")
+                all_lsh_equal = all_lsh_equal and super()._print(arg[0].lhs) == lhs
+
+            assert all_lsh_equal, "All assignments in Piecewise must have the same lhs"
+
+            if super()._print(arg[1]) == "True":
+                result = result[:-6]
+                result.append(f", {super()._print(arg[0].rhs)}")
+            else:
+                raise ValueError("Last condition in Piecewise must be True")
+
+            result.append(")" * (len(expr.args) - 1))
 
         else:
             conds, exprs = _print_Piecewise(self, expr)
-            value = f"numpy.where({conds[0]}, {exprs[0]}, {exprs[1]})"
 
-        return value
+            for c, e in zip(conds, exprs):
+                result.append("numpy.where(")
+                result.append(f"{c}")
+                result.append(", ")
+                result.append(f"{e}")
+                result.append(", ")
+
+            if c == "True":
+                result = result[:-6]
+                result.append(f", {e}")
+            else:
+                raise ValueError("Last condition in Piecewise must be True")
+
+            result.append(")" * (len(conds) - 1))
+
+        return "".join(result)
 
     def _print_And(self, expr):
         if len(expr.args) == 2:

{gotranx-0.2.2 → gotranx-0.2.3}/src/gotranx/exceptions.py

@@ -6,17 +6,17 @@ from pathlib import Path
 import lark
 
 
-class GotranParserError(Exception):
+class GotranxError(Exception):
     pass
 
 
 @dataclass
-class ODEFileNotFound(GotranParserError):
+class ODEFileNotFound(GotranxError):
     fname: Path
 
 
 @dataclass
-class StateNotFoundInComponent(GotranParserError):
+class StateNotFoundInComponent(GotranxError):
     state_name: str
     component_name: str
 
@@ -28,7 +28,7 @@ class StateNotFoundInComponent(GotranParserError):
 
 
 @dataclass
-class ParameterNotFoundInComponent(GotranParserError):
+class ParameterNotFoundInComponent(GotranxError):
     parameter_name: str
     component_name: str
 
@@ -40,7 +40,7 @@ class ParameterNotFoundInComponent(GotranParserError):
 
 
 @dataclass
-class ComponentNotCompleteError(GotranParserError):
+class ComponentNotCompleteError(GotranxError):
     component_name: str
     missing_state_derivatives: list[str]
 
@@ -52,7 +52,7 @@ class ComponentNotCompleteError(GotranParserError):
 
 
 @dataclass
-class DuplicateSymbolError(GotranParserError):
+class DuplicateSymbolError(GotranxError):
     duplicates: set[str]
 
     def __str__(self) -> str:
@@ -64,7 +64,7 @@ class DuplicateSymbolError(GotranParserError):
 
 
 @dataclass
-class UnknownTreeTypeError(GotranParserError):
+class UnknownTreeTypeError(GotranxError):
     datatype: str
     atom: str
 
@@ -73,7 +73,7 @@ class UnknownTreeTypeError(GotranParserError):
 
 
 @dataclass
-class InvalidTreeError(GotranParserError):
+class InvalidTreeError(GotranxError):
     tree: lark.Tree
 
     def __str__(self) -> str:
@@ -81,9 +81,17 @@ class InvalidTreeError(GotranParserError):
 
 
 @dataclass
-class MissingSymbolError(GotranParserError, KeyError):
+class MissingSymbolError(GotranxError, KeyError):
     symbol: str
     line_no: int
 
     def __str__(self) -> str:
         return f"Symbol {self.symbol!r} not found in line {self.line_no}"
+
+
+@dataclass
+class ResolveExpressionError(GotranxError, ValueError):
+    name: str
+
+    def __str__(self) -> str:
+        return f"Unable to resolve expression for {self.name!r}"

{gotranx-0.2.2 → gotranx-0.2.3}/src/gotranx/expressions.py

@@ -139,7 +139,7 @@ def build_expression(
                 # Only exceptions is 'abs' which is 'Abs'
                 funcname = "Abs"
 
-            return getattr(sp, funcname)(expr2symbols(tree.children[1]))
+            return getattr(sp, funcname)(*[expr2symbols(c) for c in tree.children[1:]])
 
         if tree.data == "logicalfunc":
             if tree.children[0] == "Conditional":