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

modelbase2/core/constant_container.py

@@ -1,113 +0,0 @@
-from __future__ import annotations
-
-from .data import Constant, DerivedConstant
-from dataclasses import dataclass, field
-from queue import Empty, SimpleQueue
-
-# import logging
-# logger = logging.getLogger(__name__)
-
-
-@dataclass
-class ConstantContainer:
-    constants: dict[str, Constant] = field(default_factory=dict)
-    derived_constants: dict[str, DerivedConstant] = field(default_factory=dict)
-    _derived_from_constants: set[str] = field(default_factory=set)
-    _derived_constant_order: list[str] = field(default_factory=list)
-    values: dict[str, float] = field(default_factory=dict)
-
-    ###############################################################################
-    # Basic
-    ###############################################################################
-
-    def add_basic(self, constant: Constant, update_derived: bool = True) -> None:
-        if (name := constant.name) in self.constants:
-            raise KeyError(f"Constant {name} already exists in the model.")
-        self.constants[name] = constant
-        self.values[name] = constant.value
-        # if name in self._derived_from_constants and update_derived:
-        #     self._update_derived_constant_values()
-
-    def remove_basic(self, name: str) -> None:
-        del self.constants[name]
-        del self.values[name]
-
-    def update_basic(self, name: str, value: float, update_derived: bool = True) -> None:
-        if name not in self.constants:
-            raise KeyError(
-                f"Constant {name} is not in the model. You have to add it first"
-            )
-        self.constants[name].value = value
-        self.values[name] = value
-        if name in self._derived_from_constants and update_derived:
-            self._update_derived_constant_values()
-
-    ###############################################################################
-    # Derived
-    ###############################################################################
-
-    def _sort_derived_constants(self, max_iterations: int = 10_000) -> None:
-        available_args = set(self.constants)
-        order = []
-        to_sort: SimpleQueue[tuple[str, DerivedConstant]] = SimpleQueue()
-        for k, v in self.derived_constants.items():
-            to_sort.put((k, v))
-
-        i = 0
-        last_name = ""
-        while True:
-            try:
-                name, constant = to_sort.get_nowait()
-                # logger.warning(f"Trying {name}, which requires {constant.args}")
-            except Empty:
-                break
-            if set(constant.args).issubset(available_args):
-                # logger.warning(f"Sorting in {name}")
-                available_args.add(name)
-                order.append(name)
-            elif name == last_name:
-                raise ValueError(f"Missing args for {name}")
-            else:
-                # logger.warning(f"{name} doesn't fit yet, {set(constant.args).difference(available_args)} missing")
-                to_sort.put((name, constant))
-                last_name = name
-            i += 1
-            if i > max_iterations:
-                raise ValueError(
-                    f"Exceeded max iterations on derived constants sorting {name}. "
-                    "Check if there are circular references."
-                )
-        self._derived_constant_order = order
-
-    def _update_derived_constant_values(self) -> None:
-        for name in self._derived_constant_order:
-            derived_constant = self.derived_constants[name]
-            value = derived_constant.function(
-                *(self.values[i] for i in derived_constant.args)
-            )
-            self.values[name] = value
-
-    def add_derived(self, constant: DerivedConstant, update_derived: bool = True) -> None:
-        name = constant.name
-        self.derived_constants[name] = constant
-        for arg in constant.args:
-            self._derived_from_constants.add(arg)
-
-        # Calculate initial value
-        value = constant.function(*(self.values[i] for i in constant.args))
-        self.values[name] = value
-        self._sort_derived_constants()
-
-        if name in self._derived_from_constants and update_derived:
-            self._update_derived_constant_values()
-
-    def remove_derived(self, name: str) -> DerivedConstant:
-        """Remove a derived constant from the model."""
-        old_constant = self.derived_constants.pop(name)
-        derived_from = old_constant.args
-        for i in derived_from:
-            if all(i not in j.args for j in self.derived_constants.values()):
-                self._derived_from_constants.remove(i)
-        del self.values[name]
-        self._derived_constant_order.remove(name)
-        return old_constant

modelbase2/core/data.py

