pyvcell-odesolver 0.9.4__py3-none-win_amd64.whl

pyvcell_odesolver/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from pyvcell_odesolver.sundials import __doc__, version, solve
+
+__all__ = ["__doc__", "version", "solve"]

pyvcell_odesolver/_internal/check_arch.py

@@ -0,0 +1,114 @@
+import platform
+import struct
+import os
+import platform
+
+def get_library_archs(lib_path: str) -> tuple[str, list[str]]:
+    """Determine architecture based on file type and header."""
+    _, ext = os.path.splitext(lib_path)
+
+    # ELF (Linux .so files)
+    if ext == ".so" or ".so." in str(lib_path):
+        with open(lib_path, 'rb') as f:
+            f.seek(5)
+            endian = '<' if f.read(1)[0] == 1 else '>'
+            f.seek(18)
+            machine = struct.unpack(endian + 'H', f.read(2))[0]
+
+        arch_map = {
+            0x03: 'i386',
+            0x3E: 'x86_64',
+            0xB7: 'aarch64',
+            0x28: 'armv7',
+        }
+        return "Linux", [normalize_arch(arch_map.get(machine, f'unknown (0x{machine:x})'))]
+
+    # Mach-O (macOS .dylib files)
+    elif ext == '.dylib':
+        with open(lib_path, 'rb') as f:
+            # Check for fat binary magic
+            magic = f.read(4)
+            if magic == b'\xca\xfe\xba\xbe' or magic == b'\xbf\xba\xfe\xca':
+                # Fat binary - list all architectures
+                f.seek(4)
+                num_archs = struct.unpack('>I', f.read(4))[0]
+                archs = set()
+                for i in range(num_archs):
+                    cpu_type = struct.unpack('>I', f.read(4))[0]
+                    f.read(4)  # Skip cpu_subtype
+                    f.read(4)  # Skip offset
+                    f.read(4)  # Skip size
+                    f.read(4)  # Skip align
+
+                    arch_map = {
+                        0x00000007: 'i386',
+                        0x01000007: 'x86_64',
+                        0x0100000C: 'aarch64',
+                    }
+                    archs.add(normalize_arch(arch_map.get(cpu_type, f'unknown (0x{cpu_type:x})')))
+                return "Darwin", list(archs)
+            else:
+                # Single-arch Mach-O - determine endianness
+                f.seek(4)
+                cpu_type_bytes = f.read(4)
+                # Try little-endian first (most common)
+                cpu_type = struct.unpack('<I', cpu_type_bytes)[0]
+
+                arch_map = {
+                    0x00000007: 'i386',
+                    0x01000007: 'x86_64',
+                    0x0100000C: 'aarch64',
+                }
+                return "Darwin", [ normalize_arch(arch_map.get(cpu_type, f'unknown (0x{cpu_type:x})')) ]
+
+    # PE (Windows .dll files)
+    elif ext == '.dll':
+        with open(lib_path, 'rb') as f:
+            f.seek(0x3c)
+            pe_offset = struct.unpack('<I', f.read(4))[0]
+            f.seek(pe_offset + 4)
+            machine = struct.unpack('<H', f.read(2))[0]
+
+        arch_map = {
+            0x014C: 'i386',
+            0x8664: 'x86_64',
+            0xAA64: 'aarch64',
+        }
+        return "Windows", [ normalize_arch(arch_map.get(machine, f'unknown (0x{machine:x})')) ]
+
+    return 'unknown', [ ]
+
+def get_all_valid_libraries_from_dir(lib_dir: str):
+    dir_files = [str(full_file) for f in os.listdir(lib_dir) if os.path.isfile(full_file := os.path.join(lib_dir, f))]
+    return filter_all_valid_libraries(dir_files)
+
+
+def filter_all_valid_libraries(lib_path_list: list[str]) -> list[str]:
+    if not lib_path_list:
+        raise ValueError("A list must be provided, `None` is not allowed.")
+
+    system_name = platform.system()
+    system_arch = normalize_arch(platform.machine())
+    valid_libraries = []
+    for lib_path in lib_path_list:
+        required_system_name, shared_library_archs = get_library_archs(lib_path)
+        if system_arch in shared_library_archs and required_system_name in system_name:
+            valid_libraries.append(lib_path)
+    return valid_libraries
+
+def normalize_arch(machine_str=None):
+    if machine_str is None:
+        machine_str = platform.machine().lower()
+
+    # Normalize common variants
+    if machine_str in ('x86_64', 'amd64', 'x64'):
+        return 'x86_64'
+    elif machine_str in ('aarch64', 'arm64'):
+        return 'aarch64'
+    elif machine_str in ('i386', 'i486', 'i586', 'i686', 'x86'):
+        return 'i386'
+    elif machine_str.startswith('arm'):
+        return 'arm'
+    elif machine_str.lower() != machine_str:
+        return normalize_arch(machine_str.lower())
+    raise OSError(f"Unknown machine type detected: `{machine_str}`")

