arraybridge 0.3.2__tar.gz → 0.3.4__tar.gz

{arraybridge-0.3.2 → arraybridge-0.3.4}/.github/workflows/publish.yml

@@ -42,7 +42,7 @@ jobs:
 
       - name: Verify release tag and main ancestry
         run: |
-          declared_version=$(python -c 'import tomllib; print(tomllib.load(open("pyproject.toml", "rb"))["project"]["version"])')
+          declared_version=$(python -c 'import arraybridge; print(arraybridge.__version__)')
           test "$GITHUB_REF_NAME" = "v$declared_version"
           git fetch origin main
           git merge-base --is-ancestor "$GITHUB_SHA" origin/main

{arraybridge-0.3.2 → arraybridge-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arraybridge
-Version: 0.3.2
+Version: 0.3.4
 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

{arraybridge-0.3.2 → arraybridge-0.3.4}/docs/source/conf.py

@@ -16,13 +16,15 @@ EXTERNAL_ROOT = PACKAGE_ROOT.parent
 sys.path.insert(0, str(EXTERNAL_ROOT / "metaclass-registry" / "src"))
 sys.path.insert(0, str(PACKAGE_ROOT / "src"))
 
+from arraybridge import __version__
+
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
 project = 'arraybridge'
 copyright = '2025, Tristan Simas'
 author = 'Tristan Simas'
-release = '0.3.1'
+release = __version__
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

{arraybridge-0.3.2 → arraybridge-0.3.4}/docs/source/gpu_features.rst

@@ -15,6 +15,11 @@ 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.
 
+``MemoryType.subprocess_environment()`` projects the same member-owned import
+defaults into a child-process environment. The CuPy member also derives native
+library search paths from installed NVIDIA wheels, so a fresh child interpreter
+does not depend on another framework having loaded CUDA libraries first.
+
 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.

{arraybridge-0.3.2 → arraybridge-0.3.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arraybridge"
-version = "0.3.2"
+dynamic = ["version"]
 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"}
@@ -98,6 +98,9 @@ Issues = "https://github.com/OpenHCSDev/arraybridge/issues"
 [tool.hatch.build.targets.wheel]
 packages = ["src/arraybridge"]
 
+[tool.hatch.version]
+path = "src/arraybridge/__init__.py"
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]

arraybridge-0.3.4/scripts/update_version.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""Update ArrayBridge's canonical package version without Git side effects."""
+
+import argparse
+import re
+from pathlib import Path
+
+from packaging.version import InvalidVersion, Version
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+VERSION_FILE = PROJECT_ROOT / "src/arraybridge/__init__.py"
+VERSION_PATTERN = r"(__version__\s*=\s*['\"])([^'\"]+)(['\"])"
+
+
+def current_version() -> Version:
+    """Return the package-owned canonical version."""
+
+    match = re.search(
+        VERSION_PATTERN,
+        VERSION_FILE.read_text(encoding="utf-8"),
+        flags=re.MULTILINE,
+    )
+    if match is None:
+        raise RuntimeError(f"Version declaration is missing from {VERSION_FILE}")
+    return Version(match.group(2))
+
+
+def update_version(version_text: str) -> None:
+    try:
+        requested = Version(version_text)
+    except InvalidVersion as error:
+        raise ValueError(f"Invalid version: {version_text}") from error
+    current = current_version()
+    if requested <= current:
+        raise ValueError(f"New version {requested} must be greater than {current}")
+
+    content = VERSION_FILE.read_text(encoding="utf-8")
+    updated, count = re.subn(
+        VERSION_PATTERN,
+        rf"\g<1>{requested}\g<3>",
+        content,
+        flags=re.MULTILINE,
+    )
+    if count != 1:
+        raise RuntimeError(f"Expected one version declaration in {VERSION_FILE}, found {count}")
+    VERSION_FILE.write_text(updated, encoding="utf-8")
+
+    print(f"Updated ArrayBridge version to {requested}")
+    print("Run scripts/verify_release_ready.py --allow-dirty, then review and commit.")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("version", help="New release version, for example 0.3.0")
+    args = parser.parse_args()
+    update_version(args.version)
+
+
+if __name__ == "__main__":
+    main()

{arraybridge-0.3.2 → arraybridge-0.3.4}/scripts/verify_release_ready.py

@@ -16,8 +16,6 @@ import sys
 import tempfile
 from pathlib import Path
 
-import tomllib
-
 PROJECT_ROOT = Path(__file__).resolve().parents[1]
 
 
@@ -41,20 +39,6 @@ def check_version():
         print(f"  ❌ Version '{version}' doesn't follow semantic versioning (MAJOR.MINOR.PATCH)")
         return False
 
-    pyproject_version = tomllib.loads(
-        (PROJECT_ROOT / "pyproject.toml").read_text(encoding="utf-8")
-    )["project"]["version"]
-    docs_match = re.search(
-        r"release\s*=\s*['\"]([^'\"]+)",
-        (PROJECT_ROOT / "docs/source/conf.py").read_text(encoding="utf-8"),
-    )
-    docs_version = docs_match.group(1) if docs_match else None
-    if len({version, pyproject_version, docs_version}) != 1:
-        print(
-            "  ❌ Version authorities disagree: "
-            f"package={version}, pyproject={pyproject_version}, docs={docs_version}"
-        )
-        return False
     print(f"  ✅ Version: {version}")
     return True
 
@@ -70,7 +54,8 @@ def check_pyproject_toml():
     content = pyproject_file.read_text(encoding="utf-8")
     required_fields = {
         "name": r'name\s*=\s*["\']arraybridge["\']',
-        "version": r"version\s*=",
+        "dynamic version": r'dynamic\s*=\s*\[["\']version["\']\]',
+        "version authority": r'path\s*=\s*["\']src/arraybridge/__init__\.py["\']',
         "description": r"description\s*=",
         "authors": r"authors\s*=",
         "build-backend": r'build-backend\s*=\s*["\']hatchling\.build["\']',

arraybridge-0.3.4/src/arraybridge/__init__.py

@@ -0,0 +1,109 @@
+"""
+arraybridge: Unified API for NumPy, CuPy, PyTorch, TensorFlow, JAX, and pyclesperanto.
+
+This package provides automatic memory type conversion, declarative decorators,
+and unified utilities for working with multiple array/tensor frameworks.
+
+Package-root imports stay lightweight: submodule exports load on first
+attribute access instead of at import time. Declaration-only consumers
+(memory-type tables, configuration modules) therefore do not pay the
+NumPy/numcodecs import cost.
+"""
+
+__version__ = "0.3.4"
+
+_LAZY_EXPORTS: dict[str, str] = {
+    "MemoryType": ".types",
+    "MemoryContractAttribute": ".types",
+    "ArrayPayload": ".array_payload",
+    "ArrayGeometry": ".array_geometry",
+    "CPU_MEMORY_TYPES": ".types",
+    "GPU_MEMORY_TYPES": ".types",
+    "SUPPORTED_MEMORY_TYPES": ".types",
+    "convert_memory": ".converters",
+    "detect_memory_type": ".converters",
+    "memory_types": ".decorators",
+    "DtypeConversion": ".decorators",
+    "SliceBySliceRuntimeParameter": ".decorators",
+    "wrap_dtype_preserving_callable": ".decorators",
+    "stack_slices": ".stack_utils",
+    "unstack_slices": ".stack_utils",
+    "process_slices": ".slice_processing",
+    "cleanup_all_gpu_frameworks": ".gpu_cleanup",
+    "MemoryConversionError": ".exceptions",
+    "SCALING_FUNCTIONS": ".dtype_scaling",
+    "_FRAMEWORK_CONFIG": ".framework_config",
+    "_FRAMEWORK_OPS": ".framework_ops",
+    "_execute_with_oom_recovery": ".oom_recovery",
+    "_ensure_module": ".utils",
+    "_supports_dlpack": ".utils",
+    "_get_device_id": ".utils",
+    # Decorator exports named after each memory type (numpy, cupy, torch, ...).
+    "numpy": ".decorators",
+    "cupy": ".decorators",
+    "torch": ".decorators",
+    "tensorflow": ".decorators",
+    "jax": ".decorators",
+    "pyclesperanto": ".decorators",
+}
+
+__all__ = [
+    # Types
+    "MemoryType",
+    "MemoryContractAttribute",
+    "ArrayPayload",
+    "ArrayGeometry",
+    "CPU_MEMORY_TYPES",
+    "GPU_MEMORY_TYPES",
+    "SUPPORTED_MEMORY_TYPES",
+    # Converters
+    "convert_memory",
+    "detect_memory_type",
+    # Decorators
+    "memory_types",
+    "DtypeConversion",
+    "SliceBySliceRuntimeParameter",
+    "wrap_dtype_preserving_callable",
+    # Stack utilities
+    "stack_slices",
+    "unstack_slices",
+    # Slice processing
+    "process_slices",
+    # GPU cleanup
+    "cleanup_all_gpu_frameworks",
+    # Exceptions
+    "MemoryConversionError",
+    # Scaling
+    "SCALING_FUNCTIONS",
+    # Framework config (internal but needed by some consumers)
+    "_FRAMEWORK_CONFIG",
+    "_FRAMEWORK_OPS",
+    # OOM recovery
+    "_execute_with_oom_recovery",
+    # Utils
+    "_ensure_module",
+    "_supports_dlpack",
+    "_get_device_id",
+    "numpy",
+    "cupy",
+    "torch",
+    "tensorflow",
+    "jax",
+    "pyclesperanto",
+]
+
+
+def __getattr__(name: str):
+    module_name = _LAZY_EXPORTS.get(name)
+    if module_name is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    import importlib
+
+    value = getattr(importlib.import_module(module_name, __name__), name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(_LAZY_EXPORTS))

{arraybridge-0.3.2 → arraybridge-0.3.4}/src/arraybridge/types.py

@@ -5,6 +5,8 @@ This module defines the MemoryType enum and related constants for managing
 different array/tensor frameworks.
 """
 
+from __future__ import annotations
+
 import importlib
 import importlib.util
 import logging
@@ -14,17 +16,11 @@ from collections.abc import Callable, Iterator, Mapping, MutableMapping
 from contextlib import AbstractContextManager, contextmanager, nullcontext
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, TypeVar, cast
-
-from arraybridge.array_operations import (
-    CUPY_OPERATIONS,
-    JAX_OPERATIONS,
-    NUMPY_OPERATIONS,
-    PYCLESPERANTO_OPERATIONS,
-    TENSORFLOW_OPERATIONS,
-    TORCH_OPERATIONS,
-    ArrayOperations,
-)
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+if TYPE_CHECKING:
+    from arraybridge.array_operations import ArrayOperations
 
 T = TypeVar("T")
 logger = logging.getLogger(__name__)
@@ -41,6 +37,55 @@ StreamScopeFactory = Callable[[Any, Any], AbstractContextManager[None]]
 DLPackExporter = Callable[[Any, Any], Any | None]
 DLPackValidator = Callable[[Any, Any], bool]
 OOMMatcher = Callable[[BaseException, Any | None], bool]
+SubprocessEnvironmentResolver = Callable[[Mapping[str, str]], dict[str, str]]
+
+
+def _identity_subprocess_environment(
+    environment: Mapping[str, str],
+) -> dict[str, str]:
+    return dict(environment)
+
+
+def _nvidia_wheel_library_paths() -> tuple[str, ...]:
+    """Return native-library directories declared by installed NVIDIA wheels."""
+
+    try:
+        spec = importlib.util.find_spec("nvidia")
+    except (ImportError, ModuleNotFoundError, ValueError):
+        return ()
+    if spec is None or spec.submodule_search_locations is None:
+        return ()
+
+    paths: set[str] = set()
+    for package_root in map(Path, spec.submodule_search_locations):
+        try:
+            components = tuple(package_root.iterdir())
+        except OSError:
+            continue
+        for component in components:
+            for library_directory_name in ("lib", "bin"):
+                candidate = component / library_directory_name
+                if candidate.is_dir():
+                    paths.add(str(candidate))
+    return tuple(sorted(paths))
+
+
+def _nvidia_wheel_subprocess_environment(
+    environment: Mapping[str, str],
+) -> dict[str, str]:
+    """Prepend installed NVIDIA wheel libraries to a child environment."""
+
+    prepared = dict(environment)
+    library_paths = _nvidia_wheel_library_paths()
+    if not library_paths:
+        return prepared
+
+    search_variable = "PATH" if os.name == "nt" else "LD_LIBRARY_PATH"
+    existing_paths = tuple(
+        path for path in prepared.get(search_variable, "").split(os.pathsep) if path
+    )
+    prepared[search_variable] = os.pathsep.join(dict.fromkeys((*library_paths, *existing_paths)))
+    return prepared
 
 
 class MemoryContractAttribute(str, Enum):
@@ -501,6 +546,7 @@ class FrameworkRuntime:
     dlpack_exporter: DLPackExporter | None = None
     dlpack_validator: DLPackValidator = _protocol_dlpack
     oom_matcher: OOMMatcher = _never_oom
+    subprocess_environment: SubprocessEnvironmentResolver = _identity_subprocess_environment
 
 
 class _MemoryTypeFields:
@@ -510,7 +556,7 @@ class _MemoryTypeFields:
     module_aliases: tuple[str, ...]
     import_environment: tuple[tuple[str, str], ...]
     _runtime: FrameworkRuntime
-    _operations: ArrayOperations
+    _operations_name: str
 
 
 class MemoryType(_MemoryTypeFields, Enum):
@@ -520,7 +566,7 @@ class MemoryType(_MemoryTypeFields, Enum):
         cls,
         value: str,
         *declaration: Any,
-    ) -> "MemoryType":
+    ) -> MemoryType:
         (
             import_name,
             display_name,
@@ -538,9 +584,18 @@ class MemoryType(_MemoryTypeFields, Enum):
         member.module_aliases = cast(tuple[str, ...], module_aliases)
         member.import_environment = cast(tuple[tuple[str, str], ...], import_environment)
         member._runtime = cast(FrameworkRuntime, runtime)
-        member._operations = cast(ArrayOperations, operations)
+        member._operations_name = cast(str, operations)
         return member
 
+    @property
+    def _operations(self) -> ArrayOperations:
+        """Resolve this declaration's operations registry on first access."""
+
+        from arraybridge import array_operations
+
+        operations: ArrayOperations = getattr(array_operations, self._operations_name)
+        return operations
+
     NUMPY = (
         "numpy",
         "numpy",
@@ -549,7 +604,7 @@ class MemoryType(_MemoryTypeFields, Enum):
         (),
         (),
         FrameworkRuntime(oom_matcher=_numpy_oom),
-        NUMPY_OPERATIONS,
+        "NUMPY_OPERATIONS",
     )
     CUPY = (
         "cupy",
@@ -571,8 +626,9 @@ class MemoryType(_MemoryTypeFields, Enum):
             dlpack_importer=_cupy_from_dlpack,
             dlpack_exporter=_protocol_dlpack_export,
             oom_matcher=_cupy_oom,
+            subprocess_environment=_nvidia_wheel_subprocess_environment,
         ),
-        CUPY_OPERATIONS,
+        "CUPY_OPERATIONS",
     )
     TORCH = (
         "torch",
@@ -595,7 +651,7 @@ class MemoryType(_MemoryTypeFields, Enum):
             dlpack_exporter=_protocol_dlpack_export,
             oom_matcher=_torch_oom,
         ),
-        TORCH_OPERATIONS,
+        "TORCH_OPERATIONS",
     )
     TENSORFLOW = (
         "tensorflow",
@@ -614,7 +670,7 @@ class MemoryType(_MemoryTypeFields, Enum):
             dlpack_validator=_tensorflow_dlpack,
             oom_matcher=_tensorflow_oom,
         ),
