modelbase2 0.1.79__py3-none-any.whl → 0.2.0__py3-none-any.whl

modelbase2/types.py

@@ -1,20 +1,361 @@
+"""Types Module.
+
+This module provides type definitions and utility types for use throughout the project.
+It includes type aliases for arrays, numbers, and callable functions, as well as re-exports
+of common types from standard libraries.
+
+Classes:
+    DerivedFn: Callable type for derived functions.
+    Array: Type alias for numpy arrays of float64.
+    Number: Type alias for float, list of floats, or numpy arrays.
+    Param: Type alias for parameter specifications.
+    RetType: Type alias for return types.
+    Axes: Type alias for numpy arrays of matplotlib axes.
+    ArrayLike: Type alias for numpy arrays or lists of floats.
+"""
+
 from __future__ import annotations
 
+from abc import abstractmethod
+from dataclasses import dataclass, field
+
+import pandas as pd
+
 __all__ = [
+    "AbstractSurrogate",
     "Array",
-    "Axes",
-    "DataFrame",
-    "Figure",
-    "Series",
+    "ArrayLike",
+    "Derived",
+    "Float",
+    "IntegratorProtocol",
+    "McSteadyStates",
+    "MockSurrogate",
+    "Param",
+    "ProtocolByPars",
+    "RateFn",
+    "Reaction",
+    "Readout",
+    "ResponseCoefficients",
+    "ResponseCoefficientsByPars",
+    "RetType",
+    "SteadyStates",
+    "TimeCourseByPars",
+    "unwrap",
+    "unwrap2",
 ]
 
+# Re-exporting some types here, because their imports have
+# changed between Python versions and I have no interest in
+# fixing it in every file
+from collections.abc import Callable, Iterator, Mapping
+from typing import TYPE_CHECKING, Any, ParamSpec, Protocol, TypeVar, cast
+
 import numpy as np
 import numpy.typing as npt