pyvcell_odesolver/_internal/native_calls.py

@@ -0,0 +1,53 @@
+import ctypes
+import logging
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from pyvcell_odesolver._internal.native_utils import VCellNativeLibraryLoader
+
+
+class ReturnValue(BaseModel):
+    success: bool
+    message: str
+
+
+class MutableString:
+    def __init__(self, value: str):
+        self.value: str = value
+
+
+class ODENativeCalls:
+    def __init__(self) -> None:
+        self.loader = VCellNativeLibraryLoader()
+        self.lib: ctypes.CDLL = self.loader.lib
+
+    def call_version(self) -> ReturnValue:
+        try:
+            version_str: str = self.lib.version_ctypes()
+            if version_str is None:
+                error_msg = "Failed to collect and covert version information"
+                logging.error(error_msg)
+                return ReturnValue(success=False, message=error_msg)
+            return ReturnValue(success=True, message=version_str.decode("utf-8"))
+        except Exception as e:
+            logging.exception("Error in vcml_to_finite_volume_input()", exc_info=e)
+            raise
+
+    def call_solve(
+            self, input_file_path: str, output_file_path: str, task_id: int
+    ) -> ReturnValue:
+        try:
+            solver_return_code: int = self.lib.solve_ctypes(
+                ctypes.c_char_p(input_file_path.encode("utf-8")),
+                ctypes.c_char_p(output_file_path.encode("utf-8")),
+                ctypes.c_int(task_id),
+            )
+            if solver_return_code == 0:
+                return ReturnValue(success=True, message="Solver returned successfully.")
+            error_msg = "Solver failed with exit code {}".format(solver_return_code)
+            logging.error(error_msg)
+            return ReturnValue(success=False, message=error_msg)
+        except Exception as e:
+            logging.exception("Error in calling SundialsSolverInterface::solve_ctypes(...)", exc_info=e)
+            raise e

pyvcell_odesolver/_internal/native_utils.py

@@ -0,0 +1,56 @@
+import ctypes
+import platform
+from _ctypes import byref
+from importlib.resources import files
+import os
+import sys
+
+import pyvcell_odesolver
+from pyvcell_odesolver._internal import check_arch
+
+
+class VCellNativeLibraryLoader:
+    lib: ctypes.CDLL
+
+    def __init__(self) -> None:
+        self.lib = self._load_library()
+        self._define_entry_points()
+
+    def _load_library(self) -> ctypes.CDLL:
+        system = platform.system()
+        lib_ext = {"Linux": ".so", "Darwin": ".dylib", "Windows": ".dll"}.get(system)
+        version_identifier = "VCell ODE solver (CVODE/IDA) v"
+
+        if lib_ext is None:
+            raise OSError(f"Unsupported operating system: {system}")
+
+        libs_dir = files(pyvcell_odesolver).joinpath("lib")
+        if not libs_dir.is_dir():
+            raise OSError(f"Could not find the shared library directory {libs_dir}")
+
+
+        valid_libraries = check_arch.get_all_valid_libraries_from_dir(str(libs_dir))
+        for file in valid_libraries:
+            file_str = str(file)
+            try:
+                lib = ctypes.CDLL(name=file_str)
+                lib.version_ctypes.restype = ctypes.c_char_p # signals ctypes to return as char-array
+                version_str: str = lib.version_ctypes().decode("utf-8")
+                if version_identifier not in version_str:
+                    err_str = f"`{file_str}` isn't desired lib (`{version_identifier}` not in `{version_str}`)"
+                    print(err_str, file=sys.stderr)
+            except AttributeError as e:
+                print(f"library `{file_str}` could not be loaded: {e}", file=sys.stderr)
+                continue # If we didn't get a version, we didn't get the correct lib
+            return lib
+
+        # Didn't find what we needed
+        files_checked = "\n  - ".join(valid_libraries if len(valid_libraries) > 0 else os.listdir(str(libs_dir)))
+        raise OSError(f"Could not find the shared library; in `{str(libs_dir)}` checked: \n  - {files_checked}")
+
+    def _define_entry_points(self) -> None:
+        self.lib.version_ctypes.restype = ctypes.c_char_p # technically, we did this above, but just in case
+        self.lib.version_ctypes.argtypes = []
+
+        self.lib.solve_ctypes.restype = ctypes.c_int
+        self.lib.solve_ctypes.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int]

