arraybridge 0.3.4__tar.gz → 0.3.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arraybridge
-Version: 0.3.4
+Version: 0.3.6
 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
@@ -36,6 +36,7 @@ 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: dill>=0.3.8; extra == 'dev'
 Requires-Dist: mypy>=1.0; extra == 'dev'
 Requires-Dist: packaging>=23.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0; extra == 'dev'

arraybridge-0.3.6/docs/source/release_035_validation.rst

@@ -0,0 +1,51 @@
+ArrayBridge 0.3.5 release preparation
+===================================
+
+Parent integration owner; base ea3f2a4cc91c4810d12343f58f85c1195e1a41e6.
+The reviewed callable-native dtype default and durable decorator-context
+changes are already merged through PR2 and PR3. This release preparation changes
+only the existing package version authority from 0.3.4 to 0.3.5 and records
+validation. It adds no implementation, compatibility API or parallel registry.
+
+OpenHCS PR217 requires ``dtype_config_default``. A fresh PyPI ArrayBridge0.3.4
+wheel raises TypeError at its BaSiC adapter's decoration. Its recorded local
+source candidate has that API, but is not a public release. OpenHCS now requires
+ArrayBridge>=0.3.5,<0.4 so ordinary installation cannot select the old API.
+
+Persistent evidence::
+
+    /home/ts/wt/openhcs-issue-batch-20260929/artifact-parent-20261001
+
+Focused provider-free checks, using the existing Python3.12 environment::
+
+    PYTHONPATH=src PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python -B -m pytest \
+      -o addopts='' -q tests/test_callable_dtype_default.py \
+      tests/test_durable_decorator_context.py
+
+All seven tests pass in 0.12 seconds. They retain native floating-point values,
+explicit runtime dtype overrides, unchanged default preservation, rejection of
+untyped declarations and durable serialization without thread-local leakage.
+The original complete-suite acceptance of the reviewed feature PRs is separate;
+these seven checks do not claim a full framework/GPU matrix.
+
+The wheel was built through ``uv build --offline --wheel`` from this source
+using cached build requirements. Twine6.2 accepts the resulting metadata2.4
+wheel. An initial no-isolation build lacked Hatchling in the installed OpenHCS
+environment and failed; it did not install packages or count as a pass.
+
+A fresh process loaded that exact 0.3.5 wheel archive ahead of the actual
+installed OpenHCS candidate and executed the real BaSiC adapter on 24 synthetic
+32x32 SITE observations. It returned finite float32 correction with fractional
+pixels, preserved source pixels and matched the same-fit correction formula.
+Flatfield RMSE against the known synthetic shading field is 0.0007167315491296268.
+``arraybridge-035-installed-fit.log`` records the actual wheel and site-packages
+import paths. This establishes local wheel/API interoperability, not registry
+resolution, a full installed MCP rerun or biological accuracy. The separate
+installed MCP journey is retained with OpenHCS PR217.
+
+Publication is not performed by this PR. The parent requested separate owner
+approval for the companion ArrayBridge0.3.5 publication. No tag was created,
+workflow dispatched, registry upload performed or release availability claimed.
+After approval, merge normally, tag the reviewed main version and use the
+existing trusted publishing workflow. Verify the actual registry wheel before
+claiming ordinary OpenHCS dependency installation.

arraybridge-0.3.6/docs/source/release_036_validation.rst

