mxlpy 0.8.0__py3-none-any.whl

mxlpy/types.py

@@ -0,0 +1,474 @@
+"""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",
+    "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
+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 mxlpy.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[Array | None, ArrayLike | None]:
+        """Integrate the system."""
+        ...
+
+    def integrate_time_course(
+        self, *, time_points: ArrayLike
+    ) -> tuple[Array | 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(kw_only=True, slots=True)
+class Derived:
+    """Container for a derived value."""
+
+    name: str
+    fn: RateFn
+    args: list[str]
+
+    def calculate(self, dependent: dict[str, float]) -> float:
+        """Calculate the derived value.
+
+        Args:
+            dependent: Dictionary of dependent variables.
+
+        Returns:
+            The calculated derived value.
+
+        """
+        return cast(float, self.fn(*(dependent[arg] for arg in self.args)))
+
+    def calculate_inpl(self, dependent: dict[str, float]) -> None:
+        """Calculate the derived value in place.
+
+        Args:
+            dependent: Dictionary of dependent variables.
+
+        """
+        dependent[self.name] = cast(
+            float, self.fn(*(dependent[arg] for arg in self.args))
+        )
+
+    def calculate_inpl_time_course(self, dependent: pd.DataFrame) -> None:
+        """Calculate the derived value in place.
+
+        Args:
+            dependent: Dictionary of dependent variables.
+
+        """
+        dependent[self.name] = self.fn(*dependent.loc[:, self.args].to_numpy().T)
+
+
+@dataclass(kw_only=True, slots=True)
+class Readout:
+    """Container for a readout."""
+
+    name: str
+    fn: RateFn
+    args: list[str]
+
+    def calculate(self, dependent: dict[str, float]) -> float:
+        """Calculate the derived value.
+
+        Args:
+            dependent: Dictionary of dependent variables.
+
+        Returns:
+            The calculated derived value.
+
+        """
+        return cast(float, self.fn(*(dependent[arg] for arg in self.args)))
+
+    def calculate_inpl(self, dependent: dict[str, float]) -> None:
+        """Calculate the readout in place.
+
+        Args:
+            dependent: Dictionary of dependent variables.
+
+        """
+        dependent[self.name] = cast(
+            float, self.fn(*(dependent[arg] for arg in self.args))
+        )
+
+    def calculate_inpl_time_course(self, dependent: pd.DataFrame) -> None:
+        """Calculate the derived value in place.
+
+        Args:
+            dependent: Dictionary of dependent variables.
+
+        """
+        dependent[self.name] = self.fn(*dependent.loc[:, self.args].to_numpy().T)
+
+
+@dataclass(kw_only=True, slots=True)
+class Reaction:
+    """Container for a reaction."""
+
+    name: str
+    fn: RateFn
+    stoichiometry: Mapping[str, float | Derived]
+    args: list[str]
+
+    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]
+
+    def calculate(self, dependent: dict[str, float]) -> float:
+        """Calculate the derived value.
+
+        Args:
+            dependent: Dictionary of dependent variables.
+
+        Returns:
+            The calculated derived value.
+
+        """
+        return cast(float, self.fn(*(dependent[arg] for arg in self.args)))
+
+    def calculate_inpl(self, dependent: dict[str, float]) -> None:
+        """Calculate the reaction in place.
+
+        Args:
+            dependent: Dictionary of dependent variables.
+
+        """
+        dependent[self.name] = cast(
+            float, self.fn(*(dependent[arg] for arg in self.args))
+        )
+
+    def calculate_inpl_time_course(self, dependent: pd.DataFrame) -> None:
+        """Calculate the derived value in place.
+
+        Args:
+            dependent: Dictionary of dependent variables.
+
+        """
+        try:
+            dependent[self.name] = self.fn(*dependent.loc[:, self.args].to_numpy().T)
+        except ValueError:  # e.g. numpy.where
+            sub = dependent.loc[:, self.args].to_numpy()
+            dependent[self.name] = [self.fn(*row) for row in sub]
+
+
+@dataclass(kw_only=True, slots=True)
+class ResponseCoefficients:
+    """Container for response coefficients."""
+
+    variables: pd.DataFrame
+    fluxes: pd.DataFrame
+
+    def __iter__(self) -> Iterator[pd.DataFrame]:
+        """Iterate over the concentration and flux response coefficients."""
+        return iter((self.variables, self.fluxes))
+
+    @property
+    def results(self) -> pd.DataFrame:
+        """Return the response coefficients as a DataFrame."""
+        return pd.concat((self.variables, self.fluxes), axis=1)
+
+
+@dataclass(kw_only=True, slots=True)
+class ResponseCoefficientsByPars:
+    """Container for response coefficients by parameter."""
+
+    variables: 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.variables, self.fluxes))
+
+    @property
+    def results(self) -> pd.DataFrame:
+        """Return the response coefficients as a DataFrame."""
+        return pd.concat((self.variables, self.fluxes), axis=1)
+
+
+@dataclass(kw_only=True, slots=True)
+class SteadyStates:
+    """Container for steady states."""
+
+    variables: 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.variables, self.fluxes))
+
+    @property
+    def results(self) -> pd.DataFrame:
+        """Return the steady states as a DataFrame."""
+        return pd.concat((self.variables, self.fluxes), axis=1)
+
+
+@dataclass(kw_only=True, slots=True)
+class McSteadyStates:
+    """Container for Monte Carlo steady states."""
+
+    variables: 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.variables, self.fluxes))
+
+    @property
+    def results(self) -> pd.DataFrame:
+        """Return the steady states as a DataFrame."""
+        return pd.concat((self.variables, self.fluxes), axis=1)
+
+
+@dataclass(kw_only=True, slots=True)
+class TimeCourseByPars:
+    """Container for time courses by parameter."""
+
+    variables: 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.variables, self.fluxes))
+
+    @property
+    def results(self) -> pd.DataFrame:
+        """Return the time courses as a DataFrame."""
+        return pd.concat((self.variables, 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(kw_only=True, slots=True)
+class ProtocolByPars:
+    """Container for protocols by parameter."""
+
+    variables: 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.variables, self.fluxes))
+
+    @property
+    def results(self) -> pd.DataFrame:
+        """Return the protocols as a DataFrame."""
+        return pd.concat((self.variables, 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,
+            )
+        )
+
+    def calculate_inpl(self, args: dict[str, float]) -> None:
+        """Predict outputs based on input data."""
+        args |= self.predict(np.array([args[arg] for arg in self.args]))
+
+    def calculate_inpl_time_course(self, args: pd.DataFrame) -> None:
+        """Predict outputs based on input data."""
+        args[list(self.stoichiometries)] = pd.DataFrame(
+            [self.predict(y) for y in args.loc[:, self.args].to_numpy()],
+            index=args.index,
+            dtype=float,
+        )
+
+
+@dataclass(kw_only=True)
+class MockSurrogate(AbstractSurrogate):
+    """Mock surrogate model for testing purposes."""
+
+    def predict(
+        self,
+        y: np.ndarray,
+    ) -> dict[str, float]:
+        """Predict outputs based on input data."""
+        return dict(zip(self.stoichiometries, y, strict=True))

mxlpy-0.8.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: mxlpy
+Version: 0.8.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: mike>=2.1.3
+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: symbtools>=0.4.0
+Requires-Dist: sympy>=1.13.1
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: toml>=0.10.2
+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: 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
+
+# mxlpy
+
+[![pypi](https://img.shields.io/pypi/v/mxlpy.svg)](https://pypi.python.org/pypi/mxlpy)
+[![docs][docs-badge]][docs]
+![License](https://img.shields.io/badge/license-GPL--3.0-blue?style=flat-square)
+![Coverage](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fgist.github.com%2Fmarvinvanaalst%2F98ab3ce1db511de42f9871e91d85e4cd%2Fraw%2Fcoverage.json&query=%24.message&label=Coverage&color=%24.color&suffix=%20%25)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)
+[![Downloads](https://pepy.tech/badge/mxlpy)](https://pepy.tech/project/mxlpy)
+
+[docs-badge]: https://img.shields.io/badge/docs-main-green.svg?style=flat-square
+[docs]: https://computational-biology-aachen.github.io/mxlpy/
+
+## Installation
+
+You can install mxlpy using pip: `pip install mxlpy`
+
+If you want access to the sundials solver suite via the [assimulo](https://jmodelica.org/assimulo/) package, we recommend setting up a virtual environment via [pixi](https://pixi.sh/) or [mamba / conda](https://mamba.readthedocs.io/en/latest/) using the [conda-forge](https://conda-forge.org/) channel.
+
+```bash
+pixi init
+pixi add python assimulo
+pixi add --pypi mxlpy[torch]
+```
+
+
+## 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`

mxlpy-0.8.0.dist-info/RECORD

@@ -0,0 +1,48 @@
+mxlpy/__init__.py,sha256=HwV_l1PqCqWsn1TFwUMslbfuPjX6cUGzytyWPaUz4FM,4168
+mxlpy/distributions.py,sha256=ce6RTqn19YzMMec-u09fSIUA8A92M6rehCuHuXWcX7A,8734
+mxlpy/fit.py,sha256=M8F5s9RUoUPr2s-pCLFZD_ebP2uGvajNCn7XYh1w7Tc,8078
+mxlpy/fns.py,sha256=ct_RFj9koW8vXHyr27GnbZUHUS_zfs4rDysybuFiOaU,4599
+mxlpy/label_map.py,sha256=urv-QTb0MUEKjwWvKtJSB8H2kvhLn1EKfRIH7awQQ8Y,17769
+mxlpy/linear_label_map.py,sha256=2lgERcUVDLXruRI08HBYJo_wK654y46voLUeBTzBy3k,10312
+mxlpy/mc.py,sha256=L4IFYmnq8GvSnuhbF-UBVWQf77e1Pu-vr4PPim5Fk5w,16303
+mxlpy/mca.py,sha256=JNJf0vCqKzFTQ6-og-nnamX_-phml8iQC5OKfbSjqC0,8869
+mxlpy/model.py,sha256=-BmS4bGCq_fMUnRLZG5uwl86ip_SiaWxsbgLPeV0nHQ,57656
+mxlpy/npe.py,sha256=oiRLA43-qf-AcS2KpQfJIOt7-Ev9Aj5sF6TMq9bJn84,8747
+mxlpy/parallel.py,sha256=kX4Td5YoovDwZp6kX_3cfO6QtHSS9ieJ0bMZiKs3Xv8,5002
+mxlpy/parameterise.py,sha256=2jMhhO-bHTFP_0kXercJekeATAZYBg5FrK1MQ_mWGpk,654
+mxlpy/paths.py,sha256=TK2wO4N9lG-UV1JGfeB64q48JVDbwqIUj63rl55MKuQ,1022
+mxlpy/plot.py,sha256=1sI18HAQXeBNo_H6ctS9pwLdmp3MSkGgaGQK7IrTUBc,23498
+mxlpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mxlpy/scan.py,sha256=vDmFiWoGtT4C__Z617ig9HMIOkuQptT12vKYnlEp7Ao,17738
+mxlpy/simulator.py,sha256=T9t2jZ6U5NyK1ICF1UkST8M8v4EPV_H98kzZ4TvQK-w,20115
+mxlpy/types.py,sha256=ksdn76Sdw0XhQEpQepcETvuGqcJolfrmbIRBT0R_2Bg,13612
+mxlpy/experimental/__init__.py,sha256=kZTE-92OErpHzNRqmgSQYH4CGXrogGJ5EL35XGZQ81M,206
+mxlpy/experimental/diff.py,sha256=4bztagJzFMsQJM7dlun_kv-WrWssM8CIw7gcL63hFf8,8952
+mxlpy/integrators/__init__.py,sha256=kqmV6a0TRyLGR_XqbyAI652AfptYnXAUpqbSFg0CpP8,450
+mxlpy/integrators/int_assimulo.py,sha256=Y9jvpJWXkmueUyjDnu_6SqDntyMdG_DU370EtuRyMqA,4605
+mxlpy/integrators/int_scipy.py,sha256=Z9LSwqBKgYfwmrNiMxJ3-vRad5n_yQo1Ime4WDAAZEI,4343
+mxlpy/meta/__init__.py,sha256=Jyy4063fZy6iT4LSwjPyEAVr4N_3xxcLc8wDBoDPyKc,278
+mxlpy/meta/codegen_latex.py,sha256=1z0waYPmohY9GTJ_5DBuwXOXGTCHCH8E14tg6MYsf2A,13460
+mxlpy/meta/codegen_modebase.py,sha256=qQ8p6_KqMYCw7SRmf2HHRGvl25sYPKVI_zWKhzFhFLw,3138
+mxlpy/meta/codegen_py.py,sha256=xSdeuEGPGc-QKRMgJO4VSPGMlxCPEV5prkKjNQ2D2hg,3483
+mxlpy/meta/source_tools.py,sha256=EN3OoGQaXeIsDTJvA7S15-xDBra3DCIyFZEJ6h0Fy0k,11125
+mxlpy/nn/__init__.py,sha256=yUc4o-iqfVVzkq9tZCstWwizrCqNlMft0YUwWGFFO-E,219
+mxlpy/nn/_tensorflow.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mxlpy/nn/_torch.py,sha256=_4Rw87zpIlCnrOsXC7iFp1c64_FcpfVmgBXBU0p8mlg,4063
+mxlpy/sbml/__init__.py,sha256=AS7IwrBzBgN8coUZkyBEtiYa9ICWyY1wzp1ujVm5ItA,226
+mxlpy/sbml/_data.py,sha256=XwT1sSxn6KLTXYMbk4ORbEAEgZhQDBfoyrjMBDAoY_s,1135
+mxlpy/sbml/_export.py,sha256=Q6B9rxy-yt73DORzAYu4BpfkZXxCS3MDSDUXwpoXV6Q,19970
+mxlpy/sbml/_import.py,sha256=5DJklsAe2sMV1CFxAbkSFRT3amPzOZmpo53y9NYv6TY,22015
+mxlpy/sbml/_mathml.py,sha256=bNk9RQ_NQFDhY1R354p-gwqqHaIiyAwZ1xLPHHhiguQ,24436
+mxlpy/sbml/_name_conversion.py,sha256=XK9DEyzhrD0GBBwwjK9RA0yORrDX5c-Uvx0VtKMR5rA,1325
+mxlpy/sbml/_unit_conversion.py,sha256=dW_I6_Ou09ccwnp6LIdrPriIQnQUK5lJcjzM2Fawm6U,1927
+mxlpy/surrogates/__init__.py,sha256=N_iXERECKvmrHiihwnyQEKOSBsmlGEuQhEotn-mWKdk,924
+mxlpy/surrogates/_poly.py,sha256=E54CFscQBCcYMrty1X2ynl9GlS9uoEeAUgBPnhm3iIA,3113
+mxlpy/surrogates/_torch.py,sha256=E_1eDUlPSVFwROkdMDCqYwwHE-61pjNMJWotnhjzge0,5891
+mxlpy/symbolic/__init__.py,sha256=3hQjCMw8-6iOxeUdfnCg8449fF_BRF2u6lCM1GPpkRY,222
+mxlpy/symbolic/strikepy.py,sha256=r6nRtckV1nxKq3i1bYYWZOkzwZ5XeKQuZM5ck44vUo0,20010
+mxlpy/symbolic/symbolic_model.py,sha256=YL9noEeP3_0DoKXwMPELtfmPuP6mgNcLIJgDRCkyB7A,2434
+mxlpy-0.8.0.dist-info/METADATA,sha256=EJiGUDewxhWeWCVzxuVhSSjfDYE3ao4XTYQaUKIwMyU,4245
+mxlpy-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mxlpy-0.8.0.dist-info/licenses/LICENSE,sha256=bEzjyjy1stQhfRDVaVHa3xV1x-V8emwdlbMvYO8Zo84,35073
+mxlpy-0.8.0.dist-info/RECORD,,

mxlpy-0.8.0.dist-info/WHEEL

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