@@ -1,109 +0,0 @@
-from __future__ import annotations
-
-from ..types import Array
-from .utils import check_function_arity
-from dataclasses import dataclass, field
-from typing import Any, Callable, Generator, Iterable, Protocol, TypeVar, Union
-
-T = TypeVar("T")
-
-
-class Arithmetic(Protocol[T]):
-    def __add__(self, other: T) -> T:
-        ...
-
-    def __mul__(self, other: T) -> T:
-        ...
-
-
-RateFunction = Callable[..., float]
-ModuleFunction = Callable[..., Iterable[float]]
-StoichiometryByReaction = dict[str, float]
-StoichiometryByVariable = dict[str, float]
-ValueData = Union[
-    dict[str, float],
-    dict[str, list[float]],
-    dict[str, Array],
-    Array,
-    list[float],
-]
-TimeData = Union[float, list[float], Array]
-
-
-@dataclass
-class Variable:
-    name: str
-    unit: str
-
-
-@dataclass
-class Constant:
-    name: str
-    value: float
-    unit: str
-    sources: list[str] = field(default_factory=list)
-
-
-@dataclass
-class DerivedConstant:
-    name: str
-    function: RateFunction
-    args: list[str]
-    unit: str
-
-
-@dataclass
-class DerivedStoichiometry:
-    function: RateFunction
-    args: list[str]
-
-
-@dataclass
-class AlgebraicModule:
-    name: str
-    function: ModuleFunction
-    derived_variables: list[str]
-    args: list[str]
-
-    def __post_init__(self) -> None:
-        if not check_function_arity(function=self.function, arity=len(self.args)):
-            raise ValueError(f"Function arity does not match args of {self.name}")
-
-    def __getitem__(self, key: str) -> Any:
-        return self.__dict__[key]
-
-    def __iter__(self) -> Generator:
-        yield from self.__dict__
-
-    def keys(self) -> tuple[str, ...]:
-        """Get all valid keys of the algebraic module"""
-        return tuple(self.__dict__)
-
-
-@dataclass
-class Rate:
-    name: str
-    function: RateFunction
-    args: list[str]
-
-    def __post_init__(self) -> None:
-        if not check_function_arity(function=self.function, arity=len(self.args)):
-            raise ValueError(f"Function arity does not match args of {self.name}")
-
-    def __getitem__(self, key: str) -> Any:
-        return self.__dict__[key]
-
-    def __iter__(self) -> Generator:
-        yield from self.__dict__
-
-    def keys(self) -> tuple[str, ...]:
-        return tuple(self.__dict__)
-
-
-@dataclass
-class Reaction:
-    name: str
-    function: RateFunction
-    stoichiometry: StoichiometryByReaction
-    args: list[str]
-    derived_stoichiometry: dict[str, DerivedStoichiometry] = field(default_factory=dict)

modelbase2/core/name_container.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-import logging
-from dataclasses import dataclass, field
-from typing import Iterable
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class NameContainer:
-    names: dict[str, str] = field(default_factory=dict)
-
-    def add(self, name: str, element_type: str) -> None:
-        if (old_type := self.names.get(name)) is not None:
-            raise KeyError(
-                f"Cannot add {element_type} {name}, as there already exists a {old_type} with that name."
-            )
-
-        logger.info(f"Adding name {name}")
-        self.names[name] = element_type
-
-    def remove(self, name: str) -> None:
-        logger.info(f"Removing name {name}")
-        del self.names[name]
-
-    def require_multiple(self, names: Iterable[str]) -> None:
-        if bool(difference := set(names).difference(self.names)):
-            raise KeyError(f"Names '{', '.join(difference)}' are missing.")

modelbase2/core/reaction_container.py

