gotranx 2.3.0__tar.gz → 2.5.0__tar.gz

{gotranx-2.3.0/src/gotranx.egg-info → gotranx-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gotranx
-Version: 2.3.0
+Version: 2.5.0
 Summary: A declarative language describing ordinary differential equations
 Author-email: Henrik Finsberg <henriknf@simula.no>
 License: MIT
@@ -12,6 +12,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: attrs
+Requires-Dist: black
 Requires-Dist: lark
 Requires-Dist: pint
 Requires-Dist: rich-click

{gotranx-2.3.0 → gotranx-2.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gotranx"
-version = "2.3.0"
+version = "2.5.0"
 description = "A declarative language describing ordinary differential equations"
 authors = [{name = "Henrik Finsberg", email = "henriknf@simula.no"}]
 license = {text = "MIT"}
@@ -17,6 +17,7 @@ urls = {Homepage = "https://github.com/finsberg/gotranx"}
 requires-python = ">=3.9"
 dependencies = [
     "attrs",
+    "black",
     "lark",
     "pint",
     "rich-click",
@@ -97,7 +98,8 @@ test = "pytest"
 testpaths = ["tests"]
 markers = [
     "benchmark: mark a test as a benchmark.",
-    "example: mark a test as an example."
+    "example: mark a test as an example.",
+    "julia: mark a test that runs generated code in Julia."
 ]
 
 
@@ -172,7 +174,7 @@ tag = true
 sign_tags = false
 tag_name = "v{new_version}"
 tag_message = "Bump version: {current_version} → {new_version}"
-current_version = "2.3.0"
+current_version = "2.5.0"
 
 
 [[tool.bumpversion.files]]

{gotranx-2.3.0 → gotranx-2.5.0}/src/gotranx/cli/__init__.py

@@ -669,6 +669,18 @@ def ode2cytozoo(
         None, "--model-name", help="Julia struct name (default: the ODE name in PascalCase)"
     ),
     v_name: str = typer.Option("v", "--v-name", help="State holding the transmembrane potential"),
+    remove_component: typing.Optional[typing.List[str]] = typer.Option(
+        None,
+        "--remove-component",
+        help="Generate the model without this component (repeatable). What the rest "
+        "reads from it becomes an input: a trailing writable parameter, NaN until set",
+    ),
+    keep_component: typing.Optional[str] = typer.Option(
+        None,
+        "--keep-component",
+        help="Generate only this component. What it reads from the other components "
+        "becomes an input: a trailing writable parameter, NaN until set",
+    ),
     remove_unused: bool = typer.Option(False, "--remove-unused", help="Remove unused variables"),
     remove_singularities: bool = typer.Option(
         True,
@@ -720,6 +732,8 @@ def ode2cytozoo(
         remove_unused=remove_unused,
         remove_singularities=remove_singularities,
         verbose=verbose,
+        remove_component=remove_component,
+        keep_component=keep_component,
     )
 
 

{gotranx-2.3.0 → gotranx-2.5.0}/src/gotranx/cli/gotran2cytozoo.py

@@ -6,6 +6,7 @@ import structlog
 from ..codegen.cytozoo import CytoZooCodeGenerator
 from ..load import load_ode
 from ..ode import ODE
+from .utils import select_components
 
 logger = structlog.get_logger()
 
@@ -87,6 +88,7 @@ def get_code(
         "import CytoZoo: num_monitors, monitor_names, monitor_values!",
         f"const NUM_STATES = {len(ode.states)};",
         f"const NUM_PARAMS = {len(ode.parameters)};",
+        *([f"const NUM_MISSING = {len(ode.missing_variables)};"] if ode.missing_variables else []),
         codegen.initial_parameter_values(),
         codegen.initial_state_values(),
         codegen.rhs(),
@@ -104,10 +106,13 @@ def main(
     remove_unused: bool = False,
     remove_singularities: bool = True,
     verbose: bool = False,
+    remove_component: list[str] | None = None,
+    keep_component: str | None = None,
 ) -> None:
     loglevel = logging.DEBUG if verbose else logging.INFO
     structlog.configure(wrapper_class=structlog.make_filtering_bound_logger(loglevel))
     ode = load_ode(fname, remove_singularities=remove_singularities)
+    ode = select_components(ode, remove=remove_component, keep=keep_component)
     code = get_code(
         ode,
         model_name=model_name,

{gotranx-2.3.0 → gotranx-2.5.0}/src/gotranx/cli/utils.py

@@ -5,6 +5,7 @@ from pathlib import Path
 import typer
 
 from ..codegen import CodeGenerator
+from ..ode import ODE
 from ..schemes import Scheme, get_scheme
 
 
@@ -29,14 +30,34 @@ def add_schemes(
     return comp
 
 
-def find_pyproject_toml_config() -> Path | None:
-    """Find the pyproject.toml file."""
-    from black.files import find_pyproject_toml
+def _toml_loads(text: str) -> dict[str, Any]:
+    try:
+        import tomllib  # Python >= 3.11
+    except ImportError:
+        import toml as tomllib  # type: ignore
 
-    path = find_pyproject_toml((str(Path.cwd()),))
-    if path is None:
-        return None
-    return Path(path)
+    return tomllib.loads(text)
+
+
+def find_pyproject_toml_config(start: Path | None = None) -> Path | None:
+    """The nearest `pyproject.toml` with a `[tool.gotranx]` table, searching from
+    `start` (by default the current directory) up to the root of the file system.
+
+    A `pyproject.toml` that cannot be parsed is returned too, so that
+    `read_config` reports it rather than skipping it silently.
+    """
+    start = Path.cwd() if start is None else start
+    for directory in (start, *start.parents):
+        path = directory / "pyproject.toml"
+        if not path.is_file():
+            continue
+        try:
+            config = _toml_loads(path.read_text())
+        except Exception:
+            return path
+        if "gotranx" in config.get("tool", {}):
+            return path
+    return None
 
 
 def read_config(path: Path | None) -> dict[str, Any]:
@@ -50,20 +71,8 @@ def read_config(path: Path | None) -> dict[str, Any]:
     if path is None:
         return {}
 
-    # Try to read the configuration file
     try:
-        # First try to use tomllib which is part of stdlib
-        import tomllib as toml
-    except ImportError:
-        # If tomllib is not available, try to use toml
-        try:
-            import toml  # type: ignore
-        except ImportError:
-            typer.echo("Please install 'tomllib' or 'toml' to read configuration files")
-            return {}
-
-    try:
-        config = toml.loads(Path(path).read_text())
+        config = _toml_loads(Path(path).read_text())
     except Exception:
         typer.echo(f"Could not read configuration file {path}")
         return {}
@@ -109,3 +118,29 @@ def validate_scheme(scheme: list[Scheme] | list[str]) -> list[Scheme]:
         else:
             lst.append(s)
     return lst
+
+
+def select_components(ode: ODE, remove: list[str] | None = None, keep: str | None = None) -> ODE:
+    """The part of `ode` to generate code for: without the components in `remove`
+    (`ode - ode.get_component(name)` for each), or only the component `keep`
+    (`ode.get_component(keep).to_ode()`). Names the parts share become missing
+    variables of the result."""
+    if remove and keep is not None:
+        raise typer.BadParameter("give --remove-component or --keep-component, not both")
+    names = [c.name for c in ode.components]
+    for name in [*(remove or []), *([keep] if keep is not None else [])]:
+        if name not in names:
+            raise typer.BadParameter(
+                f"no component {name!r} in {ode.name}; it has {', '.join(names)}",
+                param_hint="--remove-component" if keep is None else "--keep-component",
+            )
+    if keep is not None:
+        return ode.get_component(keep).to_ode()
+    if not remove:
+        return ode
+    # `ode - component` is named "<ode> - <component>", which is not a valid default
+    # model name (ode2cytozoo derives the struct name from it).
+    name = f"{ode.name}_without_{'_'.join(remove)}"
+    for comp in remove:
+        ode = ode - ode.get_component(comp)
+    return ODE(components=ode.components, t=ode.t, name=name, comments=ode.comments)

{gotranx-2.3.0 → gotranx-2.5.0}/src/gotranx/codegen/base.py

@@ -106,6 +106,8 @@ class Shape(str, Enum):
 
 class CodeGenerator(abc.ABC):
     variable_prefix = ""
+    #: How a function declares its missing-variables argument (C needs a type).
+    missing_variables_argument = "missing_variables"
 
     def __init__(
         self,
@@ -321,7 +323,7 @@ class CodeGenerator(abc.ABC):
 
         arguments = rhs.arguments
         if self._missing_variables:
-            arguments += ["missing_variables"]
+            arguments += [self.missing_variables_argument]
 
         values_lst = []
         index = 0
@@ -383,7 +385,7 @@ class CodeGenerator(abc.ABC):
 
         arguments = rhs.arguments
         if self._missing_variables:
-            arguments += ["missing_variables"]
+            arguments += [self.missing_variables_argument]
 
         values_lst = []
         index = 0
@@ -429,7 +431,7 @@ class CodeGenerator(abc.ABC):
 
         arguments = rhs.arguments
         if self._missing_variables:
-            arguments += ["missing_variables"]
+            arguments += [self.missing_variables_argument]
 
         values_lst = []
         N = len(values)
@@ -495,7 +497,7 @@ class CodeGenerator(abc.ABC):
 
         arguments = rhs.arguments
         if self._missing_variables:
-            arguments += ["missing_variables"]
+            arguments += [self.missing_variables_argument]
 
         dt = sympy.Symbol("dt")
         eqs = f(

{gotranx-2.3.0 → gotranx-2.5.0}/src/gotranx/codegen/c.py

@@ -81,6 +81,7 @@ class GotranCCodePrinter(C99CodePrinter):
 
 class CCodeGenerator(CodeGenerator):
     variable_prefix = "const double "
+    missing_variables_argument = "const double *__restrict missing_variables"
 
     def __init__(
         self, ode: ODE, format: Format = Format.clang_format, remove_unused: bool = False

{gotranx-2.3.0 → gotranx-2.5.0}/src/gotranx/codegen/cytozoo.py

@@ -68,7 +68,10 @@ class CytoZooCodeGenerator(JuliaCodeGenerator):
         return [s.name for s in self.ode.sorted_states()]
 
     def _parameter_name_list(self) -> list[str]:
-        return [p.name for p in self.ode.parameters]
+        # The missing variables follow the parameters, in missing_index order, because
+        # the adapter stores them in the parameter vector (templates.cytozoo.model_struct).
+        missing = sorted(self._missing_variables, key=self._missing_variables.__getitem__)
+        return [p.name for p in self.ode.parameters] + missing
 
     def _monitor_name_list(self) -> list[str]:
         # Mirror codegen.base.CodeGenerator.monitor_index (base.py:186) exactly:
@@ -142,18 +145,38 @@ class CytoZooCodeGenerator(JuliaCodeGenerator):
             )
         return "\n".join(lines)
 
+    def _missing_variables_assignments(self) -> str:
+        """Every missing-variable local, converted to the state's element type.
+
+        The missing variables are trailing entries of the parameter vector (see
+        `templates.cytozoo.model_struct`), so they are converted like the parameters:
+        a model built in Float64 and evaluated on Float32 states would otherwise
+        compute every term that reads one in Float64.
+        """
+        if not self._missing_variables:
+            return ""
+        lines = [
+            f"{name} = TYPE(missing_variables[{index + 1}])"
+            for name, index in self._missing_variables.items()
+        ]
+        return "\n".join(["", self._comment("Assign missing variables"), *lines, ""])
+
     def adapter(self) -> str:
         """The struct, name tuples, index lookups and interface methods."""
         name = self._model_name
         monitors = self._monitor_name_list()
         parts = [
-            templates.cytozoo.model_struct(name, len(self.ode.parameters)),
+            templates.cytozoo.model_struct(
+                name, len(self.ode.parameters), len(self._missing_variables)
+            ),
             templates.cytozoo.name_tuples(
                 name, self._state_name_list(), self._parameter_name_list(), monitors
             ),
             templates.cytozoo.index_lookups(
                 name, self._state_name_list(), self._parameter_name_list()
             ),
-            templates.cytozoo.interface_methods(name, self._potential_index(), len(monitors)),
+            templates.cytozoo.interface_methods(
+                name, self._potential_index(), len(monitors), len(self._missing_variables)
+            ),
         ]
         return self._format("\n".join(parts))

{gotranx-2.3.0 → gotranx-2.5.0}/src/gotranx/codegen/python.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+import functools
 import typing
 from enum import Enum
 from sympy.printing.pycode import PythonCodePrinter
@@ -46,6 +47,15 @@ class GotranPythonCodePrinter(PythonCodePrinter):
     def _print_Float(self, flt):
         return self._print(str(float(flt)))
 
+    def _print_Min(self, expr):
+        # numpy.min(a, b) would read b as an axis; numpy.minimum takes two arrays
+        args = [self._print(arg) for arg in expr.args]
+        return functools.reduce(lambda x, y: f"numpy.minimum({x}, {y})", args)
+
+    def _print_Max(self, expr):
+        args = [self._print(arg) for arg in expr.args]
+        return functools.reduce(lambda x, y: f"numpy.maximum({x}, {y})", args)
+
     def _print_Piecewise(self, expr):
         result = []
 

{gotranx-2.3.0 → gotranx-2.5.0}/src/gotranx/myokit.py

@@ -1,20 +1,17 @@
 from __future__ import annotations
 from collections import defaultdict
+import functools
 import re
 import warnings
 from pathlib import Path
-from typing import overload
+from types import ModuleType
+from typing import TYPE_CHECKING, overload
 from collections.abc import Sequence
 
 import sympy as sp
 
-try:
+if TYPE_CHECKING:
     import myokit
-    import myokit.formats.sympy
-    import myokit.lib.guess
-    import myokit.formats.cellml
-except ImportError:
-    myokit = None
 
 from . import atoms
 from .ode_component import BaseComponent, MyokitComponent
@@ -24,9 +21,24 @@ from .exceptions import GotranxImportError
 reserved_names = {name for name in dir(sp) if not name.startswith("_")}
 
 
+def _import_myokit() -> ModuleType:
+    """myokit, with the submodules used here, imported by the functions that need it.
+
+    Importing myokit imports numpy and lxml, which only reading and writing CellML
+    and `.mmt` files needs, so `import gotranx` leaves it alone.
+    """
+    try:
+        import myokit
+        import myokit.formats.cellml
+        import myokit.formats.sympy
+        import myokit.lib.guess
+    except ImportError as e:
+        raise GotranxImportError("myokit") from e
+    return myokit
+
+
 def assert_has_myokit():
-    if myokit is None:
-        raise GotranxImportError("myokit")
+    _import_myokit()
 
 
 _INVALID_NAME_CHARS = re.compile(r"\W+")
@@ -223,7 +235,7 @@ def mmt_to_gotran(filename: str | Path) -> ODE:
     gotranx.ode.ODE
         The gotran ODE
     """
-    assert_has_myokit()
+    myokit = _import_myokit()
     model, protocol, _ = myokit.load(filename)
 
     return myokit_to_gotran(model, protocol=protocol)
@@ -244,7 +256,7 @@ def myokit_to_gotran(model: "myokit.Model", protocol=None) -> ODE:
     gotranx.ode.ODE
         The gotran ODE
     """
-    assert_has_myokit()
+    myokit = _import_myokit()
     # Embed protocol
     if protocol is not None:
         model = model.clone()
@@ -346,6 +358,47 @@ def myokit_to_gotran(model: "myokit.Model", protocol=None) -> ODE:
     )
 
 
+def _sympy_reader(model: "myokit.Model") -> "myokit.formats.sympy.SymPyExpressionReader":
+    """myokit's sympy expression reader, extended to read ``Min``, ``Max`` and n-ary
+    ``And``/``Or``.
+
+    myokit has no min or max, and its ``And`` and ``Or`` take exactly two operands where sympy's
+    take any number. Rewriting ``Min``/``Max`` as sympy ``Piecewise`` first does not work: a
+    ``Piecewise`` nested in a condition, as in the clamp ``Min(Max(x, 0), 1)``, becomes an ``ITE``,
+    which the reader cannot read either, and four or more arguments produce an n-ary ``And``. So
+    each ``Min``/``Max`` is read into nested myokit ``If`` expressions, and ``And``/``Or`` are
+    folded into nested binary ones.
+    """
+    _import_myokit()
+    # An import statement rather than `myokit = _import_myokit()`, so that mypy can
+    # resolve the base class below.
+    import myokit.formats.sympy
+
+    class Reader(myokit.formats.sympy.SymPyExpressionReader):
+        def _build_op_map(self):
+            op_map = super()._build_op_map()
+            op_map[sp.Min] = self._ex_min
+            op_map[sp.Max] = self._ex_max
+            return op_map
+
+        def _fold(self, e, combine):
+            return functools.reduce(combine, [self.ex(arg) for arg in e.args])
+
+        def _ex_min(self, e):
+            return self._fold(e, lambda a, b: myokit.If(myokit.LessEqual(a, b), a, b))
+
+        def _ex_max(self, e):
+            return self._fold(e, lambda a, b: myokit.If(myokit.MoreEqual(a, b), a, b))
+
+        def _ex_and(self, e):
+            return self._fold(e, myokit.And)
+
+        def _ex_or(self, e):
+            return self._fold(e, myokit.Or)
+
+    return Reader(model=model)
+
+
 def gotran_to_myokit(ode: ODE, time_component="engine", time_unit="s") -> "myokit.Model":
     """Convert a gotran ODE to myokit model
 
@@ -359,7 +412,7 @@ def gotran_to_myokit(ode: ODE, time_component="engine", time_unit="s") -> "myoki
     myokit.Model
         The myokit model
     """
-    assert_has_myokit()
+    myokit = _import_myokit()
     model = myokit.Model(ode.name)
     model.meta["author"] = "GotranX API"
     comp = model.add_component(time_component)
@@ -420,7 +473,7 @@ def gotran_to_myokit(ode: ODE, time_component="engine", time_unit="s") -> "myoki
             var.set_unit(to_myokit_unit(intermediate.unit_str))
             global_var_map[intermediate.symbol] = sp.Symbol(var.qname())
 
-    sympy_reader = myokit.formats.sympy.SymPyExpressionReader(model=model)
+    sympy_reader = _sympy_reader(model)
     # Then we can add expressions
     for component in ode.components:
         comp = model[component_name_map[component.name]]
@@ -468,7 +521,7 @@ def cellml_to_gotran(filename: str | Path) -> ODE:
     gotranx.ode.ODE
         The gotran ODE
     """
-    assert_has_myokit()
+    myokit = _import_myokit()
     myokit_model = myokit.formats.cellml.CellMLImporter().model(filename)
     return myokit_to_gotran(myokit_model)
 
@@ -483,6 +536,6 @@ def gotran_to_cellml(ode: ODE, filename: str | Path) -> None:
     filename : str | Path
         The filename of the cellml file
     """
-    assert_has_myokit()
+    myokit = _import_myokit()
     model = gotran_to_myokit(ode)
     myokit.formats.cellml.CellMLExporter().model(filename, model, version="1.0")

{gotranx-2.3.0 → gotranx-2.5.0}/src/gotranx/ode.lark

@@ -55,6 +55,8 @@ variable: VARIABLE
     | ABSL
     | FLOOR
     | MOD
+    | MIN
+    | MAX
 
 ?logicalfunc: logicalfuncname "(" expression ("," expression)* (",")?  ")"
 ?logicalfuncname: CONTINUOUSCONDITIONAL
@@ -93,6 +95,8 @@ OR: "Or"
 EQ: "Eq"
 NOT: "Not"
 MOD: "Mod"
+MIN: "Min"
+MAX: "Max"
 
 
 PI: "pi"

{gotranx-2.3.0 → gotranx-2.5.0}/src/gotranx/singularities.py

@@ -300,7 +300,7 @@ def _depending_on(
     """Cached front for :func:`_compute_depending_on`.
 
     Called once per (assignment, variable) pair against the same model, so
-    recomputing the fixed point every time dominated the scan. The cache holds
+    recomputing the dependents every time dominated the scan. The cache holds
     only the most recent ``definitions`` object and compares by identity, so it
     can never serve a stale answer for a different model.
     """
@@ -313,25 +313,47 @@ def _depending_on(
     return set(by_seeds[key])
 
 
+_USERS_CACHE: list = []
+
+
+def _users(
+    definitions: Mapping[sympy.Symbol, sympy.Expr],
+) -> dict[sympy.Symbol, list[sympy.Symbol]]:
+    """Every symbol mapped to the symbols whose definitions use it.
+
+    The reverse of ``definitions``' dependency graph. Built once per
+    ``definitions`` object and cached by identity, as :func:`_depending_on`
+    caches its answers, since a model asks for the dependents of every state.
+    """
+    if not _USERS_CACHE or _USERS_CACHE[0] is not definitions:
+        users: dict[sympy.Symbol, list[sympy.Symbol]] = {}
+        for symbol, definition in definitions.items():
+            for used in definition.free_symbols:
+                users.setdefault(used, []).append(symbol)
+        _USERS_CACHE[:] = [definitions, users]
+    return _USERS_CACHE[1]
+
+
 def _compute_depending_on(
     definitions: Mapping[sympy.Symbol, sympy.Expr],
     seeds: set[sympy.Symbol],
 ) -> set[sympy.Symbol]:
     """Symbols in ``definitions`` that transitively depend on any of ``seeds``.
 
-    ``definitions`` is not guaranteed to be topologically sorted, so this
-    iterates to a fixed point rather than assuming one pass suffices.
+    Walks the reverse dependency graph (:func:`_users`) out from the seeds, so
+    the cost is linear in the graph whatever order ``definitions`` is in. A
+    fixed-point sweep over ``definitions``, which is not guaranteed to be
+    topologically sorted, cost a pass per level of dependency for every set of
+    seeds, which made the scan quadratic in the size of a model.
     """
+    users = _users(definitions)
     dependent: set[sympy.Symbol] = set()
-    changed = True
-    while changed:
-        changed = False
-        for symbol, definition in definitions.items():
-            if symbol in dependent:
-                continue
-            if (definition.free_symbols & seeds) or (definition.free_symbols & dependent):
-                dependent.add(symbol)
-                changed = True
+    stack = list(seeds)
+    while stack:
+        for user in users.get(stack.pop(), ()):
+            if user not in dependent:
+                dependent.add(user)
+                stack.append(user)
     return dependent
 
 
@@ -441,7 +463,15 @@ def _numeric(expr: sympy.Expr, defaults: Mapping[sympy.Symbol, float]) -> float
     None means "not usable as a guard location or as a check point": complex,
     infinite, NaN, or still carrying a free symbol ``defaults`` does not cover.
     """
-    substituted = expr.xreplace({symbol: sympy.Float(x) for symbol, x in defaults.items()})
+    # Only the expression's own symbols: converting every default in the model
+    # on every call made evaluating all of a model's defaults quadratic.
+    substituted = expr.xreplace(
+        {
+            symbol: sympy.Float(defaults[symbol])
+            for symbol in expr.free_symbols
+            if symbol in defaults
+        }
+    )
     try:
         value = complex(substituted.evalf())
     except (TypeError, ValueError, AttributeError):
@@ -1081,7 +1111,7 @@ def default_values(
     """
     values = dict(base)
     for symbol, definition in definitions.items():
-        if not definition.free_symbols <= set(values):
+        if not definition.free_symbols <= values.keys():
             continue
         try:
             value = _numeric(definition, values)

{gotranx-2.3.0 → gotranx-2.5.0}/src/gotranx/templates/c.py

@@ -45,11 +45,13 @@ def method(
     values: str,
     return_name: None = None,
     num_return_values: int = 0,
+    missing_variables: str = "",
     **kwargs,
 ):
     indent_states = indent(states, "    ")
     indent_parameters = indent(parameters, "    ")
     indent_values = indent(values, "    ")
+    indent_missing_variables = indent(missing_variables, "    ")
     return dedent(
         f"""
 void {name}({args}){{
@@ -59,7 +61,7 @@ void {name}({args}){{
 
     // Assign parameters
 {indent_parameters}
-
+{indent_missing_variables}
     // Assign expressions
 {indent_values}
 }}
@@ -102,4 +104,4 @@ def monitor_index(data: dict[str, int]) -> str:
 
 
 def missing_index(data: dict[str, int]) -> str:
-    return method_index(data, "monitor")
+    return method_index(data, "missing")