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

mxlpy/model.py

@@ -18,6 +18,7 @@ from typing import TYPE_CHECKING, Self, cast
 import numpy as np
 import pandas as pd
 import sympy
+from wadler_lindig import pformat
 
 from mxlpy import fns
 from mxlpy.meta.source_tools import fn_to_sympy
@@ -91,6 +92,10 @@ class MdText:
 
     content: list[str]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     def _repr_markdown_(self) -> str:
         return "\n".join(self.content)
 
@@ -101,6 +106,10 @@ class UnitCheck:
 
     per_variable: dict[str, dict[str, bool | Failure | None]]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     @staticmethod
     def _fmt_success(s: str) -> str:
         return f"<span style='color: green'>{s}</span>"
@@ -171,6 +180,10 @@ class Dependency:
     required: set[str]
     provided: set[str]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 class MissingDependenciesError(Exception):
     """Raised when dependencies cannot be sorted topologically.
@@ -374,6 +387,10 @@ class ModelCache:
 
     """
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     order: list[str]  # mostly for debug purposes
     var_names: list[str]
     dyn_order: list[str]
@@ -402,15 +419,19 @@ class Model:
     """
 
     _ids: dict[str, str] = field(default_factory=dict, repr=False)
+    _cache: ModelCache | None = field(default=None, repr=False)
     _variables: dict[str, Variable] = field(default_factory=dict)
     _parameters: dict[str, Parameter] = field(default_factory=dict)
     _derived: dict[str, Derived] = field(default_factory=dict)
     _readouts: dict[str, Readout] = field(default_factory=dict)
     _reactions: dict[str, Reaction] = field(default_factory=dict)
     _surrogates: dict[str, AbstractSurrogate] = field(default_factory=dict)
-    _cache: ModelCache | None = None
     _data: dict[str, pd.Series | pd.DataFrame] = field(default_factory=dict)
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     ###########################################################################
     # Cache
     ###########################################################################
@@ -2281,7 +2302,7 @@ class Model:
         if (cache := self._cache) is None:
             cache = self._create_cache()
         var_names = self.get_variable_names()
-        dependent = self._get_args(
+        args = self._get_args(
             variables=self.get_initial_conditions() if variables is None else variables,
             time=time,
             cache=cache,
@@ -2289,12 +2310,12 @@ class Model:
         dxdt = pd.Series(np.zeros(len(var_names), dtype=float), index=var_names)
         for k, stoc in cache.stoich_by_cpds.items():
             for flux, n in stoc.items():
-                dxdt[k] += n * dependent[flux]
+                dxdt[k] += n * args[flux]
 
         for k, sd in cache.dyn_stoich_by_cpds.items():
             for flux, dv in sd.items():
-                n = dv.fn(*(dependent[i] for i in dv.args))
-                dxdt[k] += n * dependent[flux]
+                n = dv.fn(*(args[i] for i in dv.args))
+                dxdt[k] += n * args[flux]
         return dxdt
 
     ##########################################################################

mxlpy/plot.py

@@ -41,6 +41,7 @@ from matplotlib.figure import Figure
 from matplotlib.legend import Legend
 from matplotlib.patches import Patch
 from mpl_toolkits.mplot3d import Axes3D
+from wadler_lindig import pformat
 
 from mxlpy.label_map import LabelMapper
 
@@ -105,6 +106,10 @@ class Axs:
         """Length of axes."""
         return len(self.axs.flatten())
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     @overload
     def __getitem__(self, row_col: int) -> Axes: ...
 
@@ -213,6 +218,28 @@ def _partition_by_order_of_magnitude(s: pd.Series) -> list[list[str]]:
     ]
 
 
+def _combine_small_groups(
+    groups: list[list[str]], min_group_size: int
+) -> list[list[str]]:
+    """Combine smaller groups."""
+    result = []
+    current_group = groups[0]
+
+    for next_group in groups[1:]:
+        if len(current_group) < min_group_size:
+            current_group.extend(next_group)
+        else:
+            result.append(current_group)
+            current_group = next_group
+
+    # Last group
+    if len(current_group) < min_group_size:
+        result[-1].extend(current_group)
+    else:
+        result.append(current_group)
+    return result
+
+
 def _split_large_groups[T](groups: list[list[T]], max_size: int) -> list[list[T]]:
     """Split groups larger than the given size into smaller groups."""
     return list(
@@ -516,7 +543,7 @@ def grid_layout(
     n_rows = math.ceil(n_groups / n_cols)
     figsize = (n_cols * col_width, n_rows * row_height)
 
-    return _default_fig_axs(
+    fig, axs = _default_fig_axs(
         ncols=n_cols,
         nrows=n_rows,
         figsize=figsize,
@@ -525,6 +552,12 @@ def grid_layout(
         grid=grid,
     )
 
+    # Disable unused plots by default
+    axsl = list(axs)
+    for i in range(n_groups, len(axs)):
+        axsl[i].set_visible(False)
+    return fig, axs
+
 
 ##########################################################################
 # Plots
@@ -586,10 +619,6 @@ def bars_grouped(
             ylabel=ylabel,
         )
 
-    axsl = list(axs)
-    for i in range(len(groups), len(axs)):
-        axsl[i].set_visible(False)
-
     return fig, axs
 
 
@@ -599,18 +628,20 @@ def bars_autogrouped(
     n_cols: int = 2,
     col_width: float = 4,
     row_height: float = 3,
+    min_group_size: int = 1,
     max_group_size: int = 6,
     grid: bool = True,
     xlabel: str | None = None,
     ylabel: str | None = None,
 ) -> FigAxs:
     """Plot a series or dataframe with lines grouped by order of magnitude."""
-    group_names = _split_large_groups(
+    group_names = (
         _partition_by_order_of_magnitude(s)
         if isinstance(s, pd.Series)
-        else _partition_by_order_of_magnitude(s.max()),
-        max_size=max_group_size,
+        else _partition_by_order_of_magnitude(s.max())
     )
+    group_names = _combine_small_groups(group_names, min_group_size=min_group_size)
+    group_names = _split_large_groups(group_names, max_size=max_group_size)
 
     groups: list[pd.Series] | list[pd.DataFrame] = (
         [s.loc[group] for group in group_names]
@@ -714,10 +745,6 @@ def lines_grouped(
             ylabel=ylabel,
         )
 
-    axsl = list(axs)
-    for i in range(len(groups), len(axs)):
-        axsl[i].set_visible(False)
-
     return fig, axs
 
 
@@ -727,6 +754,7 @@ def line_autogrouped(
     n_cols: int = 2,
     col_width: float = 4,
     row_height: float = 3,
+    min_group_size: int = 1,
     max_group_size: int = 6,
     grid: bool = True,
     xlabel: str | None = None,
@@ -736,12 +764,13 @@ def line_autogrouped(
     linestyle: Linestyle | None = None,
 ) -> FigAxs:
     """Plot a series or dataframe with lines grouped by order of magnitude."""
-    group_names = _split_large_groups(
+    group_names = (
         _partition_by_order_of_magnitude(s)
         if isinstance(s, pd.Series)
-        else _partition_by_order_of_magnitude(s.max()),
-        max_size=max_group_size,
+        else _partition_by_order_of_magnitude(s.max())
     )
+    group_names = _combine_small_groups(group_names, min_group_size=min_group_size)
+    group_names = _split_large_groups(group_names, max_size=max_group_size)
 
     groups: list[pd.Series] | list[pd.DataFrame] = (
         [s.loc[group] for group in group_names]

mxlpy/sbml/_data.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+from wadler_lindig import pformat
+
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
@@ -26,18 +28,30 @@ class AtomicUnit:
     scale: int
     multiplier: float
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class CompositeUnit:
     sbml_id: str
     units: list
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class Parameter:
     value: float
     is_constant: bool
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class Compartment:
@@ -47,6 +61,10 @@ class Compartment:
     units: str
     is_constant: bool
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class Compound:
@@ -58,21 +76,37 @@ class Compound:
     is_constant: bool
     is_concentration: bool
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class Derived:
     body: str
     args: list[str]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class Function:
     body: str
     args: list[str]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class Reaction:
     body: str
     stoichiometry: Mapping[str, float | str]
     args: list[str]
+
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)

mxlpy/sbml/_export.py

@@ -447,6 +447,7 @@ def _create_sbml_variables(
         cpd.setConstant(False)
         cpd.setBoundaryCondition(False)
         cpd.setHasOnlySubstanceUnits(False)
+        cpd.setCompartment("compartment")
         # cpd.setUnit() # FIXME: implement
         if isinstance((init := variable.initial_value), InitialAssignment):
             ar = sbml_model.createInitialAssignment()
@@ -455,7 +456,7 @@ def _create_sbml_variables(
             ar.setVariable(_convert_id_to_sbml(id_=name, prefix="IA"))
             ar.setMath(_sbmlify_fn(init.fn, init.args))
         else:
-            cpd.setInitialAmount(float(init))
+            cpd.setInitialConcentration(float(init))
 
 
 def _create_sbml_derived_variables(*, model: Model, sbml_model: libsbml.Model) -> None:
@@ -591,8 +592,8 @@ def _default_compartments(
 ) -> dict[str, Compartment]:
     if compartments is None:
         return {
-            "c": Compartment(
-                name="cytosol",
+            "compartment": Compartment(
+                name="compartment",
                 dimensions=3,
                 size=1,
                 units="litre",

mxlpy/scan.py

@@ -39,12 +39,14 @@ if TYPE_CHECKING:
 
 
 __all__ = [
+    "ProtocolTimeCourseWorker",
     "ProtocolWorker",
     "SteadyStateWorker",
     "TimeCourseWorker",
+    "protocol",
+    "protocol_time_course",
     "steady_state",
     "time_course",
-    "time_course_over_protocol",
 ]
 
 
@@ -70,11 +72,6 @@ def _update_parameters_and_initial_conditions[T](
     return fn(model)
 
 
-###############################################################################
-# Single returns
-###############################################################################
-
-
 ###############################################################################
 # Workers
 ###############################################################################
@@ -126,6 +123,22 @@ class ProtocolWorker(Protocol):
         ...
 
 
+class ProtocolTimeCourseWorker(Protocol):
+    """Worker function for protocol-based simulations."""
+
+    def __call__(
+        self,
+        model: Model,
+        protocol: pd.DataFrame,
+        time_points: Array,
+        *,
+        integrator: IntegratorType | None,
+        y0: dict[str, float] | None,
+    ) -> Result:
+        """Call the worker function."""
+        ...
+
+
 def _steady_state_worker(
     model: Model,
     *,
@@ -228,6 +241,42 @@ def _protocol_worker(
     return Result.default(model=model, time_points=time_points) if res is None else res
 
 
+def _protocol_time_course_worker(
+    model: Model,
+    protocol: pd.DataFrame,
+    time_points: Array,
+    *,
+    integrator: IntegratorType | None,
+    y0: dict[str, float] | None,
+) -> Result:
+    """Simulate the model over a protocol and return concentrations and fluxes.
+
+    Args:
+        model: Model instance to simulate.
+        y0: Initial conditions as a dictionary {species: value}.
+        protocol: DataFrame containing the protocol steps.
+        time_points: Time points where to return the simulation
+        integrator: Integrator function to use for steady state calculation
+
+    Returns:
+        TimeCourse: Object containing protocol series concentrations and fluxes.
+
+    """
+    try:
+        res = (
+            Simulator(model, integrator=integrator, y0=y0)
+            .simulate_protocol_time_course(
+                protocol=protocol,
+                time_points=time_points,
+            )
+            .get_result()
+        )
+    except ZeroDivisionError:
+        res = None
+
+    return Result.default(model=model, time_points=time_points) if res is None else res
+
+
 def steady_state(
     model: Model,
     *,
@@ -393,7 +442,7 @@ def time_course(
     )
 
 
-def time_course_over_protocol(
+def protocol(
     model: Model,
     *,
     to_scan: pd.DataFrame,
@@ -460,3 +509,72 @@ def time_course_over_protocol(
         protocol=protocol,
         raw_results=dict(res),
     )
+
+
+def protocol_time_course(
+    model: Model,
+    *,
+    to_scan: pd.DataFrame,
+    protocol: pd.DataFrame,
+    time_points: Array,
+    y0: dict[str, float] | None = None,
+    parallel: bool = True,
+    cache: Cache | None = None,
+    worker: ProtocolTimeCourseWorker = _protocol_time_course_worker,
+    integrator: IntegratorType | None = None,
+) -> ProtocolScan:
+    """Get protocol series for each supplied parameter.
+
+    Examples:
+        >>> scan.time_course_over_protocol(
+        ...     model,
+        ...     parameters=pd.DataFrame({"k2": np.linspace(1, 2, 11)}),
+        ...     protocol=make_protocol(
+        ...         {
+        ...             1: {"k1": 1},
+        ...             2: {"k1": 2},
+        ...         }
+        ...     ),
+        ... )
+
+    Args:
+        model: Model instance to simulate.
+        to_scan: DataFrame containing parameter or initial values to scan.
+        protocol: Protocol to follow for the simulation.
+        time_points: Time points where to return simulation results
+        y0: Initial conditions as a dictionary {variable: value}.
+        parallel: Whether to execute in parallel (default: True).
+        cache: Optional cache to store and retrieve results.
+        worker: Worker function to use for the simulation.
+        integrator: Integrator function to use for steady state calculation
+
+    Returns:
+        TimeCourseByPars: Protocol series results for each parameter set.
+
+    """
+    # We update the initial conditions separately here, because `to_scan` might also
+    # contain initial conditions.
+    if y0 is not None:
+        model.update_variables(y0)
+
+    res = parallelise(
+        partial(
+            _update_parameters_and_initial_conditions,
+            fn=partial(
+                worker,
+                protocol=protocol,
+                time_points=time_points,
+                integrator=integrator,
+                y0=None,
+            ),
+            model=model,
+        ),
+        inputs=list(to_scan.iterrows()),
+        cache=cache,
+        parallel=parallel,
+    )
+    return ProtocolScan(
+        to_scan=to_scan,
+        protocol=protocol,
+        raw_results=dict(res),
+    )

mxlpy/simulator.py

@@ -17,6 +17,7 @@ from typing import TYPE_CHECKING, Self, cast
 import numpy as np
 import pandas as pd
 from sympy import lambdify
+from wadler_lindig import pformat
 
 from mxlpy.integrators import DefaultIntegrator
 from mxlpy.symbolic import to_symbolic_model
@@ -63,6 +64,10 @@ class Simulator:
     _integrator_type: IntegratorType
     _time_shift: float | None
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     def __init__(
         self,
         model: Model,