mxlpy 0.20.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

mxlpy/parallel.py

@@ -103,7 +103,7 @@ def parallelise[K: Hashable, Tin, Tout](
     timeout: float | None = None,
     disable_tqdm: bool = False,
     tqdm_desc: str | None = None,
-) -> dict[Tin, Tout]:
+) -> list[tuple[K, Tout]]:
     """Execute a function in parallel over a collection of inputs.
 
     Examples:
@@ -136,9 +136,9 @@ def parallelise[K: Hashable, Tin, Tout](
         cache=cache,
     )  # type: ignore
 
-    results: dict[Tin, Tout]
+    results: list[tuple[K, Tout]]
     if parallel:
-        results = {}
+        results = []
         max_workers = (
             multiprocessing.cpu_count() if max_workers is None else max_workers
         )
@@ -157,18 +157,19 @@ def parallelise[K: Hashable, Tin, Tout](
                 try:
                     key, value = next(it)
                     pbar.update(1)
-                    results[key] = value
+                    results.append((key, value))
                 except StopIteration:
                     break
                 except TimeoutError:
                     pbar.update(1)
     else:
-        results = dict(
+        results = list(
             tqdm(
                 map(worker, inputs),  # type: ignore
                 total=len(inputs),
                 disable=disable_tqdm,
                 desc=tqdm_desc,
-            )  # type: ignore
+            )
         )  # type: ignore
+
     return results

mxlpy/report.py

@@ -3,25 +3,25 @@
 from __future__ import annotations
 
 from collections.abc import Callable
+from dataclasses import dataclass
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import cast
 
 import sympy
 
-from mxlpy.meta.source_tools import fn_to_sympy
+from mxlpy.meta.sympy_tools import fn_to_sympy, list_of_symbols
 from mxlpy.model import Model
 
-__all__ = [
-    "AnalysisFn",
-    "markdown",
-]
+__all__ = ["AnalysisFn", "MarkdownReport", "markdown"]
 
 type AnalysisFn = Callable[[Model, Model, Path], tuple[str, Path]]
 
 
-def _list_of_symbols(args: list[str]) -> list[sympy.Symbol | sympy.Expr]:
-    return [sympy.Symbol(arg) for arg in args]
+def _latex_view(expr: sympy.Expr | None) -> str:
+    if expr is None:
+        return "<span style='color:red'>PARSE ERROR<span>"
+    return f"${sympy.latex(expr)}$"
 
 
 def _new_removed_changed[T](
@@ -44,48 +44,71 @@ def _table_header(items: list[str]) -> str:
     return f"{_table_row(items)}\n{_table_row(['---'] * len(items))}"
 
 
+@dataclass
+class MarkdownReport:
+    """Report of model comparison."""
+
+    data: str
+
+    def __str__(self) -> str:
+        """Markdown string representation."""
+        return self.data
+
+    def __repr__(self) -> str:
+        """Markdown string representation."""
+        return self.data
+
+    def _repr_markdown_(self) -> str:
+        return self.data
+
+    def write(self, path: Path) -> None:
+        """Write report to file."""
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        with path.open("w+") as fp:
+            fp.write(self.data)
+
+
 def markdown(
     m1: Model,
     m2: Model,
+    *,
     analyses: list[AnalysisFn] | None = None,
     rel_change: float = 1e-2,
     img_path: Path = Path(),
-) -> str:
+    m1_name: str = "model 1",
+    m2_name: str = "model 2",
+    include_rhs: bool = True,
+) -> MarkdownReport:
     """Generate a markdown report comparing two models.
 
