cunumpy 0.5.0__tar.gz → 0.6.0__tar.gz

{cunumpy-0.5.0 → cunumpy-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cunumpy
-Version: 0.5.0
+Version: 0.6.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
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: array-api-compat
+Requires-Dist: maybempi>=0.1.2
 Requires-Dist: numpy
 Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"
@@ -63,8 +64,9 @@ never hide a NumPy name:
 
 | Submodule | Contents |
 |---|---|
-| `xp.cuda` | CUDA only: `CudaKernel`, `CudaStruct`, CUDA headers, devices, streams |
-| `xp.kernels` | `Kernel`, `KernelCatalog`, `PyccelKernel`, host implementations, `fuse` |
+| `xp.kernels` | `Kernel`, `KernelCatalog`, `PyccelKernel`, `CudaKernel`, host implementations, `fuse` |
+| `xp.arguments` | CUDA only: `CudaStruct`, `CudaStructArguments`, `CudaArguments` |
+| `xp.cuda` | CUDA only: devices, streams, debug mode, CUDA headers |
 | `xp.rng` | `random_streams`, `get_rng`, `philox_*` |
 | `xp.algorithms` | `morton_*`, `sort_by_key`, `cell_offsets`, `segment_boundaries`, `segment_sum`, `SegmentPlan` |
 | `xp.mpi` | `mpi_buffer`, reusable `MPIStaging`, CUDA-aware MPI |
@@ -73,7 +75,7 @@ never hide a NumPy name:
 | `xp.petsc` | `petsc_vec` |
 | `cunumpy.kernel_testing` | pytest helpers for host/CUDA kernel pairs |
 
-Everything except `xp.cuda` works on both backends.
+Everything except `xp.cuda`, `xp.arguments` and `CudaKernel` works on both backends.
 
 ## Install
 
@@ -372,7 +374,7 @@ def axpy(a, x, y, n):  # host version, e.g. compiled with Pyccel
         y[i] += a * x[i]
 
 
-kernel = xp.kernels.Kernel(axpy, xp.cuda.CudaKernel(AXPY, "axpy"))
+kernel = xp.kernels.Kernel(axpy, xp.kernels.CudaKernel(AXPY, "axpy"))
 
 with xp.use_backend("cupy"):
     x = xp.arange(1000, dtype=xp.float64)
@@ -395,8 +397,8 @@ the matching memory layout) and packs values into it, which the kernel takes
 as one parameter:
 
 ```python
-Vec = xp.cuda.CudaStruct("Vec", [("data", "double*"), ("n", "int")])
-scale = xp.cuda.CudaKernel(
+Vec = xp.arguments.CudaStruct("Vec", [("data", "double*"), ("n", "int")])
+scale = xp.kernels.CudaKernel(
     Vec.declaration
     + r"""
     extern "C" __global__ void scale(Vec v, double a) {
@@ -418,29 +420,15 @@ device copies. Call it once when the object is
 built, not per kernel call; on the NumPy backend it raises, so host data is
 never copied to the device implicitly.
 When the host kernel takes such a group as one object too (e.g. a Pyccel class
-holding NumPy arrays), give the group both forms with `KernelArguments`:
-`__host_args__()` returns the object for the host kernel, `__cuda_args__()`
-the flattened device arguments. `Kernel` and `PyccelKernel` resolve
-`__host_args__()` on the host path and `CudaKernel` flattens `__cuda_args__()`
-on the CUDA path, so the call site is the same on both backends and each form
-can be built lazily on first access (a CPU run never builds device arguments):
+holding NumPy arrays), write a CUDA class with the same constructor and
+attributes (a `CudaStructArguments`, see below) and let the owner of the arrays
+build the one for the active backend. CuNumpy passes argument objects through
+as they are and never converts one form into the other:
 
 ```python