-        TENSORFLOW_OPERATIONS,
+        "TENSORFLOW_OPERATIONS",
     )
     JAX = (
         "jax",
@@ -632,7 +688,7 @@ class MemoryType(_MemoryTypeFields, Enum):
             dlpack_exporter=_protocol_dlpack_export,
             oom_matcher=_jax_oom,
         ),
-        JAX_OPERATIONS,
+        "JAX_OPERATIONS",
     )
     PYCLESPERANTO = (
         "pyclesperanto",
@@ -649,7 +705,7 @@ class MemoryType(_MemoryTypeFields, Enum):
             move_to_active_device=_pyclesperanto_device_move,
             oom_matcher=_pyclesperanto_oom,
         ),
-        PYCLESPERANTO_OPERATIONS,
+        "PYCLESPERANTO_OPERATIONS",
     )
 
     @property
@@ -682,6 +738,20 @@ class MemoryType(_MemoryTypeFields, Enum):
         for name, value in self.import_environment:
             os.environ.setdefault(name, value)
 
+    @classmethod
+    def subprocess_environment(
+        cls,
+        environment: Mapping[str, str] | None = None,
+    ) -> dict[str, str]:
+        """Project framework import requirements into a child environment."""
+
+        prepared = dict(os.environ if environment is None else environment)
+        for memory_type in cls:
+            for name, value in memory_type.import_environment:
+                prepared.setdefault(name, value)
+            prepared = memory_type._runtime.subprocess_environment(prepared)
+        return prepared
+
     def loaded_module(self) -> Any | None:
         """Return an already-loaded framework without causing an import."""
 
