mxlpy-native 0.2.0__tar.gz → 0.3.0__tar.gz

mxlpy_native-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2025] [Marvin van Aalst, Anna Matuszyńska]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mxlpy_native-0.3.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: mxlpy-native
+Version: 0.3.0
+Summary: Compiled ODE solvers for MxlPy's Native integrator
+Author-email: Marvin van Aalst <marvin.vanaalst@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Computational-Biology-Aachen/mxlpy-native
+Project-URL: Issues, https://github.com/Computational-Biology-Aachen/mxlpy-native/issues
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: c/vendor/HAIRER-LICENCE.txt
+License-File: c/vendor/SCIPY-LICENCE.txt
+Requires-Dist: llvmlite>=0.45
+Dynamic: license-file
+
+# mxlpy-native
+
+The compiled Radau and LSODA solvers behind [MxlPy](https://github.com/Computational-Biology-Aachen/MxlPy)'s `Native` integrator, plus `llvmlite`, which compiles models to machine code for them. Install it through MxlPy rather than on its own:
+
+```bash
+pip install "mxlpy[native]"
+```
+
+## Platforms
+
+Wheels are published for Linux (x86_64, aarch64; glibc 2.28+), macOS (arm64, 12+) and Windows (amd64, arm64), the platforms `llvmlite` has wheels for. On anything else, `mxlpy[native]` installs the WASM backend (`wasmtime`) instead, which runs the same solvers without a compiler, a little slower.
+
+If pip has to build from the sdist anyway, it needs a C11 compiler (GCC 8+, Clang 7+ or MSVC 2019 16.8+), and nothing else: no Fortran, BLAS/LAPACK or Python headers. The build says what to install if the compiler is missing or fails.
+
+## Troubleshooting
+
+```bash
+python -m mxlpy_native
+```
+
+prints the installed version, the solver ABI, and whether the compiled solvers and `llvmlite` load, with a fix for each failure.
+
+## Development
+
+```bash
+uv sync           # builds the extension in place
+uv run pytest
+```
+
+`c/vendor/` is copied from [mxl-solvers](https://github.com/Computational-Biology-Aachen/mxl-solvers) by its `scripts/vendor.sh`. `vendor/VENDORED` records the commit and file hashes, which `tests/test_vendor.py` checks. Fix solvers there, not here. `c/mxn_solvers.c` is the glue MxlPy calls, compiled unchanged into the wheel and into MxlPy's `solvers.wasm` (`scripts/build_native_wasm.sh` in MxlPy).
+
+When an exported function's signature or meaning changes, bump `MXN_ABI_VERSION` in `c/mxn_solvers.c`, `ABI_VERSION` in `src/mxlpy_native/__init__.py` and the ABI MxlPy expects, then release both. MxlPy refuses a mismatched pair with an upgrade hint instead of crashing.
+
+## Releasing
+
+Bump `version` in `pyproject.toml` and publish a GitHub release `v<version>`. The release workflow builds the wheels with cibuildwheel plus an sdist and uploads them to PyPI via trusted publishing.

mxlpy_native-0.3.0/README.md

@@ -0,0 +1,36 @@
+# mxlpy-native
+
+The compiled Radau and LSODA solvers behind [MxlPy](https://github.com/Computational-Biology-Aachen/MxlPy)'s `Native` integrator, plus `llvmlite`, which compiles models to machine code for them. Install it through MxlPy rather than on its own:
+
+```bash
+pip install "mxlpy[native]"
+```
+
+## Platforms
+
+Wheels are published for Linux (x86_64, aarch64; glibc 2.28+), macOS (arm64, 12+) and Windows (amd64, arm64), the platforms `llvmlite` has wheels for. On anything else, `mxlpy[native]` installs the WASM backend (`wasmtime`) instead, which runs the same solvers without a compiler, a little slower.
+
+If pip has to build from the sdist anyway, it needs a C11 compiler (GCC 8+, Clang 7+ or MSVC 2019 16.8+), and nothing else: no Fortran, BLAS/LAPACK or Python headers. The build says what to install if the compiler is missing or fails.
+
+## Troubleshooting
+
+```bash
+python -m mxlpy_native
+```
+
+prints the installed version, the solver ABI, and whether the compiled solvers and `llvmlite` load, with a fix for each failure.
+
+## Development
+
+```bash
+uv sync           # builds the extension in place
+uv run pytest
+```
+
+`c/vendor/` is copied from [mxl-solvers](https://github.com/Computational-Biology-Aachen/mxl-solvers) by its `scripts/vendor.sh`. `vendor/VENDORED` records the commit and file hashes, which `tests/test_vendor.py` checks. Fix solvers there, not here. `c/mxn_solvers.c` is the glue MxlPy calls, compiled unchanged into the wheel and into MxlPy's `solvers.wasm` (`scripts/build_native_wasm.sh` in MxlPy).
+
+When an exported function's signature or meaning changes, bump `MXN_ABI_VERSION` in `c/mxn_solvers.c`, `ABI_VERSION` in `src/mxlpy_native/__init__.py` and the ABI MxlPy expects, then release both. MxlPy refuses a mismatched pair with an upgrade hint instead of crashing.
+
+## Releasing
+
+Bump `version` in `pyproject.toml` and publish a GitHub release `v<version>`. The release workflow builds the wheels with cibuildwheel plus an sdist and uploads them to PyPI via trusted publishing.

{mxlpy_native-0.2.0 → mxlpy_native-0.3.0}/c/mxn_solvers.c

@@ -15,6 +15,11 @@
 #define MXN_API
 #endif
 
+/* Bump whenever an exported signature or its meaning changes, together with ABI_VERSION
+ * in mxlpy_native/__init__.py and the version MxlPy's Native integrator expects. */
+#define MXN_ABI_VERSION 1
+MXN_API int mxn_abi_version(void) { return MXN_ABI_VERSION; }
+
 extern int radau5_(integer *n, U_fp fcn, doublereal *x, doublereal *y, doublereal *xend, doublereal *h,
                    doublereal *rtol, doublereal *atol, integer *itol, U_fp jac, integer *ijac, integer *mljac,
                    integer *mujac, U_fp mas, integer *imas, integer *mlmas, integer *mumas, U_fp solout,

mxlpy_native-0.3.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools>=77", "wheel"]
+
+[project]
+authors = [{ email = "marvin.vanaalst@gmail.com", name = "Marvin van Aalst" }]
+classifiers = [
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: C",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering",
+]
+# llvmlite JIT-compiles models for these solvers. It only has wheels for linux
+# x86_64/aarch64, macOS arm64 and windows amd64/arm64; MxlPy's `native` extra
+# installs the WASM backend everywhere else, so this is never pulled in there.
+dependencies = ["llvmlite>=0.45"]
+description = "Compiled ODE solvers for MxlPy's Native integrator"
+license = "MIT"
+license-files = ["LICENSE", "c/vendor/*LICENCE*.txt"]
+name = "mxlpy-native"
+readme = "README.md"
+requires-python = ">=3.12"
+version = "0.3.0"
+
+[project.urls]
+Homepage = "https://github.com/Computational-Biology-Aachen/mxlpy-native"
+Issues = "https://github.com/Computational-Biology-Aachen/mxlpy-native/issues"
+
+[dependency-groups]
+dev = ["pytest>=8", "ruff>=0.9", "setuptools>=77"]
+
+[tool.cibuildwheel]
+# One abi3 wheel per platform covers Python 3.12+.
+build = "cp312-*"
+# Only platforms llvmlite publishes wheels for.
+skip = ["*-musllinux_*", "*-win32", "*-manylinux_i686", "*-macosx_x86_64"]
+test-command = "python -m mxlpy_native"
+
+[tool.cibuildwheel.macos]
+environment = { MACOSX_DEPLOYMENT_TARGET = "12.0" }
+
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = ["COM812", "D203", "D213", "S101", "T201", "PLR2004"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["D", "INP001", "ANN"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.uv]
+exclude-newer = "3 days"

mxlpy_native-0.3.0/setup.py

@@ -0,0 +1,113 @@
+# Copyright 2025 Marvin van Aalst, Anna Matuszyńska
+
+"""Build the solver as one stable-ABI extension, so a wheel covers all Python versions.
+
+Wheels are published for the common platforms, so this only runs when pip has to build
+from the sdist. That needs a C11 compiler and nothing else: no Fortran, BLAS or Python
+headers. When it fails, the error says what to install instead of showing a raw
+compiler traceback.
+"""
+
+from __future__ import annotations
+
+import platform
+import shutil
+import sys
+
+from setuptools import Extension, setup
+from setuptools.command.build_ext import build_ext
+from setuptools.errors import CCompilerError, ExecError, PlatformError
+
+_NO_COMPILER_HINTS = {
+    "linux": (
+        "  Debian/Ubuntu:  sudo apt install build-essential\n"
+        "  Fedora/RHEL:    sudo dnf install gcc\n"
+        "  Alpine:         apk add build-base\n"
+        "  conda/pixi:     conda install -c conda-forge c-compiler"
+    ),
+    "darwin": "  macOS:          xcode-select --install",
+    "win32": (
+        '  Windows:        install "Build Tools for Visual Studio" (2019 16.8 or newer)\n'
+        '                  with the "Desktop development with C++" workload'
+    ),
+}
+_ALTERNATIVE = (
+    "If you can't install a compiler, use the WASM backend instead, which needs none:\n"
+    '  pip install "mxlpy[native-wasm]"'
+)
+
+
+def _platform() -> str:
+    return f"{sys.platform} {platform.machine()}, Python {platform.python_version()}"
+
+
+def _no_compiler(detail: str) -> str:
+    hints = _NO_COMPILER_HINTS.get(sys.platform, "  Install a C11 compiler such as gcc or clang.")
+    return (
+        f"mxlpy-native: no C compiler found ({detail}).\n\n"
+        f"There is no prebuilt mxlpy-native wheel for {_platform()}, so pip is building it\n"
+        "from source, which needs a C11 compiler (no Fortran, BLAS or Python headers):\n"
+        f"{hints}\n\n{_ALTERNATIVE}"
+    )
+
+
+def _compile_failed(detail: str) -> str:
+    return (
+        f"mxlpy-native: compiling the solvers failed ({detail}).\n\n"
+        f"There is no prebuilt mxlpy-native wheel for {_platform()}, so pip is building it\n"
+        "from source. The solvers need C11 support: GCC 8+, Clang 7+ or MSVC 2019 16.8+.\n"
+        "Check that your compiler is recent enough and that CC points to it. If it is, please\n"
+        "report this at https://github.com/Computational-Biology-Aachen/mxlpy-native/issues\n"
+        f"with the compiler output above.\n\n{_ALTERNATIVE}"
+    )
+
+
+class _BuildError(PlatformError):
+    """A build error that already explains itself."""
+
+
+class BuildExt(build_ext):
+    """build_ext that explains missing or unsuitable compilers."""
+
+    def run(self) -> None:
+        """Explain a missing MSVC."""
+        try:
+            super().run()
+        except _BuildError:
+            raise
+        except PlatformError as e:  # MSVC isn't installed
+            raise _BuildError(_no_compiler(str(e))) from e
+
+    def build_extension(self, ext: Extension) -> None:
+        """Explain a missing or failing compiler."""
+        compiler = getattr(self.compiler, "compiler_so", None)
+        if compiler and shutil.which(compiler[0]) is None:
+            raise _BuildError(_no_compiler(f"{compiler[0]!r} is not on PATH"))
+        try:
+            super().build_extension(ext)
+        except (ExecError, FileNotFoundError) as e:  # the compiler couldn't be started
+            raise _BuildError(_no_compiler(str(e))) from e
+        except CCompilerError as e:  # it ran, but compiling or linking failed
+            msg = _compile_failed("the compiler returned an error, see its output above")
+            raise _BuildError(msg) from e
+
+
+vendored = ["radau5.c", "dc_decsol.c", "decsol.c", "libf2c_stubs.c", "lsoda.c", "mxs_lapack.c"]
+setup(
+    ext_modules=[
+        Extension(
+            "mxlpy_native._solvers",
+            sources=["c/mxn_solvers.c", *(f"c/vendor/{s}" for s in vendored)],
+            include_dirs=["c/vendor"],
+            py_limited_api=True,
+            define_macros=[("Py_LIMITED_API", "0x030C0000")],
+            # lsoda.c needs C11 (restrict, compound literals), which MSVC only enables on request.
+            extra_compile_args=["/std:c11"]
+            if sys.platform == "win32"
+            else ["-std=gnu17", "-w", "-O2"],
+            libraries=[] if sys.platform == "win32" else ["m"],
+        )
+    ],
+    cmdclass={"build_ext": BuildExt},
+    options={"bdist_wheel": {"py_limited_api": "cp312"}},
+)

mxlpy_native-0.3.0/src/mxlpy_native/__init__.py

@@ -0,0 +1,76 @@
+# Copyright 2025 Marvin van Aalst, Anna Matuszyńska
+
+"""Compiled solvers for MxlPy's Native integrator.
+
+`load()` returns the solver library for ctypes. Everything that can go wrong with an
+installation raises `NativeInstallError` with a message saying how to fix it.
+"""
+
+from __future__ import annotations
+
+import ctypes
+from functools import lru_cache
+from importlib.machinery import EXTENSION_SUFFIXES
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+__all__ = ["ABI_VERSION", "NativeInstallError", "__version__", "library_path", "load"]
+
+# Must match MXN_ABI_VERSION in c/mxn_solvers.c. MxlPy checks it before calling into
+# the library, so a mismatched pair fails with an upgrade hint instead of crashing.
+ABI_VERSION = 1
+
+try:
+    __version__ = version("mxlpy-native")
+except PackageNotFoundError:  # running from a source tree without installing
+    __version__ = "0+unknown"
+
+_REINSTALL = 'pip install --force-reinstall --no-cache-dir "mxlpy-native"'
+
+
+class NativeInstallError(ImportError):
+    """mxlpy-native is installed, but its compiled solvers can't be used."""
+
+
+def library_path() -> Path:
+    """Return the path of the compiled solvers, for loading with ctypes."""
+    here = Path(__file__).parent
+    for suffix in EXTENSION_SUFFIXES:
+        if (path := here / f"_solvers{suffix}").exists():
+            return path
+    found = sorted(p.name for p in here.glob("_solvers*"))
+    detail = f"found only {found}, none built for this Python" if found else "none found"
+    msg = (
+        f"mxlpy-native {__version__} is installed without its compiled solvers in {here} "
+        f"({detail}).\nThis usually means a source checkout was installed without building "
+        f"it, or the wheel belongs to a different platform. Reinstall it with:\n  {_REINSTALL}"
+    )
+    raise NativeInstallError(msg)
+
+
+@lru_cache(maxsize=1)
+def load() -> ctypes.CDLL:
+    """Load the compiled solvers and check that they match this package."""
+    path = library_path()
+    try:
+        lib = ctypes.CDLL(str(path))
+    except OSError as e:
+        msg = (
+            f"mxlpy-native {__version__} can't load its compiled solvers {path}: {e}\n"
+            "The file may be corrupt or built for another platform or architecture. "
+            f"Reinstall it with:\n  {_REINSTALL}"
+        )
+        raise NativeInstallError(msg) from e
+    try:
+        lib.mxn_abi_version.restype = ctypes.c_int
+        abi = lib.mxn_abi_version()
+    except AttributeError:
+        abi = 0  # built before the ABI was versioned
+    if abi != ABI_VERSION:
+        msg = (
+            f"mxlpy-native {__version__}'s compiled solvers {path} have ABI {abi}, but its "
+            f"Python code expects {ABI_VERSION}. The build is stale; rebuild it with:\n"
+            f"  {_REINSTALL}"
+        )
+        raise NativeInstallError(msg)
+    return lib

mxlpy_native-0.3.0/src/mxlpy_native/__main__.py

@@ -0,0 +1,35 @@
+# Copyright 2025 Marvin van Aalst, Anna Matuszyńska
+
+"""Diagnose an installation: python -m mxlpy_native."""
+
+from __future__ import annotations
+
+import platform
+import sys
+
+import mxlpy_native
+
+
+def main() -> int:
+    """Print what's installed and whether the compiled solvers load."""
+    print(f"mxlpy-native {mxlpy_native.__version__} (ABI {mxlpy_native.ABI_VERSION})")
+    print(f"platform     {sys.platform} {platform.machine()}, Python {platform.python_version()}")
+    ok = True
+    try:
+        print(f"solvers      {mxlpy_native.load()._name}: ok")  # noqa: SLF001
+    except mxlpy_native.NativeInstallError as e:
+        print(f"solvers      FAILED\n{e}")
+        ok = False
+    try:
+        import llvmlite.binding as llvm  # noqa: PLC0415
+
+        llvm.initialize_native_target()
+        print(f"llvmlite     {llvm.llvm_version_info} targeting {llvm.get_default_triple()}: ok")
+    except Exception as e:  # noqa: BLE001
+        print(f"llvmlite     FAILED: {e}")
+        ok = False
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mxlpy_native-0.3.0/src/mxlpy_native.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: mxlpy-native
+Version: 0.3.0
+Summary: Compiled ODE solvers for MxlPy's Native integrator
+Author-email: Marvin van Aalst <marvin.vanaalst@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Computational-Biology-Aachen/mxlpy-native
+Project-URL: Issues, https://github.com/Computational-Biology-Aachen/mxlpy-native/issues
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: c/vendor/HAIRER-LICENCE.txt
+License-File: c/vendor/SCIPY-LICENCE.txt
+Requires-Dist: llvmlite>=0.45
+Dynamic: license-file
+
+# mxlpy-native
+
+The compiled Radau and LSODA solvers behind [MxlPy](https://github.com/Computational-Biology-Aachen/MxlPy)'s `Native` integrator, plus `llvmlite`, which compiles models to machine code for them. Install it through MxlPy rather than on its own:
+
+```bash
+pip install "mxlpy[native]"
+```
+
+## Platforms
+
+Wheels are published for Linux (x86_64, aarch64; glibc 2.28+), macOS (arm64, 12+) and Windows (amd64, arm64), the platforms `llvmlite` has wheels for. On anything else, `mxlpy[native]` installs the WASM backend (`wasmtime`) instead, which runs the same solvers without a compiler, a little slower.
+
+If pip has to build from the sdist anyway, it needs a C11 compiler (GCC 8+, Clang 7+ or MSVC 2019 16.8+), and nothing else: no Fortran, BLAS/LAPACK or Python headers. The build says what to install if the compiler is missing or fails.
+
+## Troubleshooting
+
+```bash
+python -m mxlpy_native
+```
+
+prints the installed version, the solver ABI, and whether the compiled solvers and `llvmlite` load, with a fix for each failure.
+
+## Development
+
+```bash
+uv sync           # builds the extension in place
+uv run pytest
+```
+
+`c/vendor/` is copied from [mxl-solvers](https://github.com/Computational-Biology-Aachen/mxl-solvers) by its `scripts/vendor.sh`. `vendor/VENDORED` records the commit and file hashes, which `tests/test_vendor.py` checks. Fix solvers there, not here. `c/mxn_solvers.c` is the glue MxlPy calls, compiled unchanged into the wheel and into MxlPy's `solvers.wasm` (`scripts/build_native_wasm.sh` in MxlPy).
+
+When an exported function's signature or meaning changes, bump `MXN_ABI_VERSION` in `c/mxn_solvers.c`, `ABI_VERSION` in `src/mxlpy_native/__init__.py` and the ABI MxlPy expects, then release both. MxlPy refuses a mismatched pair with an upgrade hint instead of crashing.
+
+## Releasing
+
+Bump `version` in `pyproject.toml` and publish a GitHub release `v<version>`. The release workflow builds the wheels with cibuildwheel plus an sdist and uploads them to PyPI via trusted publishing.

{mxlpy_native-0.2.0 → mxlpy_native-0.3.0}/src/mxlpy_native.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
@@ -16,7 +17,12 @@ c/vendor/lsoda.h
 c/vendor/mxs_lapack.c
 c/vendor/radau5.c
 src/mxlpy_native/__init__.py
+src/mxlpy_native/__main__.py
 src/mxlpy_native.egg-info/PKG-INFO
 src/mxlpy_native.egg-info/SOURCES.txt
 src/mxlpy_native.egg-info/dependency_links.txt
-src/mxlpy_native.egg-info/top_level.txt
+src/mxlpy_native.egg-info/requires.txt
+src/mxlpy_native.egg-info/top_level.txt
+tests/test_build_errors.py
+tests/test_solvers.py
+tests/test_vendor.py

mxlpy_native-0.3.0/src/mxlpy_native.egg-info/requires.txt

@@ -0,0 +1 @@
+llvmlite>=0.45

mxlpy_native-0.3.0/tests/test_build_errors.py

@@ -0,0 +1,48 @@
+# Copyright 2025 Marvin van Aalst, Anna Matuszyńska
+
+"""Building from source without a working compiler explains what to install."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).parents[1]
+
+pytestmark = pytest.mark.skipif(sys.platform == "win32", reason="MSVC ignores CC")
+
+
+def _build(tmp_path: Path, cc: str) -> str:
+    for name in ("setup.py", "pyproject.toml", "c", "src"):
+        src = ROOT / name
+        if src.is_dir():
+            shutil.copytree(src, tmp_path / name, ignore=shutil.ignore_patterns("*.so", "*.pyd"))
+        else:
+            shutil.copy(src, tmp_path / name)
+    proc = subprocess.run(
+        [sys.executable, "setup.py", "-q", "build_ext", "--inplace"],
+        cwd=tmp_path,
+        env={**os.environ, "CC": cc},
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert proc.returncode != 0
+    return proc.stdout + proc.stderr
+
+
+def test_missing_compiler(tmp_path: Path) -> None:
+    out = _build(tmp_path, "/nonexistent/cc")
+    assert "no C compiler found" in out
+    assert "mxlpy[native-wasm]" in out
+
+
+def test_failing_compiler(tmp_path: Path) -> None:
+    out = _build(tmp_path, "false")
+    assert "compiling the solvers failed" in out
+    assert "C11" in out

mxlpy_native-0.3.0/tests/test_solvers.py

@@ -0,0 +1,60 @@
+# Copyright 2025 Marvin van Aalst, Anna Matuszyńska
+
+"""The compiled solvers load, match the Python package and solve dy/dt = -k y."""
+
+from __future__ import annotations
+
+import ctypes as ct
+import math
+
+import pytest
+
+import mxlpy_native
+
+_DP = ct.POINTER(ct.c_double)
+_MODEL_FN = ct.CFUNCTYPE(None, ct.c_int, ct.c_double, _DP, _DP, _DP)
+
+
+@_MODEL_FN
+def _decay(n: int, t: float, y: _DP, dydt: _DP, pars: _DP) -> None:  # noqa: ARG001
+    for i in range(n):
+        dydt[i] = -pars[0] * y[i]
+
+
+def _arr(*values: float) -> ct.Array:
+    return (ct.c_double * len(values))(*values)
+
+
+def test_abi_matches() -> None:
+    assert mxlpy_native.load().mxn_abi_version() == mxlpy_native.ABI_VERSION
+
+
+@pytest.mark.parametrize("method", ["radau", "lsoda"])
+def test_solve_exponential_decay(method: str) -> None:
+    lib = mxlpy_native.load()
+    t_out = [0.0, 0.5, 1.0, 2.0]
+    y, pars, t, out = _arr(1.0, 2.0), _arr(0.7), _arr(*t_out), _arr(*[0.0] * 8)
+    lib.mxn_set_model.argtypes = [ct.c_void_p]
+    lib.mxn_set_model(ct.cast(_decay, ct.c_void_p))
+    head = (2, y, pars, ct.c_double(1e-10), ct.c_double(1e-10), 100_000)
+    if method == "radau":
+        rc = lib.mxn_radau(*head, 0, len(t_out), t, out)
+        assert rc == 1
+    else:
+        rc = lib.mxn_lsoda(*head, len(t_out), t, out)
+        assert rc == 2
+    for i, ti in enumerate(t_out):
+        assert out[2 * i] == pytest.approx(math.exp(-0.7 * ti), rel=1e-7)
+        assert out[2 * i + 1] == pytest.approx(2 * math.exp(-0.7 * ti), rel=1e-7)
+
+
+def test_missing_library_explains_reinstall(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(mxlpy_native, "EXTENSION_SUFFIXES", [".nope"])
+    with pytest.raises(mxlpy_native.NativeInstallError, match="force-reinstall"):
+        mxlpy_native.library_path()
+
+
+def test_diagnostics_pass() -> None:
+    from mxlpy_native.__main__ import main  # noqa: PLC0415
+
+    assert main() == 0

mxlpy_native-0.3.0/tests/test_vendor.py

@@ -0,0 +1,32 @@
+# Copyright 2025 Marvin van Aalst, Anna Matuszyńska
+
+"""The solvers in c/vendor must be exactly what mxl-solvers' vendor.sh copied.
+
+Fix solvers in https://github.com/Computational-Biology-Aachen/mxl-solvers and re-run
+its scripts/vendor.sh, rather than editing the copies here.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+VENDOR = Path(__file__).parents[1] / "c" / "vendor"
+
+
+def _manifest() -> dict[str, str]:
+    lines = (VENDOR / "VENDORED").read_text().splitlines()
+    return {
+        name: digest
+        for digest, name in (line.split() for line in lines if line and not line.startswith("#"))
+    }
+
+
+def test_vendored_solvers_are_unmodified() -> None:
+    manifest = _manifest()
+    actual = {
+        p.name: hashlib.sha256(p.read_bytes()).hexdigest()
+        for p in VENDOR.iterdir()
+        if p.name != "VENDORED"
+    }
+    assert actual == manifest

mxlpy_native-0.2.0/PKG-INFO

@@ -1,6 +0,0 @@
-Metadata-Version: 2.4
-Name: mxlpy-native
-Version: 0.2.0
-Summary: Compiled ODE solvers for MxlPy's Native integrator
-License-Expression: MIT
-Requires-Python: >=3.12

mxlpy_native-0.2.0/README.md

@@ -1,5 +0,0 @@
-# mxlpy-native
-
-The compiled Radau and LSODA solvers behind MxlPy's `Native` integrator. Install it with `pip install "mxlpy[native]"`, not on its own.
-
-`c/vendor/` is copied from [mxl-solvers](https://github.com/Computational-Biology-Aachen/mxl-solvers) by its `scripts/vendor.sh`. `vendor/VENDORED` records the commit and file hashes, which `tests/integrators/test_native_vendor.py` checks. Fix solvers there, not here. `c/mxn_solvers.c` is MxlPy's own glue, compiled unchanged into both the wheel and `solvers.wasm`.

mxlpy_native-0.2.0/pyproject.toml

@@ -1,18 +0,0 @@
-[build-system]
-build-backend = "setuptools.build_meta"
-requires = ["setuptools>=77", "wheel"]
-
-[project]
-description = "Compiled ODE solvers for MxlPy's Native integrator"
-license = "MIT"
-name = "mxlpy-native"
-requires-python = ">=3.12"
-version = "0.2.0"
-
-[tool.cibuildwheel]
-build = "cp312-*"
-skip = ["*-musllinux_*", "*-win32", "*-manylinux_i686"]
-test-command = "python -c \"import mxlpy_native; assert mxlpy_native.library_path().exists()\""
-
-[tool.setuptools.packages.find]
-where = ["src"]

mxlpy_native-0.2.0/setup.py

@@ -1,26 +0,0 @@
-# Copyright 2025 Marvin van Aalst, Anna Matuszyńska  # noqa: INP001
-
-"""Build the solver as one stable-ABI extension, so a wheel covers all Python versions."""
-
-import sys
-
-from setuptools import Extension, setup
-
-vendored = ["radau5.c", "dc_decsol.c", "decsol.c", "libf2c_stubs.c", "lsoda.c", "mxs_lapack.c"]
-setup(
-    ext_modules=[
-        Extension(
-            "mxlpy_native._solvers",
-            sources=["c/mxn_solvers.c", *(f"c/vendor/{s}" for s in vendored)],
-            include_dirs=["c/vendor"],
-            py_limited_api=True,
-            define_macros=[("Py_LIMITED_API", "0x030C0000")],
-            # lsoda.c needs C11 (restrict, compound literals), which MSVC only enables on request.
-            extra_compile_args=["/std:c11"]
-            if sys.platform == "win32"
-            else ["-std=gnu17", "-w", "-O2"],
-            libraries=[] if sys.platform == "win32" else ["m"],
-        )
-    ],
-    options={"bdist_wheel": {"py_limited_api": "cp312"}},
-)

mxlpy_native-0.2.0/src/mxlpy_native/__init__.py

@@ -1,18 +0,0 @@
-# Copyright 2025 Marvin van Aalst, Anna Matuszyńska
-
-"""Compiled solvers for MxlPy's Native integrator."""
-
-from importlib.machinery import EXTENSION_SUFFIXES
-from pathlib import Path
-
-__all__ = ["library_path"]
-
-
-def library_path() -> Path:
-    """Return the path of the compiled solvers, for loading with ctypes."""
-    here = Path(__file__).parent
-    for suffix in EXTENSION_SUFFIXES:
-        if (path := here / f"_solvers{suffix}").exists():
-            return path
-    msg = f"compiled solvers not found in {here}"
-    raise FileNotFoundError(msg)

mxlpy_native-0.2.0/src/mxlpy_native.egg-info/PKG-INFO

@@ -1,6 +0,0 @@
-Metadata-Version: 2.4
-Name: mxlpy-native
-Version: 0.2.0
-Summary: Compiled ODE solvers for MxlPy's Native integrator
-License-Expression: MIT
-Requires-Python: >=3.12