libvcell 0.0.17__py3-none-win32.whl

libvcell/__init__.py

@@ -0,0 +1,31 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from libvcell.model_utils import (
+    sbml_to_vcml,
+    vcell_infix_to_num_expr_infix,
+    vcell_infix_to_python_infix,
+    vcml_to_sbml,
+    vcml_to_vcml,
+)
+from libvcell.solver_utils import (
+    sbml_to_finite_volume_input,
+    vcml_to_finite_volume_input,
+    vcml_to_moving_boundary_input,
+)
+
+try:
+    __version__ = version("libvcell")
+except PackageNotFoundError:  # pragma: no cover - source tree, package not installed
+    __version__ = "0.0.0"
+
+__all__ = [
+    "__version__",
+    "sbml_to_finite_volume_input",
+    "sbml_to_vcml",
+    "vcell_infix_to_num_expr_infix",
+    "vcell_infix_to_python_infix",
+    "vcml_to_finite_volume_input",
+    "vcml_to_moving_boundary_input",
+    "vcml_to_sbml",
+    "vcml_to_vcml",
+]

libvcell/_internal/native_calls.py

@@ -0,0 +1,228 @@
+import ctypes
+import logging
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from libvcell._internal.native_utils import IsolateManager, VCellNativeLibraryLoader
+
+
+class ReturnValue(BaseModel):
+    success: bool
+    message: str
+
+
+class MutableString:
+    def __init__(self, value: str):
+        self.value: str = value
+
+
+class VCellNativeCalls:
+    def __init__(self) -> None:
+        self.loader = VCellNativeLibraryLoader()
+        self.lib = self.loader.lib
+
+    def vcml_to_finite_volume_input(
+        self, vcml_content: str, simulation_name: str, output_dir_path: Path
+    ) -> ReturnValue:
+        try:
+            with IsolateManager(self.lib) as isolate_thread:
+                json_ptr: ctypes.c_char_p = self.lib.vcmlToFiniteVolumeInput(
+                    isolate_thread,
+                    ctypes.c_char_p(vcml_content.encode("utf-8")),
+                    ctypes.c_char_p(simulation_name.encode("utf-8")),
+                    ctypes.c_char_p(str(output_dir_path).encode("utf-8")),
+                )
+
+            value: bytes | None = ctypes.cast(json_ptr, ctypes.c_char_p).value
+            if value is None:
+                logging.error("Failed to convert vcml to finite volume input")
+                return ReturnValue(success=False, message="Failed to convert vcml to finite volume input")
+            json_str: str = value.decode("utf-8")
+            # self.lib.freeString(json_ptr)
+            return ReturnValue.model_validate_json(json_data=json_str)
+        except Exception as e:
+            logging.exception("Error in vcml_to_finite_volume_input()", exc_info=e)
+            raise
+
+    def vcml_to_moving_boundary_input(
+        self, vcml_content: str, simulation_name: str, output_dir_path: Path
+    ) -> ReturnValue:
+        try:
+            with IsolateManager(self.lib) as isolate_thread:
+                json_ptr: ctypes.c_char_p = self.lib.vcmlToMovingBoundaryInput(
+                    isolate_thread,
+                    ctypes.c_char_p(vcml_content.encode("utf-8")),
+                    ctypes.c_char_p(simulation_name.encode("utf-8")),
+                    ctypes.c_char_p(str(output_dir_path).encode("utf-8")),
+                )
+
+            value: bytes | None = ctypes.cast(json_ptr, ctypes.c_char_p).value
+            if value is None:
+                logging.error("Failed to convert vcml to moving boundary input")
+                return ReturnValue(success=False, message="Failed to convert vcml to moving boundary input")
+            json_str: str = value.decode("utf-8")
+            # self.lib.freeString(json_ptr)
+            return ReturnValue.model_validate_json(json_data=json_str)
+        except Exception as e:
+            logging.exception("Error in vcml_to_moving_boundary_input()", exc_info=e)
+            raise
+
+    def sbml_to_finite_volume_input(self, sbml_content: str, output_dir_path: Path) -> ReturnValue:
+        try:
+            with IsolateManager(self.lib) as isolate_thread:
+                json_ptr: ctypes.c_char_p = self.lib.sbmlToFiniteVolumeInput(
+                    isolate_thread,
+                    ctypes.c_char_p(sbml_content.encode("utf-8")),
+                    ctypes.c_char_p(str(output_dir_path).encode("utf-8")),
+                )
+            value: bytes | None = ctypes.cast(json_ptr, ctypes.c_char_p).value
+            if value is None:
+                logging.error("Failed to convert sbml to finite volume input")
+                return ReturnValue(success=False, message="Failed to convert sbml to finite volume input")
+            json_str: str = value.decode("utf-8")
+            # self.lib.freeString(json_ptr)
+            return ReturnValue.model_validate_json(json_data=json_str)
+        except Exception as e:
+            logging.exception("Error in sbml_to_finite_volume_input()", exc_info=e)
+            raise
+
+    def vcml_to_sbml(
+        self, vcml_content: str, application_name: str, sbml_file_path: Path, round_trip_validation: bool
+    ) -> ReturnValue:
+        try:
+            with IsolateManager(self.lib) as isolate_thread:
+                json_ptr: ctypes.c_char_p = self.lib.vcmlToSbml(
+                    isolate_thread,
+                    ctypes.c_char_p(vcml_content.encode("utf-8")),
+                    ctypes.c_char_p(application_name.encode("utf-8")),
+                    ctypes.c_char_p(str(sbml_file_path).encode("utf-8")),
+                    ctypes.c_int(int(round_trip_validation)),
+                )
+
+            value: bytes | None = ctypes.cast(json_ptr, ctypes.c_char_p).value
+            if value is None:
+                logging.error("Failed to convert vcml application to sbml")
+                return ReturnValue(success=False, message="Failed to convert vcml to sbml")
+            json_str: str = value.decode("utf-8")
+            # self.lib.freeString(json_ptr)
+            return ReturnValue.model_validate_json(json_data=json_str)
+        except Exception as e:
+            logging.exception("Error in vcml_to_sbml()", exc_info=e)
+            raise
+
+    def sbml_to_vcml(self, sbml_content: str, vcml_file_path: Path) -> ReturnValue:
+        try:
+            with IsolateManager(self.lib) as isolate_thread:
+                json_ptr: ctypes.c_char_p = self.lib.sbmlToVcml(
+                    isolate_thread,
+                    ctypes.c_char_p(sbml_content.encode("utf-8")),
+                    ctypes.c_char_p(str(vcml_file_path).encode("utf-8")),
+                )
+
+            value: bytes | None = ctypes.cast(json_ptr, ctypes.c_char_p).value
+            if value is None:
+                logging.error("Failed to convert sbml to vcml")
+                return ReturnValue(success=False, message="Failed to convert sbml to vcml")
+            json_str: str = value.decode("utf-8")
+            # self.lib.freeString(json_ptr)
+            return ReturnValue.model_validate_json(json_data=json_str)
+        except Exception as e:
+            logging.exception("Error in sbml_to_vcml()", exc_info=e)
+            raise
+
+    def vcml_to_vcml(self, vcml_content: str, vcml_file_path: Path) -> ReturnValue:
+        try:
+            with IsolateManager(self.lib) as isolate_thread:
+                json_ptr: ctypes.c_char_p = self.lib.vcmlToVcml(
+                    isolate_thread,
+                    ctypes.c_char_p(vcml_content.encode("utf-8")),
+                    ctypes.c_char_p(str(vcml_file_path).encode("utf-8")),
+                )
+
+            value: bytes | None = ctypes.cast(json_ptr, ctypes.c_char_p).value
+            if value is None:
+                logging.error("Failed to regenerate vcml")
+                return ReturnValue(success=False, message="Failed to regenerate vcml")
+            json_str: str = value.decode("utf-8")
+            # self.lib.freeString(json_ptr)
+            return ReturnValue.model_validate_json(json_data=json_str)
+        except Exception as e:
+            logging.exception("Error in vcml_to_vcml()", exc_info=e)
+            raise
+
+    def vcell_infix_to_python_infix(
+        self, vcell_infix: str, target_python_infix: MutableString, buffer_size: int | None = None
+    ) -> ReturnValue:
+        try:
+            needed_buffer_size = int(1.5 * len(vcell_infix)) if buffer_size is None else buffer_size
+            buff = ctypes.create_string_buffer(needed_buffer_size)
+            with IsolateManager(self.lib) as isolate_thread:
+                json_ptr = self.lib.vcellInfixToPythonInfix(
+                    isolate_thread, ctypes.c_char_p(vcell_infix.encode("utf-8")), buff, needed_buffer_size
+                )
+            value: bytes | None = ctypes.cast(json_ptr, ctypes.c_char_p).value
+            if value is None:
+                logging.error("Failed to regenerate vcml")
+                return ReturnValue(success=False, message="Failed to generate python infix")
+            json_str = value.decode("utf-8")
+            if "not enough room, need: `" in json_str:
+                if buffer_size is not None:
+                    logging.error("Failed to identify correct buffer size reported by previous error")
+                    return ReturnValue(
+                        success=False, message="Failed to identify correct buffer size reported by previous error"
+                    )
+                # get the size from the error
+                index = json_str.find("not enough room, need: `") + len("not enough room, need: `")
+                end_index = json_str.find("`", index)
+                size_as_string: str = json_str[index:end_index]
+                if not size_as_string.isnumeric():
+                    logging.error("Buffer size reported by previous error is not an integer!")
+                    return ReturnValue(
+                        success=False, message="Buffer size reported by previous error is not an integer!"
+                    )
+                return self.vcell_infix_to_python_infix(vcell_infix, target_python_infix, int(size_as_string))
+            # self.lib.freeString(json_ptr)
+            target_python_infix.value = buff.value.decode("utf-8")
+            return ReturnValue.model_validate_json(json_data=json_str)
+        except Exception as e:
+            logging.exception("Error in vcell_infix_to_python_infix()", exc_info=e)
+            raise
+
+    def vcell_infix_to_num_expr_infix(
+        self, vcell_infix: str, target_num_expr_infix: MutableString, buffer_size: int | None = None
+    ) -> ReturnValue:
+        try:
+            needed_buffer_size = int(1.5 * len(vcell_infix)) if buffer_size is None else buffer_size
+            buff = ctypes.create_string_buffer(needed_buffer_size)
+            with IsolateManager(self.lib) as isolate_thread:
+                json_ptr = self.lib.vcellInfixToNumExprInfix(
+                    isolate_thread, ctypes.c_char_p(vcell_infix.encode("utf-8")), buff, needed_buffer_size
+                )
+            value: bytes | None = ctypes.cast(json_ptr, ctypes.c_char_p).value
+            if value is None:
+                logging.error("Failed to regenerate vcml")
+                return ReturnValue(success=False, message="Failed to generate NumExpr infix")
+            json_str = value.decode("utf-8")
+            if "not enough room, need: `" in json_str:
+                if buffer_size is not None:
+                    logging.error("Failed to identify correct buffer size reported by previous error")
+                    return ReturnValue(
+                        success=False, message="Failed to identify correct buffer size reported by previous error"
+                    )
+                # get the size from the error
+                index = json_str.find("not enough room, need: `") + len("not enough room, need: `")
+                end_index = json_str.find("`", index)
+                size_as_string: str = json_str[index:end_index]
+                if not size_as_string.isnumeric():
+                    logging.error("Buffer size reported by previous error is not an integer!")
+                    return ReturnValue(
+                        success=False, message="Buffer size reported by previous error is not an integer!"
+                    )
+                return self.vcell_infix_to_num_expr_infix(vcell_infix, target_num_expr_infix, int(size_as_string))
+            # self.lib.freeString(json_ptr)
+            target_num_expr_infix.value = buff.value.decode("utf-8")
+            return ReturnValue.model_validate_json(json_data=json_str)
+        except Exception as e:
+            logging.exception("Error in vcell_infix_to_num_expr_infix()", exc_info=e)
+            raise

