mxlpy 0.19.0__py3-none-any.whl → 0.20.0__py3-none-any.whl

mxlpy/__init__.py

@@ -42,6 +42,7 @@ from typing import TYPE_CHECKING
 import pandas as pd
 
 from . import (
+    compare,
     distributions,
     experimental,
     fit,
@@ -57,11 +58,7 @@ 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 .scan import steady_state, time_course, time_course_over_protocol
 from .simulator import Simulator
 from .symbolic import SymbolicModel, to_symbolic_model
 from .types import Derived, IntegratorProtocol, unwrap
@@ -72,11 +69,7 @@ with contextlib.suppress(ImportError):
 if TYPE_CHECKING:
     from mxlpy.types import ArrayLike
 
-    from . import (
-        nn,
-        npe,
-        surrogates,
-    )
+    from . import nn, npe, surrogates
 else:
     from lazy_import import lazy_module
 
@@ -98,6 +91,7 @@ __all__ = [
     "Simulator",
     "SymbolicModel",
     "cartesian_product",
+    "compare",
     "distributions",
     "experimental",
     "fit",

mxlpy/compare.py

@@ -0,0 +1,240 @@
+"""Docstring."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, cast
+
+import pandas as pd
+
+from mxlpy import plot
+from mxlpy.simulator import Result, Simulator
+from mxlpy.types import unwrap
+
+if TYPE_CHECKING:
+    from mxlpy.model import Model
+    from mxlpy.types import ArrayLike
+
+__all__ = [
+    "ProtocolComparison",
+    "SteadyStateComparison",
+    "TimeCourseComparison",
+    "protocol_time_courses",
+    "steady_states",
+    "time_courses",
+]
+
+
+@dataclass
+class SteadyStateComparison:
+    """Compare two steady states."""
+
+    res1: Result
+    res2: Result
+
+    @property
+    def variables(self) -> pd.DataFrame:
+        """Compare the steady state variables."""
+        ss1 = self.res1.get_variables().iloc[-1]
+        ss2 = self.res2.get_variables().iloc[-1]
+        diff = ss2 - ss1
+        return pd.DataFrame(
+            {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+        )
+
+    @property
+    def fluxes(self) -> pd.DataFrame:
+        """Compare the steady state fluxes."""
+        ss1 = self.res1.get_fluxes().iloc[-1]
+        ss2 = self.res2.get_fluxes().iloc[-1]
+        diff = ss2 - ss1
+        return pd.DataFrame(
+            {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+        )
+
+    @property
+    def all(self) -> pd.DataFrame:
+        """Compare both steady-state variables and fluxes."""
+        ss1 = self.res1.get_combined().iloc[-1]
+        ss2 = self.res2.get_combined().iloc[-1]
+        diff = ss2 - ss1
+        return pd.DataFrame(
+            {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+        )
+
+    def plot_variables(self, title: str = "Variables") -> plot.FigAxs:
+        """Plot the relative difference of steady-state variables."""
+        fig, axs = plot.bars_autogrouped(self.variables["rel_diff"], ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle(title)
+        return fig, axs
+
+    def plot_fluxes(self, title: str = "Fluxes") -> plot.FigAxs:
+        """Plot the relative difference of steady-state fluxes."""
+        fig, axs = plot.bars_autogrouped(self.fluxes["rel_diff"], ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle(title)
+        return fig, axs
+
+    def plot_all(self, title: str = "Variables and Fluxes") -> plot.FigAxs:
+        """Plot the relative difference of steady-state variables and fluxes."""
+        combined = self.all
+
+        fig, axs = plot.bars_autogrouped(combined["rel_diff"], ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle(title)
+        return fig, axs
+
+
+@dataclass
+class TimeCourseComparison:
+    """Compare two time courses."""
+
+    res1: Result
+    res2: Result
+
+    # @property
+    # def variables(self) -> pd.DataFrame:
+    #     """Compare the steady state variables."""
+    #     ss1 = self.res1.get_variables()
+    #     ss2 = self.res2.get_variables()
+    #     diff = ss2 - ss1
+    #     return pd.DataFrame(
+    #         {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+    #     )
+
+    # @property
+    # def fluxes(self) -> pd.DataFrame:
+    #     """Compare the steady state fluxes."""
+    #     ss1 = self.res1.get_fluxes()
+    #     ss2 = self.res2.get_fluxes()
+    #     diff = ss2 - ss1
+    #     return pd.DataFrame(
+    #         {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+    #     )
+
+    def plot_variables_relative_difference(self) -> plot.FigAxs:
+        """Plot the relative difference of time course variables."""
+        c1 = self.res1.variables
+        c2 = self.res2.variables
+
+        rel_diff = ((c2.loc[:, cast(list[str], c1.columns)] - c1) / c1).fillna(0)
+        fig, axs = plot.line_autogrouped(rel_diff, ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle("Variables")
+        return fig, axs
+
+    def plot_fluxes_relative_difference(self) -> plot.FigAxs:
+        """Plot the relative difference of time course fluxes."""
+        v1 = self.res1.fluxes
+        v2 = self.res2.fluxes
+
+        rel_diff = ((v2.loc[:, cast(list[str], v1.columns)] - v1) / v1).fillna(0)
+        fig, axs = plot.line_autogrouped(rel_diff, ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle("Fluxes")
+        return fig, axs
+
+
+@dataclass
+class ProtocolComparison:
+    """Compare two protocol time courses."""
+
+    res1: Result
+    res2: Result
+    protocol: pd.DataFrame
+
+    # @property
+    # def variables(self) -> pd.DataFrame:
+    #     """Compare the steady state variables."""
+    #     ss1 = self.res1.get_variables()
+    #     ss2 = self.res2.get_variables()
+    #     diff = ss2 - ss1
+    #     return pd.DataFrame(
+    #         {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+    #     )
+
+    # @property
+    # def fluxes(self) -> pd.DataFrame:
+    #     """Compare the steady state fluxes."""
+    #     ss1 = self.res1.get_fluxes()
+    #     ss2 = self.res2.get_fluxes()
+    #     diff = ss2 - ss1
+    #     return pd.DataFrame(
+    #         {"m1": ss1, "m2": ss2, "diff": diff, "rel_diff": diff / ss1}
+    #     )
+
+    def plot_variables_relative_difference(
+        self,
+        shade_protocol_variable: str | None = None,
+    ) -> plot.FigAxs:
+        """Plot the relative difference of time course variables."""
+        c1 = self.res1.variables
+        c2 = self.res2.variables
+
+        rel_diff = ((c2.loc[:, cast(list[str], c1.columns)] - c1) / c1).fillna(0)
+        fig, axs = plot.line_autogrouped(rel_diff, ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle("Variables")
+
+        if shade_protocol_variable is not None:
+            protocol = self.protocol[shade_protocol_variable]
+            for ax in axs:
+                plot.shade_protocol(protocol=protocol, ax=ax)
+        return fig, axs
+
+    def plot_fluxes_relative_difference(
+        self,
+        shade_protocol_variable: str | None = None,
+    ) -> plot.FigAxs:
+        """Plot the relative difference of time course fluxes."""
+        v1 = self.res1.fluxes
+        v2 = self.res2.fluxes
+
+        rel_diff = ((v2.loc[:, cast(list[str], v1.columns)] - v1) / v1).fillna(0)
+        fig, axs = plot.line_autogrouped(rel_diff, ylabel="")
+        plot.grid_labels(axs, ylabel="Relative difference")
+        fig.suptitle("Fluxes")
+
+        if shade_protocol_variable is not None:
+            protocol = self.protocol[shade_protocol_variable]
+            for ax in axs:
+                plot.shade_protocol(protocol=protocol, ax=ax)
+        return fig, axs
+
+
+def steady_states(m1: Model, m2: Model) -> SteadyStateComparison:
+    """Compare the steady states of two models."""
+    return SteadyStateComparison(
+        res1=unwrap(Simulator(m1).simulate_to_steady_state().get_result()),
+        res2=unwrap(Simulator(m2).simulate_to_steady_state().get_result()),
+    )
+
+
+def time_courses(m1: Model, m2: Model, time_points: ArrayLike) -> TimeCourseComparison:
+    """Compare the time courses of two models."""
+    return TimeCourseComparison(
+        res1=unwrap(
+            Simulator(m1).simulate_time_course(time_points=time_points).get_result()
+        ),
+        res2=unwrap(
+            Simulator(m2).simulate_time_course(time_points=time_points).get_result()
+        ),
+    )
+
+
+def protocol_time_courses(
+    m1: Model,
+    m2: Model,
+    protocol: pd.DataFrame,
+) -> ProtocolComparison:
+    """Compare the time courses of two models."""
+    return ProtocolComparison(
+        res1=unwrap(
+            Simulator(m1).simulate_over_protocol(protocol=protocol).get_result()
+        ),
+        res2=unwrap(
+            Simulator(m2).simulate_over_protocol(protocol=protocol).get_result()
+        ),
+        protocol=protocol,
+    )

mxlpy/experimental/diff.py

@@ -1,12 +1,24 @@
 """Diffing utilities for comparing models."""
 
-from collections.abc import Mapping
+from __future__ import annotations
+
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
 
-from mxlpy.model import Model
 from mxlpy.types import Derived
 
-__all__ = ["DerivedDiff", "ModelDiff", "ReactionDiff", "model_diff", "soft_eq"]
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from mxlpy.model import Model
+
+__all__ = [
+    "DerivedDiff",
+    "ModelDiff",
+    "ReactionDiff",
+    "model_diff",
+    "soft_eq",
+]
 
 
 @dataclass

mxlpy/fit.py

@@ -18,13 +18,12 @@ from scipy.optimize import minimize
 
 from mxlpy.integrators import DefaultIntegrator
 from mxlpy.simulator import Simulator
-from mxlpy.types import (
-    Array,
-    ArrayLike,
-    Callable,
-    IntegratorType,
-    cast,
-)
+from mxlpy.types import Array, ArrayLike, Callable, IntegratorType, cast
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+    from mxlpy.model import Model
 
 __all__ = [
     "InitialGuess",
@@ -40,10 +39,6 @@ __all__ = [
     "time_course_over_protocol",
 ]
 
-if TYPE_CHECKING:
-    import pandas as pd
-
-    from mxlpy.model import Model
 
 type InitialGuess = dict[str, float]
 type ResidualFn = Callable[[Array], float]

mxlpy/fns.py

@@ -2,11 +2,6 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from mxlpy.types import Float
-
 __all__ = [
     "add",
     "constant",
@@ -36,7 +31,7 @@ __all__ = [
 ###############################################################################
 
 
-def constant(x: Float) -> Float:
+def constant(x: float) -> float:
     """Return a constant value regardless of other model components.
 
     Parameters
@@ -58,7 +53,7 @@ def constant(x: Float) -> Float:
     return x
 
 
-def neg(x: Float) -> Float:
+def neg(x: float) -> float:
     """Calculate the negation of a value.
 
     Parameters
@@ -82,7 +77,7 @@ def neg(x: Float) -> Float:
     return -x
 
 
-def minus(x: Float, y: Float) -> Float:
+def minus(x: float, y: float) -> float:
     """Calculate the difference between two values.
 
     Parameters
@@ -108,7 +103,7 @@ def minus(x: Float, y: Float) -> Float:
     return x - y
 
 
-def mul(x: Float, y: Float) -> Float:
+def mul(x: float, y: float) -> float:
     """Calculate the product of two values.
 
     Parameters
@@ -134,7 +129,7 @@ def mul(x: Float, y: Float) -> Float:
     return x * y
 
 
-def div(x: Float, y: Float) -> Float:
+def div(x: float, y: float) -> float:
     """Calculate the quotient of two values.
 
     Parameters
@@ -160,7 +155,7 @@ def div(x: Float, y: Float) -> Float:
     return x / y
 
 
-def one_div(x: Float) -> Float:
+def one_div(x: float) -> float:
     """Calculate the reciprocal of a value.
 
     Parameters
@@ -184,7 +179,7 @@ def one_div(x: Float) -> Float:
     return 1.0 / x
 
 
-def neg_div(x: Float, y: Float) -> Float:
+def neg_div(x: float, y: float) -> float:
     """Calculate the negative quotient of two values.
 
     Parameters
@@ -210,7 +205,7 @@ def neg_div(x: Float, y: Float) -> Float:
     return -x / y
 
 
-def twice(x: Float) -> Float:
+def twice(x: float) -> float:
     """Calculate twice the value.
 
     Parameters
@@ -234,7 +229,7 @@ def twice(x: Float) -> Float:
     return x * 2
 
 
-def add(x: Float, y: Float) -> Float:
+def add(x: float, y: float) -> float:
     """Calculate the sum of two values.
 
     Parameters
@@ -260,7 +255,7 @@ def add(x: Float, y: Float) -> Float:
     return x + y
 
 
-def proportional(x: Float, y: Float) -> Float:
+def proportional(x: float, y: float) -> float:
     """Calculate the product of two values.
 
     Common in mass-action kinetics where x represents a rate constant
@@ -295,9 +290,9 @@ def proportional(x: Float, y: Float) -> Float:
 
 
 def moiety_1s(
-    x: Float,
-    x_total: Float,
-) -> Float:
+    x: float,
+    x_total: float,
+) -> float:
     """Calculate conservation relationship for one substrate.
 
     Used for creating derived variables that represent moiety conservation,
@@ -328,10 +323,10 @@ def moiety_1s(
 
 
 def moiety_2s(
-    x1: Float,
-    x2: Float,
-    x_total: Float,
-) -> Float:
+    x1: float,
+    x2: float,
+    x_total: float,
+) -> float:
     """Calculate conservation relationship for two substrates.
 
     Used for creating derived variables that represent moiety conservation
@@ -369,7 +364,7 @@ def moiety_2s(
 ###############################################################################
 
 
-def mass_action_1s(s1: Float, k: Float) -> Float:
+def mass_action_1s(s1: float, k: float) -> float:
     """Calculate irreversible mass action reaction rate with one substrate.
 
     Rate = k * [S]
@@ -398,7 +393,7 @@ def mass_action_1s(s1: Float, k: Float) -> Float:
     return k * s1
 
 
-def mass_action_1s_1p(s1: Float, p1: Float, kf: Float, kr: Float) -> Float:
+def mass_action_1s_1p(s1: float, p1: float, kf: float, kr: float) -> float:
     """Calculate reversible mass action reaction rate with one substrate and one product.
 
     Rate = kf * [S] - kr * [P]
@@ -432,7 +427,7 @@ def mass_action_1s_1p(s1: Float, p1: Float, kf: Float, kr: Float) -> Float:
     return kf * s1 - kr * p1
 
 
-def mass_action_2s(s1: Float, s2: Float, k: Float) -> Float:
+def mass_action_2s(s1: float, s2: float, k: float) -> float:
     """Calculate irreversible mass action reaction rate with two substrates.
 
     Rate = k * [S1] * [S2]
@@ -463,7 +458,7 @@ def mass_action_2s(s1: Float, s2: Float, k: Float) -> Float:
     return k * s1 * s2
 
 
-def mass_action_2s_1p(s1: Float, s2: Float, p1: Float, kf: Float, kr: Float) -> Float:
+def mass_action_2s_1p(s1: float, s2: float, p1: float, kf: float, kr: float) -> float:
     """Calculate reversible mass action reaction rate with two substrates and one product.
 
     Rate = kf * [S1] * [S2] - kr * [P]
@@ -505,7 +500,7 @@ def mass_action_2s_1p(s1: Float, s2: Float, p1: Float, kf: Float, kr: Float) ->
 ###############################################################################
 
 
-def michaelis_menten_1s(s1: Float, vmax: Float, km1: Float) -> Float:
+def michaelis_menten_1s(s1: float, vmax: float, km1: float) -> float:
     """Calculate irreversible Michaelis-Menten reaction rate for one substrate.
 
     Rate = Vmax * [S] / (Km + [S])
@@ -549,12 +544,12 @@ def michaelis_menten_1s(s1: Float, vmax: Float, km1: Float) -> Float:
 
 
 def michaelis_menten_2s(
-    s1: Float,
-    s2: Float,
-    vmax: Float,
-    km1: Float,
-    km2: Float,
-) -> Float:
+    s1: float,
+    s2: float,
+    vmax: float,
+    km1: float,
+    km2: float,
+) -> float:
     """Calculate Michaelis-Menten reaction rate (ping-pong) for two substrates.
 
     Rate = Vmax * [S1] * [S2] / ([S1]*[S2] + km1*[S2] + km2*[S1])
@@ -594,14 +589,14 @@ def michaelis_menten_2s(
 
 
 def michaelis_menten_3s(
-    s1: Float,
-    s2: Float,
-    s3: Float,
-    vmax: Float,
-    km1: Float,
-    km2: Float,
-    km3: Float,
-) -> Float:
+    s1: float,
+    s2: float,
+    s3: float,
+    vmax: float,
+    km1: float,
+    km2: float,
+    km3: float,
+) -> float:
     """Calculate Michaelis-Menten reaction rate (ping-pong) for three substrates.
 
     Rate = Vmax * [S1] * [S2] * [S3] / ([S1]*[S2] + km1*[S2]*[S3] + km2*[S1]*[S3] + km3*[S1]*[S2])
@@ -649,7 +644,7 @@ def michaelis_menten_3s(
 ###############################################################################
 
 
-def diffusion_1s_1p(inside: Float, outside: Float, k: Float) -> Float:
+def diffusion_1s_1p(inside: float, outside: float, k: float) -> float:
     """Calculate diffusion rate between two compartments.
 
     Rate = k * ([outside] - [inside])

mxlpy/identify.py

@@ -1,6 +1,9 @@
 """Numerical parameter identification estimations."""
 
+from __future__ import annotations
+
 from functools import partial
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
@@ -8,11 +11,15 @@ from tqdm import tqdm
 
 from mxlpy import fit
 from mxlpy.distributions import LogNormal, sample
-from mxlpy.model import Model
 from mxlpy.parallel import parallelise
-from mxlpy.types import Array
 
-__all__ = ["profile_likelihood"]
+if TYPE_CHECKING:
+    from mxlpy.model import Model
+    from mxlpy.types import Array
+
+__all__ = [
+    "profile_likelihood",
+]
 
 
 def _mc_fit_time_course_worker(

mxlpy/integrators/__init__.py

@@ -6,9 +6,6 @@ It includes support for both Assimulo and Scipy integrators, with Assimulo being
 
 from __future__ import annotations
 
-__all__ = ["DefaultIntegrator"]
-
-
 from .int_scipy import Scipy
 
 try:
@@ -17,3 +14,7 @@ try:
     DefaultIntegrator = Assimulo
 except ImportError:
     DefaultIntegrator = Scipy
+
+__all__ = [
+    "DefaultIntegrator",
+]

mxlpy/integrators/int_assimulo.py

@@ -2,14 +2,9 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
-
-__all__ = [
-    "Assimulo",
-]
-
 import contextlib
 import os
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Literal
 
 import numpy as np
@@ -25,6 +20,11 @@ if TYPE_CHECKING:
     from mxlpy.types import Array, ArrayLike
 
 
+__all__ = [
+    "Assimulo",
+]
+
+
 @dataclass
 class Assimulo:
     """Assimulo integrator for solving ODEs.

mxlpy/integrators/int_scipy.py

@@ -2,13 +2,8 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass, field
-
-__all__ = [
-    "Scipy",
-]
-
 import copy
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, cast
 
 import numpy as np
@@ -20,6 +15,11 @@ if TYPE_CHECKING:
     from collections.abc import Callable
 
 
+__all__ = [
+    "Scipy",
+]
+
+
 @dataclass
 class Scipy:
     """Scipy integrator for solving ODEs.

mxlpy/label_map.py

@@ -24,13 +24,15 @@ import numpy as np
 
 from mxlpy.model import Model
 
-__all__ = ["LabelMapper"]
-
 if TYPE_CHECKING:
     from collections.abc import Callable, Mapping
 
     from mxlpy.types import Derived
 
+__all__ = [
+    "LabelMapper",
+]
+
 
 def _total_concentration(*args: float) -> float:
     """Calculate sum of isotopomer concentrations.

mxlpy/linear_label_map.py

@@ -16,13 +16,15 @@ from typing import TYPE_CHECKING
 
 from mxlpy.model import Derived, Model
 
-__all__ = ["LinearLabelMapper"]
-
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
     import pandas as pd
 
+__all__ = [
+    "LinearLabelMapper",
+]
+
 
 def _generate_isotope_labels(base_name: str, num_labels: int) -> list[str]:
     """Generate list of isotopomer names for a compound.