cuda.core: import cuda.bindings for the build check through the #1824 namespace repair (#2783)

The build-configuration check imported cuda.bindings directly. In an
isolated PEP 517 build with an in-tree backend (the wheel-from-sdist CI
job), the project's own cuda/ directory is the whole `cuda` namespace,
so the cuda-bindings pip installed into the build environment is not
importable (#1824) and the check failed with "requires cuda-bindings to
build". Import it the way _import_get_cuda_path_or_home() imports
cuda.pathfinder: add the site-packages cuda/ directory to the namespace
path when the plain import fails. The pxd-path block uses the same
helper. Package metadata is not a substitute: pip's in-process hook
runner forwards find_distributions without the requested name, so it
returns this project's own metadata for `cuda-bindings`.

test_managed_ops.py asserted the old wording of the NUMA-host message
("cuda-bindings 13.0+"), which now names the CUDA 13 build; the four
regexes follow.

Author: Andy-Jost

cuda_core/build_hooks.py

@@ -66,6 +66,37 @@ def _import_get_cuda_path_or_home():
     return cuda.pathfinder.get_cuda_path_or_home
 
 
+def _import_cuda_bindings():
+    """Import cuda.bindings, working around PEP 517 namespace shadowing.
+
+    Same problem and same repair as _import_get_cuda_path_or_home() (see
+    https://github.com/NVIDIA/cuda-python/issues/1824): in an isolated build the
+    project's own ``cuda/`` directory is the whole ``cuda`` namespace, so the
+    cuda-bindings pip installed into the build environment is not importable
+    until its ``cuda/`` directory is added to the namespace path. Raises
+    ModuleNotFoundError when no cuda-bindings is installed at all.
+    (importlib.metadata is no alternative: pip's in-process hook runner forwards
+    ``find_distributions`` without the requested name, so it reports this
+    project's own metadata for any name.)
+    """
+    try:
+        import cuda.bindings
+    except ModuleNotFoundError as exc:
+        if exc.name not in ("cuda", "cuda.bindings"):
+            raise
+        import cuda
+
+        for p in sys.path:
+            sp_cuda = Path(p) / "cuda"
+            if (sp_cuda / "bindings").is_dir():
+                cuda.__path__ = list(cuda.__path__) + [str(sp_cuda)]
+                break
+        else:
+            raise
+        import cuda.bindings
+    return cuda.bindings
+
+
 @functools.cache
 def _get_cuda_path() -> str:
     get_cuda_path_or_home = _import_get_cuda_path_or_home()
@@ -178,13 +209,12 @@ def _check_build_configuration(cuda_path: str, cuda_major: str) -> None:
     requirement = floor.pip_requirement(major)
 
     try:
-        bindings_module = importlib.import_module("cuda.bindings")
-    except ImportError as exc:
+        bindings_version = _import_cuda_bindings().__version__
+    except ModuleNotFoundError as exc:
         raise RuntimeError(
             f"cuda.core requires cuda-bindings to build (install '{requirement}'). "
             "Isolated builds install it automatically; other builds must provide it."
         ) from exc
-    bindings_version = bindings_module.__version__
     bindings = floor.release_triple(bindings_version)
     if bindings is None:
         raise RuntimeError(
@@ -360,10 +390,10 @@ def _build_cuda_core(debug=False):
     # We need to add the directory containing the 'cuda' package so Cython can resolve
     # "from cuda.bindings cimport cydriver"
     try:
-        import cuda.bindings
+        cuda_bindings = _import_cuda_bindings()
 
-        bindings_path = Path(cuda.bindings.__file__).parent  # .../cuda/bindings/
-        print(f"Using cuda-bindings {cuda.bindings.__version__} from {bindings_path}", file=sys.stderr)
+        bindings_path = Path(cuda_bindings.__file__).parent  # .../cuda/bindings/
+        print(f"Using cuda-bindings {cuda_bindings.__version__} from {bindings_path}", file=sys.stderr)
         cuda_package_dir = bindings_path.parent.parent  # .../cuda_bindings/ (contains cuda/)
         if str(cuda_package_dir) not in sys.path:
             sys.path.insert(0, str(cuda_package_dir))

cuda_core/tests/memory/test_managed_ops.py

@@ -465,7 +465,7 @@ def test_accessed_by_set_assignment_validates_kind_before_mutation(
 
         with pytest.raises(
             (ValueError, TypeError),
-            match=r"does not support location_type='host_numa'|cuda-bindings 13\.0\+",
+            match=r"does not support location_type='host_numa'|CUDA 13 build of cuda\.core",
         ):
             buf.accessed_by = {device, Host(numa_id=0)}
 
@@ -517,7 +517,7 @@ def test_operation_validation(self, managed_buffer):
         # rejected at the boundary first (TypeError).
         with pytest.raises(
             (ValueError, TypeError),
-            match=r"does not support location_type='host_numa'|cuda-bindings 13\.0\+",
+            match=r"does not support location_type='host_numa'|CUDA 13 build of cuda\.core",
         ):
             buf.accessed_by.add(Host(numa_id=_INVALID_HOST_DEVICE_ORDINAL))
 
@@ -536,13 +536,13 @@ def test_advise_location_validation(self, location_ops_device, external_managed_
         # accessed_by rejects host_numa (CUDA 13: kind check; CUDA 12: boundary)
         with pytest.raises(
             (ValueError, TypeError),
-            match=r"does not support location_type='host_numa'|cuda-bindings 13\.0\+",
+            match=r"does not support location_type='host_numa'|CUDA 13 build of cuda\.core",
         ):
             buf.accessed_by.add(Host(numa_id=0))
 
         # accessed_by rejects host_numa_current (same reasoning)
         with pytest.raises(
             (ValueError, TypeError),
-            match=r"does not support location_type='host_numa_current'|cuda-bindings 13\.0\+",
+            match=r"does not support location_type='host_numa_current'|CUDA 13 build of cuda\.core",
         ):
             buf.accessed_by.add(Host.numa_current())

cuda_core/tests/test_build_hooks.py

@@ -457,12 +457,17 @@ def test_serial_builds_and_compilers_without_the_hook_keep_the_stock_path(self,
 
 
 def _fake_bindings(monkeypatch, version):
-    """Install a stand-in cuda.bindings whose __version__ is `version`."""
+    """Make the build see an installed cuda-bindings of `version` (None: not installed)."""
     import types
 
-    module = types.ModuleType("cuda.bindings")
-    module.__version__ = version
-    monkeypatch.setitem(sys.modules, "cuda.bindings", module)
+    def import_cuda_bindings():
+        if version is None:
+            raise ModuleNotFoundError("No module named 'cuda.bindings'", name="cuda.bindings")
+        module = types.ModuleType("cuda.bindings")
+        module.__version__ = version
+        return module
+
+    monkeypatch.setattr(build_hooks, "_import_cuda_bindings", import_cuda_bindings)
 
 
 def _write_cuda_h(tmp_path, cuda_version):
@@ -539,7 +544,7 @@ def test_header_is_read_even_when_the_major_override_is_set(self, tmp_path, monk
 
     @pytest.mark.agent_authored(model="claude-fable-5-1")
     def test_missing_bindings_is_a_build_error(self, tmp_path, monkeypatch):
-        monkeypatch.setitem(sys.modules, "cuda.bindings", None)  # makes `import cuda.bindings` fail
+        _fake_bindings(monkeypatch, None)  # no cuda-bindings in the build environment
         cuda_path = _write_cuda_h(tmp_path, 13040)
         with pytest.raises(RuntimeError, match="requires cuda-bindings to build"):
             build_hooks._check_build_configuration(cuda_path, "13")