-import pandas as pd
-from matplotlib.axes import Axes
-from matplotlib.figure import Figure
-from typing_extensions import TypeAlias
+from numpy.typing import NDArray
+
+type Float = npt.NDArray[np.floating[Any]] | float
+type RateFn = Callable[..., Float]
+type Array = NDArray[np.floating[Any]]
+type ArrayLike = NDArray[np.floating[Any]] | list[float]
+
+
+Param = ParamSpec("Param")
+RetType = TypeVar("RetType")
+
+
+if TYPE_CHECKING:
+    from modelbase2.model import Model
+
+
+def unwrap[T](el: T | None) -> T:
+    """Unwraps an optional value, raising an error if the value is None.
+
+    Args:
+        el: The value to unwrap. It can be of type T or None.
+
+    Returns:
+        The unwrapped value if it is not None.
+
+    Raises:
+        ValueError: If the provided value is None.
+
+    """
+    if el is None:
+        msg = "Unexpected None"
+        raise ValueError(msg)
+    return el
+
+
+def unwrap2[T1, T2](tpl: tuple[T1 | None, T2 | None]) -> tuple[T1, T2]:
+    """Unwraps a tuple of optional values, raising an error if either of them is None.
+
+    Args:
+        tpl: The value to unwrap.
+
+    Returns:
+        The unwrapped values if it is not None.
+
+    Raises:
+        ValueError: If the provided value is None.
+
+    """
+    a, b = tpl
+    if a is None or b is None:
+        msg = "Unexpected None"
+        raise ValueError(msg)
+    return a, b
+
+
+class IntegratorProtocol(Protocol):
+    """Protocol for numerical integrators."""
+
+    def __init__(
+        self,
+        rhs: Callable,
+        y0: ArrayLike,
+    ) -> None:
+        """Initialise the integrator."""
+        ...
+
+    def reset(self) -> None:
+        """Reset the integrator."""
+        ...
+
+    def integrate(
+        self,
+        *,
+        t_end: float,
+        steps: int | None = None,
+    ) -> tuple[ArrayLike | None, ArrayLike | None]:
+        """Integrate the system."""
+        ...
+
+    def integrate_time_course(
+        self, *, time_points: ArrayLike
+    ) -> tuple[ArrayLike | None, ArrayLike | None]:
+        """Integrate the system over a time course."""
+        ...
+
+    def integrate_to_steady_state(
+        self,
+        *,
+        tolerance: float,
+        rel_norm: bool,
+    ) -> tuple[float | None, ArrayLike | None]:
+        """Integrate the system to steady state."""
+        ...
+
+
+@dataclass(slots=True)
+class Derived:
+    """Container for a derived value."""
+
+    fn: RateFn
+    args: list[str]
+    math: str | None = None
+
+
+@dataclass(slots=True)
+class Readout:
+    """Container for a readout."""
+
+    fn: RateFn
+    args: list[str]
+
+
+@dataclass(slots=True)
+class Reaction:
+    """Container for a reaction."""
+
+    fn: RateFn
+    stoichiometry: Mapping[str, float | Derived]
+    args: list[str]
+    math: str | None = None
+
+    def get_modifiers(self, model: Model) -> list[str]:
+        """Get the modifiers of the reaction."""
+        include = set(model.variables)
+        exclude = set(self.stoichiometry)
+
+        return [k for k in self.args if k in include and k not in exclude]
+
+
+@dataclass(slots=True)
+class ResponseCoefficients:
+    """Container for response coefficients."""
+
+    concs: pd.DataFrame
+    fluxes: pd.DataFrame
+
+    def __iter__(self) -> Iterator[pd.DataFrame]:
+        """Iterate over the concentration and flux response coefficients."""
+        return iter((self.concs, self.fluxes))
+
+    @property
+    def results(self) -> pd.DataFrame:
+        """Return the response coefficients as a DataFrame."""
+        return pd.concat((self.concs, self.fluxes), axis=1)
+
+
+@dataclass(slots=True)
+class ResponseCoefficientsByPars:
+    """Container for response coefficients by parameter."""
+
+    concs: pd.DataFrame
+    fluxes: pd.DataFrame
+    parameters: pd.DataFrame
+
+    def __iter__(self) -> Iterator[pd.DataFrame]:
+        """Iterate over the concentration and flux response coefficients."""
+        return iter((self.concs, self.fluxes))
+
+    @property
+    def results(self) -> pd.DataFrame:
+        """Return the response coefficients as a DataFrame."""
+        return pd.concat((self.concs, self.fluxes), axis=1)
+
+
+@dataclass(slots=True)
+class SteadyStates:
+    """Container for steady states."""
+
+    concs: pd.DataFrame
+    fluxes: pd.DataFrame
+    parameters: pd.DataFrame
+
+    def __iter__(self) -> Iterator[pd.DataFrame]:
+        """Iterate over the concentration and flux steady states."""
+        return iter((self.concs, self.fluxes))
+
+    @property
+    def results(self) -> pd.DataFrame:
+        """Return the steady states as a DataFrame."""
+        return pd.concat((self.concs, self.fluxes), axis=1)
+
+
+@dataclass(slots=True)
+class McSteadyStates:
+    """Container for Monte Carlo steady states."""
+
+    concs: pd.DataFrame
+    fluxes: pd.DataFrame
+    parameters: pd.DataFrame
+    mc_parameters: pd.DataFrame
+
+    def __iter__(self) -> Iterator[pd.DataFrame]:
+        """Iterate over the concentration and flux steady states."""
+        return iter((self.concs, self.fluxes))
+
+    @property
+    def results(self) -> pd.DataFrame:
+        """Return the steady states as a DataFrame."""
+        return pd.concat((self.concs, self.fluxes), axis=1)
+
+
+@dataclass(slots=True)
+class TimeCourseByPars:
+    """Container for time courses by parameter."""
+
+    concs: pd.DataFrame
+    fluxes: pd.DataFrame
+    parameters: pd.DataFrame
+
+    def __iter__(self) -> Iterator[pd.DataFrame]:
+        """Iterate over the concentration and flux time courses."""
+        return iter((self.concs, self.fluxes))
+
+    @property
+    def results(self) -> pd.DataFrame:
+        """Return the time courses as a DataFrame."""
+        return pd.concat((self.concs, self.fluxes), axis=1)
+
+    def get_by_name(self, name: str) -> pd.DataFrame:
+        """Get time courses by name."""
+        return self.results[name].unstack().T
+
+    def get_agg_per_time(self, agg: str | Callable) -> pd.DataFrame:
+        """Get aggregated time courses."""
+        mean = cast(pd.DataFrame, self.results.unstack(level=1).agg(agg, axis=0))
+        return cast(pd.DataFrame, mean.unstack().T)
+
+    def get_agg_per_run(self, agg: str | Callable) -> pd.DataFrame:
+        """Get aggregated time courses."""
+        mean = cast(pd.DataFrame, self.results.unstack(level=0).agg(agg, axis=0))
+        return cast(pd.DataFrame, mean.unstack().T)
+
+
+@dataclass(slots=True)
+class ProtocolByPars:
+    """Container for protocols by parameter."""
+
+    concs: pd.DataFrame
+    fluxes: pd.DataFrame
+    parameters: pd.DataFrame
+    protocol: pd.DataFrame
+
+    def __iter__(self) -> Iterator[pd.DataFrame]:
+        """Iterate over the concentration and flux protocols."""
+        return iter((self.concs, self.fluxes))
+
+    @property
+    def results(self) -> pd.DataFrame:
+        """Return the protocols as a DataFrame."""
+        return pd.concat((self.concs, self.fluxes), axis=1)
+
+    def get_by_name(self, name: str) -> pd.DataFrame:
+        """Get concentration or flux by name."""
+        return self.results[name].unstack().T
+
+    def get_agg_per_time(self, agg: str | Callable) -> pd.DataFrame:
+        """Get aggregated concentration or flux."""
+        mean = cast(pd.DataFrame, self.results.unstack(level=1).agg(agg, axis=0))
+        return cast(pd.DataFrame, mean.unstack().T)
+
+    def get_agg_per_run(self, agg: str | Callable) -> pd.DataFrame:
+        """Get aggregated concentration or flux."""
+        mean = cast(pd.DataFrame, self.results.unstack(level=0).agg(agg, axis=0))
+        return cast(pd.DataFrame, mean.unstack().T)
+
+
+@dataclass(kw_only=True)
+class AbstractSurrogate:
+    """Abstract base class for surrogate models.
+
+    Attributes:
+        inputs: List of input variable names.
+        stoichiometries: Dictionary mapping reaction names to stoichiometries.
+
+    Methods:
+        predict: Abstract method to predict outputs based on input data.
+
+    """
+
+    args: list[str] = field(default_factory=list)
+    stoichiometries: dict[str, dict[str, float]] = field(default_factory=dict)
+
+    @abstractmethod
+    def predict_raw(self, y: np.ndarray) -> np.ndarray:
+        """Predict outputs based on input data."""
+
+    def predict(self, y: np.ndarray) -> dict[str, float]:
+        """Predict outputs based on input data."""
+        return dict(
+            zip(
+                self.stoichiometries,
+                self.predict_raw(y),
+                strict=True,
+            )
+        )
+
+
+@dataclass(kw_only=True)
+class MockSurrogate(AbstractSurrogate):
+    """Mock surrogate model for testing purposes."""
 