libvcell/_internal/native_utils.py

@@ -0,0 +1,102 @@
+import ctypes
+import platform
+from _ctypes import byref
+from importlib.resources import files
+
+import libvcell
+
+
+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)
+
+        if lib_ext is None:
+            raise OSError(f"Unsupported operating system: {system}")
+
+        libs_dir = files(libvcell).joinpath("lib")
+        if not libs_dir.is_dir():
+            raise OSError(f"Could not find the shared library directory {libs_dir}")
+
+        for file in libs_dir.iterdir():
+            if file.name.endswith(lib_ext):
+                print(f"Found shared library: {file}")
+                return ctypes.CDLL(name=str(file))
+
+        raise OSError("Could not find the shared library")
+
+    def _define_entry_points(self) -> None:
+        self.lib.vcmlToFiniteVolumeInput.restype = ctypes.c_char_p
+        self.lib.vcmlToFiniteVolumeInput.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p]
+
+        self.lib.sbmlToFiniteVolumeInput.restype = ctypes.c_char_p
+        self.lib.sbmlToFiniteVolumeInput.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
+
+        self.lib.sbmlToVcml.restype = ctypes.c_char_p
+        self.lib.sbmlToVcml.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
+
+        self.lib.vcmlToSbml.restype = ctypes.c_char_p
+        self.lib.vcmlToSbml.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_int,
+        ]
+
+        self.lib.vcmlToVcml.restype = ctypes.c_char_p
+        self.lib.vcmlToVcml.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
+
+        # vcmlToMovingBoundaryInput is only present in native libraries built with moving-boundary
+        # support; guard so the package still loads against older shared libraries.
+        if hasattr(self.lib, "vcmlToMovingBoundaryInput"):
+            self.lib.vcmlToMovingBoundaryInput.restype = ctypes.c_char_p
+            self.lib.vcmlToMovingBoundaryInput.argtypes = [
+                ctypes.c_void_p,
+                ctypes.c_char_p,
+                ctypes.c_char_p,
+                ctypes.c_char_p,
+            ]
+
+        self.lib.vcellInfixToPythonInfix.restype = ctypes.c_char_p
+        self.lib.vcellInfixToPythonInfix.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_longlong,
+        ]
+
+        self.lib.vcellInfixToNumExprInfix.restype = ctypes.c_char_p
+        self.lib.vcellInfixToNumExprInfix.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_longlong,
+        ]
+
+        self.lib.freeString.restype = None
+        self.lib.freeString.argtypes = [ctypes.c_char_p]
+
+
+class IsolateManager:
+    lib: ctypes.CDLL
+    isolate: ctypes.c_void_p
+    isolate_thread: ctypes.c_void_p
+
+    def __init__(self, lib: ctypes.CDLL) -> None:
+        self.lib = lib
+        self.isolate = ctypes.c_void_p()
+        self.isolate_thread = ctypes.c_void_p()
+
+    def __enter__(self) -> ctypes.c_void_p:
+        self.lib.graal_create_isolate(None, byref(self.isolate), byref(self.isolate_thread))
+        return self.isolate_thread
+
+    def __exit__(self, exc_type: type | None, exc_val: Exception, exc_tb: object | None) -> None:
+        self.lib.graal_tear_down_isolate(self.isolate_thread)

