cunumpy 0.1.4__tar.gz → 0.2.0__tar.gz

cunumpy-0.2.0/PKG-INFO

@@ -0,0 +1,267 @@
+Metadata-Version: 2.4
+Name: cunumpy
+Version: 0.2.0
+Summary: Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`.
+Author: Max
+Project-URL: Source, https://github.com/max-models/cunumpy
+Keywords: python
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+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: Programming Language :: Python :: 3.13
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: array-api-compat
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: black[jupyter]; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: cunumpy[docs,test-compiled]; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: ipykernel; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: nbconvert; extra == "docs"
+Requires-Dist: nbsphinx; extra == "docs"
+Requires-Dist: jupyterlab; extra == "docs"
+Requires-Dist: pre-commit; extra == "docs"
+Requires-Dist: pyproject-fmt; extra == "docs"
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-book-theme; extra == "docs"
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: test-compiled
+Requires-Dist: cunumpy[test]; extra == "test-compiled"
+Requires-Dist: pyccel; extra == "test-compiled"
+
+# CuNumpy
+
+CuNumpy lets a Python program use a NumPy-like API while choosing NumPy arrays
+on the CPU or CuPy arrays on an NVIDIA GPU. In the simplest case, replace
+`import numpy as np` with `import cunumpy as xp`; the array operations you
+already know then run on the selected backend.
+
+```python
+import cunumpy as xp
+
+values = xp.arange(5, dtype=xp.float64)
+print(values * 2)
+print(xp.get_backend())  # 'numpy' by default
+```
+
+CuNumpy selects an array library for newly requested operations. It does not
+move existing arrays just because the selected backend changes. This guide
+covers backend selection, array movement, mixed CPU/GPU workflows, and the
+helper APIs CuNumpy provides around NumPy and CuPy.
+
+## Install
+
+```bash
+python -m pip install cunumpy
+```
+
+NumPy and `array-api-compat` are installed as dependencies. To use a GPU,
+install a CuPy package compatible with your CUDA environment as well. CuPy
+installation depends on the CUDA version and platform; follow the CuPy
+installation instructions for your system. CuNumpy does not install CUDA.
+
+`array-api-compat` supplies NumPy and CuPy compatibility modules with more
+consistent behavior for shared array operations. CuNumpy uses them internally;
+your arrays remain ordinary NumPy or CuPy arrays. See [why CuNumpy uses
+`array-api-compat`](docs/source/array-api-compat.md) for a plain-language
+explanation and examples.
+
+## Choose a backend
+
+CuNumpy starts with NumPy unless `ARRAY_BACKEND=cupy` is set before import.
+You can also choose at runtime:
+
+```python
+import cunumpy as xp
+
+xp.set_backend("cupy")
+print(xp.get_backend())  # 'cupy' if CuPy and CUDA are functional
+
+values = xp.arange(5)  # created by the active backend
+```
+
+The accepted backend names are `"numpy"` and `"cupy"`. If CuPy is requested
+but unavailable or not functional, CuNumpy falls back to NumPy. Always check
+`get_backend()` when the effective backend matters, such as when reporting
+configuration or deciding whether GPU-specific work will happen.
+
+Use `use_backend()` for a temporary selection. It restores the previous
+selection when the block exits, including when an exception is raised:
+
+```python
+with xp.use_backend("numpy"):
+    cpu_values = xp.linspace(0, 1, 100)
+    assert xp.get_backend() == "numpy"
+
+# The previous global backend is active again here.
+```
+
+The backend selection is process-wide shared state. Do not switch it
+independently from multiple threads or async tasks; those changes can
+interfere. A context manager is useful for sequential code, tests, and
+notebooks.
+
+## Understand the two backend questions
+
+The active backend controls which library CuNumpy exposes through its NumPy
+like operations. The array backend reports where one particular array lives.
+These can differ: changing the active backend does not convert arrays that
+already exist.
+
+```python
+xp.set_backend("numpy")
+cpu_values = xp.arange(3)
+
+gpu_values = xp.to_cupy(cpu_values)  # explicit transfer
+print(xp.get_backend())  # 'numpy'
+print(xp.get_array_backend(gpu_values))  # 'cupy'
+```
+
+Use `is_cpu(array)`, `is_gpu(array)`, or `get_array_backend(array)` when
+dispatch should follow the array passed to a function. `get_array_module()`
+returns the matching `array_api_compat` module, which is useful when writing
+backend-generic functions:
+
+```python
+def vector_norm(values):
+    array_xp = xp.get_array_module(values)
+    return array_xp.sqrt(array_xp.sum(values * values))
+```
+
+## Move data between CPU and GPU
+
+Transfers are explicit so it is clear when data crosses the CPU/GPU boundary:
+
+```python
+host = xp.to_numpy(gpu_values)  # CuPy -> NumPy (host)
+device = xp.to_cupy(host)  # NumPy/array-like -> CuPy (device)
+active = xp.to_cunumpy(host)  # convert to the currently selected backend
+```
+
+`to_numpy()` also accepts ordinary array-like values. `to_cupy()` raises
+`ImportError` when CuPy or a functional CUDA runtime is unavailable.
+`to_cunumpy()` is useful at API boundaries where the consumer expects the
+currently selected backend. It does not change the original array.
+
+Avoid transferring data inside a tight loop. Keep intermediate arrays on one
+backend and move only at boundaries such as file I/O, plotting, or a
+CPU-only library call. For example:
+
+```python
+with xp.use_backend("cupy"):
+    signal = xp.asarray(host_signal)
+    filtered = xp.fft.rfft(signal)
+    result = xp.to_numpy(filtered)  # one transfer for a CPU-only consumer
+```
+
+## Random numbers and dtypes
+
+`get_rng(seed)` returns a random generator for the active backend. NumPy and
+CuPy have similar generator APIs, though exact bit-for-bit sequences are not
+guaranteed to match between libraries:
+
+```python
+rng = xp.get_rng(seed=42)
+samples = rng.normal(size=1000)
+```
+
+Use `default_float_dtype()` when code needs to explicitly request the active
+backend's `float64` dtype rather than rely on Python scalar inference:
+
+```python
+x = xp.asarray([1.0, 2.0], dtype=xp.default_float_dtype())
+```
+
+## GPU selection and memory helpers
+
+These helpers are useful for multi-GPU programs and for understanding CuPy's
+memory behavior:
+
+```python
+print("visible GPUs:", xp.device_count())
+xp.set_device(0)  # selects CUDA device 0 when CuPy is active
+print("memory (free, total):", xp.memory_info())
+```
+
+`set_device()` is a no-op on NumPy. `device_count()` checks visible CUDA
+hardware even if the active backend is NumPy; it returns zero when CuPy/CUDA
+cannot be used. `memory_info()` returns `(free_bytes, total_bytes)` on the
+active CuPy device and `None` on NumPy. `set_device_for_rank(rank)` is a
+round-robin convenience for MPI layouts where local ranks map contiguously to
+GPUs. If your scheduler uses a different mapping, select the device directly.
+
+CuPy caches released allocations in memory pools. This can make process-level
+GPU memory appear occupied after arrays go out of scope. `free_memory()` asks
+CuPy to release currently free cached blocks; it does not free memory still
+referenced by live arrays.
+
+`pin_memory(host_array)` makes a pinned host copy, which can improve transfer
+throughput for workloads that explicitly manage asynchronous transfers.
+`stream()` creates a non-blocking CuPy stream and yields it; it yields `None`
+on NumPy. GPU work is asynchronous, so synchronize before reading results on
+the host:
+
+```python
+with xp.stream():
+    device = xp.to_cupy(host)
+    transformed = xp.fft.fft(device)
+
+xp.synchronize()
+result = xp.to_numpy(transformed)
+```
+
+## Use NumPy-only kernels with CuPy arrays
+
+`PyccelKernel` adapts a callable that expects NumPy arrays. When conversion is
+needed, CuNumpy copies CuPy inputs to the host, calls the wrapped function,
+copies in-place output changes back to the device, and moves returned NumPy
+arrays to CuPy. With NumPy inputs, the wrapper calls the function directly.
+CuNumpy does not compile functions or import Pyccel for you.
+
+```python
+import cunumpy as xp
+
+
+def scale_in_place(values, factor):
+    values[:] *= factor
+    return values
+
+
+scale = xp.PyccelKernel(scale_in_place, outputs=(0,))
+
+with xp.use_backend("cupy"):
+    values = xp.arange(5, dtype=xp.float64)
+    returned = scale(values, 3.0)
+    xp.synchronize()
+```
+
+By default every converted argument is copied back, because the wrapper cannot
+know which arguments the kernel changed. `outputs=(0,)` declares that
+positional argument 0 is written, avoiding unnecessary copy-back for
+read-only inputs. For a keyword call, declare the keyword name, such as
+`outputs=("out",)`. A wrong declaration can leave GPU output values stale.
+The wrapper can also traverse arrays nested in lists, tuples, dictionaries,
+and selected application objects; see the full [API reference](docs/source/api.md)
+for `object_modules`, `is_array`, aliasing, and output declarations.
+
+## Pyodide
+
+CuNumpy supports the NumPy backend in Pyodide. It does not provide CuPy/CUDA
+there. Ordinary Python callables can be wrapped with `PyccelKernel` without
+compilation. See the [Pyodide guide](docs/source/pyodide.md) for a complete
+installation example and compatibility notes.
+
+## Documentation
+
+The [user guide](docs/source/quickstart.md) explains common workflows. The
+[API reference](docs/source/api.md) documents each helper and its behavior.
+The [Pyodide guide](docs/source/pyodide.md) covers WebAssembly usage.

cunumpy-0.2.0/README.md

@@ -0,0 +1,227 @@
+# CuNumpy
+
+CuNumpy lets a Python program use a NumPy-like API while choosing NumPy arrays
+on the CPU or CuPy arrays on an NVIDIA GPU. In the simplest case, replace
+`import numpy as np` with `import cunumpy as xp`; the array operations you
+already know then run on the selected backend.
+
+```python
+import cunumpy as xp
+
+values = xp.arange(5, dtype=xp.float64)
+print(values * 2)
+print(xp.get_backend())  # 'numpy' by default
+```
+
+CuNumpy selects an array library for newly requested operations. It does not
+move existing arrays just because the selected backend changes. This guide
+covers backend selection, array movement, mixed CPU/GPU workflows, and the
+helper APIs CuNumpy provides around NumPy and CuPy.
+
+## Install
+
+```bash
+python -m pip install cunumpy
+```
+
+NumPy and `array-api-compat` are installed as dependencies. To use a GPU,
+install a CuPy package compatible with your CUDA environment as well. CuPy
+installation depends on the CUDA version and platform; follow the CuPy
+installation instructions for your system. CuNumpy does not install CUDA.
+
+`array-api-compat` supplies NumPy and CuPy compatibility modules with more
+consistent behavior for shared array operations. CuNumpy uses them internally;
+your arrays remain ordinary NumPy or CuPy arrays. See [why CuNumpy uses
+`array-api-compat`](docs/source/array-api-compat.md) for a plain-language
+explanation and examples.
+
+## Choose a backend
+
+CuNumpy starts with NumPy unless `ARRAY_BACKEND=cupy` is set before import.
+You can also choose at runtime:
+
+```python
+import cunumpy as xp
+
+xp.set_backend("cupy")
+print(xp.get_backend())  # 'cupy' if CuPy and CUDA are functional
+
+values = xp.arange(5)  # created by the active backend
+```
+
+The accepted backend names are `"numpy"` and `"cupy"`. If CuPy is requested
+but unavailable or not functional, CuNumpy falls back to NumPy. Always check
+`get_backend()` when the effective backend matters, such as when reporting
+configuration or deciding whether GPU-specific work will happen.
+
+Use `use_backend()` for a temporary selection. It restores the previous
+selection when the block exits, including when an exception is raised:
+
+```python
+with xp.use_backend("numpy"):
+    cpu_values = xp.linspace(0, 1, 100)
+    assert xp.get_backend() == "numpy"
+
+# The previous global backend is active again here.
+```
+
+The backend selection is process-wide shared state. Do not switch it
+independently from multiple threads or async tasks; those changes can
+interfere. A context manager is useful for sequential code, tests, and
+notebooks.
+
+## Understand the two backend questions
+
+The active backend controls which library CuNumpy exposes through its NumPy
+like operations. The array backend reports where one particular array lives.
+These can differ: changing the active backend does not convert arrays that
+already exist.
+
+```python
+xp.set_backend("numpy")
+cpu_values = xp.arange(3)
+
+gpu_values = xp.to_cupy(cpu_values)  # explicit transfer
+print(xp.get_backend())  # 'numpy'
+print(xp.get_array_backend(gpu_values))  # 'cupy'
+```
+
+Use `is_cpu(array)`, `is_gpu(array)`, or `get_array_backend(array)` when
+dispatch should follow the array passed to a function. `get_array_module()`
+returns the matching `array_api_compat` module, which is useful when writing
+backend-generic functions:
+
+```python
+def vector_norm(values):
+    array_xp = xp.get_array_module(values)
+    return array_xp.sqrt(array_xp.sum(values * values))
+```
+
+## Move data between CPU and GPU
+
+Transfers are explicit so it is clear when data crosses the CPU/GPU boundary:
+
+```python
+host = xp.to_numpy(gpu_values)  # CuPy -> NumPy (host)
+device = xp.to_cupy(host)  # NumPy/array-like -> CuPy (device)
+active = xp.to_cunumpy(host)  # convert to the currently selected backend
+```
+
+`to_numpy()` also accepts ordinary array-like values. `to_cupy()` raises
+`ImportError` when CuPy or a functional CUDA runtime is unavailable.
+`to_cunumpy()` is useful at API boundaries where the consumer expects the
+currently selected backend. It does not change the original array.
+
+Avoid transferring data inside a tight loop. Keep intermediate arrays on one
+backend and move only at boundaries such as file I/O, plotting, or a
+CPU-only library call. For example:
+
+```python
+with xp.use_backend("cupy"):
+    signal = xp.asarray(host_signal)
+    filtered = xp.fft.rfft(signal)
+    result = xp.to_numpy(filtered)  # one transfer for a CPU-only consumer
+```
+
+## Random numbers and dtypes
+
+`get_rng(seed)` returns a random generator for the active backend. NumPy and
+CuPy have similar generator APIs, though exact bit-for-bit sequences are not
+guaranteed to match between libraries:
+
+```python
+rng = xp.get_rng(seed=42)
+samples = rng.normal(size=1000)
+```
+
+Use `default_float_dtype()` when code needs to explicitly request the active
+backend's `float64` dtype rather than rely on Python scalar inference:
+
+```python
+x = xp.asarray([1.0, 2.0], dtype=xp.default_float_dtype())
+```
+
+## GPU selection and memory helpers
+
+These helpers are useful for multi-GPU programs and for understanding CuPy's
+memory behavior:
+
+```python
+print("visible GPUs:", xp.device_count())
+xp.set_device(0)  # selects CUDA device 0 when CuPy is active
+print("memory (free, total):", xp.memory_info())
+```
+
+`set_device()` is a no-op on NumPy. `device_count()` checks visible CUDA
+hardware even if the active backend is NumPy; it returns zero when CuPy/CUDA
+cannot be used. `memory_info()` returns `(free_bytes, total_bytes)` on the
+active CuPy device and `None` on NumPy. `set_device_for_rank(rank)` is a
+round-robin convenience for MPI layouts where local ranks map contiguously to
+GPUs. If your scheduler uses a different mapping, select the device directly.
+
+CuPy caches released allocations in memory pools. This can make process-level
+GPU memory appear occupied after arrays go out of scope. `free_memory()` asks
+CuPy to release currently free cached blocks; it does not free memory still
+referenced by live arrays.
+
+`pin_memory(host_array)` makes a pinned host copy, which can improve transfer
+throughput for workloads that explicitly manage asynchronous transfers.
+`stream()` creates a non-blocking CuPy stream and yields it; it yields `None`
+on NumPy. GPU work is asynchronous, so synchronize before reading results on
+the host:
+
+```python
+with xp.stream():
+    device = xp.to_cupy(host)
+    transformed = xp.fft.fft(device)
+
+xp.synchronize()
+result = xp.to_numpy(transformed)
+```
+
+## Use NumPy-only kernels with CuPy arrays
+
+`PyccelKernel` adapts a callable that expects NumPy arrays. When conversion is
+needed, CuNumpy copies CuPy inputs to the host, calls the wrapped function,
+copies in-place output changes back to the device, and moves returned NumPy
+arrays to CuPy. With NumPy inputs, the wrapper calls the function directly.
+CuNumpy does not compile functions or import Pyccel for you.
+
+```python
+import cunumpy as xp
+
+
+def scale_in_place(values, factor):
+    values[:] *= factor
+    return values
+
+
+scale = xp.PyccelKernel(scale_in_place, outputs=(0,))
+
+with xp.use_backend("cupy"):
+    values = xp.arange(5, dtype=xp.float64)
+    returned = scale(values, 3.0)
+    xp.synchronize()
+```
+
+By default every converted argument is copied back, because the wrapper cannot
+know which arguments the kernel changed. `outputs=(0,)` declares that
+positional argument 0 is written, avoiding unnecessary copy-back for
+read-only inputs. For a keyword call, declare the keyword name, such as
+`outputs=("out",)`. A wrong declaration can leave GPU output values stale.
+The wrapper can also traverse arrays nested in lists, tuples, dictionaries,
+and selected application objects; see the full [API reference](docs/source/api.md)
+for `object_modules`, `is_array`, aliasing, and output declarations.
+
+## Pyodide
+
+CuNumpy supports the NumPy backend in Pyodide. It does not provide CuPy/CUDA
+there. Ordinary Python callables can be wrapped with `PyccelKernel` without
+compilation. See the [Pyodide guide](docs/source/pyodide.md) for a complete
+installation example and compatibility notes.
+
+## Documentation
+
+The [user guide](docs/source/quickstart.md) explains common workflows. The
+[API reference](docs/source/api.md) documents each helper and its behavior.
+The [Pyodide guide](docs/source/pyodide.md) covers WebAssembly usage.

{cunumpy-0.1.4 → cunumpy-0.2.0}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "setuptools", "wheel" ]
 
 [project]
 name = "cunumpy"
-version = "0.1.4"
+version = "0.2.0"
 description = "Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`."
 readme = "README.md"
 keywords = [ "python" ]
