modelbase2 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

modelbase2/experimental/symbolic.py

@@ -0,0 +1,286 @@
+# ruff: noqa: D100, D101, D102, D103, D104, D105, D106, D107, D200, D203, D400, D401
+
+import ast
+import inspect
+import textwrap
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, cast
+
+import sympy
+
+from modelbase2.model import Model
+
+__all__ = ["Context", "SymbolicModel", "model_fn_to_sympy", "to_symbolic_model"]
+
+
+@dataclass
+class Context:
+    symbols: dict[str, sympy.Symbol | sympy.Expr]
+    caller: Callable
+
+
+@dataclass
+class SymbolicModel:
+    variables: dict[str, sympy.Symbol]
+    parameters: dict[str, sympy.Symbol]
+    eqs: list[sympy.Expr]
+
+
+def to_symbolic_model(model: Model) -> SymbolicModel:
+    cache = model._create_cache()  # noqa: SLF001
+
+    variables = dict(
+        zip(model.variables, sympy.symbols(list(model.variables)), strict=True)
+    )
+    parameters = dict(
+        zip(model.parameters, sympy.symbols(list(model.parameters)), strict=True)
+    )
+    symbols = variables | parameters
+
+    for k, v in model.derived.items():
+        symbols[k] = model_fn_to_sympy(v.fn, [symbols[i] for i in v.args])
+
+    rxns = {
+        k: model_fn_to_sympy(v.fn, [symbols[i] for i in v.args])
+        for k, v in model.reactions.items()
+    }
+
+    eqs: dict[str, sympy.Expr] = {}
+    for cpd, stoich in cache.stoich_by_cpds.items():
+        for rxn, stoich_value in stoich.items():
+            eqs[cpd] = (
+                eqs.get(cpd, sympy.Float(0.0)) + sympy.Float(stoich_value) * rxns[rxn]  # type: ignore
+            )
+
+    for cpd, dstoich in cache.dyn_stoich_by_cpds.items():
+        for rxn, der in dstoich.items():
+            eqs[cpd] = eqs.get(cpd, sympy.Float(0.0)) + model_fn_to_sympy(
+                der.fn,
+                [symbols[i] for i in der.args] * rxns[rxn],  # type: ignore
+            )  # type: ignore
+
+    return SymbolicModel(
+        variables=variables,
+        parameters=parameters,
+        eqs=[eqs[i] for i in cache.var_names],
+    )
+
+
+def model_fn_to_sympy(
+    fn: Callable, model_args: list[sympy.Symbol | sympy.Expr] | None = None
+) -> sympy.Expr:
+    source = textwrap.dedent(inspect.getsource(fn))
+
+    if not isinstance(fn_def := ast.parse(source).body[0], ast.FunctionDef):
+        msg = "Expected a function definition"
+        raise TypeError(msg)
+
+    fn_args = [str(arg.arg) for arg in fn_def.args.args]
+
+    sympy_expr = _handle_fn_body(
+        fn_def.body,
+        ctx=Context(
+            symbols={name: sympy.Symbol(name) for name in fn_args},
+            caller=fn,
+        ),
+    )
+
+    if model_args is not None:
+        sympy_expr = sympy_expr.subs(dict(zip(fn_args, model_args, strict=True)))
+
+    return cast(sympy.Expr, sympy_expr)
+
+
+def _handle_fn_body(body: list[ast.stmt], ctx: Context) -> sympy.Expr:
+    pieces = []
+    remaining_body = list(body)
+
+    while remaining_body:
+        node = remaining_body.pop(0)
+
+        if isinstance(node, ast.If):
+            condition = _handle_expr(node.test, ctx)
+            if_expr = _handle_fn_body(node.body, ctx)
+            pieces.append((if_expr, condition))
+
+            # If there's an else clause
+            if node.orelse:
+                # Check if it's an elif (an If node in orelse)
+                if len(node.orelse) == 1 and isinstance(node.orelse[0], ast.If):
+                    # Push the elif back to the beginning of remaining_body to process next
+                    remaining_body.insert(0, node.orelse[0])
+                else:
+                    # It's a regular else
+                    else_expr = _handle_fn_body(node.orelse, ctx)  # FIXME: copy here
+                    pieces.append((else_expr, True))
+                    break  # We're done with this chain
+
+            elif not remaining_body and any(
+                isinstance(n, ast.Return) for n in body[body.index(node) + 1 :]
+            ):
+                else_expr = _handle_fn_body(
+                    body[body.index(node) + 1 :], ctx
+                )  # FIXME: copy here
+                pieces.append((else_expr, True))
+
+        elif isinstance(node, ast.Return):
+            if (value := node.value) is None:
+                msg = "Return value cannot be None"
+                raise ValueError(msg)
+
+            expr = _handle_expr(value, ctx)
+            if not pieces:
+                return expr
+            pieces.append((expr, True))
+            break
+
+        elif isinstance(node, ast.Assign):
+            # Handle tuple assignments like c, d = a, b
+            if isinstance(node.targets[0], ast.Tuple):
+                # Handle tuple unpacking
+                target_elements = node.targets[0].elts
+
+                if isinstance(node.value, ast.Tuple):
+                    # Direct unpacking like c, d = a, b
+                    value_elements = node.value.elts
+                    for target, value_expr in zip(
+                        target_elements, value_elements, strict=True
+                    ):
+                        if isinstance(target, ast.Name):
+                            ctx.symbols[target.id] = _handle_expr(value_expr, ctx)
+                else:
+                    # Handle potential iterable unpacking
+                    value = _handle_expr(node.value, ctx)
+            else:
+                # Regular single assignment
+                if not isinstance(target := node.targets[0], ast.Name):
+                    msg = "Only single variable assignments are supported"
+                    raise TypeError(msg)
+                target_name = target.id
+                value = _handle_expr(node.value, ctx)
+                ctx.symbols[target_name] = value
+
+    # If we have pieces to combine into a Piecewise
+    if pieces:
+        return sympy.Piecewise(*pieces)
+
+    # If no return was found but we have assignments, return the last assigned variable
+    for node in reversed(body):
+        if isinstance(node, ast.Assign) and isinstance(node.targets[0], ast.Name):
+            target_name = node.targets[0].id
+            return ctx.symbols[target_name]
+
+    msg = "No return value found in function body"
+    raise ValueError(msg)
+
+
+def _handle_unaryop(node: ast.UnaryOp, ctx: Context) -> sympy.Expr:
+    left = _handle_expr(node.operand, ctx)
+    left = cast(Any, left)  # stupid sympy types don't allow ops on symbols
+
+    if isinstance(node.op, ast.UAdd):
+        return +left
+    if isinstance(node.op, ast.USub):
+        return -left
+
+    msg = f"Operation {type(node.op).__name__} not implemented"
+    raise NotImplementedError(msg)
+
+
+def _handle_binop(node: ast.BinOp, ctx: Context) -> sympy.Expr:
+    left = _handle_expr(node.left, ctx)
+    left = cast(Any, left)  # stupid sympy types don't allow ops on symbols
+
+    right = _handle_expr(node.right, ctx)
+    right = cast(Any, right)  # stupid sympy types don't allow ops on symbols
+
+    if isinstance(node.op, ast.Add):
+        return left + right
+    if isinstance(node.op, ast.Sub):
+        return left - right
+    if isinstance(node.op, ast.Mult):
+        return left * right
+    if isinstance(node.op, ast.Div):
+        return left / right
+    if isinstance(node.op, ast.Pow):
+        return left**right
+    if isinstance(node.op, ast.Mod):
+        return left % right
+    if isinstance(node.op, ast.FloorDiv):
+        return left // right
+
+    msg = f"Operation {type(node.op).__name__} not implemented"
+    raise NotImplementedError(msg)
+
+
+def _handle_call(node: ast.Call, ctx: Context) -> sympy.Expr:
+    if not isinstance(callee := node.func, ast.Name):
+        msg = "Only function calls with names are supported"
+        raise TypeError(msg)
+
+    fn_name = str(callee.id)
+    parent_module = inspect.getmodule(ctx.caller)
+    fns = dict(inspect.getmembers(parent_module, predicate=callable))
+
+    return model_fn_to_sympy(
+        fns[fn_name],
+        model_args=[_handle_expr(i, ctx) for i in node.args],
+    )
+
+
+def _handle_name(node: ast.Name, ctx: Context) -> sympy.Symbol | sympy.Expr:
+    return ctx.symbols[node.id]
+
+
+def _handle_expr(node: ast.expr, ctx: Context) -> sympy.Expr:
+    if isinstance(node, ast.UnaryOp):
+        return _handle_unaryop(node, ctx)
+    if isinstance(node, ast.BinOp):
+        return _handle_binop(node, ctx)
+    if isinstance(node, ast.Name):
+        return _handle_name(node, ctx)
+    if isinstance(node, ast.Constant):
+        return node.value
+    if isinstance(node, ast.Compare):
+        # Handle chained comparisons like 1 < a < 2
+        left = cast(Any, _handle_expr(node.left, ctx))
+        comparisons = []
+
+        # Build all individual comparisons from the chain
+        prev_value = left
+        for op, comparator in zip(node.ops, node.comparators, strict=True):
+            right = cast(Any, _handle_expr(comparator, ctx))
+
+            if isinstance(op, ast.Gt):
+                comparisons.append(prev_value > right)
+            elif isinstance(op, ast.GtE):
+                comparisons.append(prev_value >= right)
+            elif isinstance(op, ast.Lt):
+                comparisons.append(prev_value < right)
+            elif isinstance(op, ast.LtE):
+                comparisons.append(prev_value <= right)
+            elif isinstance(op, ast.Eq):
+                comparisons.append(prev_value == right)
+            elif isinstance(op, ast.NotEq):
+                comparisons.append(prev_value != right)
+
+            prev_value = right
+
+        # Combine all comparisons with logical AND
+        result = comparisons[0]
+        for comp in comparisons[1:]:
+            result = sympy.And(result, comp)
+        return cast(sympy.Expr, result)
+    if isinstance(node, ast.Call):
+        return _handle_call(node, ctx)
+
+    # Handle conditional expressions (ternary operators)
+    if isinstance(node, ast.IfExp):
+        condition = _handle_expr(node.test, ctx)
+        if_true = _handle_expr(node.body, ctx)
+        if_false = _handle_expr(node.orelse, ctx)
+        return sympy.Piecewise((if_true, condition), (if_false, True))
+
+    msg = f"Expression type {type(node).__name__} not implemented"
+    raise NotImplementedError(msg)

