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

mxlpy/mc.py

@@ -24,9 +24,11 @@ import pandas as pd
 from mxlpy import mca, scan
 from mxlpy.parallel import Cache, parallelise
 from mxlpy.scan import (
+    ProtocolTimeCourseWorker,
     ProtocolWorker,
     SteadyStateWorker,
     TimeCourseWorker,
+    _protocol_time_course_worker,
     _protocol_worker,
     _steady_state_worker,
     _time_course_worker,
@@ -49,11 +51,12 @@ if TYPE_CHECKING:
 __all__ = [
     "ParameterScanWorker",
     "parameter_elasticities",
+    "protocol",
+    "protocol_time_course",
     "response_coefficients",
     "scan_steady_state",
     "steady_state",
     "time_course",
-    "time_course_over_protocol",
     "variable_elasticities",
 ]
 
@@ -229,7 +232,7 @@ def time_course(
     )
 
 
-def time_course_over_protocol(
+def protocol(
     model: Model,
     *,
     protocol: pd.DataFrame,
@@ -287,6 +290,64 @@ def time_course_over_protocol(
     )
 
 
+def protocol_time_course(
+    model: Model,
+    *,
+    protocol: pd.DataFrame,
+    time_points: Array,
+    mc_to_scan: pd.DataFrame,
+    y0: dict[str, float] | None = None,
+    max_workers: int | None = None,
+    cache: Cache | None = None,
+    worker: ProtocolTimeCourseWorker = _protocol_time_course_worker,
+    integrator: IntegratorType | None = None,
+) -> ProtocolScan:
+    """MC time course.
+
+    Examples:
+        >>> protocol_time_course(model, protocol, time_points, mc_to_scan)
+        p    t     x      y
+        0   0.0   0.1    0.00
+            1.0   0.2    0.01
+            2.0   0.3    0.02
+            3.0   0.4    0.03
+            ...   ...    ...
+        1   0.0   0.1    0.00
+            1.0   0.2    0.01
+            2.0   0.3    0.02
+            3.0   0.4    0.03
+
+    Returns:
+        tuple[concentrations, fluxes] using pandas multiindex
+        Both dataframes are of shape (#time_points * #mc_to_scan, #variables)
+
+    """
+    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(mc_to_scan.iterrows()),
+        max_workers=max_workers,
+        cache=cache,
+    )
+    return ProtocolScan(
+        to_scan=mc_to_scan,
+        protocol=protocol,
+        raw_results=dict(res),
+    )
+
+
 def scan_steady_state(
     model: Model,
     *,

mxlpy/meta/__init__.py

@@ -3,13 +3,18 @@
 from __future__ import annotations
 
 from .codegen_latex import generate_latex_code, to_tex_export
-from .codegen_model import generate_model_code_py, generate_model_code_rs
+from .codegen_model import (
+    generate_model_code_py,
+    generate_model_code_rs,
+    generate_model_code_ts,
+)
 from .codegen_mxlpy import generate_mxlpy_code
 
 __all__ = [
     "generate_latex_code",
     "generate_model_code_py",
     "generate_model_code_rs",
+    "generate_model_code_ts",
     "generate_mxlpy_code",
     "to_tex_export",
 ]

mxlpy/meta/codegen_latex.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 import sympy
+from wadler_lindig import pformat
 
 from mxlpy.meta.sympy_tools import fn_to_sympy, list_of_symbols
 from mxlpy.types import Derived, RateFn
@@ -358,6 +359,10 @@ class TexReaction:
     fn: RateFn
     args: list[str]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class TexExport:
@@ -397,6 +402,10 @@ class TexExport:
     reactions: dict[str, TexReaction]
     diff_eqs: dict[str, Mapping[str, float | Derived]]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     @staticmethod
     def _diff_parameters(
         p1: dict[str, float],

mxlpy/meta/codegen_model.py

@@ -9,6 +9,7 @@ from mxlpy.meta.sympy_tools import (
     fn_to_sympy,
     list_of_symbols,
     stoichiometries_to_sympy,
+    sympy_to_inline_js,
     sympy_to_inline_py,
     sympy_to_inline_rust,
 )
@@ -23,6 +24,7 @@ if TYPE_CHECKING:
 __all__ = [
     "generate_model_code_py",
     "generate_model_code_rs",
+    "generate_model_code_ts",
 ]
 
 _LOGGER = logging.getLogger(__name__)
@@ -37,6 +39,7 @@ def _generate_model_code(
     assignment_template: str,
     sympy_inline_fn: Callable[[sympy.Expr], str],
     return_template: str,
+    custom_fns: dict[str, sympy.Expr],
     imports: list[str] | None = None,
     end: str | None = None,
     free_parameters: list[str] | None = None,
@@ -70,11 +73,13 @@ def _generate_model_code(
 
     # Derived
     for name, derived in model.get_raw_derived().items():
-        expr = fn_to_sympy(
-            derived.fn,
-            origin=name,
-            model_args=list_of_symbols(derived.args),
-        )
+        expr = custom_fns.get(name)
+        if expr is None:
+            expr = fn_to_sympy(
+                derived.fn,
+                origin=name,
+                model_args=list_of_symbols(derived.args),
+            )
         if expr is None:
             msg = f"Unable to parse fn for derived value '{name}'"
             raise ValueError(msg)
@@ -82,11 +87,16 @@ def _generate_model_code(
 
     # Reactions
     for name, rxn in model.get_raw_reactions().items():
-        expr = fn_to_sympy(
-            rxn.fn,
-            origin=name,
-            model_args=list_of_symbols(rxn.args),
-        )
+        expr = custom_fns.get(name)
+        if expr is None:
+            try:
+                expr = fn_to_sympy(
+                    rxn.fn,
+                    origin=name,
+                    model_args=list_of_symbols(rxn.args),
+                )
+            except KeyError:
+                _LOGGER.warning("Failed to parse %s", name)
         if expr is None:
             msg = f"Unable to parse fn for reaction value '{name}'"
             raise ValueError(msg)
@@ -123,6 +133,7 @@ def _generate_model_code(
 
 def generate_model_code_py(
     model: Model,
+    custom_fns: dict[str, sympy.Expr] | None = None,
     free_parameters: list[str] | None = None,
 ) -> str:
     """Transform the model into a python function, inlining the function calls."""
@@ -137,21 +148,51 @@ def generate_model_code_py(
     return _generate_model_code(
         model,
         imports=[
+            "import math\n",
             "from collections.abc import Iterable\n",
         ],
         sized=False,
         model_fn=model_fn,
         variables_template="    {} = variables",
-        assignment_template="    {k} = {v}",
+        assignment_template="    {k}: float = {v}",
         sympy_inline_fn=sympy_to_inline_py,
         return_template="    return {}",
         end=None,
         free_parameters=free_parameters,
+        custom_fns={} if custom_fns is None else custom_fns,
+    )
+
+
+def generate_model_code_ts(
+    model: Model,
+    custom_fns: dict[str, sympy.Expr] | None = None,
+    free_parameters: list[str] | None = None,
+) -> str:
+    """Transform the model into a typescript function, inlining the function calls."""
+    if free_parameters is None:
+        model_fn = "function model(time: number, variables: number[]) {"
+    else:
+        args = ", ".join(f"{k}: number" for k in free_parameters)
+        model_fn = f"function model(time: number, variables: number[], {args}) {{"
+
+    return _generate_model_code(
+        model,
+        imports=[],
+        sized=False,
+        model_fn=model_fn,
+        variables_template="    let [{}] = variables;",
+        assignment_template="    let {k}: number = {v};",
+        sympy_inline_fn=sympy_to_inline_js,
+        return_template="    return [{}];",
+        end="};",
+        free_parameters=free_parameters,
+        custom_fns={} if custom_fns is None else custom_fns,
     )
 
 
 def generate_model_code_rs(
     model: Model,
+    custom_fns: dict[str, sympy.Expr] | None = None,
     free_parameters: list[str] | None = None,
 ) -> str:
     """Transform the model into a rust function, inlining the function calls."""
@@ -172,4 +213,5 @@ def generate_model_code_rs(
         return_template="    return [{}]",
         end="}",
         free_parameters=free_parameters,
+        custom_fns={} if custom_fns is None else custom_fns,
     )

mxlpy/meta/codegen_mxlpy.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, cast
 
 import sympy
+from wadler_lindig import pformat
 
 from mxlpy.meta.sympy_tools import (
     fn_to_sympy,
@@ -43,6 +44,10 @@ class SymbolicFn:
     expr: sympy.Expr
     args: list[str]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class SymbolicVariable:
@@ -51,6 +56,10 @@ class SymbolicVariable:
     value: sympy.Float | SymbolicFn  # initial assignment
     unit: Quantity | None
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class SymbolicParameter:
@@ -59,6 +68,10 @@ class SymbolicParameter:
     value: sympy.Float | SymbolicFn  # initial assignment
     unit: Quantity | None
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class SymbolicReaction:
@@ -67,6 +80,10 @@ class SymbolicReaction:
     fn: SymbolicFn
     stoichiometry: dict[str, sympy.Float | str | SymbolicFn]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class SymbolicRepr:
@@ -77,6 +94,10 @@ class SymbolicRepr:
     derived: dict[str, SymbolicFn] = field(default_factory=dict)
     reactions: dict[str, SymbolicReaction] = field(default_factory=dict)
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 def _fn_to_symbolic_repr(k: str, fn: Callable, model_args: list[str]) -> SymbolicFn:
     fn_name = fn.__name__

mxlpy/meta/source_tools.py

@@ -15,6 +15,7 @@ from typing import TYPE_CHECKING, Any, cast
 import dill
 import numpy as np
 import sympy
+from wadler_lindig import pformat
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -174,6 +175,10 @@ class Context:
     modules: dict[str, ModuleType]
     fns: dict[str, Callable]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     def updated(
         self,
         symbols: dict[str, sympy.Symbol | sympy.Expr] | None = None,

mxlpy/meta/sympy_tools.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, cast
 
 import sympy
-from sympy.printing import rust_code
+from sympy.printing import jscode, rust_code
 from sympy.printing.pycode import pycode
 
 from mxlpy.meta.source_tools import fn_to_sympy
@@ -17,6 +17,7 @@ if TYPE_CHECKING:
 __all__ = [
     "list_of_symbols",
     "stoichiometries_to_sympy",
+    "sympy_to_inline_js",
     "sympy_to_inline_py",
     "sympy_to_inline_rust",
     "sympy_to_python_fn",
@@ -53,6 +54,11 @@ def sympy_to_inline_py(expr: sympy.Expr) -> str:
     return cast(str, pycode(expr, fully_qualified_modules=True, full_prec=False))
 
 
+def sympy_to_inline_js(expr: sympy.Expr) -> str:
+    """Create rust code from sympy expression."""
+    return cast(str, jscode(expr, full_prec=False))
+
+
 def sympy_to_inline_rust(expr: sympy.Expr) -> str:
     """Create rust code from sympy expression."""
     return cast(str, rust_code(expr, full_prec=False))

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
     ###########################################################################
@@ -2250,6 +2271,24 @@ class Model:
                 dxdt[k] += n * dependent[flux]
         return tuple(dxdt[i] for i in cache.var_names)
 
+    def _get_right_hand_side(
+        self,
+        *,
+        args: dict[str, float],
+        var_names: list[str],
+        cache: ModelCache,
+    ) -> pd.Series:
+        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 * args[flux]
+
+        for k, sd in cache.dyn_stoich_by_cpds.items():
+            for flux, dv in sd.items():
+                n = dv.fn(*(args[i] for i in dv.args))
+                dxdt[k] += n * args[flux]
+        return dxdt
+
     def get_right_hand_side(
         self,
         variables: dict[str, float] | None = None,
@@ -2281,21 +2320,27 @@ 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,
         )
-        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]
+        return self._get_right_hand_side(args=args, var_names=var_names, cache=cache)
 
-        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]
-        return dxdt
+    def get_right_hand_side_time_course(self, args: pd.DataFrame) -> pd.DataFrame:
+        """Calculate the right-hand side of the differential equations for the model."""
+        if (cache := self._cache) is None:
+            cache = self._create_cache()
+        var_names = self.get_variable_names()
+
+        rhs_by_time = {}
+        for time, variables in args.iterrows():
+            rhs_by_time[time] = self._get_right_hand_side(
+                args=variables.to_dict(),
+                var_names=var_names,
+                cache=cache,
+            )
+        return pd.DataFrame(rhs_by_time).T
 
     ##########################################################################
     # Check units

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]