mxlpy 0.21.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

mxlpy/plot.py

@@ -28,6 +28,7 @@ import numpy as np
 import pandas as pd
 import seaborn as sns
 from cycler import cycler
+from matplotlib import colormaps
 from matplotlib import pyplot as plt
 from matplotlib.axes import Axes
 from matplotlib.colors import (
@@ -37,6 +38,8 @@ from matplotlib.colors import (
     colorConverter,  # type: ignore
 )
 from matplotlib.figure import Figure
+from matplotlib.legend import Legend
+from matplotlib.patches import Patch
 from mpl_toolkits.mplot3d import Axes3D
 
 from mxlpy.label_map import LabelMapper
@@ -541,7 +544,7 @@ def bars(
     sns.barplot(data=cast(pd.DataFrame, x), ax=ax)
 
     if xlabel is None:
-        xlabel = x.index.name if x.index.name is not None else ""
+        xlabel = x.index.name if x.index.name is not None else ""  # type: ignore
     _default_labels(ax, xlabel=xlabel, ylabel=ylabel)
     if isinstance(x, pd.DataFrame):
         ax.legend(x.columns)
@@ -651,7 +654,7 @@ def lines(
     )
     _default_labels(
         ax,
-        xlabel=x.index.name if xlabel is None else xlabel,
+        xlabel=x.index.name if xlabel is None else xlabel,  # type: ignore
         ylabel=ylabel,
     )
     if legend:
@@ -792,7 +795,11 @@ def line_mean_std(
         color=color,
         alpha=alpha,
     )
-    _default_labels(ax, xlabel=df.index.name, ylabel=None)
+    _default_labels(
+        ax,
+        xlabel=df.index.name,  # type: ignore
+        ylabel=None,
+    )
     return fig, ax
 
 
@@ -865,11 +872,11 @@ def _create_heatmap(
     if title is not None:
         ax.set_title(title)
     ax.set_xticks(
-        np.arange(0, len(df.columns), 1, dtype=float) + 0.5,
+        np.arange(0, len(df.columns), 1, dtype=float) + 0.5,  # type: ignore
         labels=xticklabels,
     )
     ax.set_yticks(
-        np.arange(0, len(df.index), 1, dtype=float) + 0.5,
+        np.arange(0, len(df.index), 1, dtype=float) + 0.5,  # type: ignore
         labels=yticklabels,
     )
 
@@ -906,8 +913,8 @@ def heatmap(
         ax=ax,
         df=df,
         title=title,
-        xlabel=df.index.name,
-        ylabel=df.columns.name,
+        xlabel=df.index.name,  # type: ignore
+        ylabel=df.columns.name,  # type: ignore
         xticklabels=cast(list, df.columns),
         yticklabels=cast(list, df.index),
         annotate=annotate,
@@ -943,8 +950,8 @@ def heatmap_from_2d_idx(
 
     return _create_heatmap(
         df=df2d,
-        xlabel=df2d.index.name,
-        ylabel=df2d.columns.name,
+        xlabel=df2d.index.name,  # type: ignore
+        ylabel=df2d.columns.name,  # type: ignore
         xticklabels=[f"{i:.2f}" for i in df2d.columns],
         yticklabels=[f"{i:.2f}" for i in df2d.index],
         ax=ax,
@@ -1064,11 +1071,6 @@ def shade_protocol(
     add_legend: bool = True,
 ) -> None:
     """Shade the given protocol on the given axis."""
-    from matplotlib import colormaps
-    from matplotlib.colors import Normalize
-    from matplotlib.legend import Legend
-    from matplotlib.patches import Patch
-
     cmap = colormaps[cmap_name]
     norm = Normalize(
         vmin=protocol.min() if vmin is None else vmin,

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

@@ -10,7 +10,7 @@ import numpy as np
 
 from mxlpy.meta.source_tools import get_fn_ast
 from mxlpy.sbml._data import AtomicUnit, Compartment
-from mxlpy.types import Derived
+from mxlpy.types import Derived, InitialAssignment
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -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), InitialAssignment):
             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,15 +494,23 @@ def _create_sbml_parameters(
         sbml_model : libsbml.Model
 
     """
-    for parameter_id, value in model.parameters.items():
+    for name, value in model.get_raw_parameters().items():
         k = sbml_model.createParameter()
-        k.setId(_convert_id_to_sbml(id_=parameter_id, prefix="PAR"))
+        k.setId(_convert_id_to_sbml(id_=name, prefix="PAR"))
         k.setConstant(True)
-        k.setValue(float(value))
+
+        if isinstance((init := value.value), InitialAssignment):
+            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(init.fn, init.args))
+        else:
+            k.setValue(float(init))
 
 
 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 +520,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)