modelbase2/experimental/tex.py

@@ -508,14 +508,10 @@ def get_model_tex_diff(
     gls = default_init(gls)
     section_label = "sec:model-diff"
 
-    return f"""{' start autogenerated ':%^60}
+    return f"""{" start autogenerated ":%^60}
 {_clearpage()}
-{_subsubsection('Model changes')}{_label(section_label)}
-{(
-    (_to_tex_export(m1) - _to_tex_export(m2))
-    .rename_with_glossary(gls)
-    .export_all()
-)}
+{_subsubsection("Model changes")}{_label(section_label)}
+{((_to_tex_export(m1) - _to_tex_export(m2)).rename_with_glossary(gls).export_all())}
 {_clearpage()}
-{' end autogenerated ':%^60}
+{" end autogenerated ":%^60}
 """

modelbase2/fit.py

@@ -50,7 +50,7 @@ class SteadyStateResidualFn(Protocol):
         data: pd.Series,
         model: Model,
         y0: dict[str, float],
-        integrator: type[IntegratorProtocol],
+        integrator: Callable[[Callable, ArrayLike], IntegratorProtocol],
     ) -> float:
         """Calculate residual error between model steady state and experimental data."""
         ...
@@ -67,7 +67,7 @@ class TimeSeriesResidualFn(Protocol):
         data: pd.DataFrame,
         model: Model,
         y0: dict[str, float],
-        integrator: type[IntegratorProtocol],
+        integrator: Callable[[Callable, ArrayLike], IntegratorProtocol],
     ) -> float:
         """Calculate residual error between model time course and experimental data."""
         ...
@@ -101,7 +101,7 @@ def _steady_state_residual(
     data: pd.Series,
     model: Model,
     y0: dict[str, float] | None,
-    integrator: type[IntegratorProtocol],
+    integrator: Callable[[Callable, ArrayLike], IntegratorProtocol],
 ) -> float:
     """Calculate residual error between model steady state and experimental data.
 
@@ -148,7 +148,7 @@ def _time_course_residual(
     data: pd.DataFrame,
     model: Model,
     y0: dict[str, float],
-    integrator: type[IntegratorProtocol],
+    integrator: Callable[[Callable, ArrayLike], IntegratorProtocol],
 ) -> float:
     """Calculate residual error between model time course and experimental data.
 
@@ -187,7 +187,7 @@ def steady_state(
     y0: dict[str, float] | None = None,
     minimize_fn: MinimizeFn = _default_minimize_fn,
     residual_fn: SteadyStateResidualFn = _steady_state_residual,
-    integrator: type[IntegratorProtocol] = DefaultIntegrator,
+    integrator: Callable[[Callable, ArrayLike], IntegratorProtocol] = DefaultIntegrator,
 ) -> dict[str, float]:
     """Fit model parameters to steady-state experimental data.
 
@@ -241,7 +241,7 @@ def time_course(
     y0: dict[str, float] | None = None,
     minimize_fn: MinimizeFn = _default_minimize_fn,
     residual_fn: TimeSeriesResidualFn = _time_course_residual,
-    integrator: type[IntegratorProtocol] = DefaultIntegrator,
+    integrator: Callable[[Callable, ArrayLike], IntegratorProtocol] = DefaultIntegrator,
 ) -> dict[str, float]:
     """Fit model parameters to time course of experimental data.
 

modelbase2/model.py

@@ -10,7 +10,6 @@ from __future__ import annotations
 import copy
 import inspect
 import itertools as it
-import math
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Self, cast
 
@@ -26,7 +25,13 @@ from modelbase2.types import (
     Readout,
 )
 
-__all__ = ["ArityMismatchError", "Model", "ModelCache", "SortError"]
+__all__ = [
+    "ArityMismatchError",
+    "CircularDependencyError",
+    "MissingDependenciesError",
+    "Model",
+    "ModelCache",
+]
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Mapping
@@ -35,19 +40,38 @@ if TYPE_CHECKING:
     from modelbase2.types import AbstractSurrogate, Callable, Param, RateFn, RetType
 
 
-class SortError(Exception):
+class MissingDependenciesError(Exception):
     """Raised when dependencies cannot be sorted topologically.
 
     This typically indicates circular dependencies in model components.
     """
 
-    def __init__(self, unsorted: list[str], order: list[str]) -> None:
+    def __init__(self, not_solvable: dict[str, list[str]]) -> None:
         """Initialise exception."""
+        missing_by_module = "\n".join(f"\t{k}: {v}" for k, v in not_solvable.items())
         msg = (
-            f"Exceeded max iterations on sorting derived. "
-            "Check if there are circular references.\n"
-            f"Unsorted: {unsorted}\n"
-            f"Order: {order}"
+            f"Dependencies cannot be solved. Missing dependencies:\n{missing_by_module}"
+        )
+        super().__init__(msg)
+
+
+class CircularDependencyError(Exception):
+    """Raised when dependencies cannot be sorted topologically.
+
+    This typically indicates circular dependencies in model components.
+    """
+
+    def __init__(
+        self,
+        missing: dict[str, set[str]],
+    ) -> None:
+        """Initialise exception."""
+        missing_by_module = "\n".join(f"\t{k}: {v}" for k, v in missing.items())
+        msg = (
+            f"Exceeded max iterations on sorting dependencies.\n"
+            "Check if there are circular references. "
+            "Missing dependencies:\n"
+            f"{missing_by_module}"
         )
         super().__init__(msg)
 
@@ -120,6 +144,24 @@ def _invalidate_cache(method: Callable[Param, RetType]) -> Callable[Param, RetTy
     return wrapper  # type: ignore
 
 
+def _check_if_is_sortable(
+    available: set[str],
+    elements: list[tuple[str, set[str]]],
+) -> None:
+    all_available = available.copy()
+    for name, _ in elements:
+        all_available.add(name)
+
+    # Check if it can be sorted in the first place
+    not_solvable = {}
+    for name, args in elements:
+        if not args.issubset(all_available):
+            not_solvable[name] = sorted(args.difference(all_available))
+
+    if not_solvable:
+        raise MissingDependenciesError(not_solvable=not_solvable)
+
+
 def _sort_dependencies(
     available: set[str], elements: list[tuple[str, set[str]]]
 ) -> list[str]:
@@ -138,6 +180,8 @@ def _sort_dependencies(
     """
     from queue import Empty, SimpleQueue
 
+    _check_if_is_sortable(available, elements)
+
     order = []
     # FIXME: what is the worst case here?
     max_iterations = len(elements) ** 2
@@ -171,7 +215,10 @@ def _sort_dependencies(
                     unsorted.append(queue.get_nowait()[0])
                 except Empty:
                     break
-            raise SortError(unsorted=unsorted, order=order)
+
+            mod_to_args: dict[str, set[str]] = dict(elements)
+            missing = {k: mod_to_args[k].difference(available) for k in unsorted}
+            raise CircularDependencyError(missing=missing)
     return order
 
 

modelbase2/npe.py

@@ -23,7 +23,7 @@ __all__ = [
 from abc import abstractmethod
 from dataclasses import dataclass
 from pathlib import Path
-from typing import cast
+from typing import TYPE_CHECKING, cast
 
 import numpy as np
 import pandas as pd
@@ -35,6 +35,11 @@ from torch.optim.adam import Adam
 from modelbase2.nnarchitectures import MLP, DefaultDevice, LSTMnn
 from modelbase2.parallel import Cache
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from torch.optim.optimizer import ParamsT
+
 DefaultCache = Cache(Path(".cache"))
 
 
@@ -140,7 +145,7 @@ def train_torch_ss_estimator(
     epochs: int,
     batch_size: int | None = None,
     approximator: nn.Module | None = None,
-    optimimzer_cls: type[Adam] = Adam,
+    optimimzer_cls: Callable[[ParamsT], Adam] = Adam,
     device: torch.device = DefaultDevice,
 ) -> tuple[TorchSSEstimator, pd.Series]:
     """Train a PyTorch steady state estimator.
@@ -206,7 +211,7 @@ def train_torch_time_course_estimator(
     epochs: int,
     batch_size: int | None = None,
     approximator: nn.Module | None = None,
-    optimimzer_cls: type[Adam] = Adam,
+    optimimzer_cls: Callable[[ParamsT], Adam] = Adam,
     device: torch.device = DefaultDevice,
 ) -> tuple[TorchTimeCourseEstimator, pd.Series]:
     """Train a PyTorch time course estimator.

modelbase2/plot.py

@@ -818,7 +818,7 @@ def relative_label_distribution(
                 isos = mapper.get_isotopomers_of_at_position(name, i)
                 labels = cast(pd.DataFrame, concs.loc[:, isos])
                 total = concs.loc[:, f"{name}__total"]
-                ax.plot(labels.index, (labels.sum(axis=1) / total), label=f"C{i+1}")
+                ax.plot(labels.index, (labels.sum(axis=1) / total), label=f"C{i + 1}")
             ax.set_title(name)
             ax.legend()
     else:
@@ -827,6 +827,6 @@ def relative_label_distribution(
         ):
             ax.plot(concs.index, concs.loc[:, isos])
             ax.set_title(name)
-            ax.legend([f"C{i+1}" for i in range(len(isos))])
+            ax.legend([f"C{i + 1}" for i in range(len(isos))])
 
     return fig, axs

modelbase2/sbml/_import.py

@@ -507,7 +507,11 @@ def _codgen(name: str, sbml: Parser) -> Path:
 
     # Initial assignments
     initial_assignment_order = _sort_dependencies(
-        available=set(sbml.initial_assignment) ^ set(parameters) ^ set(variables),
+        available=set(sbml.initial_assignment)
+        ^ set(parameters)
+        ^ set(variables)
+        ^ set(sbml.derived)
+        | {"time"},
         elements=[(k, set(v.args)) for k, v in sbml.initial_assignment.items()],
     )
 

modelbase2/simulator.py

@@ -21,6 +21,8 @@ from modelbase2.integrators import DefaultIntegrator
 __all__ = ["Simulator"]
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from modelbase2.model import Model
     from modelbase2.types import ArrayLike, IntegratorProtocol
 
@@ -83,7 +85,9 @@ class Simulator:
         self,
         model: Model,
         y0: dict[str, float] | None = None,
-        integrator: type[IntegratorProtocol] = DefaultIntegrator,
+        integrator: Callable[
+            [Callable, ArrayLike], IntegratorProtocol
+        ] = DefaultIntegrator,
         *,
         test_run: bool = True,
     ) -> None:
@@ -93,7 +97,7 @@ class Simulator:
             model (Model): The model to be simulated.
             y0 (dict[str, float] | None, optional): Initial conditions for the model variables.
                 If None, the initial conditions are obtained from the model. Defaults to None.
-            integrator (type[IntegratorProtocol], optional): The integrator to use for the simulation.
+            integrator (Callable[[Callable, ArrayLike], IntegratorProtocol], optional): The integrator to use for the simulation.
                 Defaults to DefaultIntegrator.
             test_run (bool, optional): If True, performs a test run to ensure the model's methods
                 (get_full_concs, get_fluxes, get_right_hand_side) work correctly with the initial conditions.
@@ -104,7 +108,7 @@ class Simulator:
         y0 = model.get_initial_conditions() if y0 is None else y0
         self.y0 = [y0[k] for k in model.get_variable_names()]
 
-        self.integrator = integrator(self.model, y0=self.y0)
+        self.integrator = integrator(self.model, self.y0)
         self.concs = None
         self.args = None
         self.simulation_parameters = None

modelbase2/surrogates/_poly.py

@@ -32,7 +32,9 @@ class PolySurrogate(AbstractSurrogate):
 def train_polynomial_surrogate(
     feature: ArrayLike,
     target: ArrayLike,
-    series: Literal["Power", "Chebyshev", "Legendre", "Laguerre", "Hermite", "HermiteE"] = "Power",
+    series: Literal[
+        "Power", "Chebyshev", "Legendre", "Laguerre", "Hermite", "HermiteE"
+    ] = "Power",
     degrees: Iterable[int] = (1, 2, 3, 4, 5, 6, 7),
     surrogate_args: list[str] | None = None,
     surrogate_stoichiometries: dict[str, dict[str, float]] | None = None,

modelbase2/surrogates/_torch.py

@@ -1,3 +1,4 @@
+from collections.abc import Callable
 from dataclasses import dataclass
 
 import numpy as np
@@ -6,9 +7,10 @@ import torch
 import tqdm
 from torch import nn
 from torch.optim.adam import Adam
+from torch.optim.optimizer import ParamsT
 
-from modelbase2.types import AbstractSurrogate
 from modelbase2.nnarchitectures import MLP, DefaultDevice
+from modelbase2.types import AbstractSurrogate
 
 __all__ = ["TorchSurrogate", "train_torch_surrogate"]
 
@@ -124,7 +126,7 @@ def train_torch_surrogate(
     surrogate_stoichiometries: dict[str, dict[str, float]] | None = None,
     batch_size: int | None = None,
     approximator: nn.Module | None = None,
-    optimimzer_cls: type[Adam] = Adam,
+    optimimzer_cls: Callable[[ParamsT], Adam] = Adam,
     device: torch.device = DefaultDevice,
 ) -> tuple[TorchSurrogate, pd.Series]:
     """Train a PyTorch surrogate model.

modelbase2/surrogates.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 from abc import abstractmethod
 from dataclasses import dataclass
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
@@ -29,6 +30,11 @@ from torch.optim.adam import Adam
 
 from modelbase2.parallel import Cache
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from torch.optim.optimizer import ParamsT
+
 __all__ = [
     "AbstractSurrogate",
     "Approximator",
@@ -251,7 +257,7 @@ def train_torch_surrogate(
     surrogate_stoichiometries: dict[str, dict[str, float]],
     batch_size: int | None = None,
     approximator: nn.Module | None = None,
-    optimimzer_cls: type[Adam] = Adam,
+    optimimzer_cls: Callable[[ParamsT], Adam] = Adam,
     device: torch.device = DefaultDevice,
 ) -> tuple[TorchSurrogate, pd.Series]:
     """Train a PyTorch surrogate model.

{modelbase2-0.3.0.dist-info → modelbase2-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelbase2
-Version: 0.3.0
+Version: 0.5.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>
@@ -33,6 +33,7 @@ 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: symbtools>=0.4.0
 Requires-Dist: sympy>=1.13.1
 Requires-Dist: tabulate>=0.9.0
 Requires-Dist: tqdm>=4.66.6