arraybridge 0.3.4__tar.gz → 0.3.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arraybridge
-Version: 0.3.4
+Version: 0.3.7
 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'
@@ -142,3 +143,17 @@ pip install "arraybridge[cupy]"
 ```
 
 Documentation: <https://arraybridge.readthedocs.io>
+
+### Native array geometry
+
+`MemoryType.reshape(array, shape)` and `MemoryType.broadcast_to(array, shape)`
+operate in the array's framework and device. `MemoryType.ones_like(reference,
+shape=..., dtype=...)` allocates on the reference's device; omitting `shape`
+retains its shape. Reshape and broadcast preserve views where the backend can
+represent them. Broadcasting is not a promise of a writable, independent buffer.
+
+These operations never silently project pixels to NumPy. Pyclesperanto cannot
+provide native changed-shape reshape or broadcasting, so those requests raise
+`NotImplementedError`. Its native ones allocation supports one to three
+dimensions and its supported integer/float32 dtypes; boolean allocation is
+explicitly unsupported. Existing conversion and disk boundaries remain separate.

{arraybridge-0.3.4 → arraybridge-0.3.7}/README.md

@@ -71,3 +71,17 @@ pip install "arraybridge[cupy]"
 ```
 
 Documentation: <https://arraybridge.readthedocs.io>