@@ -1,115 +0,0 @@
-from __future__ import annotations
-
-import logging
-import numpy as np
-import pandas as pd
-from ..types import Array
-from .data import DerivedStoichiometry, RateFunction, Reaction, StoichiometryByVariable
-from dataclasses import dataclass, field
-from typing import Optional
-
-logger = logging.getLogger()
-
-
-@dataclass
-class ReactionContainer:
-    reactions: dict[str, Reaction] = field(default_factory=dict)
-    stoichiometries_by_variables: dict[str, StoichiometryByVariable] = field(
-        default_factory=dict
-    )
-
-    def set_stoichiometry(self, variable: str, reaction: str, factor: float) -> None:
-        self.stoichiometries_by_variables.setdefault(variable, {})[reaction] = factor
-
-    def update_stoichiometry(self, name: str, reaction: Reaction) -> None:
-        for variable, factor in reaction.stoichiometry.items():
-            self.set_stoichiometry(variable, name, factor)
-
-    def update_derived_stoichiometry(
-        self, name: str, reaction: Reaction, constants: dict[str, float]
-    ) -> None:
-        for variable, derived_stoich in reaction.derived_stoichiometry.items():
-            factor = derived_stoich.function(*(constants[i] for i in derived_stoich.args))
-            self.set_stoichiometry(variable, name, factor)
-
-    def update_derived_stoichiometries(self, constants: dict[str, float]) -> None:
-        for name, reaction in self.reactions.items():
-            self.update_derived_stoichiometry(name, reaction, constants)
-
-    def add(self, reaction: Reaction, constants: dict[str, float]) -> None:
-        if (name := reaction.name) in self.reactions:
-            raise KeyError(f"Reaction {name} already exists in the model.")
-        self.reactions[name] = reaction
-        self.update_stoichiometry(name, reaction)
-        self.update_derived_stoichiometry(name, reaction, constants)
-
-    def remove(self, name: str) -> Reaction:
-        reaction = self.reactions.pop(name)
-        for variable in reaction.stoichiometry:
-            del self.stoichiometries_by_variables[variable][name]
-            if not bool(self.stoichiometries_by_variables[variable]):
-                del self.stoichiometries_by_variables[variable]
-
-        return reaction
-
-    def update(
-        self,
-        name: str,
-        function: Optional[RateFunction],
-        stoichiometry: Optional[StoichiometryByVariable],
-        # derived_stoichiometry: Optional[DerivedStoichiometry],
-        derived_stoichiometry: Optional[dict[str, DerivedStoichiometry]],
-        args: Optional[list[str]],
-        constants: dict[str, float],
-    ) -> None:
-        reaction = self.remove(name)
-        if function is not None:
-            reaction.function = function
-        if stoichiometry is not None:
-            reaction.stoichiometry = stoichiometry
-        if derived_stoichiometry is not None:
-            reaction.derived_stoichiometry = derived_stoichiometry
-        if args is not None:
-            reaction.args = args
-        self.add(reaction, constants)
-
-    def get_names(self) -> list[str]:
-        return list(self.reactions)
-
-    def get_stoichiometries(self) -> pd.DataFrame:
-        reactions = self.reactions
-        variables = self.stoichiometries_by_variables
-        variable_indexes = {v: k for k, v in enumerate(variables)}
-        reaction_indexes = {v: k for k, v in enumerate(reactions)}
-
-        data = np.zeros(shape=[len(variables), len(reactions)])
-        for cpd, stoich in variables.items():
-            for reaction, factor in stoich.items():
-                data[variable_indexes[cpd], reaction_indexes[reaction]] = factor
-        # for stoich_idx, reaction in enumerate(reactions.values()):
-        #     for cpd, stoich in reaction.stoichiometry.items():
-        #         data[variable_indexes[cpd], stoich_idx] = stoich
-        return pd.DataFrame(
-            data=data,
-            index=variables,
-            columns=reactions,
-        )
-
-    def get_fluxes_float(self, args: dict[str, float]) -> dict[str, float]:
-        fluxes = {}
-        for name, reaction in self.reactions.items():
-            fluxes[name] = reaction.function(*(args[arg] for arg in reaction.args))
-        return fluxes
-
-    def get_fluxes_array(self, args: dict[str, Array]) -> dict[str, Array]:
-        fluxes = np.full((len(self.reactions), len(args["time"])), np.nan, dtype=float)
-        for i, reaction in enumerate(self.reactions.values()):
-            fluxes[i, :] = reaction.function(*(args[arg] for arg in reaction.args))
-        return dict(zip(self.reactions.keys(), fluxes))
-
-    def get_right_hand_side_float(self, fluxes: dict[str, float]) -> dict[str, float]:
-        rhs: dict[str, float] = {}
-        for cpd, stoichiometry in self.stoichiometries_by_variables.items():
-            for rate, factor in stoichiometry.items():
-                rhs[cpd] = rhs.get(cpd, 0) + factor * fluxes[rate]
-        return rhs

modelbase2/core/utils.py