@@ -887,7 +957,7 @@ class MemoryType(_MemoryTypeFields, Enum):
         payload = data if isinstance(data, DLPackPayload) else DLPackPayload(data, data)
         return importer(payload, framework)
 
-    def convert_to(self, data: Any, target: "MemoryType", device_id: int) -> Any:
+    def convert_to(self, data: Any, target: MemoryType, device_id: int) -> Any:
         """Convert one array through the source and target declarations."""
 
         if self is target:

{arraybridge-0.3.2 → arraybridge-0.3.4}/tests/test_types.py

@@ -145,6 +145,58 @@ class TestMemoryTypeOwnership:
         assert os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] == "true"
         assert os.environ["XLA_PYTHON_CLIENT_PREALLOCATE"] == "custom"
 
+    def test_subprocess_environment_derives_nvidia_wheel_paths_from_cupy_owner(
+        self,
+        monkeypatch,
+        tmp_path,
+    ):
+        from arraybridge import types
+
+        nvidia_root = tmp_path / "nvidia"
+        cublas_lib = nvidia_root / "cublas" / "lib"
+        runtime_bin = nvidia_root / "cuda_runtime" / "bin"
+        cublas_lib.mkdir(parents=True)
+        runtime_bin.mkdir(parents=True)
+        monkeypatch.setattr(
+            types.importlib.util,
+            "find_spec",
+            lambda name: (
+                SimpleNamespace(submodule_search_locations=(str(nvidia_root),))
+                if name == "nvidia"
+                else None
+            ),
+        )
+        search_variable = "PATH" if os.name == "nt" else "LD_LIBRARY_PATH"
+        original = {search_variable: "/existing", "CUSTOM": "value"}
+
+        prepared = MemoryType.subprocess_environment(original)
+
+        assert original == {search_variable: "/existing", "CUSTOM": "value"}
+        assert prepared[search_variable].split(os.pathsep) == [
+            *sorted((str(cublas_lib), str(runtime_bin))),
+            "/existing",
+        ]
+        assert prepared["CUSTOM"] == "value"
+        assert prepared["TF_FORCE_GPU_ALLOW_GROWTH"] == "true"
+        assert prepared["XLA_PYTHON_CLIENT_PREALLOCATE"] == "false"
+
+    def test_subprocess_environment_preserves_host_values_without_nvidia_wheels(
+        self,
+        monkeypatch,
+    ):
+        from arraybridge import types
+
+        monkeypatch.setattr(types.importlib.util, "find_spec", lambda name: None)
+        original = {
+            "TF_FORCE_GPU_ALLOW_GROWTH": "host",
+            "XLA_PYTHON_CLIENT_PREALLOCATE": "host",
+        }
+
+        prepared = MemoryType.subprocess_environment(original)
+
+        assert prepared == original
+        assert prepared is not original
+
     def test_preloaded_framework_reports_late_import_preparation(
         self,
         monkeypatch,

arraybridge-0.3.2/scripts/update_version.py

@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-"""Update ArrayBridge's three version projections without Git side effects."""
-
-import argparse
-import re
-from pathlib import Path
-
-from packaging.version import InvalidVersion, Version
-
-PROJECT_ROOT = Path(__file__).resolve().parents[1]
-VERSION_FILES = {
-    PROJECT_ROOT
-    / "src/arraybridge/__init__.py": (
-        r"(__version__\s*=\s*['\"])([^'\"]+)(['\"])",
-        "package",
-    ),
-    PROJECT_ROOT
-    / "pyproject.toml": (
-        r"(^version\s*=\s*['\"])([^'\"]+)(['\"])",
-        "project",
-    ),
-    PROJECT_ROOT
-    / "docs/source/conf.py": (
-        r"(^release\s*=\s*['\"])([^'\"]+)(['\"])",
-        "documentation",
-    ),
-}
-
-
-def current_version() -> Version:
-    """Return the agreed version, failing when a projection has drifted."""
-    declared_versions: dict[str, Version] = {}
-    for path, (pattern, projection_name) in VERSION_FILES.items():
-        match = re.search(pattern, path.read_text(encoding="utf-8"), flags=re.MULTILINE)
-        if match is None:
-            raise RuntimeError(f"Version declaration is missing from {path}")
-        declared_versions[projection_name] = Version(match.group(2))
-
-    unique_versions = set(declared_versions.values())
-    if len(unique_versions) != 1:
-        declarations = ", ".join(f"{name}={version}" for name, version in declared_versions.items())
-        raise RuntimeError(f"Version projections have drifted: {declarations}")
-    return unique_versions.pop()
-
-
-def update_version(version_text: str) -> None:
-    try:
-        requested = Version(version_text)
-    except InvalidVersion as error:
-        raise ValueError(f"Invalid version: {version_text}") from error
-    current = current_version()
-    if requested <= current:
-        raise ValueError(f"New version {requested} must be greater than {current}")
-
-    for path, (pattern, _projection_name) in VERSION_FILES.items():
-        content = path.read_text(encoding="utf-8")
-        updated, count = re.subn(
-            pattern,
-            rf"\g<1>{requested}\g<3>",
-            content,
-            flags=re.MULTILINE,
-        )
-        if count != 1:
-            raise RuntimeError(f"Expected one version declaration in {path}, found {count}")
-        path.write_text(updated, encoding="utf-8")
-
-    print(f"Updated ArrayBridge version projections to {requested}")
-    print("Run scripts/verify_release_ready.py --allow-dirty, then review and commit.")
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("version", help="New release version, for example 0.3.0")
-    args = parser.parse_args()
-    update_version(args.version)
-
-
-if __name__ == "__main__":
-    main()

arraybridge-0.3.2/src/arraybridge/__init__.py

@@ -1,75 +0,0 @@
-"""
-arraybridge: Unified API for NumPy, CuPy, PyTorch, TensorFlow, JAX, and pyclesperanto.
-
-This package provides automatic memory type conversion, declarative decorators,
-and unified utilities for working with multiple array/tensor frameworks.
-"""
-
-__version__ = "0.3.2"
-
-from . import decorators as _decorators
-from .array_geometry import ArrayGeometry
-from .array_payload import ArrayPayload
-from .converters import convert_memory, detect_memory_type
-from .dtype_scaling import SCALING_FUNCTIONS
-from .exceptions import MemoryConversionError
-from .framework_config import _FRAMEWORK_CONFIG
-from .framework_ops import _FRAMEWORK_OPS
-from .gpu_cleanup import cleanup_all_gpu_frameworks
-from .oom_recovery import _execute_with_oom_recovery
-from .slice_processing import process_slices
-from .stack_utils import stack_slices, unstack_slices
-from .types import (
-    CPU_MEMORY_TYPES,
-    GPU_MEMORY_TYPES,
-    SUPPORTED_MEMORY_TYPES,
-    MemoryContractAttribute,
-    MemoryType,
-)
-from .utils import _ensure_module, _get_device_id, _supports_dlpack
-
-DtypeConversion = _decorators.DtypeConversion
-SliceBySliceRuntimeParameter = _decorators.SliceBySliceRuntimeParameter
-memory_types = _decorators.memory_types
-wrap_dtype_preserving_callable = _decorators.wrap_dtype_preserving_callable
-for _memory_type in MemoryType:
-    globals()[_memory_type.value] = getattr(_decorators, _memory_type.value)
-
-__all__ = [
-    # Types
-    "MemoryType",
-    "MemoryContractAttribute",
-    "ArrayPayload",
-    "ArrayGeometry",
-    "CPU_MEMORY_TYPES",
-    "GPU_MEMORY_TYPES",
-    "SUPPORTED_MEMORY_TYPES",
-    # Converters
-    "convert_memory",
-    "detect_memory_type",
-    # Decorators
-    "memory_types",
-    "DtypeConversion",
-    "SliceBySliceRuntimeParameter",
-    "wrap_dtype_preserving_callable",
-    # Stack utilities
-    "stack_slices",
-    "unstack_slices",
-    # Slice processing
-    "process_slices",
-    # GPU cleanup
-    "cleanup_all_gpu_frameworks",
-    # Exceptions
-    "MemoryConversionError",
-    # Scaling
-    "SCALING_FUNCTIONS",
-    # Framework config (internal but needed by some consumers)
-    "_FRAMEWORK_CONFIG",
-    "_FRAMEWORK_OPS",
-    # OOM recovery
-    "_execute_with_oom_recovery",
-    # Utils
-    "_ensure_module",
-    "_supports_dlpack",
-    "_get_device_id",
-] + [memory_type.value for memory_type in MemoryType]