mxlpy 0.22.0__py3-none-any.whl → 0.24.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,
@@ -35,10 +37,10 @@ from mxlpy.scan import (
 from mxlpy.types import (
     IntegratorType,
     McSteadyStates,
-    ProtocolByPars,
+    ProtocolScan,
     ResponseCoefficientsByPars,
-    SteadyStates,
-    TimeCourseByPars,
+    SteadyStateScan,
+    TimeCourseScan,
 )
 
 if TYPE_CHECKING:
@@ -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",
 ]
 
@@ -69,7 +72,7 @@ class ParameterScanWorker(Protocol):
         y0: dict[str, float] | None,
         rel_norm: bool,
         integrator: IntegratorType,
-    ) -> SteadyStates:
+    ) -> SteadyStateScan:
         """Call the worker function."""
         ...
 
@@ -81,7 +84,7 @@ def _parameter_scan_worker(
     y0: dict[str, float] | None,
     rel_norm: bool,
     integrator: IntegratorType,
-) -> SteadyStates:
+) -> SteadyStateScan:
     """Worker function for parallel steady state scanning across parameter sets.
 
     This function executes a parameter scan for steady state solutions for a
@@ -125,7 +128,7 @@ def steady_state(
     rel_norm: bool = False,
     worker: SteadyStateWorker = _steady_state_worker,
     integrator: IntegratorType | None = None,
-) -> SteadyStates:
+) -> SteadyStateScan:
     """Monte-carlo scan of steady states.
 
     Examples:
@@ -163,10 +166,14 @@ def steady_state(
         max_workers=max_workers,
         cache=cache,
     )
-    return SteadyStates(
-        variables=pd.concat({k: v.variables for k, v in res}, axis=1).T,
-        fluxes=pd.concat({k: v.fluxes for k, v in res}, axis=1).T,
-        parameters=mc_to_scan,
+    return SteadyStateScan(
+        raw_index=(
+            pd.Index(mc_to_scan.iloc[:, 0])
+            if mc_to_scan.shape[1] == 1
+            else pd.MultiIndex.from_frame(mc_to_scan)
+        ),
+        raw_results=[i[1] for i in res],
+        to_scan=mc_to_scan,
     )
 
 
@@ -180,7 +187,7 @@ def time_course(
     cache: Cache | None = None,
     worker: TimeCourseWorker = _time_course_worker,
     integrator: IntegratorType | None = None,
-) -> TimeCourseByPars:
+) -> TimeCourseScan:
     """MC time course.
 
     Examples:
@@ -219,14 +226,13 @@ def time_course(
         cache=cache,
     )
 
-    return TimeCourseByPars(
-        parameters=mc_to_scan,
-        variables=pd.concat({k: v.variables.T for k, v in res}, axis=1).T,
-        fluxes=pd.concat({k: v.fluxes.T for k, v in res}, axis=1).T,
+    return TimeCourseScan(
+        to_scan=mc_to_scan,
+        raw_results=dict(res),
     )
 
 
-def time_course_over_protocol(
+def protocol(
     model: Model,
     *,
     protocol: pd.DataFrame,
@@ -237,7 +243,7 @@ def time_course_over_protocol(
     cache: Cache | None = None,
     worker: ProtocolWorker = _protocol_worker,
     integrator: IntegratorType | None = None,
-) -> ProtocolByPars:
+) -> ProtocolScan:
     """MC time course.
 
     Examples:
@@ -277,13 +283,68 @@ def time_course_over_protocol(
         max_workers=max_workers,
         cache=cache,
     )
-    concs = {k: v.variables.T for k, v in res}
-    fluxes = {k: v.fluxes.T for k, v in res}
-    return ProtocolByPars(
-        variables=pd.concat(concs, axis=1).T,
-        fluxes=pd.concat(fluxes, axis=1).T,
-        parameters=mc_to_scan,
+    return ProtocolScan(
+        to_scan=mc_to_scan,
+        protocol=protocol,
+        raw_results=dict(res),
+    )
+
+
+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),
     )
 
 

mxlpy/mca.py

@@ -91,8 +91,12 @@ def _response_coefficient_worker(
         y0=None,
     )
 
-    conc_resp = (upper.variables - lower.variables) / (2 * displacement * old)
-    flux_resp = (upper.fluxes - lower.fluxes) / (2 * displacement * old)
+    conc_resp = (upper.variables.iloc[-1] - lower.variables.iloc[-1]) / (
+        2 * displacement * old
+    )
+    flux_resp = (upper.fluxes.iloc[-1] - lower.fluxes.iloc[-1]) / (
+        2 * displacement * old
+    )
     # Reset
     model.update_parameters({parameter: old})
     if normalized:
@@ -102,8 +106,8 @@ def _response_coefficient_worker(
             integrator=integrator,
             y0=None,
         )
-        conc_resp *= old / norm.variables
-        flux_resp *= old / norm.fluxes
+        conc_resp *= old / norm.variables.iloc[-1]
+        flux_resp *= old / norm.fluxes.iloc[-1]
     return conc_resp, flux_resp
 
 

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)
@@ -110,7 +120,8 @@ def _generate_model_code(
         _LOGGER.warning(msg)
 
     # Return
-    ret = ", ".join(f"d{i}dt" for i in diff_eqs) if len(diff_eqs) > 0 else "()"
+    ret_order = [i for i in variables if i in diff_eqs]
+    ret = ", ".join(f"d{i}dt" for i in ret_order) if len(diff_eqs) > 0 else "()"
     source.append(return_template.format(ret))
 
     if end is not None:
@@ -122,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."""
@@ -136,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."""
@@ -171,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,
     )