-class ParticleArguments(xp.kernels.KernelArguments):
-    def __init__(self, markers):
-        self.markers = markers
-        self._host = None
-
-    def __host_args__(self):
-        if self._host is None:
-            self._host = MarkerArguments(self.markers)  # Pyccel class
-        return self._host
-
-    def __cuda_args__(self):
-        return (self.markers, self.markers.shape[0])
-
-
-kernel(particles.kernel_args, dt, n_threads=n)  # host or CUDA kernel
+args_class = CudaMarkerArguments if xp.is_gpu(markers) else MarkerArguments
+particles.args_markers = args_class(markers, markers.shape[0])
+kernel(particles.args_markers, dt)  # host or CUDA kernel
 ```
 
 Kernels ported from pyccel index arrays like `markers[ip, j]`, which needs
@@ -456,11 +444,11 @@ class MarkerArguments:
     def __init__(self, markers: "float[:, :]", n_markers: int, valid: "bool[:]"): ...
 
 
-MarkerArgs = xp.cuda.CudaStruct.from_signature(MarkerArguments.__init__, "MarkerArgs")
+MarkerArgs = xp.arguments.CudaStruct.from_signature(MarkerArguments.__init__, "MarkerArgs")
 MarkerArgs.to_header(
     "marker_args.cuh"
 )  # Array2D<double> markers; long long n_markers; ...
-push = xp.cuda.CudaKernel(
+push = xp.kernels.CudaKernel(
     r"""
     #include "marker_args.cuh"
     #include <cunumpy/index.cuh>

{cunumpy-0.5.0 → cunumpy-0.6.0}/README.md

@@ -24,8 +24,9 @@ never hide a NumPy name:
 
 | Submodule | Contents |
 |---|---|
-| `xp.cuda` | CUDA only: `CudaKernel`, `CudaStruct`, CUDA headers, devices, streams |
-| `xp.kernels` | `Kernel`, `KernelCatalog`, `PyccelKernel`, host implementations, `fuse` |
+| `xp.kernels` | `Kernel`, `KernelCatalog`, `PyccelKernel`, `CudaKernel`, host implementations, `fuse` |
+| `xp.arguments` | CUDA only: `CudaStruct`, `CudaStructArguments`, `CudaArguments` |
+| `xp.cuda` | CUDA only: devices, streams, debug mode, CUDA headers |
 | `xp.rng` | `random_streams`, `get_rng`, `philox_*` |
 | `xp.algorithms` | `morton_*`, `sort_by_key`, `cell_offsets`, `segment_boundaries`, `segment_sum`, `SegmentPlan` |
 | `xp.mpi` | `mpi_buffer`, reusable `MPIStaging`, CUDA-aware MPI |
@@ -34,7 +35,7 @@ never hide a NumPy name:
 | `xp.petsc` | `petsc_vec` |
 | `cunumpy.kernel_testing` | pytest helpers for host/CUDA kernel pairs |
 
-Everything except `xp.cuda` works on both backends.
+Everything except `xp.cuda`, `xp.arguments` and `CudaKernel` works on both backends.
 
 ## Install
 
@@ -333,7 +334,7 @@ def axpy(a, x, y, n):  # host version, e.g. compiled with Pyccel
         y[i] += a * x[i]
 
 
-kernel = xp.kernels.Kernel(axpy, xp.cuda.CudaKernel(AXPY, "axpy"))
+kernel = xp.kernels.Kernel(axpy, xp.kernels.CudaKernel(AXPY, "axpy"))
 
 with xp.use_backend("cupy"):
     x = xp.arange(1000, dtype=xp.float64)
@@ -356,8 +357,8 @@ the matching memory layout) and packs values into it, which the kernel takes
 as one parameter:
 
 ```python