@@ -0,0 +1,58 @@
+ArrayBridge typed thread-local release correction
+================================================
+
+Parent integration owner. Actual failed original 0.3.5 publisher:
+https://github.com/OpenHCSDev/ArrayBridge/actions/runs/36946585391.
+Ruff and Black passed; mypy rejected decorators.py:284 because current()
+returned Any from the dynamic threading.local context slot. No wheel was
+published. The failure and original v0.3.5 tag are preserved unchanged.
+
+The existing ThreadGPUContext runtime owner now uses a threading.local
+subclass declaring its sole context slot. The original per-thread lazy
+initialization and stream identity remain; current() consumes the declared
+optional value, not hasattr plus an untyped foreign attribute. No cast,
+type-ignore, fallback reader, new context registry or serialization path.
+BOUND-7: declare the native storage boundary instead of probing raw attributes.
+Native threading.local retains thread isolation. Durable decorated callables
+continue to refer to the original importable ThreadGPUContext owner.
+
+This patch uses version0.3.6 rather than moving/reusing an existing release tag.
+The already reviewed dtype_config_default behavior is unchanged. OpenHCS's
+>=0.3.5,<0.4 requirement admits this corrected patch release normally.
+
+Retained bounded local red mypy reproduces the exact hosted no-any-return
+error: exit1,2.65s,96.91MiB. Green mypy checks all17 source files with no
+errors: exit0,2.75s,97.14MiB. Ruff passes src/scripts; Black leaves20 files
+unchanged. Existing interpreter/tooling only; no dependency installation.
+
+Original supervisor logs/commands reside at:
+/home/ts/wt/openhcs-issue-batch-20260929/s1-installed-20261001/
+arraybridge036-mypy-red and arraybridge036-mypy-green. Kernel512MiB,
+no swap, oneCPU/thread,60-second shard. Source behavior and release artifact
+verification are recorded below when complete; no registry success claimed
+by source checks alone.
+
+Original focused behavior suite passes11 tests,0.30s pytest/0.82s total,
+52.7MiB. It covers thread-local context identity/isolation, framework/device
+stream identity, actual NumPy dtype controls, and dill restore of unpublished
+decorated callables with a live unpicklable runtime handle. Assertions and the
+existing three test files are unchanged; no real GPU runtime is needed here.
+
+Original packaged R0 against merged e9aaa262 at source33d5a99f reports zero
+nonzero deltas across both changed product files, exit0,1.93s/43.73MiB. The
+original global NRA R1 remains a separate unfinished OpenHCS tool-owner check;
+this bounded ratchet does not claim that global analysis completed.
+
+Original cached offline uv build produces wheel and sdist, exit0,
+1.26s/66.22MiB. Twine accepts both. Local wheel SHA256:
+f7fa23f5dcf1925742592109b396fe17662fb56f15e1755a304a45c90e79a249;
+local sdist SHA256:
+a558dcb5827876725c854cb367a7598765a55a43e658d82678db4f2c541663d4.
+These local bytes are not assumed equal to the independently hosted rebuild.
+
+Addresses ArrayBridge issue5. Original source proof does not establish a full
+GPU matrix. The unchanged original publisher owns the complete hosted check,
+build and trusted upload. Merge this reviewed source checkpoint without waiting
+on optional CI, push a new annotated v0.3.6 at actual merged main, and verify
+PyPI installer visibility and the hosted wheel source/API before admitting the
+consumer. Do not replace v0.3.5 or replay the failed original publisher.

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

