arraybridge 0.2.11__tar.gz → 0.3.1__tar.gz

{arraybridge-0.2.11 → arraybridge-0.3.1}/.github/workflows/ci.yml

@@ -155,4 +155,4 @@ jobs:
       - name: Run mypy (type checking)
         continue-on-error: true  # Scientific code often has complex types
         run: |
-          mypy src/ --ignore-missing-imports
+          mypy src/

{arraybridge-0.2.11 → arraybridge-0.3.1}/.github/workflows/coverage-pages.yml

@@ -6,7 +6,7 @@ on:
   workflow_dispatch:
 
 permissions:
-  contents: write  # Needed for badge commit
+  contents: read
   pages: write
   id-token: write
 
@@ -40,7 +40,6 @@ jobs:
           pip install torch --index-url https://download.pytorch.org/whl/cpu
 
       - name: Run tests with coverage
-        continue-on-error: true  # Continue workflow even if tests fail
         run: |
           mkdir -p site
           python -m pytest --cov=arraybridge \
@@ -50,8 +49,7 @@ jobs:
 
       - name: Generate coverage badge
         run: |
-          mkdir -p .github/badges
-          genbadge coverage -i coverage.xml -o .github/badges/coverage.svg -n "coverage"
+          genbadge coverage -i coverage.xml -o site/coverage-badge.svg -n "coverage"
 
       - name: Create index.html and README
         run: |
@@ -72,7 +70,7 @@ jobs:
           # Create README.md in the site directory
           echo "# arraybridge Code Coverage Reports" > site/README.md
           echo "" >> site/README.md
-          echo "This site contains the code coverage reports for the [arraybridge](https://github.com/trissim/arraybridge) project." >> site/README.md
+          echo "This site contains the code coverage reports for the [arraybridge](https://github.com/OpenHCSDev/arraybridge) project." >> site/README.md
           echo "" >> site/README.md
           echo "## Navigation" >> site/README.md
           echo "" >> site/README.md
@@ -85,19 +83,10 @@ jobs:
           echo "" >> site/README.md
           echo "Last updated: $(date)" >> site/README.md
 
-      - name: Commit and push if coverage badge changed
-        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
-        run: |
-          git config --local user.email "github-actions[bot]@users.noreply.github.com"
-          git config --local user.name "github-actions[bot]"
-          git add .github/badges/coverage.svg -f
-          git commit -m "chore: update coverage badge" || exit 0
-          git push
-
       - name: Check GitHub Pages status
         run: |
           echo "⚠️ IMPORTANT: Make sure GitHub Pages is enabled in your repository settings!"
-          echo "Go to https://github.com/trissim/arraybridge/settings/pages"
+          echo "Go to https://github.com/OpenHCSDev/arraybridge/settings/pages"
           echo "Set 'Source' to 'GitHub Actions' to enable GitHub Pages deployment."
 
       - name: Setup Pages

{arraybridge-0.2.11 → arraybridge-0.3.1}/.github/workflows/publish.yml

@@ -20,6 +20,8 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
 
       - name: Set up Python
         uses: actions/setup-python@v5
@@ -29,7 +31,21 @@ jobs:
       - name: Install build dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install build
+          pip install -e ".[dev]"
+
+      - name: Validate source and tests
+        run: |
+          ruff check src/ scripts/
+          black --check src/ scripts/
+          mypy src/
+          pytest -q --no-cov
+
+      - name: Verify release tag and main ancestry
+        run: |
+          declared_version=$(python -c 'import tomllib; print(tomllib.load(open("pyproject.toml", "rb"))["project"]["version"])')
+          test "$GITHUB_REF_NAME" = "v$declared_version"
+          git fetch origin main
+          git merge-base --is-ancestor "$GITHUB_SHA" origin/main
 
       - name: Build package
         run: python -m build