-Vec = xp.cuda.CudaStruct("Vec", [("data", "double*"), ("n", "int")])
-scale = xp.cuda.CudaKernel(
+Vec = xp.arguments.CudaStruct("Vec", [("data", "double*"), ("n", "int")])
+scale = xp.kernels.CudaKernel(
     Vec.declaration
     + r"""
     extern "C" __global__ void scale(Vec v, double a) {
@@ -379,29 +380,15 @@ device copies. Call it once when the object is
 built, not per kernel call; on the NumPy backend it raises, so host data is
 never copied to the device implicitly.
 When the host kernel takes such a group as one object too (e.g. a Pyccel class
-holding NumPy arrays), give the group both forms with `KernelArguments`:
-`__host_args__()` returns the object for the host kernel, `__cuda_args__()`
-the flattened device arguments. `Kernel` and `PyccelKernel` resolve
-`__host_args__()` on the host path and `CudaKernel` flattens `__cuda_args__()`
-on the CUDA path, so the call site is the same on both backends and each form
-can be built lazily on first access (a CPU run never builds device arguments):
+holding NumPy arrays), write a CUDA class with the same constructor and
+attributes (a `CudaStructArguments`, see below) and let the owner of the arrays
+build the one for the active backend. CuNumpy passes argument objects through
+as they are and never converts one form into the other:
 
 ```python
-class ParticleArguments(xp.kernels.KernelArguments):
-    def __init__(self, markers):
-        self.markers = markers
-        self._host = None
-
-    def __host_args__(self):
-        if self._host is None:
-            self._host = MarkerArguments(self.markers)  # Pyccel class
-        return self._host
-
-    def __cuda_args__(self):
-        return (self.markers, self.markers.shape[0])
-
-
-kernel(particles.kernel_args, dt, n_threads=n)  # host or CUDA kernel
+args_class = CudaMarkerArguments if xp.is_gpu(markers) else MarkerArguments
+particles.args_markers = args_class(markers, markers.shape[0])
+kernel(particles.args_markers, dt)  # host or CUDA kernel
 ```
 
 Kernels ported from pyccel index arrays like `markers[ip, j]`, which needs
@@ -417,11 +404,11 @@ class MarkerArguments:
     def __init__(self, markers: "float[:, :]", n_markers: int, valid: "bool[:]"): ...
 
 
-MarkerArgs = xp.cuda.CudaStruct.from_signature(MarkerArguments.__init__, "MarkerArgs")
+MarkerArgs = xp.arguments.CudaStruct.from_signature(MarkerArguments.__init__, "MarkerArgs")
 MarkerArgs.to_header(
     "marker_args.cuh"
 )  # Array2D<double> markers; long long n_markers; ...
-push = xp.cuda.CudaKernel(
+push = xp.kernels.CudaKernel(
     r"""
     #include "marker_args.cuh"
     #include <cunumpy/index.cuh>

{cunumpy-0.5.0 → cunumpy-0.6.0}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "setuptools", "wheel" ]
 
 [project]
 name = "cunumpy"
-version = "0.5.0"
+version = "0.6.0"
 description = "Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`."
 readme = "README.md"
 keywords = [ "python" ]
@@ -23,6 +23,7 @@ classifiers = [
 ]
 dependencies = [
   "array-api-compat",
+  "maybempi>=0.1.2",
   "numpy",
 ]
 

{cunumpy-0.5.0 → cunumpy-0.6.0}/src/cunumpy/LLM_GUIDE.md

@@ -18,7 +18,7 @@ https://max-models.github.io/cunumpy/ and in `docs/source/` of the repository.
   with one rank per GPU, profiling.
 * A kernel layer for porting compiled CPU kernels (Pyccel, Numba, Python loops)
   to CUDA one at a time: `PyccelKernel`, `CudaKernel`, `Kernel`,
-  `KernelCatalog`, `KernelArguments`, `CudaStruct`, `DeviceMirror`, and test
+  `KernelCatalog`, `CudaStruct`, `CudaStructArguments`, `DeviceMirror`, and test
   helpers in `cunumpy.kernel_testing`.
 
 ## Hard rules
@@ -54,12 +54,12 @@ https://max-models.github.io/cunumpy/ and in `docs/source/` of the repository.
     An argument the kernel writes but that is not declared leaves stale device
     data, silently. If unsure, leave `outputs=None` (copies everything back).
 11. **Helpers are in submodules; the top level is NumPy plus backend control.**
-    `xp.cuda.CudaKernel`, `xp.kernels.Kernel`, `xp.rng.random_streams`,
+    `xp.kernels.CudaKernel`, `xp.kernels.Kernel`, `xp.arguments.CudaStructArguments`,
+    `xp.rng.random_streams`,
     `xp.algorithms.morton_keys`, `xp.mpi.mpi_buffer`, `xp.profiling.timed_region`,
     `xp.memory.HostStaging`, `xp.petsc.petsc_vec`; kernel test helpers in
-    `cunumpy.kernel_testing`. The old top-level names (`xp.CudaKernel`) and
-    `cunumpy.testing` are deprecated (removed in 0.6); do not write new code
-    with them. Modules starting with `_` (`cunumpy._cuda_kernel`, ...) are
+    `cunumpy.kernel_testing`. There is no `xp.CudaKernel`, `xp.cuda.CudaKernel`
+    or `cunumpy.testing`; use the submodule names above. Modules starting with `_` (`cunumpy._cuda_kernel`, ...) are
     private; never import from them.
 
 ## Decision guide
@@ -71,7 +71,7 @@ https://max-models.github.io/cunumpy/ and in `docs/source/` of the repository.
 | normalize inputs at an API boundary | `xp.to_cunumpy(a)` once |
 | hand data to SciPy/matplotlib/h5py | `xp.to_numpy(a)` |
 | call an existing NumPy-only kernel with GPU arrays (slow, correct) | `xp.kernels.PyccelKernel(fn, outputs=(...))` |
-| launch a hand-written CUDA C kernel | `xp.cuda.CudaKernel(source, "name")` / `CudaKernel.from_file(path)` |
+| launch a hand-written CUDA C kernel | `xp.kernels.CudaKernel(source, "name")` / `CudaKernel.from_file(path)` |
 | host kernel + CUDA port, chosen by backend | `xp.kernels.Kernel(host_fn, cuda_kernel_or_None)` |
 | many kernels in a package, ported incrementally | `xp.kernels.KernelCatalog.from_package(__name__, missing_cuda="fallback")` |
 | host kernels compiled at first call (your compile function), NumPy fallback | `from_package(..., host_suffix="_pyccel", compile_host=my_compile, host_fallback={...})` -> `xp.kernels.CompiledHostKernel` |
@@ -89,8 +89,8 @@ https://max-models.github.io/cunumpy/ and in `docs/source/` of the repository.
 | copy device arrays to the host for output without stalling | `xp.memory.HostStaging(shape, dtype)`: `c = staging.copy(a)` ... `c.result()` |
 | PIC recipes (compaction, sort by cell, MPI exchange, graphs) | docs guide "Particle codes" |
 | reproducible random numbers per MPI rank | `xp.rng.random_streams.seed(seed, rank=rank)`, then `xp.rng.random_streams.normal(...)` / `.generator()` |
-| group arrays/scalars into one kernel argument | `xp.cuda.CudaArguments` (device only), `xp.kernels.KernelArguments` (host object + device tuple), `xp.cuda.CudaStruct` (C struct), `xp.cuda.CudaStructArguments` (C struct as a class) |
-| CUDA struct from a Pyccel argument class | `xp.cuda.CudaStruct.from_signature(Cls.__init__, "Name")`, `xp.cuda.write_cuda_header(...)` |
+| group arrays/scalars into one kernel argument | `xp.arguments.CudaArguments` (flattened), `xp.arguments.CudaStruct` (C struct), `xp.arguments.CudaStructArguments` (C struct as a class); host kernels take their own argument objects, the caller picks one per backend |
+| CUDA struct from a Pyccel argument class | `xp.arguments.CudaStruct.from_signature(Cls.__init__, "Name")`, `xp.arguments.write_cuda_header(...)` |
 | SciPy (sparse, sparse.linalg, fft, special, ndimage, ...) on either backend | `xp.scipy.<subpackage>.<name>` (SciPy or `cupyx.scipy`); `xp.scipy.special.available(name)` |
 | chain of elementwise operations as one GPU kernel | `@xp.kernels.fuse` (`cupy.fuse` for CuPy arrays, plain call otherwise) |
 | PETSc solve on device arrays without copies | `xp.petsc.petsc_vec(array)` (CUDA/HIP petsc4py for CuPy arrays); `xp.synchronize()` around PETSc calls |
@@ -153,6 +153,7 @@ MPI = (
     xp.mpi.get_mpi()
 )  # mpi4py.MPI under mpirun/srun, else a serial stand-in (no MPI_Init)
 xp.mpi.launched_under_mpi()  # from the launcher env, without importing mpi4py
+xp.mpi.is_serial(MPI)  # True for the stand-in (re-exported from maybempi; MAYBEMPI=0/1)
 xp.mpi.mpi_is_cuda_aware(comm)  # collective, once at startup; remembered
 with xp.mpi.mpi_buffer(a) as buf:
     comm.Send(buf, ...)  # host array, CUDA-aware device
@@ -263,17 +264,17 @@ CuPy. Does not compile anything.
 `CudaKernel`:
 
 ```python
-k = xp.cuda.CudaKernel(source, name, *, block_size=128, options=(), include_dirs=(),
+k = xp.kernels.CudaKernel(source, name, *, block_size=128, options=(), include_dirs=(),
                   source_dir=None, structs=(), template_args=None,
                   check_signature=True, debug=None)
-k = xp.cuda.CudaKernel.from_file("push/push_cuda.cu")           # name "push"
-ks = xp.cuda.CudaKernel.all_from_file("ops.cu")                 # dict name -> kernel
+k = xp.kernels.CudaKernel.from_file("push/push_cuda.cu")           # name "push"
+ks = xp.kernels.CudaKernel.all_from_file("ops.cu")                 # dict name -> kernel
 k(*args, n_threads=None, grid=None, block=None, shared_mem=0, stream=None)
 k.compile(log_stream=None); k.recompile(log_stream=None)
 k.is_compiled  # successful compilation on the current CUDA device
 k.launch_shape(n_threads=None, *, grid=None, block=None, args=None) -> (grid, block)
 k.included_headers; k.compile_options(); k.debug_active()
-xp.cuda.CudaKernelVariants(factory).get(*key); .compile_all(keys, jobs=1)
+xp.kernels.CudaKernelVariants(factory).get(*key); .compile_all(keys, jobs=1)
 xp.cuda.ctype_of(np.float64) == "double"
 xp.cuda.cuda_kernel_names(source); xp.cuda.parse_cuda_signature(source, name)
 xp.cuda.cuda_include_dir()
@@ -339,20 +340,12 @@ function `<name>` (host); optional `pkg/<name>/<name>_cuda.cu` defines
 Argument objects:
 
 ```python
-class Dev(xp.cuda.CudaArguments):  # flattened into several CUDA params
+class Dev(xp.arguments.CudaArguments):  # flattened into several CUDA params
     def __init__(self, x, n):
         super().__init__(x, n)
 
 
-class Args(xp.kernels.KernelArguments):  # one object, host form + device form
-    def __host_args__(self):
-        return host_object  # host kernel gets this
-
-    def __cuda_args__(self):
-        return (arr, n, ...)  # CUDA kernel gets these, flattened
-
-
-S = xp.cuda.CudaStruct(
+S = xp.arguments.CudaStruct(
     "S", [("x", "double*"), ("n", "long long"), ("a", "Array2D<double>")]
 )
 S.declaration
@@ -360,12 +353,12 @@ S.dtype
 S.to_header(path)
 value = S(x=..., n=..., a=...)
 S.verify_layout()  # GPU test: compiler layout == S.dtype (also verify_layout("hdr.cuh"))
-S = xp.cuda.CudaStruct.from_signature(Cls.__init__, "S", int_type="long long")
-xp.cuda.write_cuda_header("args.cuh", [S1, S2])
+S = xp.arguments.CudaStruct.from_signature(Cls.__init__, "S", int_type="long long")
+xp.arguments.write_cuda_header("args.cuh", [S1, S2])
 
 
 class A(
-    xp.cuda.CudaStructArguments
+    xp.arguments.CudaStructArguments
 ):  # the struct as a class; A.struct is the CudaStruct
     struct_name = "A"
     fields = (("x", "double*"), ("n", "int"))
@@ -375,12 +368,14 @@ class A(
         self.pack()  # repacks itself when a field changes; copies repack
 
 
-xp.cuda.CudaKernel(S.declaration + src, "k", structs=[S])
-xp.kernels.resolve_host_args(args, kwargs)
+xp.kernels.CudaKernel(S.declaration + src, "k", structs=[S])
+
+# host kernels: a pyccel class and a CudaStructArguments with the same
+# constructor; the owner builds one per backend, cunumpy never converts them
+args = (CudaMarkerArguments if xp.is_gpu(markers) else MarkerArguments)(markers, n)
 ```
 
-Only top-level arguments are resolved. Cache both forms lazily and invalidate
-them when the underlying arrays are replaced. A packed struct holds device
+A packed struct holds device
 addresses: re-pack after replacing an array (a `CudaStructArguments` does this
 itself at the next launch; make its fields properties to follow an owner's arrays).
 
@@ -409,7 +404,7 @@ Debugging:
 
 ```python
 xp.cuda.set_cuda_debug(True); xp.cuda.get_cuda_debug(); with xp.cuda.cuda_debug(): ...
-xp.cuda.CudaKernel(..., debug=True)    # env: CUNUMPY_CUDA_DEBUG=1
+xp.kernels.CudaKernel(..., debug=True)    # env: CUNUMPY_CUDA_DEBUG=1
 ```
 
 Debug mode adds `-lineinfo -DCUNUMPY_BOUNDS_CHECK` at compile time and
@@ -443,12 +438,8 @@ def test_parity(kernel): check_parity(kernel)
 # without a GPU: CUNUMPY_FAKE_CUPY=1 CUNUMPY_BACKEND=cupy pytest   (fake CuPy: strict host
 # stand-in, no kernel launches; fake_cupy_active(); requires_cupy skips)
 
-# argument classes with a pyccel host class: one object on both backends
-class MarkerArguments(xp.kernels.PyccelStructArguments):
-    struct_name = "MarkerArgs"; fields = (("markers", "Array2D<double>"), ("Np", "long long"))
-    host_class = pusher_args_kernels.MarkerArguments    # pyccel class; cannot inherit
-    host_fields = ("markers", "Np")                      # its constructor args, in order
-MarkerArgs = xp.cuda.CudaStruct.from_pyccel_class("pusher_args_kernels.py", "MarkerArguments", "MarkerArgs")
+# struct fields from a pyccel argument class (contiguous=True or names -> CArray2D<T>)
+MarkerArgs = xp.arguments.CudaStruct.from_pyccel_class("pusher_args_kernels.py", "MarkerArguments", "MarkerArgs")
 kernel.n_threads_from = lambda args: args[0].n_markers   # launch size from an argument
 kernel.check_finite = True                               # NaN/inf after each launch (debug)
 ```
@@ -497,7 +488,7 @@ def scale_host(x: "float[:]", a: float, n: int):
 
 
 scale = xp.kernels.Kernel(
-    scale_host, xp.cuda.CudaKernel(SRC, "scale"), host_options={"outputs": (0,)}
+    scale_host, xp.kernels.CudaKernel(SRC, "scale"), host_options={"outputs": (0,)}
 )
 scale(x, 2.0, x.size, n_threads=x.size)
 ```

{cunumpy-0.5.0 → cunumpy-0.6.0}/src/cunumpy/__init__.py

@@ -1,9 +1,19 @@
 # cunumpy/__init__.py
 import re as _re
-import warnings as _warnings
 from importlib.metadata import PackageNotFoundError, version
 
-from cunumpy import algorithms, cuda, kernels, memory, mpi, petsc, profiling, rng, xp
+from cunumpy import (
+    algorithms,
+    arguments,
+    cuda,
+    kernels,
+    memory,
+    mpi,
+    petsc,
+    profiling,
+    rng,
+    xp,
+)
 from cunumpy._scipy_backend import scipy
 from cunumpy.xp import (
     as_device_array,
@@ -25,42 +35,6 @@ from cunumpy.xp import (
     use_backend,
 )
 
-# Names that were at the top level before cunumpy 0.5, and the submodule each
-# moved to. They still resolve (with a DeprecationWarning) until cunumpy 0.6.
-_MOVED = {
-    **dict.fromkeys(cuda.__all__, "cuda"),
-    **dict.fromkeys(
-        (
-            name
-            for name in kernels.__all__
-            if not name.endswith(
-                ("_host_kernel_implementation", "_device_kernel_implementation")
-            )
-            and name != "DEVICE_IMPLEMENTATIONS"
-        ),
-        "kernels",
-    ),
-    **dict.fromkeys(rng.__all__, "rng"),
-    **dict.fromkeys(algorithms.__all__, "algorithms"),
-    # the names of cunumpy.mpi that were at the top level (not the later ones)
-    **dict.fromkeys(
-        (
-            "get_mpi_cuda_aware",
-            "local_rank",
-            "mpi_buffer",
-            "mpi_is_cuda_aware",
-            "require_cuda_aware_mpi",
-            "set_mpi_cuda_aware",
-            "synchronize_for_mpi",
-        ),
-        "mpi",
-    ),
-    **dict.fromkeys(profiling.__all__, "profiling"),
-    **dict.fromkeys(memory.__all__, "memory"),
-    "petsc_vec": "petsc",
-}
-_MOVED.pop("BIT_GENERATORS")  # never was at the top level
-
 try:
     __version__ = version("cunumpy")
 except PackageNotFoundError:
@@ -97,6 +71,7 @@ def require_version(minimum: str) -> None:
 __all__ = [
     "__version__",
     "algorithms",
+    "arguments",
     "as_device_array",
     "assert_same_backend",
     "backend_info",
@@ -134,31 +109,19 @@ def __getattr__(name: str):
 
     The public names of the active backend are copied into this namespace (see
     `_sync_backend_namespace`), so this only runs for names missing from the
-    backend's ``__all__``, for ``numpy_backend``/``cupy_backend``, and for the
-    names moved to a submodule in cunumpy 0.5 (see ``_MOVED``), which still
-    resolve with a ``DeprecationWarning``.
+    backend's ``__all__`` and for ``numpy_backend``/``cupy_backend``.
     """
     if name == "numpy_backend":
         return xp.numpy_backend
     if name == "cupy_backend":
         return xp.cupy_backend
-    submodule = _MOVED.get(name)
-    if submodule is not None:
-        _warnings.warn(
-            f"cunumpy.{name} moved to cunumpy.{submodule}.{name}; the top-level "
-            "name is deprecated and will be removed in cunumpy 0.6",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return getattr(globals()[submodule], name)
     return getattr(xp.xp, name)
 
 
 # `xp.zeros` must be as fast as `numpy.zeros`. A module-level __getattr__ runs
 # only after the normal lookup failed, which costs about 3 us per access, so the
 # public names of the active backend module are copied into this namespace, and
-# replaced whenever the backend changes. cunumpy's own names and the deprecated
-# names of _MOVED (e.g. `fuse`, which CuPy also has) are never overwritten.
+# replaced whenever the backend changes. cunumpy's own names are never overwritten.
 _OWN_NAMES = frozenset(globals())
 _backend_names: dict[int, dict[str, object]] = {}  # id(module) -> names to copy
 _switches: dict[tuple[int, int], tuple[tuple[str, ...], dict[str, object]]] = {}
@@ -173,7 +136,6 @@ def _names_of(module) -> dict[str, object]:
             for name in getattr(module, "__all__", ())
             if not name.startswith("_")
             and name not in _OWN_NAMES
-            and name not in _MOVED
             and hasattr(module, name)
         }
         _backend_names[id(module)] = names

{cunumpy-0.5.0 → cunumpy-0.6.0}/src/cunumpy/__init__.pyi

@@ -9,6 +9,7 @@ import numpy as np
 from numpy import *
 
 from cunumpy import algorithms as algorithms
+from cunumpy import arguments as arguments
 from cunumpy import cuda as cuda
 from cunumpy import kernels as kernels
 from cunumpy import memory as memory