arraybridge 0.2.0__py3-none-any.whl

arraybridge/types.py

@@ -0,0 +1,70 @@
+"""
+Memory type definitions for arraybridge.
+
+This module defines the MemoryType enum and related constants for managing
+different array/tensor frameworks.
+"""
+
+from enum import Enum
+from typing import Any, Callable, TypeVar
+
+T = TypeVar('T')
+ConversionFunc = Callable[[Any], Any]
+
+
+class MemoryType(Enum):
+    """Enum representing different array/tensor framework types."""
+
+    NUMPY = "numpy"
+    CUPY = "cupy"
+    TORCH = "torch"
+    TENSORFLOW = "tensorflow"
+    JAX = "jax"
+    PYCLESPERANTO = "pyclesperanto"
+
+    @property
+    def converter(self):
+        """Get the converter instance for this memory type."""
+        from arraybridge.conversion_helpers import _CONVERTERS
+        return _CONVERTERS[self]
+
+
+# Auto-generate to_X() methods on enum
+def _add_conversion_methods():
+    """Add to_X() conversion methods to MemoryType enum."""
+    for target_type in MemoryType:
+        method_name = f"to_{target_type.value}"
+
+        def make_method(target):
+            def method(self, data, gpu_id):
+                return getattr(self.converter, f"to_{target.value}")(data, gpu_id)
+            return method
+
+        setattr(MemoryType, method_name, make_method(target_type))
+
+
+_add_conversion_methods()
+
+
+# Memory type sets
+CPU_MEMORY_TYPES: set[MemoryType] = {MemoryType.NUMPY}
+GPU_MEMORY_TYPES: set[MemoryType] = {
+    MemoryType.CUPY,
+    MemoryType.TORCH,
+    MemoryType.TENSORFLOW,
+    MemoryType.JAX,
+    MemoryType.PYCLESPERANTO
+}
+SUPPORTED_MEMORY_TYPES: set[MemoryType] = CPU_MEMORY_TYPES | GPU_MEMORY_TYPES
+
+# String value sets for validation
+VALID_MEMORY_TYPES = {mt.value for mt in MemoryType}
+VALID_GPU_MEMORY_TYPES = {mt.value for mt in GPU_MEMORY_TYPES}
+
+# Memory type constants for direct access
+MEMORY_TYPE_NUMPY = MemoryType.NUMPY.value
+MEMORY_TYPE_CUPY = MemoryType.CUPY.value
+MEMORY_TYPE_TORCH = MemoryType.TORCH.value
+MEMORY_TYPE_TENSORFLOW = MemoryType.TENSORFLOW.value
+MEMORY_TYPE_JAX = MemoryType.JAX.value
+MEMORY_TYPE_PYCLESPERANTO = MemoryType.PYCLESPERANTO.value

arraybridge/utils.py

