modelbase2 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

modelbase2/model.py

@@ -984,7 +984,7 @@ class Model:
         return copy.deepcopy(self._reactions)
 
     def get_stoichiometries(
-        self, concs: dict[str, float] | None = None, time: float = 0.0
+        self, variables: dict[str, float] | None = None, time: float = 0.0
     ) -> pd.DataFrame:
         """Retrieve the stoichiometries of the model.
 
@@ -1000,7 +1000,7 @@ class Model:
         """
         if (cache := self._cache) is None:
             cache = self._create_cache()
-        args = self.get_dependent(concs=concs, time=time)
+        args = self.get_dependent(variables=variables, time=time)
 
         stoich_by_cpds = copy.deepcopy(cache.stoich_by_cpds)
         for cpd, stoich in cache.dyn_stoich_by_cpds.items():
@@ -1291,6 +1291,13 @@ class Model:
         self._surrogates.pop(name)
         return self
 
+    def get_surrogate_reaction_names(self) -> list[str]:
+        """Return reaction names by surrogates."""
+        names = []
+        for i in self._surrogates.values():
+            names.extend(i.stoichiometries)
+        return names
+
     ##########################################################################
     # Get dependent values. This includes
     # - derived parameters
@@ -1301,7 +1308,7 @@ class Model:
 
     def _get_dependent(
         self,
-        concs: dict[str, float],
+        variables: dict[str, float],
         time: float = 0.0,
         *,
         cache: ModelCache,
@@ -1313,7 +1320,7 @@ class Model:
                 {"x1": 1.0, "x2": 2.0, "k1": 0.1, "time": 0.0}
 
         Args:
-            concs: A dictionary of concentrations with keys as the names of the substances
+            variables: A dictionary of concentrations with keys as the names of the substances
                    and values as their respective concentrations.
             time: The time point for the calculation
             cache: A ModelCache object containing precomputed values and dependencies.
@@ -1325,7 +1332,7 @@ class Model:
                 with their respective names as keys and their calculated values as values.
 
         """
-        args: dict[str, float] = cache.all_parameter_values | concs
+        args: dict[str, float] = cache.all_parameter_values | variables
         args["time"] = time
 
         containers = self._derived | self._reactions | self._surrogates
@@ -1336,7 +1343,7 @@ class Model:
 
     def get_dependent(
         self,
-        concs: dict[str, float] | None = None,
+        variables: dict[str, float] | None = None,
         time: float = 0.0,
         *,
         include_readouts: bool = False,
@@ -1346,18 +1353,18 @@ class Model:
         Examples:
             # Using initial conditions
             >>> model.get_args()
-                {"x1": 1.0, "x2": 2.0, "k1": 0.1, "time": 0.0}
+                {"x1": 1.get_dependent, "x2": 2.0, "k1": 0.1, "time": 0.0}
 
             # With custom concentrations
-            >>> model.get_args({"x1": 1.0, "x2": 2.0})
+            >>> model.get_dependent({"x1": 1.0, "x2": 2.0})
                 {"x1": 1.0, "x2": 2.0, "k1": 0.1, "time": 0.0}
 
             # With custom concentrations and time
-            >>> model.get_args({"x1": 1.0, "x2": 2.0}, time=1.0)
+            >>> model.get_dependent({"x1": 1.0, "x2": 2.0}, time=1.0)
                 {"x1": 1.0, "x2": 2.0, "k1": 0.1, "time": 1.0}
 
         Args:
-            concs: A dictionary where keys are the names of the concentrations and values are their respective float values.
+            variables: A dictionary where keys are the names of the concentrations and values are their respective float values.
             time: The time point at which the arguments are generated (default is 0.0).
             include_readouts: Whether to include readouts in the arguments (default is False).
 
@@ -1369,7 +1376,7 @@ class Model:
             cache = self._create_cache()
 
         args = self._get_dependent(
-            concs=self.get_initial_conditions() if concs is None else concs,
+            variables=self.get_initial_conditions() if variables is None else variables,
             time=time,
             cache=cache,
         )
@@ -1382,14 +1389,14 @@ class Model:
 
     def get_dependent_time_course(
         self,
-        concs: pd.DataFrame,
+        variables: pd.DataFrame,
         *,
         include_readouts: bool = False,
     ) -> pd.DataFrame:
         """Generate a DataFrame containing time course arguments for model evaluation.
 
         Examples:
-            >>> model.get_args_time_course(
+            >>> model.get_dependent_time_course(
             ...     pd.DataFrame({"x1": [1.0, 2.0], "x2": [2.0, 3.0]}
             ... )
                 pd.DataFrame({
@@ -1400,7 +1407,7 @@ class Model:
                 )
 
         Args:
-            concs: A DataFrame containing concentration data with time as the index.
+            variables: A DataFrame containing concentration data with time as the index.
             include_readouts: If True, include readout variables in the resulting DataFrame.
 
         Returns:
@@ -1413,14 +1420,14 @@ class Model:
 
         pars_df = pd.DataFrame(
             np.full(
-                (len(concs), len(cache.all_parameter_values)),
+                (len(variables), len(cache.all_parameter_values)),
                 np.fromiter(cache.all_parameter_values.values(), dtype=float),
             ),
-            index=concs.index,
+            index=variables.index,
             columns=list(cache.all_parameter_values),
         )
 
-        args = pd.concat((concs, pars_df), axis=1)
+        args = pd.concat((variables, pars_df), axis=1)
         args["time"] = args.index
 
         containers = self._derived | self._reactions | self._surrogates
@@ -1438,7 +1445,7 @@ class Model:
 
     def get_args(
         self,
-        concs: dict[str, float] | None = None,
+        variables: dict[str, float] | None = None,
         time: float = 0.0,
         *,
         include_derived: bool = True,
@@ -1460,7 +1467,7 @@ class Model:
                 {"x1": 1.0, "x2": 2.0, "k1": 0.1, "time": 1.0}
 
         Args:
-            concs: A dictionary where keys are the names of the concentrations and values are their respective float values.
+            variables: A dictionary where keys are the names of the concentrations and values are their respective float values.
             time: The time point at which the arguments are generated.
             include_derived: Whether to include derived variables in the arguments.
             include_readouts: Whether to include readouts in the arguments.
@@ -1476,13 +1483,13 @@ class Model:
             names.extend(self._readouts)
 
         args = self.get_dependent(
-            concs=concs, time=time, include_readouts=include_readouts
+            variables=variables, time=time, include_readouts=include_readouts
         )
         return args.loc[names]
 
     def get_args_time_course(
         self,
-        concs: pd.DataFrame,
+        variables: pd.DataFrame,
         *,
         include_derived: bool = True,
         include_readouts: bool = False,
@@ -1501,7 +1508,7 @@ class Model:
                 )
 
         Args:
-            concs: A DataFrame containing concentration data with time as the index.
+            variables: A DataFrame containing concentration data with time as the index.
             include_derived: Whether to include derived variables in the arguments.
             include_readouts: If True, include readout variables in the resulting DataFrame.
 
@@ -1515,7 +1522,7 @@ class Model:
             names.extend(self.get_derived_variable_names())
 
         args = self.get_dependent_time_course(
-            concs=concs, include_readouts=include_readouts
+            variables=variables, include_readouts=include_readouts
         )
         return args.loc[:, names]
 
@@ -1547,7 +1554,7 @@ class Model:
 
     def get_fluxes(
         self,
-        concs: dict[str, float] | None = None,
+        variables: dict[str, float] | None = None,
         time: float = 0.0,
     ) -> pd.Series:
         """Calculate the fluxes for the given concentrations and time.
@@ -1566,7 +1573,7 @@ class Model:
                 pd.Series({"r1": 0.1, "r2": 0.2})
 
         Args:
-            concs: A dictionary where keys are species names and values are their concentrations.
+            variables: A dictionary where keys are species names and values are their concentrations.
             time: The time at which to calculate the fluxes. Defaults to 0.0.
 
         Returns:
@@ -1578,13 +1585,13 @@ class Model:
             names.extend(surrogate.stoichiometries)
 
         args = self.get_dependent(
-            concs=concs,
+            variables=variables,
             time=time,
             include_readouts=False,
         )
         return args.loc[names]
 
-    def get_fluxes_time_course(self, args: pd.DataFrame) -> pd.DataFrame:
+    def get_fluxes_time_course(self, variables: pd.DataFrame) -> pd.DataFrame:
         """Generate a time course of fluxes for the given reactions and surrogates.
 
         Examples:
@@ -1596,9 +1603,9 @@ class Model:
         time course of fluxes.
 
         Args:
-            args (pd.DataFrame): A DataFrame containing the input arguments for the reactions
-                                 and surrogates. Each column corresponds to a specific input
-                                 variable, and each row represents a different time point.
+            variables: A DataFrame containing the input arguments for the reactions
+                       and surrogates. Each column corresponds to a specific input
+                       variable, and each row represents a different time point.
 
         Returns:
             pd.DataFrame: A DataFrame containing the calculated fluxes for each reaction and
@@ -1610,17 +1617,17 @@ class Model:
         for surrogate in self._surrogates.values():
             names.extend(surrogate.stoichiometries)
 
-        args = self.get_dependent_time_course(
-            concs=args,
+        variables = self.get_dependent_time_course(
+            variables=variables,
             include_readouts=False,
         )
-        return args.loc[:, names]
+        return variables.loc[:, names]
 
     ##########################################################################
     # Get rhs
     ##########################################################################
 
-    def __call__(self, /, time: float, concs: Array) -> Array:
+    def __call__(self, /, time: float, variables: Array) -> Array:
         """Simulation version of get_right_hand_side.
 
         Examples:
@@ -1632,7 +1639,7 @@ class Model:
 
         Args:
             time: The current time point.
-            concs: Array of concentrations
+            variables: Array of concentrations
 
 
         Returns:
@@ -1641,15 +1648,15 @@ class Model:
         """
         if (cache := self._cache) is None:
             cache = self._create_cache()
-        concsd: dict[str, float] = dict(
+        vars_d: dict[str, float] = dict(
             zip(
                 cache.var_names,
-                concs,
+                variables,
                 strict=True,
             )
         )
         dependent: dict[str, float] = self._get_dependent(
-            concs=concsd,
+            variables=vars_d,
             time=time,
             cache=cache,
         )
@@ -1667,7 +1674,7 @@ class Model:
 
     def get_right_hand_side(
         self,
-        concs: dict[str, float] | None = None,
+        variables: dict[str, float] | None = None,
         time: float = 0.0,
     ) -> pd.Series:
         """Calculate the right-hand side of the differential equations for the model.
@@ -1686,7 +1693,7 @@ class Model:
                 pd.Series({"x1": 0.1, "x2": 0.2})
 
         Args:
-            concs: A dictionary mapping compound names to their concentrations.
+            variables: A dictionary mapping compound names to their concentrations.
             time: The current time point. Defaults to 0.0.
 
         Returns:
@@ -1697,7 +1704,7 @@ class Model:
             cache = self._create_cache()
         var_names = self.get_variable_names()
         dependent = self._get_dependent(
-            concs=self.get_initial_conditions() if concs is None else concs,
+            variables=self.get_initial_conditions() if variables is None else variables,
             time=time,
             cache=cache,
         )

modelbase2/nnarchitectures.py

@@ -33,17 +33,18 @@ class MLP(nn.Module):
     def __init__(
         self,
         n_inputs: int,
-        layers: list[int],
-        activation: Callable | None = nn.ReLU(),
+        neurons_per_layer: list[int],
+        activation: Callable | None = None,
         output_activation: Callable | None = None,
     ) -> None:
         """Initializes the MLP with the given number of inputs and list of (hidden) layers.
 
         Args:
-            n_inputs (int): The number of input features.
-            n_outputs list(int): A list containing the number of neurons in hidden and output layer.
-            activation Callable | None (default nn.ReLU()): The activation function to be applied after each hidden layer
-            activation Callable | None (default None): The activation function to be applied after the final (output) layer
+            n_inputs: The number of input features.
+            neurons_per_layer: Number of neurons per layer
+            n_outputs: A list containing the number of neurons in hidden and output layer.
+            activation: The activation function to be applied after each hidden layer (default nn.ReLU)
+            output_activation: The activation function to be applied after the final (output) layer
 
         For instance, MLP(10, layers = [50, 50, 10]) initializes a neural network with the following architecture:
         - Linear layer with `n_inputs` inputs and 50 outputs
@@ -57,8 +58,8 @@ class MLP(nn.Module):
 
         """
         super().__init__()
-        self.layers = layers
-        self.activation = activation
+        self.layers = neurons_per_layer
+        self.activation = nn.ReLU() if activation is None else activation
         self.output_activation = output_activation
 
         levels = []

modelbase2/npe.py

@@ -174,7 +174,8 @@ def train_torch_ss_estimator(
         n_hidden = max(2 * len(features.columns) * len(targets.columns), 10)
         n_outputs = len(targets.columns)
         approximator = MLP(
-            n_inputs=len(features.columns), layers=[n_hidden, n_hidden, n_outputs]
+            n_inputs=len(features.columns),
+            neurons_per_layer=[n_hidden, n_hidden, n_outputs],
         ).to(device)
 
     features_ = torch.Tensor(features.to_numpy(), device=device)

modelbase2/parameterise.py

@@ -17,8 +17,7 @@ def get_km_and_kcat_from_brenda(
     You can obtain the database from https://www.brenda-enzymes.org/download.php
     """
     brenda = Brenda()
-    if brenda_path is not None:
-        brenda.read_database(brenda_path)
+    brenda.read_database(brenda_path)
 
     kms, kcats = brenda.get_kms_and_kcats(
         ec=ec,

modelbase2/sbml/_export.py

@@ -1,16 +1,14 @@
 from __future__ import annotations
 
 import ast
-import inspect
 import re
-import textwrap
 from datetime import UTC, datetime
 from typing import TYPE_CHECKING, Any, cast
 
-import dill
 import libsbml
 import numpy as np
 
+from modelbase2.experimental.source_tools import get_fn_ast
 from modelbase2.sbml._data import AtomicUnit, Compartment
 from modelbase2.types import Derived
 
@@ -322,17 +320,7 @@ def _tree_to_sbml(
 
 
 def _sbmlify_fn(fn: Callable, user_args: list[str]) -> libsbml.ASTNode:
-    try:
-        source = inspect.getsource(fn)
-    except OSError:  # could not get source code
-        source = dill.source.getsource(fn)
-
-    tree = ast.parse(textwrap.dedent(source))
-    if not isinstance(fn_def := tree.body[0], ast.FunctionDef):
-        msg = "Not a function"
-        raise TypeError(msg)
-
-    return _tree_to_sbml(fn_def, args=user_args)
+    return _tree_to_sbml(get_fn_ast(fn), args=user_args)
 
 
 ##########################################################################

modelbase2/scan.py

@@ -35,7 +35,7 @@ import pandas as pd
 
 from modelbase2.parallel import Cache, parallelise
 from modelbase2.simulator import Simulator
-from modelbase2.types import ProtocolByPars, SteadyStates, TimeCourseByPars
+from modelbase2.types import ProtocolByPars, SteadyStates, TimeCourseByPars, unwrap
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -325,10 +325,10 @@ def _steady_state_worker(
 
     """
     try:
-        c, v = (
+        c, v = unwrap(
             Simulator(model, y0=y0)
             .simulate_to_steady_state(rel_norm=rel_norm)
-            .get_full_concs_and_fluxes()
+            .get_result()
         )
     except ZeroDivisionError:
         c = None
@@ -353,10 +353,10 @@ def _time_course_worker(
 
     """
     try:
-        c, v = (
+        c, v = unwrap(
             Simulator(model, y0=y0)
             .simulate_time_course(time_points=time_points)
-            .get_full_concs_and_fluxes()
+            .get_result()
         )
     except ZeroDivisionError:
         c = None
@@ -382,13 +382,13 @@ def _protocol_worker(
         TimeCourse: Object containing protocol series concentrations and fluxes.
 
     """
-    c, v = (
+    c, v = unwrap(
         Simulator(model, y0=y0)
         .simulate_over_protocol(
             protocol=protocol,
             time_points_per_step=time_points_per_step,
         )
-        .get_full_concs_and_fluxes()
+        .get_result()
     )
     time_points = np.linspace(
         0,