@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-import inspect
-from typing import Callable
-
-
-def check_function_arity(function: Callable, arity: int) -> bool:
-    """Check if the amount of arguments given match argument count"""
-    argspec = inspect.getfullargspec(function)
-    # Give up on *args functions
-    if argspec.varargs is not None:
-        return True
-
-    # The sane case
-    if len(argspec.args) == arity:
-        return True
-
-    # It might be that the user has set some args to default values,
-    # in which case they are also ok (might be kwonly as well)
-    defaults = argspec.defaults
-    if defaults is not None:
-        if len(argspec.args) + len(defaults) == arity:
-            return True
-    kwonly = argspec.kwonlyargs
-    if defaults is not None:
-        if len(argspec.args) + len(kwonly) == arity:
-            return True
-    return False

modelbase2/core/variable_container.py

@@ -1,24 +0,0 @@
-from __future__ import annotations
-
-from .data import Variable
-from dataclasses import dataclass, field
-from typing import Iterator
-
-
-@dataclass
-class VariableContainer:
-    variables: dict[str, Variable] = field(default_factory=dict)
-
-    def __iter__(self) -> Iterator[str]:
-        return iter(self.variables)
-
-    def add(self, variable: Variable) -> None:
-        name = variable.name
-        if name == "time":
-            raise KeyError("'time' is a protected variable for the simulation time")
-        if name in self.variables:
-            raise KeyError(f"Variable {variable} already exists.")
-        self.variables[variable.name] = variable
-
-    def remove(self, variable: str) -> None:
-        del self.variables[variable]

modelbase2/ode/__init__.py

@@ -1,13 +0,0 @@
-from __future__ import annotations
-
-__all__ = [
-    "Assimulo",
-    "Model",
-    "Simulator",
-    "mca",
-]
-
-from . import mca
-from .integrator import Assimulo
-from .model import Model
-from .simulator import Simulator

modelbase2/ode/integrator.py

@@ -1,80 +0,0 @@
-from __future__ import annotations
-
-import numpy as np
-from ..types import Array
-from assimulo.problem import Explicit_Problem  # type: ignore
-from assimulo.solvers import CVode  # type: ignore
-from assimulo.solvers.sundials import CVodeError  # type: ignore
-from dataclasses import dataclass
-from typing import Callable, Optional, cast
-
-
-@dataclass
-class AssmimuloSettings:
-    atol: float = 1e-8
-    rtol: float = 1e-8
-    maxnef: int = 4
-    maxncf: int = 1
-    verbosity: int = 50
-
-
-@dataclass
-class IntegrationResult:
-    time: Array
-    values: Array
-
-
-@dataclass(init=False)
-class Assimulo:
-    problem: Explicit_Problem
-    integrator: CVode
-    settings: AssmimuloSettings
-
-    def __init__(
-        self,
-        rhs: Callable,
-        y0: list[float],
-        settings: Optional[AssmimuloSettings] = None,
-    ) -> None:
-        self.problem = Explicit_Problem(rhs, y0)
-        self.integrator = CVode(self.problem)
-        self.settings = AssmimuloSettings() if settings is None else settings
-
-    def _set_settings(self) -> None:
-        for k, v in self.settings.__dict__.items():
-            setattr(self.integrator, k, v)
-
-    def update_settings(self, settings: AssmimuloSettings) -> None:
-        self.settings = settings
-
-    def integrate(
-        self,
-        t_end: float,
-        steps: Optional[int],
-        time_points: Optional[list[float]],
-    ) -> Optional[IntegrationResult]:
-        self._set_settings()
-        if steps is None:
-            steps = 0
-        try:
-            t, y = self.integrator.simulate(t_end, steps, time_points)
-            return IntegrationResult(np.array(t, dtype=float), np.array(y, dtype=float))
-        except CVodeError:
-            return None
-
-    def integrate_to_steady_state(self, tolerance: float) -> Optional[Array]:
-        self.reset()
-        self._set_settings()
-        t_end = 1000
-        for _ in range(1, 4):
-            res = self.integrate(t_end, None, None)
-            if res is None:
-                return None
-            y = res.values
-            if np.linalg.norm(y[-1] - y[-2], ord=2) < tolerance:
-                return cast(Array, y[-1])
-            t_end *= 1000
-        return None
-
-    def reset(self) -> None:
-        self.integrator.reset()