+
+### Native array geometry
+
+`MemoryType.reshape(array, shape)` and `MemoryType.broadcast_to(array, shape)`
+operate in the array's framework and device. `MemoryType.ones_like(reference,
+shape=..., dtype=...)` allocates on the reference's device; omitting `shape`
+retains its shape. Reshape and broadcast preserve views where the backend can
+represent them. Broadcasting is not a promise of a writable, independent buffer.
+
+These operations never silently project pixels to NumPy. Pyclesperanto cannot
+provide native changed-shape reshape or broadcasting, so those requests raise
+`NotImplementedError`. Its native ones allocation supports one to three
+dimensions and its supported integer/float32 dtypes; boolean allocation is
+explicitly unsupported. Existing conversion and disk boundaries remain separate.

{arraybridge-0.3.4 → arraybridge-0.3.7}/docs/source/index.rst

@@ -20,6 +20,8 @@ applications.
    examples/index
    contributing
    ci-cd
+   release_035_validation
+   release_036_validation
 
 Boundary rule
 -------------

arraybridge-0.3.7/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.7/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.7}/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.7}/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.7"
 
 _LAZY_EXPORTS: dict[str, str] = {
     "MemoryType": ".types",

arraybridge-0.3.7/src/arraybridge/array_operations.py

@@ -0,0 +1,450 @@
+"""Native array operations carried by MemoryType declarations."""
+
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+
+_SCALING_RANGES: dict[str, float | tuple[float, float]] = {
+    "uint8": 255.0,
+    "uint16": 65535.0,
+    "uint32": 4294967295.0,
+    "int16": (65535.0, 32768.0),
+    "int32": (4294967295.0, 2147483648.0),
+}
+
+
+def _dtype_name(dtype: Any) -> str:
+    declared_name = getattr(dtype, "name", None)
+    if declared_name is not None:
+        return str(declared_name)
+    return getattr(dtype, "__name__", str(dtype).rsplit(".", maxsplit=1)[-1])
+
+
+def _numpy_dtype_name(dtype: Any) -> str:
+    return str(np.dtype(dtype).name)
+
+
+def _torch_dtype_name(dtype: Any) -> str:
+    return str(dtype).rsplit(".", maxsplit=1)[-1]
+
+
+def _tensorflow_dtype_name(dtype: Any) -> str:
+    numpy_dtype = getattr(dtype, "as_numpy_dtype", dtype)
+    return str(np.dtype(numpy_dtype).name)
+
+
+def _scaled_values(result: Any, result_min: Any, result_max: Any, target_dtype: Any) -> Any:
+    normalized = (result - result_min) / (result_max - result_min)
+    range_info = _SCALING_RANGES.get(_dtype_name(target_dtype))
+    if range_info is None:
+        return normalized
+    if isinstance(range_info, tuple):
+        scale, offset = range_info
+        return normalized * scale - offset
+    return normalized * range_info
+
+
+def _clamp_bounds(target_dtype: Any) -> tuple[float, float] | None:
+    range_info = _SCALING_RANGES.get(_dtype_name(target_dtype))
+    if range_info is None:
+        return None
+    if isinstance(range_info, tuple):
+        scale, offset = range_info
+        return -offset, scale - offset - 128
+    return 0, range_info
+
+
+def _mapped_dtype(target_dtype: Any, module: Any) -> Any:
+    try:
+        dtype_name = np.dtype(target_dtype).name
+    except TypeError as error:
+        raise TypeError(f"Unsupported target dtype {target_dtype!r}") from error
+    mapped = getattr(module, dtype_name, None)
+    if mapped is None:
+        module_name = getattr(module, "__name__", type(module).__name__)
+        raise TypeError(f"{module_name} does not expose dtype {dtype_name}")
+    return mapped
+
+
+class ArrayOperations(ABC):
+    """Native array semantics selected by the existing MemoryType declaration."""
+
+    @staticmethod
+    @abstractmethod
+    def to_numpy(data: Any, module: Any) -> Any:
+        """Project pixels to the explicit host boundary."""
+
+    @staticmethod
+    @abstractmethod
+    def from_numpy(data: Any, module: Any, device_id: int) -> Any:
+        """Admit host pixels on the selected framework device."""
+
+    @staticmethod
+    @abstractmethod
+    def scale_dtype(result: Any, target_dtype: Any, module: Any) -> Any:
+        """Apply the framework's existing intensity conversion law."""
+
+    @staticmethod
+    def dtype_name(dtype: Any) -> str:
+        return _numpy_dtype_name(dtype)
+
+    @staticmethod
+    def stack(values: Sequence[Any], module: Any) -> Any:
+        return module.stack(tuple(values), axis=0)
+
+    @staticmethod
+    def cast(data: Any, dtype: Any, module: Any) -> Any:
+        return data.astype(dtype, copy=False)
+
+    @staticmethod
+    def logical_and(left: Any, right: Any, module: Any) -> Any:
+        return module.logical_and(left, right)
+
+    @staticmethod
+    def reshape(data: Any, shape: tuple[int, ...], module: Any) -> Any:
+        return data.reshape(shape)
+
+    @staticmethod
+    def broadcast_to(data: Any, shape: tuple[int, ...], module: Any) -> Any:
+        return module.broadcast_to(data, shape)
+
+    @staticmethod
+    def ones_like(reference: Any, shape: tuple[int, ...], dtype: Any, module: Any) -> Any:
+        return module.ones(shape, dtype=dtype)
+
+
+class NumpyArrayOperations(ArrayOperations):
+    """Numpy native operation leaves."""
+
+    @staticmethod
+    def to_numpy(data: Any, module: Any) -> Any:
+        del module
+        return data
+
+    @staticmethod
+    def from_numpy(data: Any, module: Any, device_id: int) -> Any:
+        del module, device_id
+        return data
+
+    @staticmethod
+    def scale_dtype(result: Any, target_dtype: Any, module: Any) -> Any:
+        if not hasattr(result, "dtype"):
+            return result
+        if not (
+            module.issubdtype(result.dtype, module.floating)
+            and module.issubdtype(target_dtype, module.integer)
+        ):
+            return result.astype(target_dtype)
+        result_min = result.min()
+        result_max = result.max()
+        if result_max <= result_min:
+            return result.astype(target_dtype)
+        scaled = _scaled_values(result, result_min, result_max, target_dtype)
+        bounds = _clamp_bounds(target_dtype)
+        if bounds is not None:
+            scaled = module.clip(scaled, *bounds)
+        return scaled.astype(target_dtype)
+
+
+class CupyArrayOperations(ArrayOperations):
+    """Cupy native operation leaves."""
+
+    @staticmethod
+    def to_numpy(data: Any, module: Any) -> Any:
+        del module
+        return data.get()
+
+    @staticmethod
+    def from_numpy(data: Any, module: Any, device_id: int) -> Any:
+        del device_id
+        return module.array(data)
+
+    @staticmethod
+    def scale_dtype(result: Any, target_dtype: Any, module: Any) -> Any:
+        if not hasattr(result, "dtype"):
+            return result
+        if not (
+            module.issubdtype(result.dtype, module.floating)
+            and not module.issubdtype(target_dtype, module.floating)
+        ):
+            return result.astype(target_dtype)
+        result_min = module.min(result)
+        result_max = module.max(result)
+        if result_max <= result_min:
+            return result.astype(target_dtype)
+        scaled = _scaled_values(result, result_min, result_max, target_dtype)
+        bounds = _clamp_bounds(target_dtype)
+        if bounds is not None:
+            scaled = module.clip(scaled, *bounds)
+        return scaled.astype(target_dtype)
+
+
+class TorchArrayOperations(ArrayOperations):
+    """Torch native operation leaves."""
+
+    @staticmethod
+    def to_numpy(data: Any, module: Any) -> Any:
+        del module
+        return data.cpu().numpy()
+
+    @staticmethod
+    def from_numpy(data: Any, module: Any, device_id: int) -> Any:
+        host_data = (
+            np.ascontiguousarray(data)
+            if any(stride < 0 for stride in getattr(data, "strides", ()))
+            else data
+        )
+        return module.from_numpy(host_data).to(f"cuda:{device_id}")
+
+    @staticmethod
+    def scale_dtype(result: Any, target_dtype: Any, module: Any) -> Any:
+        if not hasattr(result, "dtype"):
+            return result
+        mapped = _mapped_dtype(target_dtype, module)
+        floats = (module.float16, module.float32, module.float64)
+        if not (result.dtype in floats and np.issubdtype(np.dtype(target_dtype), np.integer)):
+            return result.to(mapped)
+        result_min = result.min()
+        result_max = result.max()
+        if result_max <= result_min:
+            return result.to(mapped)
+        scaled = _scaled_values(result, result_min, result_max, target_dtype)
+        bounds = _clamp_bounds(target_dtype)
+        if bounds is not None:
+            scaled = module.clamp(scaled, min=bounds[0], max=bounds[1])
+        return scaled.to(mapped)
+
+    @staticmethod
+    def stack(values: Sequence[Any], module: Any) -> Any:
+        return module.stack(tuple(values), dim=0)
+
+    @staticmethod
+    def cast(data: Any, dtype: Any, module: Any) -> Any:
+        return data.to(dtype=_mapped_dtype(dtype, module))
+
+    @staticmethod
+    def dtype_name(dtype: Any) -> str:
+        return str(dtype).rsplit(".", maxsplit=1)[-1]
+
+    @staticmethod
+    def broadcast_to(data: Any, shape: tuple[int, ...], module: Any) -> Any:
+        return data.expand(shape)
+
+    @staticmethod
+    def ones_like(reference: Any, shape: tuple[int, ...], dtype: Any, module: Any) -> Any:
+        return module.ones(shape, dtype=_mapped_dtype(dtype, module), device=reference.device)
+
+
+class TensorflowArrayOperations(ArrayOperations):
+    """Tensorflow native operation leaves."""
+
+    @staticmethod
+    def to_numpy(data: Any, module: Any) -> Any:
+        del module
+        return data.numpy()
+
+    @staticmethod
+    def from_numpy(data: Any, module: Any, device_id: int) -> Any:
+        del device_id
+        return module.convert_to_tensor(data)
+
+    @staticmethod
+    def scale_dtype(result: Any, target_dtype: Any, module: Any) -> Any:
+        if not hasattr(result, "dtype"):
+            return result
+        mapped = _mapped_dtype(target_dtype, module)
+        floats = (module.float16, module.float32, module.float64)
+        if not (result.dtype in floats and np.issubdtype(np.dtype(target_dtype), np.integer)):
+            return module.cast(result, mapped)
+        result_min = module.reduce_min(result)
+        result_max = module.reduce_max(result)
+        if result_max <= result_min:
+            return module.cast(result, mapped)
+        scaled = _scaled_values(result, result_min, result_max, target_dtype)
+        bounds = _clamp_bounds(target_dtype)
+        if bounds is not None:
+            scaled = module.clip_by_value(scaled, *bounds)
+        return module.cast(scaled, mapped)
+
+    @staticmethod
+    def cast(data: Any, dtype: Any, module: Any) -> Any:
+        return module.cast(data, _mapped_dtype(dtype, module))
+
+    @staticmethod
+    def reshape(data: Any, shape: tuple[int, ...], module: Any) -> Any:
+        return module.reshape(data, shape)
+
+    @staticmethod
+    def ones_like(reference: Any, shape: tuple[int, ...], dtype: Any, module: Any) -> Any:
+        with module.device(reference.device):
+            return module.ones(shape, dtype=_mapped_dtype(dtype, module))
+
+
+class JaxArrayOperations(ArrayOperations):
+    """Jax native operation leaves."""
+
+    @staticmethod
+    def to_numpy(data: Any, module: Any) -> Any:
+        del module
+        return np.asarray(data)
+
+    @staticmethod
+    def from_numpy(data: Any, module: Any, device_id: int) -> Any:
+        devices = tuple(device for device in module.devices() if device.platform == "gpu")
+        return module.device_put(data, devices[device_id])
+
+    @staticmethod
+    def scale_dtype(result: Any, target_dtype: Any, module: Any) -> Any:
+        if not hasattr(result, "dtype"):
+            return result
+        if np.dtype(target_dtype) == np.dtype(np.float64):
+            x64_enabled = getattr(module.config, "x64_enabled", None)
+            if x64_enabled is None:
+                x64_enabled = module.config.read("jax_enable_x64")
+            if not x64_enabled:
+                raise ValueError(
+                    "JAX float64 output requires x64 mode; set JAX_ENABLE_X64=true before import"
+                )
+        jnp = module.numpy
+        mapped = _mapped_dtype(target_dtype, jnp)
+        floats = (jnp.float16, jnp.float32, jnp.float64)
+        if not (result.dtype in floats and np.issubdtype(np.dtype(target_dtype), np.integer)):
+            return result.astype(mapped)
+        result_min = jnp.min(result)
+        result_max = jnp.max(result)
+        if result_max <= result_min:
+            return result.astype(mapped)
+        scaled = _scaled_values(result, result_min, result_max, target_dtype)
+        bounds = _clamp_bounds(target_dtype)
+        if bounds is not None:
+            scaled = jnp.clip(scaled, *bounds)
+        return scaled.astype(mapped)
+
+    @staticmethod
+    def stack(values: Sequence[Any], module: Any) -> Any:
+        return module.numpy.stack(tuple(values), axis=0)
+
+    @staticmethod
+    def cast(data: Any, dtype: Any, module: Any) -> Any:
+        return data.astype(_mapped_dtype(dtype, module.numpy))
+
+    @staticmethod
+    def logical_and(left: Any, right: Any, module: Any) -> Any:
+        return module.numpy.logical_and(left, right)
+
+    @staticmethod
+    def broadcast_to(data: Any, shape: tuple[int, ...], module: Any) -> Any:
+        return module.numpy.broadcast_to(data, shape)
+
+    @staticmethod
+    def ones_like(reference: Any, shape: tuple[int, ...], dtype: Any, module: Any) -> Any:
+        return module.numpy.ones(shape, dtype=dtype, device=reference.device)
+
+
+class PyclesperantoArrayOperations(ArrayOperations):
+    """Pyclesperanto native operation leaves."""
+
+    @staticmethod
+    def to_numpy(data: Any, module: Any) -> Any:
+        return module.pull(data)
+
+    @staticmethod
+    def from_numpy(data: Any, module: Any, device_id: int) -> Any:
+        del device_id
+        return module.push(data)
+
+    @staticmethod
+    def scale_dtype(result: Any, target_dtype: Any, module: Any) -> Any:
+        if not hasattr(result, "dtype"):
+            return result
+        target_is_int = np.issubdtype(np.dtype(target_dtype), np.integer)
+        if not (np.issubdtype(result.dtype, np.floating) and target_is_int):
+            return module.push(module.pull(result).astype(target_dtype))
+        result_min = float(module.minimum_of_all_pixels(result))
+        result_max = float(module.maximum_of_all_pixels(result))
+        if result_max <= result_min:
+            return module.push(module.pull(result).astype(target_dtype))
+        normalized = module.subtract_image_from_scalar(result, scalar=result_min)
+        normalized = module.multiply_image_and_scalar(
+            normalized,
+            scalar=1.0 / (result_max - result_min),
+        )
+        range_info = _SCALING_RANGES.get(_dtype_name(target_dtype))
+        if isinstance(range_info, tuple):
+            scale, offset = range_info
+            scaled = module.multiply_image_and_scalar(normalized, scalar=scale)
+            scaled = module.subtract_image_from_scalar(scaled, scalar=offset)
+        elif range_info is not None:
+            scaled = module.multiply_image_and_scalar(normalized, scalar=range_info)
+        else:
+            scaled = normalized
+        host_values = module.pull(scaled)
+        bounds = _clamp_bounds(target_dtype)
+        if bounds is not None:
+            host_values = np.clip(host_values, *bounds)
+        return module.push(host_values.astype(target_dtype))
+
+    @staticmethod
+    def stack(values: Sequence[Any], module: Any) -> Any:
+        if not values:
+            raise ValueError("Cannot stack an empty pyclesperanto sequence")
+        if len(values) == 1:
+            source = values[0]
+            result = module.create((1, *source.shape), dtype=source.dtype)
+            return module.copy_slice(source, result, 0)
+        result = values[0]
+        for value in values[1:]:
+            result = module.concatenate_along_z(result, value)
+        return result
+
+    @staticmethod
+    def cast(data: Any, dtype: Any, module: Any) -> Any:
+        return module.push(module.pull(data).astype(dtype, copy=False))
+
+    @staticmethod
+    def logical_and(left: Any, right: Any, module: Any) -> Any:
+        return module.push(np.logical_and(module.pull(left), module.pull(right)))
+
+    @staticmethod
+    def reshape(data: Any, shape: tuple[int, ...], module: Any) -> Any:
+        if tuple(data.shape) == shape:
+            return data
+        raise NotImplementedError(
+            "pyclesperanto does not provide native array reshape; its reshape downloads pixels"
+        )
+
+    @staticmethod
+    def broadcast_to(data: Any, shape: tuple[int, ...], module: Any) -> Any:
+        if tuple(data.shape) == shape:
+            return data
+        raise NotImplementedError("pyclesperanto does not provide native array broadcasting")
+
+    @staticmethod
+    def ones_like(reference: Any, shape: tuple[int, ...], dtype: Any, module: Any) -> Any:
+        if np.dtype(dtype).name not in {
+            "float32",
+            "int8",
+            "int16",
+            "int32",
+            "uint8",
+            "uint16",
+            "uint32",
+        }:
+            raise NotImplementedError(f"pyclesperanto cannot allocate native dtype {dtype!r}")
+        if not 1 <= len(shape) <= 3:
+            raise NotImplementedError(
+                "pyclesperanto native allocation requires one to three dimensions"
+            )
+        result = module.create(shape, dtype=dtype, device=reference.device)
+        module.set(result, scalar=1, device=reference.device)
+        return result
+
+
+NUMPY_OPERATIONS = NumpyArrayOperations()
+CUPY_OPERATIONS = CupyArrayOperations()
+TORCH_OPERATIONS = TorchArrayOperations()
+TENSORFLOW_OPERATIONS = TensorflowArrayOperations()
+JAX_OPERATIONS = JaxArrayOperations()
+PYCLESPERANTO_OPERATIONS = PyclesperantoArrayOperations()