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

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,