Remove module class wrapping and coverage tool (#1573)

Addresses issue
nv-legate/cupynumeric.internal#1572

Author: reazulhoque

cupynumeric/__init__.py

@@ -25,22 +25,54 @@
 
 from __future__ import annotations
 
-import numpy as _np
 
-from . import linalg, random, fft, ma  # noqa: F401
+from . import linalg, random, fft  # noqa: F401
 from ._array.array import ndarray  # noqa: F401
-from ._array.util import maybe_convert_to_np_ndarray
 from ._dlpack import from_dlpack  # noqa: F401
 from ._module import *  # noqa: F403
 from ._ufunc import *  # noqa: F403
 from ._utils.array import is_supported_dtype, local_task_array  # noqa: F401
-from ._utils.coverage import clone_module
 
-clone_module(_np, globals(), maybe_convert_to_np_ndarray)
-
-del maybe_convert_to_np_ndarray
-del clone_module
-del _np
+# ============================================================
+# NumPy dtypes and constants
+# These were previously copied by clone_module(), now explicit
+# ============================================================
+
+from numpy import (
+    # Commonly used dtypes
+    bool_,  # noqa: F401
+    int8,  # noqa: F401
+    int16,  # noqa: F401
+    int32,  # noqa: F401
+    int64,  # noqa: F401
+    uint8,  # noqa: F401
+    uint16,  # noqa: F401
+    uint32,  # noqa: F401
+    uint64,  # noqa: F401
+    float16,  # noqa: F401
+    float32,  # noqa: F401
+    float64,  # noqa: F401
+    complex64,  # noqa: F401
+    complex128,  # noqa: F401
+    # Type hierarchy (abstract base classes)
+    integer,  # noqa: F401
+    signedinteger,  # noqa: F401
+    unsignedinteger,  # noqa: F401
+    inexact,  # noqa: F401
+    floating,  # noqa: F401
+    complexfloating,  # noqa: F401
+    # Commonly used constants
+    pi,  # noqa: F401
+    e,  # noqa: F401
+    inf,  # noqa: F401
+    nan,  # noqa: F401
+    newaxis,  # noqa: F401
+    # Dtype class
+    dtype,  # noqa: F401
+    # Info functions
+    iinfo,  # noqa: F401
+    finfo,  # noqa: F401
+)
 
 
 def _fixup_version() -> str:

cupynumeric/_array/array.py

@@ -27,7 +27,6 @@
 
 from .. import _ufunc
 from .._utils.array import max_identity, min_identity, to_core_type
-from .._utils.coverage import clone_class, is_implemented
 from .._utils.linalg import dot_modes
 from ..config import (
     FFTDirection,
@@ -49,7 +48,6 @@
     broadcast_where,
     check_writeable,
     convert_to_cupynumeric_ndarray,
-    maybe_convert_to_np_ndarray,
     sanitize_shape,
 )
 
@@ -89,21 +87,6 @@
 
 from math import prod
 
-NDARRAY_INTERNAL = {
-    "__array_finalize__",
-    "__array_function__",
-    "__array_interface__",
-    "__array_prepare__",
-    "__array_priority__",
-    "__array_struct__",
-    "__array_ufunc__",
-    "__array_wrap__",
-    # Avoid auto-wrapping Array API specifics:
-    "__array_namespace__",
-    "device",
-    "to_device",
-}
-
 
 def _warn_and_convert(array: ndarray, dtype: np.dtype[Any]) -> ndarray:
     if array.dtype != dtype:
@@ -115,7 +98,6 @@ def _warn_and_convert(array: ndarray, dtype: np.dtype[Any]) -> ndarray:
         return array
 
 
-@clone_class(np.ndarray, NDARRAY_INTERNAL, maybe_convert_to_np_ndarray)
 class ndarray:
     _thunk: NumPyThunk
     _legate_data: dict[str, Any] | None
@@ -312,8 +294,6 @@ def __array_function__(
     ) -> Any:
         import cupynumeric as cn
 
-        what = func.__name__
-
         for t in types:
             # Be strict about which types we support.  Accept superclasses
             # (for basic subclassing support) and NumPy.
@@ -323,29 +303,13 @@ def __array_function__(
         # We are wrapping all NumPy modules, so we can expect to find the implemented
         # NumPy API call in cuPyNumeric.
         module = reduce(getattr, func.__module__.split(".")[1:], cn)
-        cn_func = getattr(module, func.__name__)
-
-        # We can't immediately forward to the corresponding cuPyNumeric
-        # entrypoint. Say that we reached this point because the user code
-        # invoked `np.foo(x, bar=True)` where `x` is a `cupynumeric.ndarray`.
-        # If our implementation of `foo` is not complete, and cannot handle
-        # `bar=True`, then forwarding this call to `cn.foo` would fail. This
-        # goes against the semantics of `__array_function__`, which shouldn't
-        # fail if the custom implementation cannot handle the provided
-        # arguments. Conversely, if the user calls `cn.foo(x, bar=True)`
-        # directly, that means they requested the cuPyNumeric implementation
-        # specifically, and the `NotImplementedError` should not be hidden.
-        if is_implemented(cn_func):
-            try:
-                return cn_func(*args, **kwargs)
-            except NotImplementedError:
-                # Inform the user that we support the requested API in general,
-                # but not this specific combination of arguments.
-                what = f"the requested combination of arguments to {what}"
-
-        # We cannot handle this call - raise an error instead of falling back
+        cn_func = getattr(module, func.__name__, None)
+
+        if cn_func is not None:
+            return cn_func(*args, **kwargs)
+
         raise NotImplementedError(
-            f"cuPyNumeric has not implemented {what}. "
+            f"cuPyNumeric has not implemented {func.__name__}. "
             f"This function is not available."
         )
 

cupynumeric/_array/util.py

@@ -230,10 +230,9 @@ def maybe_convert_to_np_ndarray(obj: Any) -> Any:
     """
     Converts cuPyNumeric arrays into NumPy arrays, otherwise has no effect.
     """
-    from ..ma import MaskedArray
     from .array import ndarray
 
-    if isinstance(obj, (ndarray, MaskedArray)):
+    if isinstance(obj, ndarray):
         return obj.__array__()
     return obj
 

cupynumeric/_module/indexing.py

@@ -26,9 +26,7 @@
 )
 from .._module.array_dimension import broadcast_arrays, broadcast_to
 from .._utils.array import calculate_volume
-from .._utils.coverage import is_implemented
 from ..lib.array_utils import normalize_axis_index
-from ..runtime import runtime
 from ..types import NdShape
 from .array_joining import hstack
 from .array_shape import reshape
@@ -232,12 +230,6 @@ def mask_indices(
     """
     # this implementation is based on the Cupy
     a = ones((n, n), dtype=bool)
-    if not is_implemented(mask_func):
-        runtime.warn(
-            "Calling non-cuPyNumeric functions in mask_func can result in bad "
-            "performance",
-            category=UserWarning,
-        )
     return mask_func(a, k).nonzero()
 
 

cupynumeric/_sphinxext/_comparison_util.py

@@ -18,13 +18,8 @@
 from types import ModuleType
 from typing import TYPE_CHECKING, Any, Iterable, Iterator
 
-from .._utils.coverage import (
-    GPUSupport,
-    is_implemented,
-    is_multi,
-    is_single,
-    is_wrapped,
-)
+from ._gpu_support import parse_gpu_support_from_docstring, GPUSupport
+
 from ._comparison_config import MISSING_NP_REFS, SKIP
 
 if TYPE_CHECKING:
@@ -95,8 +90,8 @@ def filter_wrapped_names(
 ) -> Iterator[str]:
     names = (n for n in dir(obj))  # every name in the module or class
     names = (
-        n for n in names if is_wrapped(getattr(obj, n))
-    )  # that is wrapped
+        n for n in names if callable(getattr(obj, n, None))
+    )  # Exists and is callable
     names = (n for n in names if n not in skip)  # except the ones we skip
     names = (n for n in names if not n.startswith("_"))  # or any private names
     return names
@@ -113,17 +108,17 @@ def filter_type_names(obj: Any, *, skip: Iterable[str] = ()) -> Iterator[str]:
 
 
 def get_item(name: str, np_obj: Any, lg_obj: Any) -> ItemDetail:
-    lg_attr = getattr(lg_obj, name, None)
-
-    # If attribute doesn't exist in cuPyNumeric, mark as not implemented
-    if lg_attr is None:
-        implemented = False
-        single = multi = ""
-    elif implemented := is_implemented(lg_attr):
-        single = _support_symbol(is_single(lg_attr))
-        multi = _support_symbol(is_multi(lg_attr))
+    if (lg_attr := getattr(lg_obj, name, None)) is not None:
+        # Parse docstring at build time
+        single_support, multi_support = parse_gpu_support_from_docstring(
+            lg_attr
+        )
+        single = single_support.value
+        multi = multi_support.value
+        implemented = True
     else:
         single = multi = ""
+        implemented = False
 
     return ItemDetail(
         name=name,

cupynumeric/_sphinxext/_gpu_support.py

@@ -0,0 +1,67 @@
+# Copyright 2026 NVIDIA Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+
+
+class GPUSupport(Enum):
+    YES = 1
+    NO = 2
+    PARTIAL = 3
+
+
+def parse_gpu_support_from_docstring(
+    obj: Any,
+) -> tuple[GPUSupport, GPUSupport]:
+    """
+    Extract GPU support from function docstring.
+
+    Looks for these patterns in the docstring:
+    - "Single GPU" -> single_gpu = YES
+    - "Multiple GPUs" -> multi_gpu = YES
+    - "Multiple GPUs (partial)" -> multi_gpu = PARTIAL
+
+    Parameters
+    ----------
+    obj : Any
+            Function or method object
+
+    Returns
+    -------
+    single_gpu : GPUSupport
+            Single GPU support level
+    multi_gpu : GPUSupport
+            Multi GPU support level
+    """
+    doc = getattr(obj, "__doc__", None) or ""
+
+    # Parse multi-GPU support
+    if "Multiple GPUs (partial)" in doc:
+        multi = GPUSupport.PARTIAL
+    elif "Multiple GPUs" in doc:
+        multi = GPUSupport.YES
+    else:
+        multi = GPUSupport.NO
+
+    # Parse single-GPU support
+    if "Single GPU" in doc:
+        single = GPUSupport.YES
+    else:
+        # If multi-GPU works, single-GPU definitely works
+        single = multi if multi != GPUSupport.NO else GPUSupport.NO
+
+    return single, multi

cupynumeric/_sphinxext/implemented_index.py

@@ -22,18 +22,15 @@
 
 import cupynumeric as cn
 
-from .._utils.coverage import is_implemented
 from . import PARALLEL_SAFE, SphinxParallelSpec
 from ._cupynumeric_directive import CupynumericDirective
 
 log = getLogger(__name__)
 
 
 def _filter(x: Any) -> bool:
-    return (
-        callable(x)
-        and is_implemented(x)
-        and (x.__name__.startswith("__") or not x.__name__.startswith("_"))
+    return callable(x) and (
+        x.__name__.startswith("__") or not x.__name__.startswith("_")
     )