libvcell/model_utils.py

@@ -0,0 +1,91 @@
+from pathlib import Path
+
+from libvcell._internal.native_calls import MutableString, ReturnValue, VCellNativeCalls
+
+
+def vcml_to_sbml(
+    vcml_content: str, application_name: str, sbml_file_path: Path, round_trip_validation: bool
+) -> tuple[bool, str]:
+    """
+    Convert VCML content to SBML file
+
+    Args:
+        vcml_content (str): VCML content
+        application_name (str): VCell Biomodel application name
+        sbml_file_path (Path): path to resulting SBML file
+
+    Returns:
+        tuple[bool, str]: A tuple containing the success status and a message
+    """
+    native = VCellNativeCalls()
+    return_value: ReturnValue = native.vcml_to_sbml(
+        vcml_content=vcml_content,
+        application_name=application_name,
+        sbml_file_path=sbml_file_path,
+        round_trip_validation=round_trip_validation,
+    )
+    return return_value.success, return_value.message
+
+
+def sbml_to_vcml(sbml_content: str, vcml_file_path: Path) -> tuple[bool, str]:
+    """
+    Convert SBML content to finite volume input files
+
+    Args:
+        sbml_content (str): SBML content
+        vcml_file_path (Path): path to resulting VCML file
+
+    Returns:
+        tuple[bool, str]: A tuple containing the success status and a message
+    """
+    native = VCellNativeCalls()
+    return_value: ReturnValue = native.sbml_to_vcml(sbml_content=sbml_content, vcml_file_path=vcml_file_path)
+    return return_value.success, return_value.message
+
+
+def vcml_to_vcml(vcml_content: str, vcml_file_path: Path) -> tuple[bool, str]:
+    """
+    Process VCML content to regenerated VCML file
+
+    Args:
+        vcml_content (str): VCML content
+        vcml_file_path (Path): path to resulting VCML file
+
+    Returns:
+        tuple[bool, str]: A tuple containing the success status and a message
+    """
+    native = VCellNativeCalls()
+    return_value: ReturnValue = native.vcml_to_vcml(vcml_content=vcml_content, vcml_file_path=vcml_file_path)
+    return return_value.success, return_value.message
+
+
+def vcell_infix_to_python_infix(vcell_infix: str) -> tuple[bool, str, str]:
+    """
+    Converts an infix string version of a VCell Native Expression, and converts it to a Python compatible version
+
+    Args:
+        vcell_infix (str): the infix to convert
+
+    Returns:
+        tuple[bool, str, str]: A tuple containing the success status, a message, and the converted infix
+    """
+    native = VCellNativeCalls()
+    target_python_infix = MutableString("")
+    return_value: ReturnValue = native.vcell_infix_to_python_infix(vcell_infix, target_python_infix)
+    return return_value.success, return_value.message, target_python_infix.value
+
+
+def vcell_infix_to_num_expr_infix(vcell_infix: str) -> tuple[bool, str, str]:
+    """
+    Converts an infix string version of a VCell Native Expression, and converts it to a NumExpr compatible version
+
+    Args:
+        vcell_infix (str): the infix to convert
+
+    Returns:
+        tuple[bool, str, str]: A tuple containing the success status, a message, and the converted infix
+    """
+    native = VCellNativeCalls()
+    target_num_expr_infix = MutableString("")
+    return_value: ReturnValue = native.vcell_infix_to_num_expr_infix(vcell_infix, target_num_expr_infix)
+    return return_value.success, return_value.message, target_num_expr_infix.value