@@ -39,6 +55,9 @@ jobs:
           pip install twine
           twine check dist/*
 
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
       - name: Create GitHub Release
         uses: softprops/action-gh-release@v2
         with:
@@ -46,6 +65,3 @@ jobs:
           generate_release_notes: true
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1

arraybridge-0.3.1/ADDING_NEW_FRAMEWORKS.md

@@ -0,0 +1,63 @@
+# Adding a framework
+
+This is a maintainer how-to for extending ArrayBridge's closed framework
+taxonomy. Applications should consume `MemoryType`; they should not add their
+own framework registry.
+
+## 1. Define typed leaves
+
+Add an `ArrayOperations` bundle in
+`src/arraybridge/array_operations.py`. It must provide four ordinary callables:
+
+- project an array to NumPy;
+- create an array from NumPy on the requested framework-local device;
+- stack prepared 2D arrays into one 3D array;
+- apply the framework's dtype-scaling semantics.
+
+Define device, stream, DLPack, cleanup, and OOM leaves in
+`src/arraybridge/types.py`. Use the no-op defaults in `FrameworkRuntime` only
+when the framework genuinely lacks that capability. Do not encode behavior as
+strings or add a parallel `MemoryType`-keyed table.
+
+## 2. Add the declaration
+
+Add one `MemoryType` member carrying:
+
+1. its stable value and import name;
+2. its display name and module aliases;
+3. whether it is GPU-backed;
+4. any environment defaults that must be set before first import;
+5. its `FrameworkRuntime` leaves;
+6. its `ArrayOperations` bundle.
+
+The converter classes, target conversion methods, compatibility operation view,
+dtype-scaling view, cleanup adapters, and framework decorator are generated
+from the enum. Do not wire them manually.
+
+## 3. Prove the extension
+
+Add focused tests for:
+
+- module-name detection and optional-dependency failure;
+- NumPy round trips and every supported DLPack pair;
+- CPU-only installations of a nominally GPU framework;
+- invalid, negative, and multiple framework-local device IDs;
+- same-framework moves between two devices;
+- one-, two-, and multi-slice stack/unstack behavior;
+- immutable array types;
+- cleanup and OOM behavior without importing an absent framework;
+- generated registry and export completeness.
+
+Run:
+
+```bash
+ruff check src tests
+black --check src tests
+mypy src --ignore-missing-imports
+pytest
+python -m sphinx -E -W --keep-going -b html docs/source /tmp/arraybridge-docs
+```
+
+When GPU hardware is available, also exercise every installed framework pair in
+one process. This catches import-order, allocator-coexistence, DLPack, and real
+API-shape defects that isolated mocks cannot prove.

{arraybridge-0.2.11 → arraybridge-0.3.1}/CONTRIBUTING.md

@@ -332,35 +332,48 @@ git push origin feature/your-feature-name
 
 ### 1. Update Version
 
-Edit `pyproject.toml`:
+Update all three validated version projections with the side-effect-free helper:
 
-```toml
-[project]
-version = "0.2.0"
+```bash
+python scripts/update_version.py 0.3.0
 ```
 
+Review the package, project, and documentation changes, then run
+`python scripts/verify_release_ready.py --allow-dirty` before committing.
+
 ### 2. Update Changelog
 
 Add release notes to `CHANGELOG.md` (if exists) or create GitHub release notes.
 
-### 3. Create Tag
+### 3. Validate, Commit, and Push
 
 ```bash
-# Ensure you're on main branch
-git checkout main
-git pull upstream main
+ruff check src tests scripts
+black --check src scripts
+mypy src --ignore-missing-imports
+pytest
+python -m sphinx -E -W --keep-going -b html docs/source /tmp/arraybridge-docs
+git commit
+git push origin HEAD:main
+```
 
-# Create and push tag
-git tag -a v0.2.0 -m "Release version 0.2.0"
-git push upstream v0.2.0
+### 4. Create the Release Tag
+
+After the pushed commit is exactly `origin/main`, run:
+
+```bash
+python scripts/release.py
 ```
 
-### 4. Automated Publishing
+The script validates the clean published commit, confirms the PyPI version, and
+pushes the matching annotated tag.
+
+### 5. Automated Publishing
 
 GitHub Actions will automatically:
-1. Build the package
-2. Create GitHub release
-3. Publish to PyPI
+1. verify the tag, source, tests, and package metadata;
+2. publish to PyPI;
+3. create the GitHub release.
 
 ## Development Guidelines
 
@@ -391,12 +404,14 @@ GitHub Actions will automatically:
 
 To add support for a new framework:
 
-1. Update `MemoryType` enum in `types.py`
-2. Add framework config in `framework_config.py`
-3. Implement converter in `conversion_helpers.py`
-4. Add decorator support in `decorators.py`
-5. Update documentation
-6. Add tests with availability checks
+1. Add typed array-operation leaves in `array_operations.py`.
+2. Add one `MemoryType` declaration carrying those operations and its runtime leaves.
+3. Add detection, conversion-pair, stack, cross-device, and optional-dependency tests.
+4. Update the extension and reference documentation.
+
+Do not add framework behavior to `_FRAMEWORK_CONFIG`, a consumer registry, or
+generated decorator exports. See `ADDING_NEW_FRAMEWORKS.md` for the complete
+declaration-owned extension procedure.
 
 ## Getting Help
 

{arraybridge-0.2.11 → arraybridge-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arraybridge
-Version: 0.2.11
+Version: 0.3.1
 Summary: Unified API for NumPy, CuPy, PyTorch, TensorFlow, JAX, and pyclesperanto with automatic memory type conversion
 Project-URL: Homepage, https://github.com/OpenHCSDev/arraybridge
 Project-URL: Documentation, https://arraybridge.readthedocs.io
@@ -34,10 +34,13 @@ Provides-Extra: cupy
 Requires-Dist: cupy>=10.0; extra == 'cupy'
 Provides-Extra: dev
 Requires-Dist: black>=23.0; extra == 'dev'
+Requires-Dist: build>=1.0; extra == 'dev'
 Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: packaging>=23.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: sphinx-autodoc-typehints>=1.25; extra == 'docs'
 Requires-Dist: sphinx-rtd-theme>=2.0; extra == 'docs'
@@ -92,8 +95,10 @@ copy = convert_memory(
 ```
 
 `convert_memory` requires the declared source type, target type, and device id.
-It uses the registered converter for the source framework. The device id is
-required even for CPU conversions so call sites have one stable signature.
+The source and target `MemoryType` declarations perform conversion directly.
+The device id is required even for CPU conversions so call sites have one
+stable signature. A GPU target must declare that identifier as available;
+ArrayBridge does not silently place the value on the CPU.
 
 ## Declarative decorators
 
@@ -105,11 +110,12 @@ def normalize(image):
     return image / max(float(image.max()), 1.0)
 ```
 
-The framework decorators attach `input_memory_type` and `output_memory_type`
-metadata, provide dtype/slice runtime parameters, and add framework-specific
-stream/OOM handling where supported. They do **not** convert inputs or outputs
-between frameworks and do not accept a `gpu_id` argument. A host runtime must
-call `convert_memory` at the boundary it plans.
+The framework decorators attach `input_memory_type`, `output_memory_type`, and
+`execution_memory_type` metadata, provide dtype/slice runtime parameters, and
+add framework-specific stream/OOM handling where supported. They do **not**
+convert inputs or outputs between frameworks and do not accept a `gpu_id`
+argument. A host runtime must call `convert_memory` at the boundary it plans and
+scope execution using the execution declaration.
 
 ## Stack utilities
 

{arraybridge-0.2.11 → arraybridge-0.3.1}/README.md

@@ -25,8 +25,10 @@ copy = convert_memory(
 ```
 
 `convert_memory` requires the declared source type, target type, and device id.
-It uses the registered converter for the source framework. The device id is
-required even for CPU conversions so call sites have one stable signature.
+The source and target `MemoryType` declarations perform conversion directly.
+The device id is required even for CPU conversions so call sites have one
+stable signature. A GPU target must declare that identifier as available;
+ArrayBridge does not silently place the value on the CPU.
 
 ## Declarative decorators
 
@@ -38,11 +40,12 @@ def normalize(image):
     return image / max(float(image.max()), 1.0)
 ```
 
-The framework decorators attach `input_memory_type` and `output_memory_type`
-metadata, provide dtype/slice runtime parameters, and add framework-specific
-stream/OOM handling where supported. They do **not** convert inputs or outputs
-between frameworks and do not accept a `gpu_id` argument. A host runtime must
-call `convert_memory` at the boundary it plans.
+The framework decorators attach `input_memory_type`, `output_memory_type`, and
+`execution_memory_type` metadata, provide dtype/slice runtime parameters, and
+add framework-specific stream/OOM handling where supported. They do **not**
+convert inputs or outputs between frameworks and do not accept a `gpu_id`
+argument. A host runtime must call `convert_memory` at the boundary it plans and
+scope execution using the execution declaration.
 
 ## Stack utilities
 

arraybridge-0.3.1/TESTING.md

@@ -0,0 +1,46 @@
+# Testing ArrayBridge
+
+This is the practical test guide. The workflow files under `.github/workflows`
+are the authority for the current CI matrix.
+
+## Local core checks
+
+```bash
+python -m pip install -e ".[dev,docs]"
+ruff check src tests
+black --check src tests
+mypy src --ignore-missing-imports
+pytest
+python -m sphinx -E -W --keep-going -b html docs/source /tmp/arraybridge-docs
+```
+
+The default suite uses real optional frameworks when installed and otherwise
+exercises declared unavailable paths and focused fakes. Markers such as
+`torch`, `tensorflow`, `jax`, `cupy`, `pyclesperanto`, and `gpu` can select or
+exclude framework-specific tests.
+
+## Real GPU lattice check
+
+On a GPU host, validate more than a single NumPy round trip:
+
+- import all installed frameworks in one fresh process;
+- enumerate framework-local devices through each `MemoryType`;
+- convert a small exact array through every available source-target pair;
+- stack and unstack one, two, and several planes in every framework;
+- verify same-framework movement across multiple local devices when present;
+- confirm absent frameworks are not imported by discovery or cleanup;
+- exercise DLPack success and explicit CPU fallback paths;
+- target OOM cleanup to the device that owned execution.
+
+Use a fresh process and unset TensorFlow/JAX allocator variables when checking
+that declaration-owned import defaults work. Framework warnings about shared
+CUDA plugin registration should be recorded separately from value, device, or
+shape failures.
+
+## Interpreting CI
+
+The main CI workflow runs the test suite across its declared Python and OS
+matrix. The manual GPU-named workflow installs CPU-capable Torch and JAX on a
+standard runner; it does not prove CUDA behavior. Real multi-framework and
+multi-device results therefore remain a required release check on suitable
+hardware.

arraybridge-0.3.1/docs/source/advanced_topics.rst

@@ -0,0 +1,24 @@
+Advanced extension topics
+=========================
+
+Framework behavior is carried by each ``MemoryType`` member. Add a framework by
+extending that owning declaration:
+
+1. add the ``MemoryType`` member;
+2. provide its typed runtime and array-operation leaves;
+3. define conversion, stack, scaling, and device behavior;
+4. add cleanup and OOM behavior only when the framework supports them;
+5. exercise detection and every supported conversion pair.
+
+Do not add a parallel framework-name table in a consumer. Generic consumers use
+``MemoryType`` directly. The converter registry and historical framework config
+are generated projections, not authorities.
+
+Version 0.3 keeps the private ``_FRAMEWORK_CONFIG`` and ``_FRAMEWORK_OPS`` names
+only as read-only operation views. Their historical mapping shape is not a
+compatibility contract. Migrate callers to ``MemoryType`` methods.
+
+Conversion caching and batching belong to the caller because value lifetime and
+semantic identity are application concerns. ArrayBridge functions remain
+stateless at the conversion boundary except for declared thread-local GPU
+context.

{arraybridge-0.2.11 → arraybridge-0.3.1}/docs/source/api_reference.rst

@@ -5,11 +5,18 @@ Public imports
 --------------
 
 ``MemoryType``, ``CPU_MEMORY_TYPES``, ``GPU_MEMORY_TYPES``, ``SUPPORTED_MEMORY_TYPES``
-  Nominal framework identities.
+  Framework declarations. Each member owns import identity, conversion,
+  stacking, dtype scaling, device discovery, scoped selection, movement,
+  DLPack import/export, cleanup, and pre-import coexistence defaults.
 
 ``detect_memory_type`` and ``convert_memory``
   Detection and explicit conversion.
 
+``ArrayGeometry``
+  Framework-neutral shape inspection for arrays and nominal ``ArrayPayload``
+  values. Geometry inspection reads declared shape metadata and does not move
+  device data to host memory.
+
 ``memory_types``, ``numpy``, ``cupy``, ``torch``, ``tensorflow``, ``jax``, ``pyclesperanto``
   Callable memory declarations and wrappers.
 

{arraybridge-0.2.11 → arraybridge-0.3.1}/docs/source/conf.py

@@ -22,7 +22,7 @@ sys.path.insert(0, str(PACKAGE_ROOT / "src"))
 project = 'arraybridge'
 copyright = '2025, Tristan Simas'
 author = 'Tristan Simas'
-release = '0.2.11'
+release = '0.3.1'
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

{arraybridge-0.2.11 → arraybridge-0.3.1}/docs/source/contributing.rst

@@ -17,9 +17,9 @@ Framework extensions
 --------------------
 
 A framework extension must update the nominal ``MemoryType`` declaration and
-the owning conversion/framework strategies. Add detection tests, conversion
-pair tests, stack tests, and optional-dependency behavior. Consumers should not
-maintain a second framework-name registry.
+its typed operation leaves. Add detection, conversion-pair, stack,
+cross-device, and optional-dependency tests. Consumers should not maintain a
+second framework-name registry.
 
 See :doc:`advanced_topics` for the ownership model and the repository's
 `contribution guide

arraybridge-0.3.1/docs/source/converters.rst

@@ -0,0 +1,47 @@
+Conversion system
+=================
+
+``convert_memory(data, source_type, target_type, gpu_id)`` resolves the source
+and target ``MemoryType`` declarations and lets those declarations perform the
+conversion.
+
+.. code-block:: python
+
+   import numpy as np
+
+   from arraybridge import MemoryType, convert_memory
+
+   value = np.arange(4)
+   result = convert_memory(
+       value,
+       MemoryType.NUMPY,
+       MemoryType.NUMPY,
+       0,
+   )
+
+Both ``source_type`` and ``target_type`` accept either the canonical
+``MemoryType`` member or its string value. Decorators normalize the same
+members to string metadata at declaration time, so callable contracts and
+conversion plans share one taxonomy without carrying duplicate enum classes.
+
+Call ``detect_memory_type`` when the source type is not already known. Passing a
+wrong source declaration is a caller error; conversion planning should keep the
+declared type aligned with the actual value.
+
+Device semantics
+----------------
+
+``gpu_id`` is required. GPU converters use it for allocation or device
+selection. CPU conversion accepts the same argument for a uniform API. Moving a
+value between two devices is expressed as conversion with the target device id.
+
+Declarations prefer framework-native or DLPack paths when both endpoints
+support them and otherwise use an explicit NumPy round trip. No zero-copy
+guarantee applies to every pair.
+
+Failures
+--------
+
+Invalid framework names raise ``ValueError``. Conversion failures raise
+``MemoryConversionError`` with source/target context. Optional frameworks are
+loaded only when their declaration is used.

{arraybridge-0.2.11 → arraybridge-0.3.1}/docs/source/decorators.rst

@@ -27,6 +27,21 @@ metadata, add keyword-only ``slice_by_slice`` and ``dtype_config`` runtime
 parameters, apply the selected dtype policy, and wrap supported GPU frameworks
 with thread-local stream/OOM handling.
 
+Framework helpers also attach ``execution_memory_type``. It identifies the
+framework that owns the function body even when ``input_type`` or
+``output_type`` is overridden. Host runtimes use that declaration when scoping
+callable execution; boundary types alone do not prove execution ownership.
+
+Metadata key API
+----------------
+
+``MemoryContractAttribute`` is the public owner of the callable metadata keys:
+``INPUT`` maps to ``input_memory_type``, ``OUTPUT`` maps to
+``output_memory_type``, and ``EXECUTION`` maps to ``execution_memory_type``.
+Each member provides ``read(namespace, default=None)`` and
+``write(namespace, value)`` for object and mapping namespaces. Host libraries
+can consume these members without maintaining a duplicate key registry.
+
 The decorator does not accept ``gpu_id`` or ``clear_cuda_cache``. Device
 selection belongs to explicit conversion or the host runtime. A non-callable
 ``contract`` is stored as declarative metadata; a callable contract validates
@@ -38,3 +53,7 @@ Dtype policy
 Direct calls default to preserving the input dtype. Hosts can pass an object
 implementing ``DtypeConversionConfig`` to select native or explicit output dtype
 behavior.
+
+``wrap_dtype_preserving_callable(func, memory_type)`` exposes the dtype and
+slice-control wrapper as a public integration boundary for host registries that
+already own their memory and processing contracts.

arraybridge-0.3.1/docs/source/gpu_features.rst

@@ -0,0 +1,34 @@
+GPU lifecycle
+=============
+
+GPU-backed conversion uses the explicit ``gpu_id`` passed to
+``convert_memory``, ``stack_slices``, or ``unstack_slices``. Framework-specific
+``MemoryType`` declarations own device discovery, validation, scopes, movement,
+and cache cleanup. Device identifiers are local to one framework. Equal numeric
+identifiers from different frameworks do not establish physical-device
+identity.
+
+Before importing TensorFlow or JAX, their declarations apply coexistence-safe
+defaults with ``setdefault``: TensorFlow memory growth is enabled and JAX GPU
+preallocation is disabled. An environment value supplied by the host is never
+overwritten. Hosts that import optional frameworks themselves should call
+``MemoryType.prepare_import()`` first. ArrayBridge warns when it encounters an
+already-loaded framework whose import-time defaults were absent.
+
+JAX float64 output requires x64 mode to be enabled before import. ArrayBridge
+raises instead of silently returning float32 when a caller requests float64
+while that capability is disabled.
+
+Decorated GPU callables may execute in a thread-local framework stream and may
+retry supported OOM failures when ``oom_recovery=True``. Decorators do not
+select a device and do not convert an incompatible input.
+
+``cleanup_all_gpu_frameworks(device_id=None)`` invokes allocator cleanup only
+for loaded frameworks that declare a real cleanup leaf. Supplying ``device_id``
+targets that framework-local identifier. Cleanup never imports an absent
+framework. JAX compilation-cache clearing is not presented as GPU-memory
+cleanup. The application decides when values are no longer live and cleanup is
+appropriate.
+
+ArrayBridge exposes mechanisms, not scheduling policy. Worker counts, device
+assignment, retry scope, and concurrency limits belong to the host runtime.

{arraybridge-0.2.11 → arraybridge-0.3.1}/docs/source/user_guide.rst

@@ -26,10 +26,10 @@ Framework names
 
 The public conversion and stack APIs use string values: ``numpy``, ``cupy``,
 ``torch``, ``tensorflow``, ``jax``, and ``pyclesperanto``. ``convert_memory``
-also accepts a ``MemoryType`` member for ``target_type``, but callers should
-prefer strings consistently because ``source_type`` and stack utilities require
-them. Availability depends on optional dependencies and hardware. ArrayBridge
-never silently substitutes a different framework for an invalid target.
+accepts the canonical ``MemoryType`` member at both its source and target
+boundaries. Availability depends on optional dependencies and hardware.
+ArrayBridge never silently substitutes a different framework for an invalid
+target.
 
 Applications should carry these values through typed configuration or plans,
 not infer them from function names.

{arraybridge-0.2.11 → arraybridge-0.3.1}/pyproject.toml

@@ -1,10 +1,11 @@
 [build-system]
-requires = ["hatchling"]
+# Hatchling 1.32 emits Core Metadata 2.5, which Twine 6.2 rejects.
+requires = ["hatchling>=1.28,<1.32"]
 build-backend = "hatchling.build"
 
 [project]
 name = "arraybridge"
-version = "0.2.11"
+version = "0.3.1"
 description = "Unified API for NumPy, CuPy, PyTorch, TensorFlow, JAX, and pyclesperanto with automatic memory type conversion"
 authors = [{name = "Tristan Simas", email = "tristan.simas@mail.mcgill.ca"}]
 license = {text = "MIT"}
@@ -71,6 +72,9 @@ all = [
 dev = [
     "pytest>=7.0",
     "pytest-cov>=4.0",
+    "build>=1.0",
+    "twine>=5.0",
+    "packaging>=23.0",
     "black>=23.0",
     "ruff>=0.1.0",
     "mypy>=1.0",
@@ -119,6 +123,12 @@ select = ["E", "F", "I", "N", "W", "UP"]
 
 [tool.mypy]
 python_version = "3.10"
+follow_imports_for_stubs = true
+ignore_missing_imports = true
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = false  # Too strict for scientific code
+
+[[tool.mypy.overrides]]
+module = "numpy.*"
+follow_imports = "skip"