-    Parameters
-    ----------
-    m1
-        The first model to compare
-    m2
-        The second model to compare
-    analyses
-        A list of functions that analyze both models and return a report section with image
-    rel_change
-        The relative change threshold for numerical differences
-    img_path
-        The path to save images
-
-    Returns
-    -------
-    str
-        Markdown formatted report comparing the two models
-
-    Examples
-    --------
-    >>> from mxlpy import Model
-    >>> m1 = Model().add_parameter("k1", 0.1).add_variable("S", 1.0)
-    >>> m2 = Model().add_parameter("k1", 0.2).add_variable("S", 1.0)
-    >>> report = markdown(m1, m2)
-    >>> "Parameters" in report and "k1" in report
-    True
-
-    >>> # With custom analysis function
-    >>> def custom_analysis(m1, m2, path):
-    ...     return "## Custom analysis", path / "image.png"
-    >>> report = markdown(m1, m2, analyses=[custom_analysis])
-    >>> "Custom analysis" in report
-    True
+    Args:
+        m1: The first model to compare
+        m2: The second model to compare
+        analyses: A list of functions that analyze both models and return a report section with image
+        rel_change: The relative change threshold for numerical differences
+        img_path: The path to save images
+        m1_name: Name of the first model
+        m2_name: Name of the second model
+        include_rhs: Whether to include numerical differences in the right hand side
+
+    Returns:
+        str: Markdown formatted report comparing the two models
+
+    Examples:
+        >>> from mxlpy import Model
+        >>> m1 = Model().add_parameter("k1", 0.1).add_variable("S", 1.0)
+        >>> m2 = Model().add_parameter("k1", 0.2).add_variable("S", 1.0)
+        >>> report = markdown(m1, m2)
+        >>> "Parameters" in report and "k1" in report
+        True
+
+        >>> # With custom analysis function
+        >>> def custom_analysis(m1, m2, path):
+        ...     return "## Custom analysis", path / "image.png"
+        >>> report = markdown(m1, m2, analyses=[custom_analysis])
+        >>> "Custom analysis" in report
+        True
 
     """
     content: list[str] = [
@@ -101,20 +124,20 @@ def markdown(
     # Model stats
     content.extend(
         [
-            "| Model component | Old | New |",
+            f"| Model component | {m1_name} | {m2_name} |",
             "| --- | --- | --- |",
-            f"| variables | {len(m1.variables)} | {len(m2.variables)}|",
-            f"| parameters | {len(m1.parameters)} | {len(m2.parameters)}|",
-            f"| derived parameters | {len(m1.derived_parameters)} | {len(m2.derived_parameters)}|",
-            f"| derived variables | {len(m1.derived_variables)} | {len(m2.derived_variables)}|",
-            f"| reactions | {len(m1.reactions)} | {len(m2.reactions)}|",
+            f"| variables | {len(m1.get_raw_parameters())} | {len(m2.get_raw_parameters())}|",
+            f"| parameters | {len(m1.get_parameter_values())} | {len(m2.get_parameter_values())}|",
+            f"| derived parameters | {len(m1.get_derived_parameters())} | {len(m2.get_derived_parameters())}|",
+            f"| derived variables | {len(m1.get_derived_variables())} | {len(m2.get_derived_variables())}|",
+            f"| reactions | {len(m1.get_raw_reactions())} | {len(m2.get_raw_reactions())}|",
             f"| surrogates | {len(m1._surrogates)} | {len(m2._surrogates)}|",  # noqa: SLF001
         ]
     )
 
     # Variables
     new_variables, removed_variables, changed_variables = _new_removed_changed(
-        m1.variables, m2.variables
+        m1.get_initial_conditions(), m2.get_initial_conditions()
     )
     variables = []
     variables.extend(
@@ -131,8 +154,8 @@ def markdown(
     if len(variables) >= 1:
         content.extend(
             (
-                "## Variables\n\n",
-                "| Name | Old Value | New Value |",
+                "\n## Variables\n",
+                f"| Name | {m1_name} | {m2_name} |",
                 "| ---- | --------- | --------- |",
             )
         )
@@ -140,7 +163,7 @@ def markdown(
 
     # Parameters
     new_parameters, removed_parameters, changed_parameters = _new_removed_changed(
-        m1.parameters, m2.parameters
+        m1.get_parameter_values(), m2.get_parameter_values()
     )
     pars = []
     pars.extend(
@@ -157,8 +180,8 @@ def markdown(
     if len(pars) >= 1:
         content.extend(
             (
-                "## Parameters\n\n",
-                "| Name | Old Value | New Value |",
+                "\n## Parameters\n",
+                f"| Name | {m1_name} | {m2_name} |",
                 "| ---- | --------- | --------- |",
             )
         )
@@ -166,17 +189,37 @@ def markdown(
 
     # Derived
     new_derived, removed_derived, changed_derived = _new_removed_changed(
-        m1.derived, m2.derived
+        m1.get_raw_derived(),
+        m2.get_raw_derived(),
     )
     derived = []
     for k, v in new_derived.items():
-        expr = sympy.latex(fn_to_sympy(v.fn, _list_of_symbols(v.args)))
-        derived.append(f"| <span style='color:green'>{k}<span> | - | ${expr}$ |")
+        expr = _latex_view(
+            fn_to_sympy(
+                v.fn,
+                origin=k,
+                model_args=list_of_symbols(v.args),
+            )
+        )
+        derived.append(f"| <span style='color:green'>{k}<span> | - | {expr} |")
+
     for k, (v1, v2) in changed_derived.items():
-        expr1 = sympy.latex(fn_to_sympy(v1.fn, _list_of_symbols(v1.args)))
-        expr2 = sympy.latex(fn_to_sympy(v2.fn, _list_of_symbols(v2.args)))
+        expr1 = _latex_view(
+            fn_to_sympy(
+                v1.fn,
+                origin=k,
+                model_args=list_of_symbols(v1.args),
+            )
+        )
+        expr2 = _latex_view(
+            fn_to_sympy(
+                v2.fn,
+                origin=k,
+                model_args=list_of_symbols(v2.args),
+            )
+        )
         derived.append(
-            f"| <span style='color: orange'>{k}</span> | ${expr1}$ | ${expr2}$ |"
+            f"| <span style='color: orange'>{k}</span> | {expr1} | {expr2} |"
         )
     derived.extend(
         f"| <span style='color:red'>{k}</span> | - | - |" for k in removed_derived
@@ -184,8 +227,8 @@ def markdown(
     if len(derived) >= 1:
         content.extend(
             (
-                "## Derived\n\n",
-                "| Name | Old Value | New Value |",
+                "\n## Derived\n",
+                f"| Name | {m1_name} | {m2_name} |",
                 "| ---- | --------- | --------- |",
             )
         )
@@ -193,17 +236,36 @@ def markdown(
 
     # Reactions
     new_reactions, removed_reactions, changed_reactions = _new_removed_changed(
-        m1.reactions, m2.reactions
+        m1.get_raw_reactions(), m2.get_raw_reactions()
     )
     reactions = []
     for k, v in new_reactions.items():
-        expr = sympy.latex(fn_to_sympy(v.fn, _list_of_symbols(v.args)))
-        reactions.append(f"| <span style='color:green'>{k}<span> | - | ${expr}$ |")
+        expr = _latex_view(
+            fn_to_sympy(
+                v.fn,
+                origin=k,
+                model_args=list_of_symbols(v.args),
+            )
+        )
+        reactions.append(f"| <span style='color:green'>{k}<span> | - | {expr} |")
+
     for k, (v1, v2) in changed_reactions.items():
-        expr1 = sympy.latex(fn_to_sympy(v1.fn, _list_of_symbols(v1.args)))
-        expr2 = sympy.latex(fn_to_sympy(v2.fn, _list_of_symbols(v2.args)))
+        expr1 = _latex_view(
+            fn_to_sympy(
+                v1.fn,
+                origin=k,
+                model_args=list_of_symbols(v1.args),
+            )
+        )
+        expr2 = _latex_view(
+            fn_to_sympy(
+                v2.fn,
+                origin=k,
+                model_args=list_of_symbols(v2.args),
+            )
+        )
         reactions.append(
-            f"| <span style='color: orange'>{k}</span> | ${expr1}$ | ${expr2}$ |"
+            f"| <span style='color: orange'>{k}</span> | {expr1} | {expr2} |"
         )
     reactions.extend(
         f"| <span style='color:red'>{k}</span> | - | - |" for k in removed_reactions
@@ -212,8 +274,8 @@ def markdown(
     if len(reactions) >= 1:
         content.extend(
             (
-                "## Reactions\n\n",
-                "| Name | Old Value | New Value |",
+                "\n## Reactions\n",
+                f"| Name | {m1_name} | {m2_name} |",
                 "| ---- | --------- | --------- |",
             )
         )
@@ -221,8 +283,8 @@ def markdown(
 
     # Now check for any numerical differences
     dependent = []
-    d1 = m1.get_dependent()
-    d2 = m2.get_dependent()
+    d1 = m1.get_args()
+    d2 = m2.get_args()
     rel_diff = ((d1 - d2) / d1).dropna()
     for k, v in rel_diff.loc[rel_diff.abs() >= rel_change].items():
         k = cast(str, k)
@@ -233,30 +295,31 @@ def markdown(
         content.extend(
             (
                 "## Numerical differences of dependent values\n\n",
-                "| Name | Old Value | New Value | Relative Change | ",
+                f"| Name | {m1_name} | {m2_name} | Relative Change | ",
                 "| ---- | --------- | --------- | --------------- | ",
             )
         )
         content.append("\n".join(dependent))
 
-    rhs = []
-    r1 = m1.get_right_hand_side()
-    r2 = m2.get_right_hand_side()
-    rel_diff = ((r1 - r2) / r1).dropna()
-    for k, v in rel_diff.loc[rel_diff.abs() >= rel_change].items():
-        k = cast(str, k)
-        rhs.append(
-            f"| <span style='color:orange'>{k}</span> | {r1[k]:.2f} | {r2[k]:.2f} |  {v:.1%} |"
-        )
-    if len(rhs) >= 1:
-        content.extend(
-            (
-                "## Numerical differences of right hand side values\n\n",
-                "| Name | Old Value | New Value | Relative Change | ",
-                "| ---- | --------- | --------- | --------------- | ",
+    if include_rhs:
+        rhs = []
+        r1 = m1.get_right_hand_side()
+        r2 = m2.get_right_hand_side()
+        rel_diff = ((r1 - r2) / r1).dropna()
+        for k, v in rel_diff.loc[rel_diff.abs() >= rel_change].items():
+            k = cast(str, k)
+            rhs.append(
+                f"| <span style='color:orange'>{k}</span> | {r1[k]:.2f} | {r2[k]:.2f} |  {v:.1%} |"
             )
-        )
-        content.append("\n".join(rhs))
+        if len(rhs) >= 1:
+            content.extend(
+                (
+                    "\n## Numerical differences of right hand side values\n",
+                    f"| Name | {m1_name} | {m2_name} | Relative Change | ",
+                    "| ---- | --------- | --------- | --------------- | ",
+                )
+            )
+            content.append("\n".join(rhs))
 
     # Comparison functions
     if analyses is not None:
@@ -266,4 +329,4 @@ def markdown(
             # content.append(f"![{name}]({img_path})")
             content.append(f"<img src='{img_path}' alt='{name}' width='500'/>")
 
-    return "\n".join(content)
+    return MarkdownReport(data="\n".join(content))

mxlpy/sbml/_export.py

@@ -440,30 +440,32 @@ def _create_sbml_variables(
         sbml_model : libsbml.Model
 
     """