libvcell/solver_utils.py

@@ -0,0 +1,56 @@
+from pathlib import Path
+
+from libvcell._internal.native_calls import ReturnValue, VCellNativeCalls
+
+
+def vcml_to_finite_volume_input(vcml_content: str, simulation_name: str, output_dir_path: Path) -> tuple[bool, str]:
+    """
+    Convert VCML content to finite volume input files
+
+    Args:
+        vcml_content (str): VCML content
+        simulation_name (str): simulation name
+        output_dir_path (Path): output directory path
+
+    Returns:
+        tuple[bool, str]: A tuple containing the success status and a message
+    """
+    native = VCellNativeCalls()
+    return_value: ReturnValue = native.vcml_to_finite_volume_input(vcml_content, simulation_name, output_dir_path)
+    return return_value.success, return_value.message
+
+
+def vcml_to_moving_boundary_input(vcml_content: str, simulation_name: str, output_dir_path: Path) -> tuple[bool, str]:
+    """
+    Convert VCML content to Moving Boundary solver input (a MovingBoundarySetup XML file)
+
+    The named simulation must be configured for the Moving Boundary solver. The generated
+    MovingBoundarySetup XML can be consumed by the vcell-mbsolver package (``MovingBoundarySolver.from_xml``).
+
+    Args:
+        vcml_content (str): VCML content
+        simulation_name (str): simulation name (must use the Moving Boundary solver)
+        output_dir_path (Path): output directory path
+
+    Returns:
+        tuple[bool, str]: A tuple containing the success status and a message
+    """
+    native = VCellNativeCalls()
+    return_value: ReturnValue = native.vcml_to_moving_boundary_input(vcml_content, simulation_name, output_dir_path)
+    return return_value.success, return_value.message
+
+
+def sbml_to_finite_volume_input(sbml_content: str, output_dir_path: Path) -> tuple[bool, str]:
+    """
+    Convert SBML content to finite volume input files
+
+    Args:
+        sbml_content (str): SBML content
+        output_dir_path (Path): output directory path
+
+    Returns:
+        tuple[bool, str]: A tuple containing the success status and a message
+    """
+    native = VCellNativeCalls()
+    return_value: ReturnValue = native.sbml_to_finite_volume_input(sbml_content, output_dir_path)
+    return return_value.success, return_value.message