@@ -75,6 +75,7 @@ all = [
 ]
 dev = [
     "pytest>=7.0",
+    "dill>=0.3.8",
     "pytest-cov>=4.0",
     "build>=1.0",
     "twine>=5.0",

{arraybridge-0.3.4 → arraybridge-0.3.6}/src/arraybridge/__init__.py

@@ -10,7 +10,7 @@ attribute access instead of at import time. Declaration-only consumers
 NumPy/numcodecs import cost.
 """
 
-__version__ = "0.3.4"
+__version__ = "0.3.6"
 
 _LAZY_EXPORTS: dict[str, str] = {
     "MemoryType": ".types",

{arraybridge-0.3.4 → arraybridge-0.3.6}/src/arraybridge/decorators.py

@@ -82,11 +82,13 @@ class DtypeConversionConfig(RuntimeParameterDeclarationABC):
         return DtypeConversionConfig
 
     @classmethod
-    def parameter(cls) -> inspect.Parameter:
+    def parameter(
+        cls, *, default_value: "DtypeConversionConfig | None" = None
+    ) -> inspect.Parameter:
         return inspect.Parameter(
             cls.require_parameter_name(),
             inspect.Parameter.KEYWORD_ONLY,
-            default=cls.default_value(),
+            default=cls.default_value() if default_value is None else default_value,
             annotation=cls.annotation_type(),
         )
 
@@ -264,12 +266,30 @@ class KeywordOnlySignatureExtension:
         return len(parameters)
 
 
-# Thread-local storage for GPU streams and contexts
-_thread_gpu_contexts = threading.local()
+class ThreadGPUContextStorage(threading.local):
+    """Declare the existing native thread-local context slot and its type."""
+
+    context: "ThreadGPUContext | None" = None
 
 
 class ThreadGPUContext:
-    """Thread-local streams keyed by framework-local device identity."""
+    """Runtime-owned thread-local streams keyed by framework/device identity.
+
+    Keep the runtime handle on its importable owner, not in decorator function
+    globals. A retained, unpublished decorated callable is serialized by value;
+    its durable closure must not pull a ``threading.local`` into history.
+    """
+
+    _contexts: ClassVar[ThreadGPUContextStorage] = ThreadGPUContextStorage()
+
+    @classmethod
+    def current(cls) -> "ThreadGPUContext":
+        """Return this thread's runtime context without serializing its handle."""
+        context = cls._contexts.context
+        if context is None:
+            context = cls()
+            cls._contexts.context = context
+        return context
 
     def __init__(self):
         self._streams: dict[tuple[MemoryType, int], Any] = {}
@@ -301,13 +321,6 @@ class ThreadGPUContext:
         return device_id, self._streams[key]
 
 
-def _get_thread_gpu_context():
-    """Get or create thread-local GPU context."""
-    if not hasattr(_thread_gpu_contexts, "context"):
-        _thread_gpu_contexts.context = ThreadGPUContext()
-    return _thread_gpu_contexts.context
-
-
 def memory_types(
     input_type: str | MemoryType,
     output_type: str | MemoryType,
@@ -352,6 +365,7 @@ def wrap_dtype_preserving_callable(
     mem_type: MemoryType,
     *,
     slice_by_slice_default: bool = False,
+    dtype_config_default: DtypeConversionConfig | None = None,
 ):
     """
     Return a callable with ArrayBridge dtype and slice controls.
@@ -363,18 +377,25 @@ def wrap_dtype_preserving_callable(
     input_memory_type = MemoryType(MemoryContractAttribute.INPUT.read(func, mem_type.value))
     output_memory_type = MemoryType(MemoryContractAttribute.OUTPUT.read(func, mem_type.value))
     scale_func = output_memory_type.scale_dtype
+    default_dtype_config = (
+        DtypeConversionConfig.default_value()
+        if dtype_config_default is None
+        else dtype_config_default
+    )
+    if not isinstance(default_dtype_config, DtypeConversionConfig):
+        raise TypeError("Callable dtype default must be a DtypeConversionConfig.")
 
     @functools.wraps(func)
     def dtype_wrapper(image, *args, **kwargs):
         # Pipeline runtimes may inject dtype_config; direct calls use the same
-        # preserve-input default explicitly.
+        # callable-owned default explicitly (preserve-input when undeclared).
         slice_by_slice = kwargs.pop(
             SliceBySliceRuntimeParameter.require_parameter_name(),
             slice_by_slice_default,
         )
         dtype_config: DtypeConversionConfig = kwargs.pop(
             DtypeConversionConfig.require_parameter_name(),
-            DtypeConversionConfig.default_value(),
+            default_dtype_config,
         )
         dtype_conversion = dtype_config.default_dtype_conversion
 
@@ -424,7 +445,7 @@ def wrap_dtype_preserving_callable(
             )
         )
         dtype_signature = KeywordOnlySignatureExtension(dtype_signature).with_parameter(
-            DtypeConversionConfig.parameter()
+            DtypeConversionConfig.parameter(default_value=default_dtype_config)
         )
         setattr(dtype_wrapper, "__signature__", dtype_signature)
 
@@ -461,7 +482,7 @@ def _create_gpu_wrapper(func, mem_type: MemoryType, oom_recovery: bool):
         # Check if GPU is available for this framework
         if framework is not None and mem_type.available_device_ids(framework):
             # Get thread-local context
-            ctx = _get_thread_gpu_context()
+            ctx = ThreadGPUContext.current()
 
             device_id, stream = ctx.stream_for(mem_type, framework)
 
@@ -510,6 +531,7 @@ def _create_memory_decorator(mem_type: MemoryType):
         oom_recovery=True,
         contract=None,
         slice_by_slice_default=False,
+        dtype_config_default: DtypeConversionConfig | None = None,
     ):
         """
         Decorator for {mem_type} memory type functions.
@@ -521,6 +543,8 @@ def _create_memory_decorator(mem_type: MemoryType):
             oom_recovery: Enable automatic OOM recovery (default: True)
             contract: Optional validation function for outputs
             slice_by_slice_default: Default for the decorator-owned slice control
+            dtype_config_default: Callable-owned dtype policy for direct calls;
+                explicit runtime dtype_config still overrides this default.
 
         Returns:
             Decorated function with memory type metadata and dtype preservation
@@ -538,6 +562,7 @@ def _create_memory_decorator(mem_type: MemoryType):
                 func,
                 mem_type,
                 slice_by_slice_default=slice_by_slice_default,
+                dtype_config_default=dtype_config_default,
             )
 
             # Apply GPU wrapper if this is a GPU memory type

arraybridge-0.3.6/tests/test_callable_dtype_default.py

@@ -0,0 +1,61 @@
+"""Callable defaults use the existing typed dtype policy and real conversion."""
+
+from dataclasses import dataclass
+import inspect
+
+import numpy as np
+import pytest
+
+from arraybridge.decorators import (
+    DtypeConversion,
+    DtypeConversionConfig,
+    PreserveInputDtypeConfig,
+    numpy as numpy_func,
+)
+
+
+@dataclass(frozen=True)
+class NativeConfig(DtypeConversionConfig):
+    default_dtype_conversion: DtypeConversion = DtypeConversion.NATIVE_OUTPUT
+
+
+def test_declared_native_output_preserves_fraction_negative_and_large_values():
+    native = NativeConfig()
+
+    @numpy_func(dtype_config_default=native)
+    def correct(image):
+        return np.array([-1.25, 12.5, 70000.5], dtype=np.float32)
+
+    output = correct(np.array([0, 1, 65535], dtype=np.uint16))
+    np.testing.assert_array_equal(output, [-1.25, 12.5, 70000.5])
+    assert output.dtype == np.float32
+    assert inspect.signature(correct).parameters["dtype_config"].default is native
+
+
+def test_explicit_runtime_dtype_policy_overrides_callable_default():
+    @numpy_func(dtype_config_default=NativeConfig())
+    def correct(image):
+        return image.astype(np.float32) + 0.25, np.array([2.5], dtype=np.float32)
+
+    output, sidecar = correct(
+        np.array([1, 2], dtype=np.uint16),
+        dtype_config=PreserveInputDtypeConfig(),
+    )
+    assert output.dtype == np.uint16
+    assert sidecar.dtype == np.float32
+    np.testing.assert_array_equal(sidecar, [2.5])
+
+
+def test_undeclared_defaults_still_preserve_input_dtype():
+    @numpy_func
+    def correct(image):
+        return image.astype(np.float32) + 0.25
+
+    assert correct(np.array([1, 2], dtype=np.uint16)).dtype == np.uint16
+
+
+def test_untyped_default_is_rejected_at_decoration():
+    with pytest.raises(TypeError, match="DtypeConversionConfig"):
+        numpy_func(dtype_config_default={"default_dtype_conversion": "native"})(
+            lambda image: image
+        )

arraybridge-0.3.6/tests/test_durable_decorator_context.py

@@ -0,0 +1,50 @@
+"""Retained callable declarations exclude thread-local GPU lifecycle handles."""
+
+import threading
+from concurrent.futures import ThreadPoolExecutor
+
+import dill
+import numpy as np
+import pytest
+
+from arraybridge.decorators import ThreadGPUContext, cupy, numpy
+from arraybridge.types import MemoryType
+
+
+def test_context_is_stable_per_thread_and_never_shared_between_threads():
+    current = ThreadGPUContext.current()
+    with ThreadPoolExecutor(max_workers=1) as executor:
+        other, repeated = executor.submit(
+            lambda: (ThreadGPUContext.current(), ThreadGPUContext.current())
+        ).result()
+    assert ThreadGPUContext.current() is current
+    assert other is repeated
+    assert other is not current
+
+
+@pytest.mark.parametrize("decorator", [numpy, cupy])
+def test_unpublished_decorated_callable_serializes_without_runtime_context(decorator):
+    # Like a replaced custom function retained by an undo snapshot, this
+    # declaration has no importable public alias. Dill must persist its body.
+    @decorator
+    def declared(image, scale=3):
+        return image * scale
+
+    context = ThreadGPUContext.current()
+    key = (MemoryType.CUPY, -1)
+    handle = threading.local()
+    context._streams[key] = handle
+    try:
+        restored = dill.loads(dill.dumps(declared))
+        assert restored.__name__ == declared.__name__
+        assert restored.__wrapped__.__name__ == declared.__wrapped__.__name__
+        # CPU NumPy invocation checks actual restored behavior. GPU behavior
+        # keeps its existing focused tests; this receipt starts no GPU runtime.
+        if decorator is numpy:
+            np.testing.assert_array_equal(
+                restored(np.array([1, 2], dtype=np.uint16), scale=4), [4, 8]
+            )
+        assert ThreadGPUContext.current() is context
+        assert context._streams[key] is handle
+    finally:
+        del context._streams[key]