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

mxlpy/__init__.py

@@ -52,6 +52,7 @@ from . import (
     plot,
     report,
     sbml,
+    scan,
     units,
 )
 from .integrators import DefaultIntegrator, Diffrax, Scipy
@@ -59,7 +60,6 @@ from .label_map import LabelMapper
 from .linear_label_map import LinearLabelMapper
 from .mc import Cache
 from .model import Model
-from .scan import steady_state, time_course, time_course_over_protocol
 from .simulator import Simulator
 from .symbolic import SymbolicModel, to_symbolic_model
 from .types import (
@@ -116,11 +116,9 @@ __all__ = [
     "plot",
     "report",
     "sbml",
-    "steady_state",
+    "scan",
     "surrogates",
     "symbolic",
-    "time_course",
-    "time_course_over_protocol",
     "to_symbolic_model",
     "units",
     "unwrap",

mxlpy/carousel.py

@@ -9,6 +9,7 @@ from functools import partial
 from typing import TYPE_CHECKING
 
 import pandas as pd
+from wadler_lindig import pformat
 
 from mxlpy import parallel, scan
 
@@ -25,6 +26,10 @@ if TYPE_CHECKING:
 class ReactionTemplate:
     """Template for a reaction in a model."""
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     fn: RateFn
     args: list[str]
     additional_parameters: dict[str, float] = field(default_factory=dict)
@@ -37,6 +42,10 @@ class CarouselSteadyState:
     carousel: list[Model]
     results: list[Result]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     def get_variables_by_model(self) -> pd.DataFrame:
         """Get the variables of the time course results, indexed by model."""
         return pd.DataFrame(
@@ -51,6 +60,10 @@ class CarouselTimeCourse:
     carousel: list[Model]
     results: list[Result]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     def get_variables_by_model(self) -> pd.DataFrame:
         """Get the variables of the time course results, indexed by model."""
         return pd.concat({i: r.variables for i, r in enumerate(self.results)})
@@ -76,6 +89,10 @@ class Carousel:
 
     variants: list[Model]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     def __init__(
         self,
         model: Model,
@@ -115,7 +132,7 @@ class Carousel:
             results=results,
         )
 
-    def protocol_time_course(
+    def protocol(
         self,
         protocol: pd.DataFrame,
         *,
@@ -141,6 +158,34 @@ class Carousel:
             results=results,
         )
 
+    def protocol_time_course(
+        self,
+        protocol: pd.DataFrame,
+        time_points: Array,
+        *,
+        y0: dict[str, float] | None = None,
+        integrator: IntegratorType | None = None,
+    ) -> CarouselTimeCourse:
+        """Simulate the carousel of models over a protocol time course."""
+        results = [
+            i[1]
+            for i in parallel.parallelise(
+                partial(
+                    scan._protocol_time_course_worker,  # noqa: SLF001
+                    protocol=protocol,
+                    integrator=integrator,
+                    time_points=time_points,
+                    y0=y0,
+                ),
+                list(enumerate(self.variants)),
+            )
+        ]
+
+        return CarouselTimeCourse(
+            carousel=self.variants,
+            results=results,
+        )
+
     def steady_state(
         self,
         *,

mxlpy/compare.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, cast
 
 import pandas as pd
+from wadler_lindig import pformat
 
 from mxlpy import plot
 from mxlpy.simulator import Simulator
@@ -32,6 +33,10 @@ class SteadyStateComparison:
     res1: Result
     res2: Result
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     @property
     def variables(self) -> pd.DataFrame:
         """Compare the steady state variables."""
@@ -93,6 +98,10 @@ class TimeCourseComparison:
     res1: Result
     res2: Result
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     # @property
     # def variables(self) -> pd.DataFrame:
     #     """Compare the steady state variables."""
@@ -144,6 +153,10 @@ class ProtocolComparison:
     res2: Result
     protocol: pd.DataFrame
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     # @property
     # def variables(self) -> pd.DataFrame:
     #     """Compare the steady state variables."""

mxlpy/experimental/diff.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
+from wadler_lindig import pformat
+
 from mxlpy.types import Derived
 
 if TYPE_CHECKING:
@@ -28,6 +30,10 @@ class DerivedDiff:
     args1: list[str] = field(default_factory=list)
     args2: list[str] = field(default_factory=list)
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class ReactionDiff:
@@ -38,6 +44,10 @@ class ReactionDiff:
     stoichiometry1: dict[str, float | Derived] = field(default_factory=dict)
     stoichiometry2: dict[str, float | Derived] = field(default_factory=dict)
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class ModelDiff:
@@ -56,6 +66,10 @@ class ModelDiff:
     different_readouts: dict[str, DerivedDiff] = field(default_factory=dict)
     different_derived: dict[str, DerivedDiff] = field(default_factory=dict)
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     def __str__(self) -> str:
         """Return a human-readable string representation of the diff."""
         content = ["Model Diff", "----------"]

mxlpy/fit.py

@@ -18,6 +18,7 @@ from typing import TYPE_CHECKING, Protocol
 
 import numpy as np
 from scipy.optimize import minimize
+from wadler_lindig import pformat
 
 from mxlpy import parallel
 from mxlpy.simulator import Simulator
@@ -61,6 +62,10 @@ class MinResult:
     parameters: dict[str, float]
     residual: float
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class FitResult:
@@ -70,6 +75,10 @@ class FitResult:
     best_pars: dict[str, float]
     loss: float
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
 
 @dataclass
 class CarouselFit:
@@ -77,6 +86,10 @@ class CarouselFit:
 
     fits: list[FitResult]
 
+    def __repr__(self) -> str:
+        """Return default representation."""
+        return pformat(self)
+
     def get_best_fit(self) -> FitResult:
         """Get the best fit from the carousel."""
         return min(self.fits, key=lambda x: x.loss)
@@ -561,6 +574,8 @@ def protocol_time_course(
 ) -> FitResult | None:
     """Fit model parameters to time course of experimental data.
 
+    Time points of protocol time course are taken from the data.
+
     Examples:
         >>> time_course(model, p0, data)
         {'k1': 0.1, 'k2': 0.2}
@@ -688,8 +703,10 @@ def carousel_time_course(
 ) -> CarouselFit:
     """Fit model parameters to time course of experimental data over a carousel.
 
+    Time points are taken from the data.
+
     Examples:
-        >>> carousel_steady_state(carousel, p0=p0, data=data)
+        >>> carousel_time_course(carousel, p0=p0, data=data)
 
     Args:
         carousel: Model carousel to fit
@@ -748,6 +765,8 @@ def carousel_protocol_time_course(
 ) -> CarouselFit:
     """Fit model parameters to time course of experimental data over a protocol.
 
+    Time points of protocol time course are taken from the data.
+
     Examples:
         >>> carousel_steady_state(carousel, p0=p0, data=data)
 

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))