libvcell-0.0.17.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: libvcell
+Version: 0.0.17
+Summary: This is a python package which wraps a subset of VCell Java code as a native python package.
+License-File: LICENSE
+Author: Jim Schaff
+Author-email: schaff@uchc.edu
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+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.10.6,<3.0.0)
+Project-URL: Documentation, https://virtualcell.github.io/libvcell/
+Project-URL: Repository, https://github.com/virtualcell/libvcell
+Description-Content-Type: text/markdown
+
+# libvcell
+
+[![Release](https://img.shields.io/github/v/release/virtualcell/libvcell)](https://img.shields.io/github/v/release/virtualcell/libvcell)
+[![Build status](https://img.shields.io/github/actions/workflow/status/virtualcell/libvcell/main.yml?branch=main)](https://github.com/virtualcell/libvcell/actions/workflows/main.yml?query=branch%3Amain)
+[![codecov](https://codecov.io/gh/virtualcell/libvcell/branch/main/graph/badge.svg)](https://codecov.io/gh/virtualcell/libvcell)
+[![Commit activity](https://img.shields.io/github/commit-activity/m/virtualcell/libvcell)](https://img.shields.io/github/commit-activity/m/virtualcell/libvcell)
+[![License](https://img.shields.io/github/license/virtualcell/libvcell)](https://img.shields.io/github/license/virtualcell/libvcell)
+
+libvcell is a subset of VCell algorithms intended to support the [pyvcell](https://pypi.org/project/pyvcell/) python package.
+
+- **Github repository**: <https://github.com/virtualcell/libvcell/>
+- **Documentation** <https://virtualcell.github.io/libvcell/>
+
+## Getting started with your project
+
+First, create a repository on GitHub with the same name as this project, and then run the following commands:
+
+```bash
+git init -b main
+git add .
+git commit -m "init commit"
+git remote add origin git@github.com:virtualcell/libvcell.git
+git push -u origin main
+```
+
+Finally, install the environment and the pre-commit hooks with
+
+```bash
+make install
+```
+
+You are now ready to start development on your project!
+The CI/CD pipeline will be triggered when you open a pull request, merge to main, or when you create a new release.
+
+To finalize the set-up for publishing to PyPI or Artifactory, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/publishing/#set-up-for-pypi).
+For activating the automatic documentation with MkDocs, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/mkdocs/#enabling-the-documentation-on-github).
+To enable the code coverage reports, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/codecov/).
+
+## Releasing a new version
+
+- Create an API Token on [PyPI](https://pypi.org/).
+- Add the API Token to your projects secrets with the name `PYPI_TOKEN` by visiting [this page](https://github.com/virtualcell/libvcell/settings/secrets/actions/new).
+- Create a [new release](https://github.com/virtualcell/libvcell/releases/new) on Github.
+- Create a new tag in the form `*.*.*`.
+- For more details, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/cicd/#how-to-trigger-a-release).
+
+---
+
+Repository initiated with [fpgmaas/cookiecutter-poetry](https://github.com/fpgmaas/cookiecutter-poetry).
+

libvcell-0.0.17.dist-info/RECORD

@@ -0,0 +1,13 @@
+libvcell/__init__.py,sha256=QyvFcsVpgutciGNcV2fK4UoetJVwfIugmW-Nv4I2wKo,820
+libvcell/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libvcell/_internal/native_calls.py,sha256=xXRC7CcTCGU019WOZD-DF3r7abqHCwWrrbWyknrMiZw,11723
+libvcell/_internal/native_utils.py,sha256=hmSEOI2pCxwtY9CH4oOogQgacMPxk0fSuvB0wibr1sQ,3740
+libvcell/lib/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libvcell/lib/libvcell.dll,sha256=jYputwvK0ec4M569fAJ8Ei08NU5dJbPHQThzRrWwAk4,126287872
+libvcell/model_utils.py,sha256=6ELwJHL3woshU78PxFpfHjK-GGG0ijRujEOsIi99a1c,3376
+libvcell/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libvcell/solver_utils.py,sha256=UX6N05i_dMbi2o3ZqD7bocRZQZ8jZf3Pwt040rwwBVY,2255
+libvcell-0.0.17.dist-info/licenses/LICENSE,sha256=uuKYfnhjRd2IOKltacW_z7JSZLVs9Mqj50o9fVnRFyI,1089
+libvcell-0.0.17.dist-info/METADATA,sha256=2EeiBlGt6p5fSuTwU1jeePTpkeSvE94sdG3tLtbkT-U,3424
+libvcell-0.0.17.dist-info/WHEEL,sha256=_2Rjawn4aPnD-wKFdXk6FO5w2r5WnOXvEEEUm7i__ms,92
+libvcell-0.0.17.dist-info/RECORD,,

libvcell-0.0.17.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.1
+Root-Is-Purelib: false
+Tag: py3-none-win32
+

libvcell-0.0.17.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025, Jim Schaff
+
+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.