Split into get_user_mode_driver_version and get_kernel_mode_driver_version

Per review feedback, split the consolidated get_driver_version() into
two separate functions so each returns a simple tuple[int, ...]:

- get_user_mode_driver_version(): works with or without NVML (falls
  back to cuDriverGetVersion), returns (major, minor)
- get_kernel_mode_driver_version(): requires NVML, returns
  (major, minor, patch) or (major, minor) on WSL

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

Author: leofang

cuda_core/cuda/core/system/__init__.py

@@ -11,7 +11,8 @@
 
 __all__ = [
     "CUDA_BINDINGS_NVML_IS_COMPATIBLE",
-    "get_driver_version",
+    "get_kernel_mode_driver_version",
+    "get_user_mode_driver_version",
     "get_num_devices",
     "get_process_name",
 ]

cuda_core/cuda/core/system/_system.pyx

@@ -26,41 +26,52 @@ if CUDA_BINDINGS_NVML_IS_COMPATIBLE:
 
     from cuda.core.system._nvml_context import initialize
 else:
-    from cuda.core._utils.cuda_utils import handle_return, runtime
+    from cuda.core._utils.cuda_utils import driver, handle_return, runtime
 
 
-def get_driver_version() -> tuple[tuple[int, ...], tuple[int, ...]]:
+def get_user_mode_driver_version() -> tuple[int, ...]:
     """
-    Get the driver version.
+    Get the user-mode (UMD / CUDA) driver version.
 
-    Returns both the user-mode (UMD / CUDA) driver version and the
-    kernel-mode (KMD / GPU) driver version.
+    This is the most commonly needed version when checking CUDA driver
+    compatibility.  It works with all ``cuda-bindings`` versions: when
+    NVML is available it uses NVML, otherwise it falls back to the
+    CUDA driver API.
 
     Returns
     -------
-    version : tuple[tuple[int, ...], tuple[int, ...]]
-        ``(umd_version, kmd_version)`` where ``umd_version`` is typically
-        a 2-tuple ``(MAJOR, MINOR)`` and ``kmd_version`` is typically
-        a 3-tuple ``(MAJOR, MINOR, PATCH)`` (2-tuple on WSL).
+    version : tuple[int, ...]
+        A 2-tuple ``(MAJOR, MINOR)``.
+    """
+    cdef int v
+    if CUDA_BINDINGS_NVML_IS_COMPATIBLE:
+        initialize()
+        v = nvml.system_get_cuda_driver_version()
+    else:
+        v = handle_return(driver.cuDriverGetVersion())
+    return (v // 1000, (v // 10) % 100)
+
+
+def get_kernel_mode_driver_version() -> tuple[int, ...]:
+    """
+    Get the kernel-mode (KMD / GPU) driver version.
+
+    Returns
+    -------
+    version : tuple[int, ...]
+        Typically a 3-tuple ``(MAJOR, MINOR, PATCH)`` (2-tuple on WSL).
 
     Raises
     ------
     RuntimeError
         If the NVML library is not available.
     """
     if not CUDA_BINDINGS_NVML_IS_COMPATIBLE:
-        raise RuntimeError("get_driver_version requires NVML support")
+        raise RuntimeError(
+            "get_kernel_mode_driver_version requires NVML support"
+        )
     initialize()
-
-    # UMD (user-mode / CUDA toolkit) version
-    cdef int v
-    v = nvml.system_get_cuda_driver_version()
-    umd = (v // 1000, (v // 10) % 100)
-
-    # KMD (kernel-mode / GPU driver) version
-    kmd = tuple(int(x) for x in nvml.system_get_driver_version().split("."))
-
-    return (umd, kmd)
+    return tuple(int(x) for x in nvml.system_get_driver_version().split("."))
 
 
 def get_nvml_version() -> tuple[int, ...]:
@@ -123,7 +134,8 @@ def get_process_name(pid: int) -> str:
 
 __all__ = [
     "get_driver_branch",
-    "get_driver_version",
+    "get_kernel_mode_driver_version",
+    "get_user_mode_driver_version",
     "get_nvml_version",
     "get_num_devices",
     "get_process_name",

cuda_core/docs/source/api.rst

@@ -254,7 +254,8 @@ Basic functions
 .. autosummary::
    :toctree: generated/
 
-   system.get_driver_version
+   system.get_user_mode_driver_version
+   system.get_kernel_mode_driver_version
    system.get_driver_branch
    system.get_num_devices
    system.get_nvml_version

cuda_core/docs/source/release/1.0.0-notes.rst

@@ -152,13 +152,11 @@ Breaking changes
   :mod:`cuda.core.utils` module.
   (`#2028 <https://github.com/NVIDIA/cuda-python/issues/2028>`__)
 
-- Consolidated ``system.get_driver_version()`` and
-  ``system.get_driver_version_full()`` into a single
-  :func:`system.get_driver_version` that returns
-  ``(umd_version, kmd_version)`` — a 2-tuple of version tuples
-  (UMD is ``(MAJOR, MINOR)``, KMD is ``(MAJOR, MINOR, PATCH)``).
-  The function now requires NVML support and raises :class:`RuntimeError`
-  if it is not available.
+- Replaced ``system.get_driver_version()`` and
+  ``system.get_driver_version_full()`` with
+  :func:`system.get_user_mode_driver_version` (works with or without
+  NVML) and :func:`system.get_kernel_mode_driver_version` (requires
+  NVML).  Each returns a ``tuple[int, ...]``.
 
 Fixes and enhancements
 -----------------------

cuda_core/tests/system/test_system_system.py

@@ -19,18 +19,18 @@
 from .conftest import skip_if_nvml_unsupported
 
 
-@skip_if_nvml_unsupported
-def test_driver_version():
-    umd, kmd = system.get_driver_version()
-
-    # UMD: 2-tuple (major, minor), cross-check against cuDriverGetVersion
+def test_user_mode_driver_version():
+    umd = system.get_user_mode_driver_version()
     assert isinstance(umd, tuple)
     assert len(umd) == 2
     version = handle_return(driver.cuDriverGetVersion())
-    expected_umd = (version // 1000, (version % 1000) // 10)
-    assert umd == expected_umd, "UMD driver version does not match expected value"
+    expected = (version // 1000, (version % 1000) // 10)
+    assert umd == expected, "UMD driver version does not match expected value"
 
-    # KMD: 3-tuple (major, minor, patch), or 2-tuple on WSL
+
+@skip_if_nvml_unsupported
+def test_kernel_mode_driver_version():
+    kmd = system.get_kernel_mode_driver_version()
     assert isinstance(kmd, tuple)
     assert len(kmd) in (2, 3)
     ver_maj, ver_min, *ver_patch = kmd
@@ -55,11 +55,11 @@ def test_devices():
         assert device.device_id == expected_device.device_id, "Device ID does not match expected value"
 
 
-def test_driver_version_requires_nvml():
+def test_kernel_mode_driver_version_requires_nvml():
     if system.CUDA_BINDINGS_NVML_IS_COMPATIBLE:
         pytest.skip("NVML is available, cannot test the error path")
     with pytest.raises(RuntimeError, match="requires NVML support"):
-        system.get_driver_version()
+        system.get_kernel_mode_driver_version()
 
 
 @skip_if_nvml_unsupported