fix(test): unblock root pixi run test workflow (#1978)

* fix(test): unblock root pixi run test workflow

`pixi run test` failed at the cuda_bindings build stage because list-form
pixi `cmd` arrays didn't expand `$PIXI_ENVIRONMENT_NAME` reliably, so the
inner per-package `pixi run` calls picked the cuda_bindings default
environment (no cuda-version pin). The conda solver then resolved
cuda-version=12.9 and the build failed with a missing `CUatomicOperation_enum`
(a CUDA-13.x-only symbol).

Wrap the three test-* tasks in `bash -c '...'` so the shell expands
`$PIXI_ENVIRONMENT_NAME` and forward it explicitly via `-e` to each inner
pixi run.

Once the bindings build was unblocked, cuda_core's cython test build hit a
second issue: `cythonize` cannot resolve `cimport cuda.bindings.*` against
pixi-build's editable install, which exposes the cuda namespace package via a
finder hook that Cython's filesystem .pxd resolver does not consult. Replace
the `cythonize` CLI invocation with a small Python wrapper that calls
`Cython.Build.cythonize()` with an explicit `include_path` resolved from the
imported `cuda.bindings` package.

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

* fix(test): satisfy ruff isort grouping in build_tests.py

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

* fix(test): replace cython build wrapper with PYTHONPATH shim

Drop cuda_core/tests/cython/build_tests.py in favor of a small PYTHONPATH
shim in build_tests.sh. Same outcome (Cython's .pxd resolver finds
cuda.bindings via the package's parent directory), three lines instead of
a separate setuptools entry point.

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

* 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>

* style: ruff isort grouping and format in build_tests.py

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

---------

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
+
+from Cython.Build import cythonize
+from setuptools import setup
+
+import cuda.bindings
+
+
+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
+
+from Cython.Build import cythonize
+from setuptools import setup
+
+import cuda.bindings
+
+
+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,18 +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
 
-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,30 +18,40 @@ 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 -e environment propagates via PIXI_ENVIRONMENT_NAME
+# 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]
 cmd = [
-    "pixi",
-    "run",
-    "--manifest-path",
-    "$PIXI_PROJECT_ROOT/cuda_pathfinder",
-    "test",
+    "bash",
+    "-c",
+    'pixi run --manifest-path "$PIXI_PROJECT_ROOT/cuda_pathfinder" -e "$PIXI_ENVIRONMENT_NAME" test',
 ]
 
 [target.linux.tasks.test-bindings]
 cmd = [
-    "pixi",
-    "run",
-    "--manifest-path",
-    "$PIXI_PROJECT_ROOT/cuda_bindings",
-    "test",
+    "bash",
+    "-c",
+    'pixi run --manifest-path "$PIXI_PROJECT_ROOT/cuda_bindings" -e "$PIXI_ENVIRONMENT_NAME" test',
 ]
 
 [target.linux.tasks.test-core]
-cmd = ["pixi", "run", "--manifest-path", "$PIXI_PROJECT_ROOT/cuda_core", "test"]
+cmd = [
+    "bash",
+    "-c",
+    'pixi run --manifest-path "$PIXI_PROJECT_ROOT/cuda_core" -e "$PIXI_ENVIRONMENT_NAME" test',
+]
 
 [target.linux.tasks.test]
 depends-on = [