fix(test): use Cython include_path wrapper for editable installs

Replace the PYTHONPATH shim in cuda_core/tests/cython/build_tests.sh
with a small Python driver (build_tests.py) that calls
Cython.Build.cythonize() with an explicit include_path resolved at
runtime from cuda.bindings.__file__. Avoids platform-specific
PYTHONPATH separator handling and surfaces missing-import failures
as Python exceptions instead of silent fallbacks.

Apply the same wrapper pattern to cuda_bindings/tests/cython/ for
symmetry; both shell scripts gain `set -eo pipefail` and `${VAR:-}`
defaults so the previously optional CPLUS_INCLUDE_PATH / CL env vars
keep working under stricter error mode.

Expand the pixi.toml comment block to document why each test-* task
is wrapped in `bash -c '...'` and note Linux-only scope.

Verified end-to-end: `pixi run test` passes 4,314 tests
(974 pathfinder + 384 bindings + 2,956 core), 208 skipped, 2 xfailed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: rparolin

cuda_bindings/tests/cython/build_tests.py

@@ -0,0 +1,53 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+"""Build cuda_bindings Cython test extensions in-place.
+
+pixi-build's editable install exposes the `cuda` namespace package via a
+PEP 660 finder hook. Python's import machinery honors the hook, but
+Cython's filesystem .pxd resolver only walks real directories on sys.path,
+so `cimport cuda.bindings.*` fails to locate the .pxd files. We resolve
+the namespace package's source root from `cuda.bindings.__file__` and pass
+it via `include_path=` so cythonize finds the .pxd tree on every platform.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import cuda.bindings
+from Cython.Build import cythonize
+from setuptools import setup
+
+
+def _bindings_source_root() -> Path:
+    # cuda.bindings.__file__ -> .../<root>/cuda/bindings/__init__.py
+    root = Path(cuda.bindings.__file__).resolve().parents[2]
+    if not (root / "cuda" / "bindings").is_dir():
+        raise RuntimeError(
+            f"cuda.bindings source tree not found at {root}; "
+            "pixi-build editable install layout may have changed."
+        )
+    return root
+
+
+def main() -> None:
+    script_dir = Path(__file__).resolve().parent
+    pyx_files = sorted(str(p) for p in script_dir.glob("test_*.pyx"))
+    if not pyx_files:
+        raise SystemExit(f"no test_*.pyx files under {script_dir}")
+
+    ext_modules = cythonize(
+        pyx_files,
+        language_level=3,
+        nthreads=1,
+        include_path=[str(_bindings_source_root())],
+        compiler_directives={"freethreading_compatible": True},
+    )
+
+    sys.argv = [sys.argv[0], "build_ext", "--inplace"]
+    setup(name="cuda_bindings_cython_tests", ext_modules=ext_modules)
+
+
+if __name__ == "__main__":
+    main()

cuda_bindings/tests/cython/build_tests.sh

@@ -1,18 +1,23 @@
 #!/bin/bash
+set -eo pipefail
 
 # SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
 
 UNAME=$(uname)
 if [ "$UNAME" == "Linux" ] ; then
   SCRIPTPATH=$(dirname $(realpath "$0"))
-  export CPLUS_INCLUDE_PATH=$CUDA_HOME/include:$CPLUS_INCLUDE_PATH
+  export CPLUS_INCLUDE_PATH=$CUDA_HOME/include:${CPLUS_INCLUDE_PATH:-}
 elif [[ "$UNAME" == CYGWIN* || "$UNAME" == MINGW* || "$UNAME" == MSYS* ]] ; then
   SCRIPTPATH="$(dirname $(cygpath -w $(realpath "$0")))"
-  export CL="/I\"${CUDA_HOME}\\include\" ${CL}"
+  export CL="/I\"${CUDA_HOME}\\include\" ${CL:-}"
 else
   exit 1
 fi
 
-# Use -j 1 to side-step any process-pool issues and ensure deterministic single-threaded builds
-cythonize -3 -j 1 -i -Xfreethreading_compatible=True ${SCRIPTPATH}/test_*.pyx
+# Use a Python driver so the cuda.bindings source root is resolved at
+# runtime and passed via Cython's include_path -- avoids platform-specific
+# PYTHONPATH separator handling and surfaces import errors as exceptions.
+# nthreads=1 inside the driver mirrors the previous `-j 1` to side-step
+# any process-pool issues and keep builds deterministic.
+python "${SCRIPTPATH}/build_tests.py"

cuda_core/tests/cython/build_tests.py

@@ -0,0 +1,52 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Build cuda_core Cython test extensions in-place.
+
+pixi-build's editable install exposes the `cuda` namespace package via a
+PEP 660 finder hook. Python's import machinery honors the hook, but
+Cython's filesystem .pxd resolver only walks real directories on sys.path,
+so `cimport cuda.bindings.*` fails to locate the .pxd files. We resolve
+the namespace package's source root from `cuda.bindings.__file__` and pass
+it via `include_path=` so cythonize finds the .pxd tree on every platform.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import cuda.bindings
+from Cython.Build import cythonize
+from setuptools import setup
+
+
+def _bindings_source_root() -> Path:
+    # cuda.bindings.__file__ -> .../<root>/cuda/bindings/__init__.py
+    root = Path(cuda.bindings.__file__).resolve().parents[2]
+    if not (root / "cuda" / "bindings").is_dir():
+        raise RuntimeError(
+            f"cuda.bindings source tree not found at {root}; "
+            "pixi-build editable install layout may have changed."
+        )
+    return root
+
+
+def main() -> None:
+    script_dir = Path(__file__).resolve().parent
+    pyx_files = sorted(str(p) for p in script_dir.glob("test_*.pyx"))
+    if not pyx_files:
+        raise SystemExit(f"no test_*.pyx files under {script_dir}")
+
+    ext_modules = cythonize(
+        pyx_files,
+        language_level=3,
+        include_path=[str(_bindings_source_root())],
+        compiler_directives={"freethreading_compatible": True},
+    )
+
+    sys.argv = [sys.argv[0], "build_ext", "--inplace"]
+    setup(name="cuda_core_cython_tests", ext_modules=ext_modules)
+
+
+if __name__ == "__main__":
+    main()

cuda_core/tests/cython/build_tests.sh

@@ -1,25 +1,22 @@
 #!/bin/bash
+set -eo pipefail
 
 # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
 UNAME=$(uname)
 if [ "$UNAME" == "Linux" ] ; then
   SCRIPTPATH=$(dirname $(realpath "$0"))
-  export CPLUS_INCLUDE_PATH=${SCRIPTPATH}/../../cuda/core/_include:$CUDA_HOME/include:$CPLUS_INCLUDE_PATH
+  export CPLUS_INCLUDE_PATH=${SCRIPTPATH}/../../cuda/core/_include:$CUDA_HOME/include:${CPLUS_INCLUDE_PATH:-}
 elif [[ "$UNAME" == CYGWIN* || "$UNAME" == MINGW* || "$UNAME" == MSYS* ]] ; then
   SCRIPTPATH="$(dirname $(cygpath -w $(realpath "$0")))"
   CUDA_CORE_INCLUDE_PATH=$(echo "${SCRIPTPATH}\..\..\cuda\core\_include" | sed 's/\\/\\\\/g')
-  export CL="/I\"${CUDA_CORE_INCLUDE_PATH}\" /I\"${CUDA_HOME}\\include\" ${CL}"
+  export CL="/I\"${CUDA_CORE_INCLUDE_PATH}\" /I\"${CUDA_HOME}\\include\" ${CL:-}"
 else
   exit 1
 fi
 
-# pixi-build's editable install exposes the cuda namespace package via a
-# finder hook that Cython's filesystem .pxd resolver does not consult.
-# Surface the package's parent directory on PYTHONPATH so `cimport
-# cuda.bindings.*` can locate the .pxd files.
-CUDA_PKG_PARENT=$(python -c "import cuda.bindings as m, os; print(os.path.dirname(os.path.dirname(os.path.dirname(m.__file__))))")
-export PYTHONPATH="${CUDA_PKG_PARENT}${PYTHONPATH:+:${PYTHONPATH}}"
-
-cythonize -3 -i -Xfreethreading_compatible=True ${SCRIPTPATH}/test_*.pyx
+# Use a Python driver so the cuda.bindings source root is resolved at
+# runtime and passed via Cython's include_path -- avoids platform-specific
+# PYTHONPATH separator handling and surfaces import errors as exceptions.
+python "${SCRIPTPATH}/build_tests.py"

pixi.toml

@@ -18,9 +18,18 @@ docs = { features = [], solve-group = "docs" }
 PIXI_ENVIRONMENT_NAME = "${PIXI_ENVIRONMENT_NAME/default/cu13}"
 
 # Test Tasks
-# Runs tests across all sub-packages: pathfinder → bindings → core (dependency order)
-# Each sub-package has its own pixi.toml; the active environment is forwarded
-# explicitly via -e "$PIXI_ENVIRONMENT_NAME" in each inner pixi run.
+# Runs tests across all sub-packages: pathfinder → bindings → core (dependency order).
+#
+# Each sub-package has its own pixi.toml. We wrap each task in `bash -c '...'`
+# (single-quoted in TOML, double-quoted inside) because pixi `cmd` arrays do
+# not expand shell variables -- without this, the inner `pixi run` would drop
+# into the sub-package's `default` environment, which lacks a cuda-version
+# pin, causing the conda solver to pick a mismatched CUDA toolkit. Forwarding
+# `-e "$PIXI_ENVIRONMENT_NAME"` keeps the active environment consistent end
+# to end.
+#
+# Linux-only for now; Windows/macOS root test-task parity is tracked
+# separately.
 #
 # Usage: pixi run test | pixi run -e cu12 test | pixi run -e cu13 test
 [target.linux.tasks.test-pathfinder]