cuda.core: consolidate get_driver_version and get_driver_version_full

Merge the two separate driver version query functions into a single
get_driver_version() that returns (umd_version, kmd_version) — a pair
of version tuples. UMD is a 2-tuple (major, minor) and KMD is a
3-tuple (major, minor, patch). The function now requires NVML.

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

Author: leofang

cuda_core/cuda/core/system/__init__.py

@@ -12,7 +12,6 @@
 __all__ = [
     "CUDA_BINDINGS_NVML_IS_COMPATIBLE",
     "get_driver_version",
-    "get_driver_version_full",
     "get_num_devices",
     "get_process_name",
 ]

cuda_core/cuda/core/system/_system.pyx

@@ -29,52 +29,38 @@ else:
     from cuda.core._utils.cuda_utils import driver, handle_return, runtime
 
 
-def get_driver_version(kernel_mode: bool = False) -> tuple[int, int]:
+def get_driver_version() -> tuple[tuple[int, ...], tuple[int, ...]]:
     """
     Get the driver version.
 
-    Parameters
-    ----------
-    kernel_mode: bool
-        When `True`, return the kernel-mode driver version, e.g. 580.65.06.
-        Otherwise, return the user-mode driver version, e.g. 13.0.1.
+    Returns both the user-mode (UMD / CUDA) driver version and the
+    kernel-mode (KMD / GPU) driver version.
 
     Returns
     -------
-    version: tuple[int, int]
-        Tuple in the format `(MAJOR, MINOR)`.
+    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)``.
+
+    Raises
+    ------
+    RuntimeError
+        If the NVML library is not available.
     """
-    return get_driver_version_full(kernel_mode)[:2]
+    if not CUDA_BINDINGS_NVML_IS_COMPATIBLE:
+        raise RuntimeError("get_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)
 
-def get_driver_version_full(kernel_mode: bool = False) -> tuple[int, int, int]:
-    """
-    Get the full driver version.
+    # KMD (kernel-mode / GPU driver) version
+    kmd = tuple(int(x) for x in nvml.system_get_driver_version().split("."))
 
-    Parameters
-    ----------
-    kernel_mode: bool
-        When `True`, return the kernel-mode driver version, e.g. 580.65.06.
-        Otherwise, return the user-mode driver version, e.g. 13.0.1.
-
-    Returns
-    -------
-    version: tuple[int, int, int]
-        Tuple in the format `(MAJOR, MINOR, PATCH)`.
-    """
-    cdef int v
-    if kernel_mode:
-        if not CUDA_BINDINGS_NVML_IS_COMPATIBLE:
-            raise ValueError("Kernel-mode driver version requires NVML support")
-        initialize()
-        return tuple(int(v) for v in nvml.system_get_driver_version().split("."))
-    else:
-        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, v % 10)
+    return (umd, kmd)
 
 
 def get_nvml_version() -> tuple[int, ...]:
@@ -138,7 +124,6 @@ def get_process_name(pid: int) -> str:
 __all__ = [
     "get_driver_branch",
     "get_driver_version",
-    "get_driver_version_full",
     "get_nvml_version",
     "get_num_devices",
     "get_process_name",

cuda_core/docs/source/api.rst

@@ -255,7 +255,6 @@ Basic functions
    :toctree: generated/
 
    system.get_driver_version
-   system.get_driver_version_full
    system.get_driver_branch
    system.get_num_devices
    system.get_nvml_version

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

@@ -152,6 +152,14 @@ 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.
+
 Fixes and enhancements
 -----------------------
 

cuda_core/tests/system/test_system_system.py

@@ -19,11 +19,24 @@
 from .conftest import skip_if_nvml_unsupported
 
 
+@skip_if_nvml_unsupported
 def test_driver_version():
-    driver_version = system.get_driver_version()
+    umd, kmd = system.get_driver_version()
+
+    # UMD: 2-tuple (major, minor), cross-check against cuDriverGetVersion
+    assert isinstance(umd, tuple)
+    assert len(umd) == 2
     version = handle_return(driver.cuDriverGetVersion())
-    expected_driver_version = (version // 1000, (version % 1000) // 10)
-    assert driver_version == expected_driver_version, "Driver version does not match expected value"
+    expected_umd = (version // 1000, (version % 1000) // 10)
+    assert umd == expected_umd, "UMD driver version does not match expected value"
+
+    # KMD: 3-tuple (major, minor, patch)
+    assert isinstance(kmd, tuple)
+    assert len(kmd) == 3
+    ver_maj, ver_min, ver_patch = kmd
+    assert 400 <= ver_maj < 1000
+    assert ver_min >= 0
+    assert 0 <= ver_patch <= 99
 
 
 def test_num_devices():
@@ -41,28 +54,11 @@ def test_devices():
         assert device.device_id == expected_device.device_id, "Device ID does not match expected value"
 
 
-def test_cuda_driver_version():
-    cuda_driver_version = system.get_driver_version_full()
-    assert isinstance(cuda_driver_version, tuple)
-    assert len(cuda_driver_version) == 3
-
-    ver_maj, ver_min, ver_patch = cuda_driver_version
-    assert ver_maj >= 10
-    assert 0 <= ver_min <= 99
-    assert 0 <= ver_patch <= 9
-
-
-@skip_if_nvml_unsupported
-def test_gpu_driver_version():
-    driver_version = system.get_driver_version(kernel_mode=True)
-    assert isinstance(driver_version, tuple)
-    assert len(driver_version) in (2, 3)
-
-    (ver_maj, ver_min, *ver_patch) = driver_version
-    assert 400 <= ver_maj < 1000
-    assert ver_min >= 0
-    if ver_patch:
-        assert 0 <= ver_patch[0] <= 99
+def test_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()
 
 
 @skip_if_nvml_unsupported