@@ -30,7 +30,7 @@ dependencies = [
 optional-dependencies.dev = [
   "black[jupyter]",
   "isort",
-  "cunumpy[test,docs]",
+  "cunumpy[test-compiled,docs]",
 ]
 # https://medium.com/@pratikdomadiya123/build-project-documentation-quickly-with-the-sphinx-python-2a9732b66594
 optional-dependencies.docs = [
@@ -44,7 +44,8 @@ optional-dependencies.docs = [
   "sphinx",
   "sphinx-book-theme",
 ]
-optional-dependencies.test = [ "coverage", "pyccel", "pytest" ]
+optional-dependencies.test = [ "coverage", "pytest" ]
+optional-dependencies.test-compiled = [ "cunumpy[test]", "pyccel" ]
 urls."Source" = "https://github.com/max-models/cunumpy"
 
 [tool.setuptools.packages.find]

{cunumpy-0.1.4 → cunumpy-0.2.0}/src/cunumpy/__init__.py

@@ -4,12 +4,24 @@ from importlib.metadata import PackageNotFoundError, version
 from . import xp
 from .kernel import PyccelKernel
 from .xp import (
+    assert_same_backend,
     cupy_available,
+    default_float_dtype,
+    device_count,
+    free_memory,
+    get_array_backend,
+    get_array_module,
     get_backend,
+    get_rng,
     is_cpu,
     is_gpu,
+    memory_info,
+    pin_memory,
+    same_backend,
     set_backend,
     set_device,
+    set_device_for_rank,
+    stream,
     synchronize,
     to_cunumpy,
     to_cupy,
@@ -25,14 +37,26 @@ except PackageNotFoundError:
 __all__ = [
     "PyccelKernel",
     "__version__",
+    "assert_same_backend",
     "cupy_available",
     "cupy_backend",
+    "default_float_dtype",
+    "device_count",
+    "free_memory",
+    "get_array_backend",
+    "get_array_module",
     "get_backend",
+    "get_rng",
     "is_cpu",
     "is_gpu",
+    "memory_info",
     "numpy_backend",
+    "pin_memory",
+    "same_backend",
     "set_backend",
     "set_device",
+    "set_device_for_rank",
+    "stream",
     "synchronize",
     "to_cunumpy",
     "to_cupy",

{cunumpy-0.1.4 → cunumpy-0.2.0}/src/cunumpy/__init__.pyi

@@ -14,13 +14,26 @@ def to_numpy(array: Any) -> np.ndarray: ...
 def to_cupy(array: Any) -> Any: ...
 def to_cunumpy(array: Any) -> Any: ...
 def cupy_available() -> bool: ...
-def get_backend(array: Any) -> str: ...
+def get_array_module(array: Any) -> Any: ...
+def get_backend() -> str: ...
+def get_array_backend(array: Any) -> str: ...
 def is_gpu(array: Any) -> bool: ...
 def is_cpu(array: Any) -> bool: ...
+def same_backend(*arrays: Any) -> bool: ...
+def assert_same_backend(*arrays: Any) -> None: ...
 @contextmanager
 def use_backend(backend: str) -> Generator[None]: ...
 def set_backend(backend: str) -> None: ...
 def set_device(device_id: int) -> None: ...
+def set_device_for_rank(rank: int, devices_per_node: int | None = ...) -> int: ...
+def device_count() -> int: ...
+def memory_info() -> tuple[int, int] | None: ...
+def free_memory() -> None: ...
+def pin_memory(array: Any) -> Any: ...
+@contextmanager
+def stream() -> Generator[Any]: ...
+def get_rng(seed: int | None = ...) -> Any: ...
+def default_float_dtype() -> Any: ...
 def synchronize() -> None: ...
 
 numpy_backend: bool

{cunumpy-0.1.4 → cunumpy-0.2.0}/src/cunumpy/kernel.py

@@ -8,6 +8,9 @@ made by the kernel are copied back to the device afterwards, and any arrays
 returned by the kernel are moved back to the device.
 
 On the NumPy backend the wrapper is a no-op and the kernel is called directly.
+Ordinary Python callables are supported, including in Pyodide. This module
+neither imports Pyccel nor compiles kernels; compilation, if desired, is the
+caller's responsibility.
 """
 
 from __future__ import annotations
@@ -24,7 +27,7 @@ __all__ = ["PyccelKernel"]
 
 
 class PyccelKernel:
-    """Call a Pyccel-compiled kernel with NumPy or CuPy arrays.
+    """Call a NumPy callable or Pyccel-compiled kernel with NumPy or CuPy arrays.
 
     Parameters
     ----------
@@ -38,6 +41,12 @@ class PyccelKernel:
         Module prefixes (e.g. ``("struphy.", "feectools.")``) whose instances
         should be traversed attribute-by-attribute when looking for arrays to
         convert. Objects from other modules are passed through untouched.
+    is_array : callable, optional
+        Predicate deciding whether a host-side value returned by the kernel
+        (or reachable from a declared output) counts as an array to move
+        back to the device. Defaults to ``isinstance(value, np.ndarray)``.
+        Override this if the kernel returns/mutates a NumPy subclass or a
+        custom host array type that should also be converted back to CuPy.
     outputs : sequence of int or str, optional
         Which arguments the kernel writes to. Only those are copied back to the
         device after the call, which avoids pointless device transfers for the
@@ -65,11 +74,13 @@ class PyccelKernel:
         kernel: Callable[..., Any],
         use_cupy: bool | None = None,
         object_modules: Sequence[str] = (),
+        is_array: Callable[[Any], bool] | None = None,
         outputs: Sequence[int | str] | None = None,
     ) -> None:
         self._kernel = kernel
         self._use_cupy = use_cupy
         self._object_modules = tuple(object_modules)
+        self._is_array = is_array or (lambda value: isinstance(value, np.ndarray))
 
         if outputs is None:
             self._outputs: tuple[int | str, ...] | None = None
@@ -162,15 +173,14 @@ class PyccelKernel:
 
         return value
 
-    @staticmethod
-    def _convert_from_numpy(value: Any) -> Any:
-        """Move NumPy arrays returned by the kernel back to the device."""
-        if isinstance(value, np.ndarray):
+    def _convert_from_numpy(self, value: Any) -> Any:
+        """Move host arrays returned by the kernel back to the device."""
+        if self._is_array(value):
             return to_cupy(value)
         if isinstance(value, tuple):
-            return tuple(PyccelKernel._convert_from_numpy(item) for item in value)
+            return tuple(self._convert_from_numpy(item) for item in value)
         if isinstance(value, list):
-            return [PyccelKernel._convert_from_numpy(item) for item in value]
+            return [self._convert_from_numpy(item) for item in value]
         return value
 
     def _collect_host_arrays(self, value: Any, found: set[int], seen: set[int]) -> None:
@@ -180,7 +190,7 @@ class PyccelKernel:
         :meth:`_convert_to_numpy`, so that an output declared as a container or
         an object contributes the arrays nested inside it.
         """
-        if isinstance(value, np.ndarray):
+        if self._is_array(value):
             found.add(id(value))
             return
 
@@ -338,6 +348,11 @@ class PyccelKernel:
         """Module prefixes whose instances are traversed for arrays."""
         return self._object_modules
 
+    @property
+    def is_array(self) -> Callable[[Any], bool]:
+        """Predicate identifying host values to convert back to the device."""
+        return self._is_array
+
     @property
     def outputs(self) -> tuple[int | str, ...] | None:
         """Declared output arguments, or ``None`` if every array is copied back."""