pyvcell_odesolver/lib/README.md

@@ -0,0 +1 @@
+After building the IDAWin library, a copy of it should be placed here for packaging into a working python wheel.

pyvcell_odesolver/sundials.py

@@ -0,0 +1,13 @@
+from pyvcell_odesolver._internal.native_calls import ODENativeCalls
+
+def version() -> str:
+    obj = ODENativeCalls()
+    return obj.call_version()
+
+def solve(input_file_path: str, output_file_path: str, task_id: int = -1) -> int:
+    obj = ODENativeCalls()
+    # In python, True == 1; we want 0 == true (a.k.a.: process returned exit code 0)
+    return int(not obj.call_solve(input_file_path, output_file_path, task_id).success)
+
+if __name__ == "__main__":
+    print(version())

pyvcell_odesolver-0.9.4.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.3
+Name: pyvcell_odesolver
+Version: 0.9.4
+Summary: Virtual Cell CVODE / IDA based ODE solver
+Author: Jim Schaff, Logan Drescher
+Author-email: Jim Schaff <schaff@uchc.edu>, Logan Drescher <drescher@uchc.edu>
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: build ; extra == 'build'
+Requires-Dist: wheel ; extra == 'build'
+Requires-Dist: pytest ; extra == 'test'
+Requires-Python: >=3.10
+Provides-Extra: build
+Provides-Extra: test
+Description-Content-Type: text/markdown
+
+<p align="center" width="100%">
+ <a href="https://vcell.org">
+    <img width="10%" src="https://github.com/biosimulations/biosimulations/blob/dev/docs/src/assets/images/about/partners/vcell.svg">
+ </a>
+</p>
+
+## The Virtual Cell Project
+The Virtual Cell is a modeling and simulation framework for computational biology.  For details see http://vcell.org and http://github.com/virtualcell.
+
+---
+# vcell-ode
+![CI](https://github.com/virtualcell/vcell-ode/actions/workflows/cd.yml/badge.svg)
+
+Virtual Cell ODE [virtualcell/vcell-ode](https://github.com/virtualcell/vcell-ode) is a collection of numerical 
+simulation libraries and protocols used to process ODEs in the Virtual Cell framework [virtualcell/vcell](https://github.com/virtualcell/vcell)).
+
+## Building VCell ODE
+There are two ways to build VCell ODE, but both start out the same way
+### Step 1: Acquire the source-code
+The source code can be found online at the GitHub repository.
+`git clone https://github.com/virtualcell/vcell.git`
+
+### Step 2: Install Dependencies 
+You will need to acquire a unix-style C and C++ compiler suite in order to build VCell ODE. Traditionally, this project 
+uses CLang + Mold, but other compiler suites may work. Additionally, you'll need to install the other dependencies for 
+VCell ODE, which can be done in one of two ways:
+
+#### Method 1: Conan Toolchain (Recommended)
+The VCell ODE project uses the C++ dependency management system called ***conan*** to handle dependency management when 
+building VCell ODE. We provide a number of conan-profiles that will provide conan the information need to automatically 
+build the desired toolchain for cmake.
+
+#### Method 2: Manual Dependency Installation
+If you'd rather manually install all the dependencies build-tools to create VCell CLI, you'll need the following:
+##### Dependencies
+* If you want live messaging while the solver runs: `libcurl` (add `-DOPTION_TARGET_MESSAGING` to cmake call below)
+##### Build Tools
+* `cmake` to perform the build configuration
+* `ninja` (or equivalent) to perform the actual build process
+
+### Step 3: Invoke the Build
+In a shell with conan and/or the other build tools in path, navigate to the project's root directory and 
+run the following commands (tested in bash on unix and powershell on windows)
+
+Note that if using `conan`, you'll need to define a profile. use `conan profile detect --force` to generate one automatically, 
+or use one of the provided ones in `<project_root>/conan-profiles` [link](https://docs.conan.io/2/reference/config_files/profiles.html)
+to further reading on the official `conan` website.
+#### Powershell
+```pwsh
+    mdkir build # Must do if not using conan
+    conan install . --output-folder build --build=missing # If building using conan's help
+    cd build
+    ./conanbuild.ps1 # If building using conan's help
+    cmake -B . -S .. -G "Ninja" -DCMAKE_TOOLCHAIN_FILE="conan_toolchain.cmake" -DCMAKE_BUILD_TYPE=Release
+    cmake --build . --config Release
+```
+
+```bash
+    mdkir build # must do if not building conan
+    conan install . --output-folder build --build=missing # If building using conan's help
+    cd build
+    ./conanbuild.sh # If building using conan's help
+    cmake -B . -S .. -G "Ninja" -DCMAKE_TOOLCHAIN_FILE="conan_toolchain.cmake" -DCMAKE_BUILD_TYPE=Release
+    cmake --build . --config Release
+```
+
+### Step 4: Manual user/system install
+Currently, VCell ODE does not have an automated installation script. You will either need to move the resulting executables
+in `<project_root>/build/bin` to an appropriate folder in path, or put said folder into path for your computer.

pyvcell_odesolver-0.9.4.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyvcell_odesolver/__init__.py,sha256=tCVNXPq-mNEw3_Mgl2jY2plhJ47alNww0Ey9K7AbXbo,147
+pyvcell_odesolver/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyvcell_odesolver/_internal/check_arch.py,sha256=SldYkqmGc9RqXidlzO9z_MKbgPCPJmLlClTHNdJgfpA,4352
+pyvcell_odesolver/_internal/native_calls.py,sha256=pBrkg9ceWtHpjUiVHK7KK_FoZhw2SXIKEiszUziMwHE,1935
+pyvcell_odesolver/_internal/native_utils.py,sha256=l78LJXZ4PPOoBGd2GuNrgt2uDonHdeXcz2SzQYmcYYo,2381
+pyvcell_odesolver/lib/IDAWin.dll,sha256=uRmIDqFZj2pr-XeNk0_j0lDio9o2b8ClLRGJwC8uBuw,1033728
+pyvcell_odesolver/lib/README.md,sha256=O3e3gN08qZWr85izOaKG1-kb8GMuDLUxDSA-ozMMWow,112
+pyvcell_odesolver/sundials.py,sha256=Cxz85SKDxHxOfrToCViCMHOBIgFEPieVmOy5B7chLsU,490
+pyvcell_odesolver-0.9.4.dist-info/WHEEL,sha256=1EjGHjH5dz_UZIF9e_7PpgY8tR3oVUD4yQEimBKjzys,88
+pyvcell_odesolver-0.9.4.dist-info/METADATA,sha256=xvSfIP_SIAcd2bZYNpunQwHpKoJqrjHv3JuRnAPfaX4,4566
+pyvcell_odesolver-0.9.4.dist-info/RECORD,,

pyvcell_odesolver-0.9.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.28
+Root-Is-Purelib: true
+Tag: py3-none-win_amd64
+