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

mxlpy/simulator.py

@@ -11,383 +11,29 @@ Classes:
 from __future__ import annotations
 
 import logging
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Literal, Self, cast, overload
+from dataclasses import dataclass
+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
+from mxlpy.types import Result
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
-
     from mxlpy.model import Model
     from mxlpy.types import Array, ArrayLike, IntegratorProtocol, IntegratorType
 
 _LOGGER = logging.getLogger(__name__)
 
 __all__ = [
-    "Result",
     "Simulator",
 ]
 
 
-def _normalise_split_results(
-    results: list[pd.DataFrame],
-    normalise: float | ArrayLike,
-) -> list[pd.DataFrame]:
-    """Normalize split results by a given factor or array.
-
-    Args:
-        results: List of DataFrames containing the results to normalize.
-        normalise: Normalization factor or array.
-
-    Returns:
-        list[pd.DataFrame]: List of normalized DataFrames.
-
-    """
-    if isinstance(normalise, int | float):
-        return [i / normalise for i in results]
-    if len(normalise) == len(results):
-        return [(i.T / j).T for i, j in zip(results, normalise, strict=True)]
-
-    results = []
-    start = 0
-    end = 0
-    for i in results:
-        end += len(i)
-        results.append(i / np.reshape(normalise[start:end], (len(i), 1)))  # type: ignore
-        start += end
-    return results
-
-
-@dataclass(kw_only=True, slots=True)
-class Result:
-    """Simulation results."""
-
-    model: Model
-    raw_variables: list[pd.DataFrame]
-    raw_parameters: list[dict[str, float]]
-    raw_args: list[pd.DataFrame] = field(default_factory=list)
-
-    @property
-    def variables(self) -> pd.DataFrame:
-        """Simulation variables."""
-        return self.get_variables(
-            include_derived_variables=True,
-            include_readouts=True,
-            concatenated=True,
-            normalise=None,
-        )
-
-    @property
-    def fluxes(self) -> pd.DataFrame:
-        """Simulation fluxes."""
-        return self.get_fluxes()
-
-    def __iter__(self) -> Iterator[pd.DataFrame]:
-        """Iterate over the concentration and flux response coefficients."""
-        return iter((self.variables, self.fluxes))
-
-    def _compute_args(self) -> list[pd.DataFrame]:
-        # Already computed
-        if len(self.raw_args) > 0:
-            return self.raw_args
-
-        # Compute new otherwise
-        for res, p in zip(self.raw_variables, self.raw_parameters, strict=True):
-            self.model.update_parameters(p)
-            self.raw_args.append(
-                self.model.get_args_time_course(
-                    variables=res,
-                    include_variables=True,
-                    include_parameters=True,
-                    include_derived_parameters=True,
-                    include_derived_variables=True,
-                    include_reactions=True,
-                    include_surrogate_outputs=True,
-                    include_readouts=True,
-                )
-            )
-        return self.raw_args
-
-    def _select_data(
-        self,
-        dependent: list[pd.DataFrame],
-        *,
-        include_variables: bool = False,
-        include_parameters: bool = False,
-        include_derived_parameters: bool = False,
-        include_derived_variables: bool = False,
-        include_reactions: bool = False,
-        include_surrogate_outputs: bool = False,
-        include_readouts: bool = False,
-    ) -> list[pd.DataFrame]:
-        names = self.model.get_arg_names(
-            include_time=False,
-            include_variables=include_variables,
-            include_parameters=include_parameters,
-            include_derived_parameters=include_derived_parameters,
-            include_derived_variables=include_derived_variables,
-            include_reactions=include_reactions,
-            include_surrogate_outputs=include_surrogate_outputs,
-            include_readouts=include_readouts,
-        )
-        return [i.loc[:, names] for i in dependent]
-
-    def _adjust_data(
-        self,
-        data: list[pd.DataFrame],
-        normalise: float | ArrayLike | None = None,
-        *,
-        concatenated: bool = True,
-    ) -> pd.DataFrame | list[pd.DataFrame]:
-        if normalise is not None:
-            data = _normalise_split_results(data, normalise=normalise)
-        if concatenated:
-            return pd.concat(data, axis=0)
-        return data
-
-    @overload
-    def get_args(  # type: ignore
-        self,
-        *,
-        include_variables: bool = True,
-        include_parameters: bool = False,
-        include_derived_parameters: bool = False,
-        include_derived_variables: bool = True,
-        include_reactions: bool = True,
-        include_surrogate_outputs: bool = False,
-        include_readouts: bool = False,
-        concatenated: Literal[False],
-        normalise: float | ArrayLike | None = None,
-    ) -> list[pd.DataFrame]: ...
-
-    @overload
-    def get_args(
-        self,
-        *,
-        include_variables: bool = True,
-        include_parameters: bool = False,
-        include_derived_parameters: bool = False,
-        include_derived_variables: bool = True,
-        include_reactions: bool = True,
-        include_surrogate_outputs: bool = False,
-        include_readouts: bool = False,
-        concatenated: Literal[True],
-        normalise: float | ArrayLike | None = None,
-    ) -> pd.DataFrame: ...
-
-    @overload
-    def get_args(
-        self,
-        *,
-        include_variables: bool = True,
-        include_parameters: bool = False,
-        include_derived_parameters: bool = False,
-        include_derived_variables: bool = True,
-        include_reactions: bool = True,
-        include_surrogate_outputs: bool = False,
-        include_readouts: bool = False,
-        concatenated: bool = True,
-        normalise: float | ArrayLike | None = None,
-    ) -> pd.DataFrame: ...
-
-    def get_args(
-        self,
-        *,
-        include_variables: bool = True,
-        include_parameters: bool = False,
-        include_derived_parameters: bool = False,
-        include_derived_variables: bool = True,
-        include_reactions: bool = True,
-        include_surrogate_outputs: bool = False,
-        include_readouts: bool = False,
-        concatenated: bool = True,
-        normalise: float | ArrayLike | None = None,
-    ) -> pd.DataFrame | list[pd.DataFrame]:
-        """Get the variables over time.
-
-        Examples:
-            >>> Result().get_variables()
-            Time            ATP      NADPH
-            0.000000   1.000000   1.000000
-            0.000100   0.999900   0.999900
-            0.000200   0.999800   0.999800
-
-        """
-        variables = self._select_data(
-            self._compute_args(),
-            include_variables=include_variables,
-            include_parameters=include_parameters,
-            include_derived_parameters=include_derived_parameters,
-            include_derived_variables=include_derived_variables,
-            include_reactions=include_reactions,
-            include_surrogate_outputs=include_surrogate_outputs,
-            include_readouts=include_readouts,
-        )
-        return self._adjust_data(
-            variables, normalise=normalise, concatenated=concatenated
-        )
-
-    @overload
-    def get_variables(  # type: ignore
-        self,
-        *,
-        include_derived_variables: bool = True,
-        include_readouts: bool = True,
-        concatenated: Literal[False],
-        normalise: float | ArrayLike | None = None,
-    ) -> list[pd.DataFrame]: ...
-
-    @overload
-    def get_variables(
-        self,
-        *,
-        include_derived_variables: bool = True,
-        include_readouts: bool = True,
-        concatenated: Literal[True],
-        normalise: float | ArrayLike | None = None,
-    ) -> pd.DataFrame: ...
-
-    @overload
-    def get_variables(
-        self,
-        *,
-        include_derived_variables: bool = True,
-        include_readouts: bool = True,
-        concatenated: bool = True,
-        normalise: float | ArrayLike | None = None,
-    ) -> pd.DataFrame: ...
-
-    def get_variables(
-        self,
-        *,
-        include_derived_variables: bool = True,
-        include_readouts: bool = True,
-        concatenated: bool = True,
-        normalise: float | ArrayLike | None = None,
-    ) -> pd.DataFrame | list[pd.DataFrame]:
-        """Get the variables over time.
-
-        Examples:
-            >>> Result().get_variables()
-            Time            ATP      NADPH
-            0.000000   1.000000   1.000000
-            0.000100   0.999900   0.999900
-            0.000200   0.999800   0.999800
-
-        """
-        if not include_derived_variables and not include_readouts:
-            return self._adjust_data(
-                self.raw_variables,
-                normalise=normalise,
-                concatenated=concatenated,
-            )
-
-        variables = self._select_data(
-            self._compute_args(),
-            include_variables=True,
-            include_derived_variables=include_derived_variables,
-            include_readouts=include_readouts,
-        )
-        return self._adjust_data(
-            variables, normalise=normalise, concatenated=concatenated
-        )
-
-    @overload
-    def get_fluxes(  # type: ignore
-        self,
-        *,
-        include_surrogates: bool = True,
-        normalise: float | ArrayLike | None = None,
-        concatenated: Literal[False],
-    ) -> list[pd.DataFrame]: ...
-
-    @overload
-    def get_fluxes(
-        self,
-        *,
-        include_surrogates: bool = True,
-        normalise: float | ArrayLike | None = None,
-        concatenated: Literal[True],
-    ) -> pd.DataFrame: ...
-
-    @overload
-    def get_fluxes(
-        self,
-        *,
-        include_surrogates: bool = True,
-        normalise: float | ArrayLike | None = None,
-        concatenated: bool = True,
-    ) -> pd.DataFrame: ...
-
-    def get_fluxes(
-        self,
-        *,
-        include_surrogates: bool = True,
-        normalise: float | ArrayLike | None = None,
-        concatenated: bool = True,
-    ) -> pd.DataFrame | list[pd.DataFrame]:
-        """Get the flux results.
-
-        Examples:
-            >>> Result.get_fluxes()
-            Time             v1         v2
-            0.000000   1.000000   10.00000
-            0.000100   0.999900   9.999000
-            0.000200   0.999800   9.998000
-
-        Returns:
-            pd.DataFrame: DataFrame of fluxes.
-
-        """
-        fluxes = self._select_data(
-            self._compute_args(),
-            include_reactions=True,
-            include_surrogate_outputs=include_surrogates,
-        )
-        return self._adjust_data(
-            fluxes,
-            normalise=normalise,
-            concatenated=concatenated,
-        )
-
-    def get_combined(self) -> pd.DataFrame:
-        """Get the variables and fluxes as a single pandas.DataFrame.
-
-        Examples:
-            >>> Result.get_combined()
-            Time            ATP      NADPH         v1         v2
-            0.000000   1.000000   1.000000   1.000000   10.00000
-            0.000100   0.999900   0.999900   0.999900   9.999000
-            0.000200   0.999800   0.999800   0.999800   9.998000
-
-        Returns:
-            pd.DataFrame: DataFrame of fluxes.
-
-        """
-        return pd.concat((self.variables, self.fluxes), axis=1)
-
-    def get_new_y0(self) -> dict[str, float]:
-        """Get the new initial conditions after the simulation.
-
-        Examples:
-            >>> Simulator(model).simulate_to_steady_state().get_new_y0()
-            {"ATP": 1.0, "NADPH": 1.0}
-
-        """
-        return dict(
-            self.get_variables(
-                include_derived_variables=False,
-                include_readouts=False,
-            ).iloc[-1]
-        )
-
-
 @dataclass(
     init=False,
     slots=True,
@@ -418,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,
@@ -478,7 +128,7 @@ class Simulator:
         y0 = self.y0
         self.integrator = self._integrator_type(
             self.model,
-            [y0[k] for k in self.model.get_variable_names()],
+            tuple(y0[k] for k in self.model.get_variable_names()),
             jac_fn,
         )