-    for name, value in model.variables.items():
+    for name, variable in model.get_raw_variables().items():
         cpd = sbml_model.createSpecies()
         cpd.setId(_convert_id_to_sbml(id_=name, prefix="CPD"))
 
         cpd.setConstant(False)
         cpd.setBoundaryCondition(False)
         cpd.setHasOnlySubstanceUnits(False)
-        if isinstance(value, Derived):
+        # cpd.setUnit() # FIXME: implement
+        if isinstance((init := variable.initial_value), Derived):
             ar = sbml_model.createInitialAssignment()
             ar.setId(_convert_id_to_sbml(id_=name, prefix="IA"))
             ar.setName(_convert_id_to_sbml(id_=name, prefix="IA"))
             ar.setVariable(_convert_id_to_sbml(id_=name, prefix="IA"))
-            ar.setMath(_sbmlify_fn(value.fn, value.args))
+            ar.setMath(_sbmlify_fn(init.fn, init.args))
         else:
-            cpd.setInitialAmount(float(value))
+            cpd.setInitialAmount(float(init))
 
 
 def _create_sbml_derived_variables(*, model: Model, sbml_model: libsbml.Model) -> None:
-    for name, dv in model.derived_variables.items():
+    for name, dv in model.get_derived_variables().items():
         sbml_ar = sbml_model.createAssignmentRule()
         sbml_ar.setId(_convert_id_to_sbml(id_=name, prefix="AR"))
         sbml_ar.setName(_convert_id_to_sbml(id_=name, prefix="AR"))
         sbml_ar.setVariable(_convert_id_to_sbml(id_=name, prefix="AR"))
         sbml_ar.setMath(_sbmlify_fn(dv.fn, dv.args))