@@ -0,0 +1,352 @@
+"""
+Memory conversion utility functions for arraybridge.
+
+This module provides utility functions for memory conversion operations,
+supporting Clause 251 (Declarative Memory Conversion Interface) and
+Clause 65 (Fail Loudly).
+"""
+
+import importlib
+import logging
+from typing import Any, Optional
+
+from arraybridge.types import MemoryType
+
+from .exceptions import MemoryConversionError
+from .framework_config import _FRAMEWORK_CONFIG
+
+logger = logging.getLogger(__name__)
+
+class _ModulePlaceholder:
+    """
+    Placeholder for missing optional modules that allows attribute access
+    for type annotations while still being falsy and failing on actual use.
+    """
+    def __init__(self, module_name: str):
+        self._module_name = module_name
+
+    def __bool__(self):
+        return False
+
+    def __getattr__(self, name):
+        # Return another placeholder for chained attribute access
+        # This allows things like cp.ndarray in type annotations to work
+        return _ModulePlaceholder(f"{self._module_name}.{name}")
+
+    def __call__(self, *args, **kwargs):
+        # If someone tries to actually call a function, fail loudly
+        raise ImportError(
+            f"Module '{self._module_name}' is not available. "
+            f"Please install the required dependency."
+        )
+
+    def __repr__(self):
+        return f"<ModulePlaceholder for '{self._module_name}'>"
+
+
+def optional_import(module_name: str) -> Optional[Any]:
+    """
+    Import a module if available, otherwise return a placeholder that handles
+    attribute access gracefully for type annotations but fails on actual use.
+
+    This function allows for graceful handling of optional dependencies.
+    It can be used to import libraries that may not be installed,
+    particularly GPU-related libraries like torch, tensorflow, and cupy.
+
+    Args:
+        module_name: Name of the module to import
+
+    Returns:
+        The imported module if available, a placeholder otherwise
+
+    Example:
+        ```python
+        # Import torch if available
+        torch = optional_import("torch")
+
+        # Check if torch is available before using it
+        if torch:
+            # Use torch
+            tensor = torch.tensor([1, 2, 3])
+        else:
+            # Handle the case where torch is not available
+            raise ImportError("PyTorch is required for this function")
+        ```
+    """
+    try:
+        # Use importlib.import_module which handles dotted names properly
+        return importlib.import_module(module_name)
+    except (ImportError, ModuleNotFoundError, AttributeError):
+        # Return a placeholder that handles attribute access gracefully
+        return _ModulePlaceholder(module_name)
+
+
+def _ensure_module(module_name: str) -> Any:
+    """
+    Ensure a module is imported and meets version requirements.
+
+    Args:
+        module_name: The name of the module to import
+
+    Returns:
+        The imported module
+
+    Raises:
+        ImportError: If the module cannot be imported or does not meet version requirements
+        RuntimeError: If the module has known issues with specific versions
+    """
+    try:
+        module = importlib.import_module(module_name)
+
+        # Check TensorFlow version for DLPack compatibility
+        if module_name == "tensorflow":
+            import pkg_resources
+            tf_version = pkg_resources.parse_version(module.__version__)
+            min_version = pkg_resources.parse_version("2.12.0")
+
+            if tf_version < min_version:
+                raise RuntimeError(
+                    f"TensorFlow version {module.__version__} is not supported "
+                    f"for DLPack operations. "
+                    f"Version 2.12.0 or higher is required for stable DLPack support. "
+                    f"Clause 88 (No Inferred Capabilities) violation: "
+                    f"Cannot infer DLPack capability."
+                )
+
+        return module
+    except ImportError:
+        raise ImportError(
+            f"Module {module_name} is required for this operation "
+            f"but is not installed"
+        )
+
+
+def _supports_cuda_array_interface(obj: Any) -> bool:
+    """
+    Check if an object supports the CUDA Array Interface.
+
+    Args:
+        obj: The object to check
+
+    Returns:
+        True if the object supports the CUDA Array Interface, False otherwise
+    """
+    return hasattr(obj, "__cuda_array_interface__")
+
+
+def _supports_dlpack(obj: Any) -> bool:
+    """
+    Check if an object supports DLPack.
+
+    Args:
+        obj: The object to check
+
+    Returns:
+        True if the object supports DLPack, False otherwise
+
+    Note:
+        For TensorFlow tensors, this function enforces Clause 88 (No Inferred Capabilities)
+        by explicitly checking:
+        1. TensorFlow version must be 2.12+ for stable DLPack support
+        2. Tensor must be on GPU (CPU tensors might succeed even without proper DLPack support)
+        3. tf.experimental.dlpack module must exist
+    """
+    # Check for PyTorch, CuPy, or JAX DLPack support
+    # PyTorch: __dlpack__ method, CuPy: toDlpack method, JAX: __dlpack__ method
+    if hasattr(obj, "toDlpack") or hasattr(obj, "to_dlpack") or hasattr(obj, "__dlpack__"):
+        # Special handling for TensorFlow to enforce Clause 88
+        if 'tensorflow' in str(type(obj)):
+            try:
+                import tensorflow as tf
+
+                # Check TensorFlow version - DLPack is only stable in TF 2.12+
+                tf_version = tf.__version__
+                major, minor = map(int, tf_version.split('.')[:2])
+
+                if major < 2 or (major == 2 and minor < 12):
+                    # Explicitly fail for TF < 2.12 to prevent silent fallbacks
+                    raise RuntimeError(
+                        f"TensorFlow version {tf_version} does not support "
+                        f"stable DLPack operations. "
+                        f"Version 2.12.0 or higher is required. "
+                        f"Clause 88 violation: Cannot infer DLPack capability."
+                    )
+
+                # Check if tensor is on GPU - CPU tensors might succeed
+                # even without proper DLPack support
+                device_str = obj.device.lower()
+                if "gpu" not in device_str:
+                    # Explicitly fail for CPU tensors to prevent deceptive behavior
+                    raise RuntimeError(
+                        "TensorFlow tensor on CPU cannot use DLPack operations reliably. "
+                        "Only GPU tensors are supported for DLPack operations. "
+                        "Clause 88 violation: Cannot infer GPU capability."
+                    )
+
+                # Check if experimental.dlpack module exists
+                if not hasattr(tf.experimental, "dlpack"):
+                    raise RuntimeError(
+                        "TensorFlow installation missing experimental.dlpack module. "
+                        "Clause 88 violation: Cannot infer DLPack capability."
+                    )
+
+                return True
+            except (ImportError, AttributeError) as e:
+                # Re-raise with more specific error message
+                raise RuntimeError(
+                    f"TensorFlow DLPack support check failed: {str(e)}. "
+                    f"Clause 88 violation: Cannot infer DLPack capability."
+                ) from e
+
+        # For non-TensorFlow types, return True if they have DLPack methods
+        return True
+
+    return False
+
+
+# NOTE: Device operations now defined in framework_config.py
+# This eliminates the scattered _DEVICE_OPS dict
+
+
+def _get_device_id(data: Any, memory_type: str) -> Optional[int]:
+    """
+    Get the GPU device ID from a data object using framework config.
+
+    Args:
+        data: The data object
+        memory_type: The memory type
+
+    Returns:
+        The GPU device ID or None if not applicable
+
+    Raises:
+        MemoryConversionError: If the device ID cannot be determined for a GPU memory type
+    """
+    # Convert string to enum
+    mem_type = MemoryType(memory_type)
+    config = _FRAMEWORK_CONFIG[mem_type]
+    get_id_handler = config['get_device_id']
+
+    # Check if it's a callable handler (pyclesperanto)
+    if callable(get_id_handler):
+        mod = _ensure_module(mem_type.value)
+        return get_id_handler(data, mod)
+
+    # Check if it's None (CPU)
+    if get_id_handler is None:
+        return None
+
+    # It's an eval expression
+    try:
+        mod = _ensure_module(mem_type.value)  # noqa: F841 (used in eval)
+        return eval(get_id_handler)
+    except (AttributeError, Exception) as e:
+        logger.warning(f"Failed to get device ID for {mem_type.value} array: {e}")
+        # Try fallback if available
+        if 'get_device_id_fallback' in config:
+            return eval(config['get_device_id_fallback'])
+
+
+def _set_device(memory_type: str, device_id: int) -> None:
+    """
+    Set the current device for a specific memory type using framework config.
+
+    Args:
+        memory_type: The memory type
+        device_id: The GPU device ID
+
+    Raises:
+        MemoryConversionError: If the device cannot be set
+    """
+    # Convert string to enum
+    mem_type = MemoryType(memory_type)
+    config = _FRAMEWORK_CONFIG[mem_type]
+    set_device_handler = config['set_device']
+
+    # Check if it's a callable handler (pyclesperanto)
+    if callable(set_device_handler):
+        try:
+            mod = _ensure_module(mem_type.value)
+            set_device_handler(device_id, mod)
+        except Exception as e:
+            raise MemoryConversionError(
+                source_type=memory_type,
+                target_type=memory_type,
+                method="device_selection",
+                reason=f"Failed to set {mem_type.value} device to {device_id}: {e}"
+            ) from e
+        return
+
+    # Check if it's None (frameworks that don't need global device setting)
+    if set_device_handler is None:
+        return
+
+    # It's an eval expression
+    try:
+        mod = _ensure_module(mem_type.value)  # noqa: F841 (used in eval)
+        eval(set_device_handler.format(mod='mod'))
+    except Exception as e:
+        raise MemoryConversionError(
+            source_type=memory_type,
+            target_type=memory_type,
+            method="device_selection",
+            reason=f"Failed to set {mem_type.value} device to {device_id}: {e}"
+        ) from e
+
+
+def _move_to_device(data: Any, memory_type: str, device_id: int) -> Any:
+    """
+    Move data to a specific GPU device using framework config.
+
+    Args:
+        data: The data to move
+        memory_type: The memory type
+        device_id: The target GPU device ID
+
+    Returns:
+        The data on the target device
+
+    Raises:
+        MemoryConversionError: If the data cannot be moved to the specified device
+    """
+    # Convert string to enum
+    mem_type = MemoryType(memory_type)
+    config = _FRAMEWORK_CONFIG[mem_type]
+    move_handler = config['move_to_device']
+
+    # Check if it's a callable handler (pyclesperanto)
+    if callable(move_handler):
+        try:
+            mod = _ensure_module(mem_type.value)
+            return move_handler(data, device_id, mod, memory_type)
+        except Exception as e:
+            raise MemoryConversionError(
+                source_type=memory_type,
+                target_type=memory_type,
+                method="device_movement",
+                reason=f"Failed to move {mem_type.value} array to device {device_id}: {e}"
+            ) from e
+
+    # Check if it's None (CPU memory types)
+    if move_handler is None:
+        return data
+
+    # It's an eval expression
+    try:
+        mod = _ensure_module(mem_type.value)  # noqa: F841 (used in eval)
+
+        # Handle context managers (CuPy, TensorFlow)
+        if 'move_context' in config and config['move_context']:
+            context_expr = config['move_context'].format(mod='mod')
+            context = eval(context_expr)
+            with context:
+                return eval(move_handler.format(mod='mod'))
+        else:
+            return eval(move_handler.format(mod='mod'))
+    except Exception as e:
+        raise MemoryConversionError(
+            source_type=memory_type,
+            target_type=memory_type,
+            method="device_movement",
+            reason=f"Failed to move {mem_type.value} array to device {device_id}: {e}"
+        ) from e

