gotranx 2.4.0__tar.gz → 2.6.0__tar.gz

{gotranx-2.4.0/src/gotranx.egg-info → gotranx-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gotranx
-Version: 2.4.0
+Version: 2.6.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.4.0 → gotranx-2.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gotranx"
-version = "2.4.0"
+version = "2.6.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.4.0"
+current_version = "2.6.0"
 
 
 [[tool.bumpversion.files]]

{gotranx-2.4.0 → gotranx-2.6.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.4.0 → gotranx-2.6.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.4.0 → gotranx-2.6.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.4.0 → gotranx-2.6.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.4.0 → gotranx-2.6.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.4.0 → gotranx-2.6.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.4.0 → gotranx-2.6.0}/src/gotranx/myokit.py

@@ -4,18 +4,14 @@ 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
@@ -25,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+")
@@ -224,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)
@@ -245,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()
@@ -358,6 +369,10 @@ def _sympy_reader(model: "myokit.Model") -> "myokit.formats.sympy.SymPyExpressio
     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):
@@ -397,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)
@@ -506,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)
 
@@ -521,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")