-Array: TypeAlias = npt.NDArray[np.float64]
-Series: TypeAlias = pd.Series
-DataFrame: TypeAlias = pd.DataFrame
+    def predict_raw(
+        self,
+        y: np.ndarray,
+    ) -> np.ndarray:
+        """Predict outputs based on input data."""
+        return y

modelbase2-0.2.0.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: modelbase2
+Version: 0.2.0
+Summary: A package to build metabolic models
+Author-email: Marvin van Aalst <marvin.vanaalst@gmail.com>
+Maintainer-email: Marvin van Aalst <marvin.vanaalst@gmail.com>
+License-Expression: GPL-3.0-or-later
+License-File: LICENSE
+Keywords: metabolic,modelling,ode
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Requires-Python: >=3.12
+Requires-Dist: dill>=0.3.9
+Requires-Dist: latexify-py>=0.4.4
+Requires-Dist: matplotlib>=3.9.2
+Requires-Dist: more-itertools>=10.5.0
+Requires-Dist: numpy>=2.1.2
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: parameteriser>=0.1.0
+Requires-Dist: pebble>=5.0.7
+Requires-Dist: python-libsbml>=5.20.4
+Requires-Dist: scipy>=1.14.1
+Requires-Dist: seaborn>=0.13.2
+Requires-Dist: sympy>=1.13.1
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: tqdm>=4.66.6
+Requires-Dist: typing-extensions>=4.12.2
+Provides-Extra: dev
+Requires-Dist: coverage>=7.6.4; extra == 'dev'
+Requires-Dist: jupyter>=1.1.1; extra == 'dev'
+Requires-Dist: mkdocs-jupyter>=0.25.1; extra == 'dev'
+Requires-Dist: mkdocs-material>=9.5.42; extra == 'dev'
+Requires-Dist: mkdocs>=1.6.1; extra == 'dev'
+Requires-Dist: mypy>=1.13.0; extra == 'dev'
+Requires-Dist: pre-commit>=4.0.1; extra == 'dev'
+Requires-Dist: pyright>=1.1.387; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.3; extra == 'dev'
+Requires-Dist: qtbmodels<0.2,>=0.1.0; extra == 'dev'
+Requires-Dist: requests>=2.32.3; extra == 'dev'
+Requires-Dist: ruff>=0.7.1; extra == 'dev'
+Requires-Dist: ssort>=0.13.0; extra == 'dev'
+Requires-Dist: toml-sort<0.24,>=0.23.1; extra == 'dev'
+Provides-Extra: torch
+Requires-Dist: torch>=2.5.1; extra == 'torch'
+Description-Content-Type: text/markdown
+
+# modelbase
+
+
+## Development setup
+
+You have two choices here, using `uv` (pypi-only) or using `pixi` (conda-forge, including assimulo)
+
+### uv
+
+- Install `uv` as described in [the docs](https://docs.astral.sh/uv/getting-started/installation/).
+- Run `uv sync --extra dev --extra torch` to install dependencies locally
+
+### pixi
+
+- Install `pixi` as described in [the docs](https://pixi.sh/latest/#installation)
+- Run `pixi install --frozen`
+
+
+## Notes
+
+- `uv add $package`
+- `uv add --optional dev $package`

modelbase2-0.2.0.dist-info/RECORD

@@ -0,0 +1,42 @@
+modelbase2/__init__.py,sha256=mGA_ckCmdG8Bi1i_eiES7JShez_4qwobwRVYaMBe27E,3967
+modelbase2/distributions.py,sha256=sbqmkw3PTPK0vWOcIFqP3WXH_2Q3i-_pl_NmvAYCngM,7927
+modelbase2/fit.py,sha256=kCuwsuUs9DSRyeQXmP6RSclGGMVL1Q7XD3KLhu073yo,8010
+modelbase2/fns.py,sha256=8JtIzPk3DAnNHz3LoJ1ukLFTjPNO1rNCeZ7VnRmJY2o,4503
+modelbase2/label_map.py,sha256=LUwcOHQWiGfBGV5XUmPM_SOwM9IyDVcQVJ11DPfVpAo,17774
+modelbase2/linear_label_map.py,sha256=gA8CHxcehgtI6ovwZ9qNUPDvxfqbO1J1kBC_mltD4TY,10225
+modelbase2/mc.py,sha256=zlDL7e_udpIMRhSjfFJo5AwkigD0B_3H2rQxyelBuzI,16285
+modelbase2/mca.py,sha256=nMS2VnzR2VEujCFUaj9WL82CNd-oxTb3jCHP8IlJvxA,8845
+modelbase2/model.py,sha256=SJloqNi8C5oSrIyknMkXfPFDBHPW-ybrT_F9nsbREzQ,53854
+modelbase2/npe.py,sha256=fSnEyXvsS1h3S7rIbPtRW2oeJc917yt73rSw75Het3o,11199
+modelbase2/parallel.py,sha256=kX4Td5YoovDwZp6kX_3cfO6QtHSS9ieJ0bMZiKs3Xv8,5002
+modelbase2/parameterise.py,sha256=7VrYxrQv0visraqUthWSnWfx-cxh2evlXbszIY5031U,690
+modelbase2/paths.py,sha256=uatKXDa79uniUB2Z3dr8eBJVuUPXDI-o_bf-DqPKq1Y,1039
+modelbase2/plot.py,sha256=tsQRUeKFKpthWOw8JqKhqcxBTBaMscJlemJzNpENAnc,22640
+modelbase2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modelbase2/scan.py,sha256=PvWZA4EgNS0JVMvm87bF72hSmhvo6O2KGg4vRzxve_8,18104
+modelbase2/scope.py,sha256=4twnEh8LrTmlLE-uRvubVkE3SSWejlLvtBzTCPqG3Aw,3710
+modelbase2/simulator.py,sha256=3UIAjGa6AUosd7384I4s9kVyFuY6H0bPcqIm19QpTIQ,19708
+modelbase2/surrogates.py,sha256=XGXZaFwO8CZsATbFohkuK0eQdTR_hsVEUPJyzfIKpSk,9121
+modelbase2/types.py,sha256=N74pWUZDcGlSMfDkjqqwHn5dkozlqgS6Wqg-58YKdvg,9904
+modelbase2/experimental/__init__.py,sha256=En8_KLrfA5RulThEr_Zx2D1n0H0wv1L0Rj6EBwWz7RM,379
+modelbase2/experimental/codegen.py,sha256=J_0iCtojwjmDXAfC8EqiXP0gmWaSH8MPkWvdLsZWsXU,6962
+modelbase2/experimental/diff.py,sha256=e7fjD9kqxkRUNxSevbAznd5cOlEdWJ6pj0y7Kd5KKrw,8973
+modelbase2/experimental/notes.md,sha256=YlM2biTzub6jSlx-aDZaBYsvQcGwb7NHyVAbbl2acGE,238
+modelbase2/experimental/tex.py,sha256=M-Pdq3eQw1Huo-z1gv8EhWVO5ecJyFS8MMy9yoX81VI,13634
+modelbase2/integrators/__init__.py,sha256=kqmV6a0TRyLGR_XqbyAI652AfptYnXAUpqbSFg0CpP8,450
+modelbase2/integrators/int_assimulo.py,sha256=VEQIZFZcEovLPy8i_jR8H8XcxBRQoRVmNzzCYzInPc0,4611
+modelbase2/integrators/int_scipy.py,sha256=-_9MS55eTc9jI7tk-3X49p-c7zrydoXaCCvDTn7Tybw,4334
+modelbase2/sbml/__init__.py,sha256=FBaQsVvrVc7QbCBXuG9tZOdSzHcqmmsaRbFx80rxrac,231
+modelbase2/sbml/_data.py,sha256=XwT1sSxn6KLTXYMbk4ORbEAEgZhQDBfoyrjMBDAoY_s,1135
+modelbase2/sbml/_export.py,sha256=9BLD3Qz86vlfDTZXwOnNOSVWq8mHrJoQjQmKJRZL_Wo,20285
+modelbase2/sbml/_import.py,sha256=uT5JpFvCKjQNBFmGPba61xYShHmjzjczqnaYflilSMI,21523
+modelbase2/sbml/_mathml.py,sha256=bNk9RQ_NQFDhY1R354p-gwqqHaIiyAwZ1xLPHHhiguQ,24436
+modelbase2/sbml/_name_conversion.py,sha256=XK9DEyzhrD0GBBwwjK9RA0yORrDX5c-Uvx0VtKMR5rA,1325
+modelbase2/sbml/_unit_conversion.py,sha256=dW_I6_Ou09ccwnp6LIdrPriIQnQUK5lJcjzM2Fawm6U,1927
+modelbase2/surrogates/__init__.py,sha256=0OH8BmdB5toHo7sXcZHZVASx3EEnpzcc7TeTP2tF5Ek,944
+modelbase2/surrogates/_poly.py,sha256=zKeoj3FchMAIgbnq99VkH_RfLsdy6N5lZaV0AeG9JKs,2185
+modelbase2/surrogates/_torch.py,sha256=7XHES1NyVmGTc8qmcScsfroai6rJVeV4eAGU2-oqH9A,7402
+modelbase2-0.2.0.dist-info/METADATA,sha256=f3af5XY5IQ0GkvPWYqUcnFJ79EKxxDjufw8Z2yCwk3o,2853
+modelbase2-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+modelbase2-0.2.0.dist-info/licenses/LICENSE,sha256=qvG2VolmSkrcocL34V1ieOx-Rn-fpVcUbb25gHzVgZw,35079
+modelbase2-0.2.0.dist-info/RECORD,,

{modelbase2-0.1.79.dist-info → modelbase2-0.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.3.2
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

modelbase2/core/__init__.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-__all__ = [
-    "AlgebraicModule",
-    "AlgebraicModuleContainer",
-    "Constant",
-    "ConstantContainer",
-    "DerivedConstant",
-    "DerivedStoichiometry",
-    "NameContainer",
-    "Reaction",
-    "ReactionContainer",
-    "Variable",
-    "VariableContainer",
-]
-
-from .algebraic_module_container import AlgebraicModuleContainer
-from .constant_container import ConstantContainer
-from .data import (
-    AlgebraicModule,
-    Constant,
-    DerivedConstant,
-    DerivedStoichiometry,
-    Reaction,
-    Variable,
-)
-from .name_container import NameContainer
-from .reaction_container import ReactionContainer
-from .variable_container import VariableContainer

modelbase2/core/algebraic_module_container.py

@@ -1,130 +0,0 @@
-from __future__ import annotations
-
-import logging
-from ..types import Array
-from .data import AlgebraicModule, ModuleFunction
-from dataclasses import dataclass, field
-from queue import Empty, SimpleQueue
-from typing import Iterable, Iterator, Optional, cast
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class AlgebraicModuleContainer:
-    modules: dict[str, AlgebraicModule] = field(default_factory=dict)
-    module_order: list[str] = field(default_factory=list)
-
-    def __iter__(self) -> Iterator[AlgebraicModule]:
-        return iter(self.modules.values())
-
-    def _sort_algebraic_modules(
-        self, available_args: set[str], max_iterations: int = 10_000
-    ) -> None:
-        module_order = []
-        modules_to_sort: SimpleQueue[tuple[str, AlgebraicModule]] = SimpleQueue()
-        for k, v in self.modules.items():
-            modules_to_sort.put((k, v))
-
-        last_name = None
-        i = 0
-        while True:
-            try:
-                name, mod = modules_to_sort.get_nowait()
-            except Empty:
-                break
-            if set(mod.args).issubset(available_args):
-                available_args.update(mod.derived_variables)
-                module_order.append(name)
-            else:
-                if last_name == name:
-                    module_order.append(name)
-                    break
-                modules_to_sort.put((name, mod))
-                last_name = name
-            i += 1
-            if i > max_iterations:
-                raise ValueError(
-                    "Exceeded max iterations on algebraic module sorting. Check if there are circular references."
-                )
-        self.module_order = module_order
-
-    def get_derived_variables(self) -> list[str]:
-        return [
-            variable
-            for module in self.modules.values()
-            for variable in module.derived_variables
-        ]
-
-    def add(
-        self,
-        module: AlgebraicModule,
-        available_args: set[str],
-        sort_modules: bool,
-    ) -> None:
-        if (name := module.name) in self.modules:
-            raise KeyError(f"Module {name} already exists.")
-        logger.info(f"Adding algebraic module {name}")
-        self.modules[name] = module
-        if sort_modules:
-            self._sort_algebraic_modules(available_args)
-
-    def update(
-        self,
-        name: str,
-        function: Optional[ModuleFunction],
-        derived_variables: Optional[list[str]],
-        args: Optional[list[str]],
-        available_args: set[str],
-    ) -> None:
-        module = self.remove(name, available_args, sort_modules=False)
-        if function is not None:
-            module.function = function
-        if derived_variables is not None:
-            module.derived_variables = derived_variables
-        if args is not None:
-            module.args = args
-        self.add(module, available_args, sort_modules=True)
-
-    def remove(
-        self,
-        name: str,
-        available_args: set[str],
-        sort_modules: bool,
-    ) -> AlgebraicModule:
-        logger.info(f"Removing algebraic module {name}")
-        module = self.modules.pop(name)
-        if sort_modules:
-            self._sort_algebraic_modules(available_args)
-        return module
-
-    ##########################################################################
-    # Simulation functions
-    ##########################################################################
-
-    def get_values_float(self, args: dict[str, float]) -> dict[str, float]:
-        derived_variables: dict[str, float] = {}
-        for name in self.module_order:
-            module = self.modules[name]
-            _values = module.function(*(args[arg] for arg in module.args))
-            values = dict(zip(module.derived_variables, _values))
-            derived_variables |= values
-            args |= values
-        return derived_variables
-
-    def get_values_array(
-        self,
-        args: dict[str, Array],
-    ) -> dict[str, Array]:
-        derived_variables: dict[str, Array] = {}
-        for name in self.module_order:
-            module = self.modules[name]
-            # values = np.array(module.function(*(args[arg] for arg in module.args)), dtype=float)
-            # values = values.reshape((len(module.derived_variables), -1))
-            _values = cast(
-                Iterable[Array], module.function(*(args[arg] for arg in module.args))
-            )
-            values = dict(zip(module.derived_variables, _values))
-            derived_variables |= values
-            args |= values
-        return derived_variables