arraybridge-0.2.0.dist-info/METADATA

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: arraybridge
+Version: 0.2.0
+Summary: Unified API for NumPy, CuPy, PyTorch, TensorFlow, JAX, and pyclesperanto with automatic memory type conversion
+Project-URL: Homepage, https://github.com/trissim/arraybridge
+Project-URL: Documentation, https://arraybridge.readthedocs.io
+Project-URL: Repository, https://github.com/trissim/arraybridge
+Project-URL: Issues, https://github.com/trissim/arraybridge/issues
+Author-email: Tristan Simas <tristan.simas@mail.mcgill.ca>
+License: MIT
+License-File: LICENSE
+Keywords: array,conversion,cupy,gpu,jax,numpy,pytorch,tensor,tensorflow
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.20
+Provides-Extra: all
+Requires-Dist: cupy>=10.0; extra == 'all'
+Requires-Dist: jax>=0.3; extra == 'all'
+Requires-Dist: jaxlib>=0.3; extra == 'all'
+Requires-Dist: pyclesperanto>=0.10; extra == 'all'
+Requires-Dist: tensorflow>=2.8; extra == 'all'
+Requires-Dist: torch>=1.10; extra == 'all'
+Provides-Extra: cupy
+Requires-Dist: cupy>=10.0; extra == 'cupy'
+Provides-Extra: dev
+Requires-Dist: black>=23.0; extra == 'dev'
+Requires-Dist: mypy>=1.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'
+Provides-Extra: docs
+Requires-Dist: sphinx-autodoc-typehints>=1.25; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme>=2.0; extra == 'docs'
+Requires-Dist: sphinx>=7.0; extra == 'docs'
+Provides-Extra: jax
+Requires-Dist: jax>=0.3; extra == 'jax'
+Requires-Dist: jaxlib>=0.3; extra == 'jax'
+Provides-Extra: pyclesperanto
+Requires-Dist: pyclesperanto>=0.10; extra == 'pyclesperanto'
+Provides-Extra: tensorflow
+Requires-Dist: tensorflow>=2.8; extra == 'tensorflow'
+Provides-Extra: torch
+Requires-Dist: torch>=1.10; extra == 'torch'
+Description-Content-Type: text/markdown
+
+# arraybridge
+
+**Unified API for NumPy, CuPy, PyTorch, TensorFlow, JAX, and pyclesperanto**
+
+[![PyPI version](https://badge.fury.io/py/arraybridge.svg)](https://badge.fury.io/py/arraybridge)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- **Unified API**: Single interface for 6 array/tensor frameworks
+- **Automatic Conversion**: DLPack + NumPy fallback with automatic path selection
+- **Declarative Decorators**: `@numpy`, `@torch`, `@cupy` for memory type declarations
+- **Device Management**: Thread-local GPU contexts and automatic stream management
+- **OOM Recovery**: Automatic out-of-memory detection and cache clearing
+- **Dtype Preservation**: Automatic dtype preservation across conversions
+- **Zero Dependencies**: Only requires NumPy (framework dependencies are optional)
+
+## Quick Start
+
+```python
+from arraybridge import convert_memory, detect_memory_type
+import numpy as np
+
+# Create NumPy array
+data = np.array([[1, 2], [3, 4]])
+
+# Convert to PyTorch (if installed)
+torch_data = convert_memory(data, source_type='numpy', target_type='torch', gpu_id=0)
+
+# Detect memory type
+mem_type = detect_memory_type(torch_data)  # 'torch'
+```
+
+## Declarative Decorators
+
+```python
+from arraybridge import numpy, torch, cupy
+
+@torch(input_type='numpy', output_type='torch', oom_recovery=True)
+def my_gpu_function(data):
+    """Automatically converts input from NumPy to PyTorch."""
+    return data * 2
+
+# Use with NumPy input
+result = my_gpu_function(np.array([1, 2, 3]))  # Returns PyTorch tensor
+```
+
+## Installation
+
+```bash
+# Base installation (NumPy only)
+pip install arraybridge
+
+# With specific frameworks
+pip install arraybridge[torch]
+pip install arraybridge[cupy]
+pip install arraybridge[tensorflow]
+pip install arraybridge[jax]
+pip install arraybridge[pyclesperanto]
+
+# With all frameworks
+pip install arraybridge[all]
+```
+
+## Supported Frameworks
+
+| Framework | CPU | GPU | DLPack | Notes |
+|-----------|-----|-----|--------|-------|
+| NumPy | ✅ | ❌ | ❌ | Base framework |
+| CuPy | ❌ | ✅ | ✅ | CUDA arrays |
+| PyTorch | ✅ | ✅ | ✅ | Tensors |
+| TensorFlow | ✅ | ✅ | ✅ | Tensors |
+| JAX | ✅ | ✅ | ✅ | Arrays |
+| pyclesperanto | ❌ | ✅ | ❌ | OpenCL arrays |
+
+## Why arraybridge?
+
+**Before** (Manual conversion hell):
+```python
+import numpy as np
+import torch
+import cupy as cp
+
+def process_data(data, target='torch'):
+    if target == 'torch':
+        if isinstance(data, np.ndarray):
+            return torch.from_numpy(data).cuda()
+        elif isinstance(data, cp.ndarray):
+            return torch.as_tensor(data, device='cuda')
+    elif target == 'cupy':
+        if isinstance(data, np.ndarray):
+            return cp.asarray(data)
+        elif hasattr(data, '__cuda_array_interface__'):
+            return cp.asarray(data)
+    # ... 30 more lines of if/elif ...
+```
+
+**After** (arraybridge):
+```python
+from arraybridge import convert_memory, detect_memory_type
+
+def process_data(data, target='torch'):
+    source = detect_memory_type(data)
+    return convert_memory(data, source_type=source, target_type=target, gpu_id=0)
+```
+
+## Advanced Features
+
+### Thread-Local GPU Streams
+
+```python
+from arraybridge import torch
+
+@torch(oom_recovery=True)
+def parallel_processing(data):
+    # Automatically uses thread-local CUDA stream
+    # Enables true parallelization across threads
+    return data * 2
+```
+
+### OOM Recovery
+
+```python
+from arraybridge import cupy
+
+@cupy(oom_recovery=True)
+def memory_intensive_operation(data):
+    # Automatically catches OOM errors
+    # Clears GPU cache and retries
+    return data @ data.T
+```
+
+### Stack Utilities
+
+```python
+from arraybridge import stack_slices, unstack_slices
+
+# Stack 2D slices into 3D array
+slices_2d = [np.random.rand(100, 100) for _ in range(50)]
+volume_3d = stack_slices(slices_2d, memory_type='torch', gpu_id=0)
+
+# Unstack 3D array into 2D slices
+slices_back = unstack_slices(volume_3d, memory_type='torch')
+```
+
+## Documentation
+
+Full documentation available at [arraybridge.readthedocs.io](https://arraybridge.readthedocs.io)
+
+## Performance
+
+arraybridge uses DLPack for zero-copy conversions when possible:
+
+| Conversion | Method | Speed |
+|------------|--------|-------|
+| NumPy → PyTorch | `torch.from_numpy()` | Zero-copy |
+| PyTorch → CuPy | DLPack | Zero-copy |
+| CuPy → JAX | DLPack | Zero-copy |
+| NumPy → CuPy | Copy | Fast |
+| PyTorch → NumPy | `.numpy()` | Zero-copy (CPU) |
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Contributing
+
+Contributions welcome! Please see CONTRIBUTING.md for guidelines.
+
+## Credits
+
+Developed by Tristan Simas as part of the OpenHCS project.

arraybridge-0.2.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+arraybridge/__init__.py,sha256=oOdSZQZ1Jv5TeN-f9tdn0Ig3Yy5Z_W795TcI3l10BWM,998
+arraybridge/conversion_helpers.py,sha256=VJZybT2EjkQ42u8wrnrQlgcDKFdc4EVQ5BTVmZcEojA,5556
+arraybridge/converters.py,sha256=5tvw--rZTu2DR8rbHl7RIuYW29EUhA9ScGkUnIhfQco,1927
+arraybridge/decorators.py,sha256=zH_hLIXkuoSH0yiG7uj7YtIRE82FHwGw9e-g3xUGIZU,14269
+arraybridge/dtype_scaling.py,sha256=I2ci6VeSzB4V4_gLtqG-nz2NkHnsfokr1aR-tQg-kak,5565
+arraybridge/exceptions.py,sha256=fhej5ZS39QcBFWzNeNYjoqeLVnOgwwp-cWIme25jyuo,752
+arraybridge/framework_config.py,sha256=h1k5MZhENhQoy-MTCMSrTecX3u9QDnTqwVaSHRzEQHA,17948
+arraybridge/framework_ops.py,sha256=Na5e_SkM6l3ZcmCdXowavdUkprYrwhc45hKFDhmd3X8,462
+arraybridge/gpu_cleanup.py,sha256=uvHD-ATYBg5LCeTKHdTh7VseZ8UecjeTnpvRuF_LI3g,5118
+arraybridge/oom_recovery.py,sha256=KP6Q_1itOMi2qPCvm1WcA7BksRfNwt68RxryqpItl-U,4591
+arraybridge/slice_processing.py,sha256=jVJjBp5AzPpQPjnUFnCN1xemRDn6-qY6HfKopkUeklo,2693
+arraybridge/stack_utils.py,sha256=jwHkF7LeuP9rMGSwjWg0HtQoHv8LdFHgpMtysRxeLN8,11211
+arraybridge/types.py,sha256=7m3N8kA0Y9m04HyG3VebglT0CP8SqHJBRzYofN7AX5A,1999
+arraybridge/utils.py,sha256=X1_weXzXLKm3wZd9BKHDXEnzFgaDEovIy_qwj9OfrcA,12313
+arraybridge-0.2.0.dist-info/METADATA,sha256=P5FAPjx4x3FUQdrBSms_FpfEA3O4ao5PjfKUPEPw4ds,7155
+arraybridge-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+arraybridge-0.2.0.dist-info/licenses/LICENSE,sha256=xagEoeTAj1WT64RmyR3E6HH-eTGdgXN6gqPMUUt7L_Y,1070
+arraybridge-0.2.0.dist-info/RECORD,,

arraybridge-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

arraybridge-0.2.0.dist-info/licenses/LICENSE

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