+        # cpd.setUnit() # FIXME: implement
 
 
 def _create_derived_parameter(
@@ -477,6 +479,7 @@ def _create_derived_parameter(
     ar.setName(_convert_id_to_sbml(id_=name, prefix="AR"))
     ar.setVariable(_convert_id_to_sbml(id_=name, prefix="AR"))
     ar.setMath(_sbmlify_fn(dp.fn, dp.args))
+    # cpd.setUnit() # FIXME: implement
 
 
 def _create_sbml_parameters(
@@ -491,7 +494,7 @@ def _create_sbml_parameters(
         sbml_model : libsbml.Model
 
     """
-    for parameter_id, value in model.parameters.items():
+    for parameter_id, value in model.get_parameter_values().items():
         k = sbml_model.createParameter()
         k.setId(_convert_id_to_sbml(id_=parameter_id, prefix="PAR"))
         k.setConstant(True)
@@ -499,7 +502,7 @@ def _create_sbml_parameters(
 
 
 def _create_sbml_derived_parameters(*, model: Model, sbml_model: libsbml.Model) -> None:
-    for name, dp in model.derived_parameters.items():
+    for name, dp in model.get_derived_parameters().items():
         _create_derived_parameter(sbml_model, name, dp)
 
 
@@ -509,7 +512,7 @@ def _create_sbml_reactions(
     sbml_model: libsbml.Model,
 ) -> None:
     """Create the reactions for the sbml model."""
-    for name, rxn in model.reactions.items():
+    for name, rxn in model.get_raw_reactions().items():
         sbml_rxn = sbml_model.createReaction()
         sbml_rxn.setId(_convert_id_to_sbml(id_=name, prefix="RXN"))
         sbml_rxn.setName(name)

mxlpy/sbml/_import.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
+import logging
 import math  # noqa: F401  # models might need it
 import re
-import warnings
 from collections import defaultdict
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -32,6 +32,8 @@ from mxlpy.types import unwrap
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+_LOGGER = logging.getLogger(__name__)
+
 __all__ = [
     "INDENT",
     "OPERATOR_MAPPINGS",
@@ -216,10 +218,8 @@ class Parser:
 
             node = assignment.getMath()
             if node is None:
-                warnings.warn(
-                    f"Unusable math for {name}",
-                    stacklevel=1,
-                )
+                msg = f"Unusable math for {name}"
+                _LOGGER.warning(msg)
                 continue
 
             body, args = parse_sbml_math(node)
@@ -493,7 +493,7 @@ def _codgen(name: str, sbml: Parser) -> Path:
             variables[k] = v.size
 
     # Ensure non-zero value for initial assignments
-    # EXPLAIN: we need to do this for the first round of get_dependent to work
+    # EXPLAIN: we need to do this for the first round of get_args to work
     # otherwise we run into a ton of DivisionByZero errors.
     # Since the values are overwritte afterwards, it doesn't really matter anyways
     for k in sbml.initial_assignment:
@@ -552,7 +552,7 @@ def get_model() -> Model:
     {variables_str}
     {derived_str}
     {rxn_str}
-    args = m.get_dependent()
+    args = m.get_args()
     {initial_assignment_source}
     return m
 """