refactor(pathfinder): introduce header descriptor catalog

Mirror the dynamic-library descriptor-catalog pattern for headers.
All per-header metadata (basename, site-packages dirs, anchor layout,
platform availability, system install dirs) is now authored once in
HeaderDescriptorSpec entries in header_descriptor_catalog.py.

- header_descriptor.py provides a name-keyed HEADER_DESCRIPTORS registry
- supported_nvidia_headers.py derives its legacy tables from the catalog
- find_nvidia_headers.py uses descriptors directly, eliminating
  name-based if/else branching (nvvm, cccl special cases) in favor of
  descriptor fields (anchor_include_rel_dirs, include_subdirs, etc.)

Public API (LocatedHeaderDir, find_nvidia_header_directory,
locate_nvidia_header_directory, SUPPORTED_HEADERS_CTK) is unchanged.

Made-with: Cursor

Author: cpcloud

cuda_pathfinder/cuda/pathfinder/_headers/find_nvidia_headers.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
 from __future__ import annotations
@@ -7,16 +7,20 @@
 import glob
 import os
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
 from cuda.pathfinder._dynamic_libs.load_nvidia_dynamic_lib import (
     _resolve_system_loaded_abs_path_in_subprocess,
 )
 from cuda.pathfinder._dynamic_libs.search_steps import derive_ctk_root
-from cuda.pathfinder._headers import supported_nvidia_headers
+from cuda.pathfinder._headers.header_descriptor import HEADER_DESCRIPTORS
 from cuda.pathfinder._utils.env_vars import get_cuda_home_or_path
 from cuda.pathfinder._utils.find_sub_dirs import find_sub_dirs_all_sitepackages
 from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
 
+if TYPE_CHECKING:
+    from cuda.pathfinder._headers.header_descriptor import HeaderDescriptor
+
 
 @dataclass
 class LocatedHeaderDir:
@@ -38,37 +42,33 @@ def _joined_isfile(dirpath: str, basename: str) -> bool:
 
 
 def _locate_under_site_packages(sub_dir: str, h_basename: str) -> LocatedHeaderDir | None:
-    # Installed from a wheel
     hdr_dir: str  # help mypy
     for hdr_dir in find_sub_dirs_all_sitepackages(tuple(sub_dir.split("/"))):
         if _joined_isfile(hdr_dir, h_basename):
             return LocatedHeaderDir(abs_path=hdr_dir, found_via="site-packages")
     return None
 
 
-def _locate_based_on_ctk_layout(libname: str, h_basename: str, anchor_point: str) -> str | None:
-    parts = [anchor_point]
-    if libname == "nvvm":
-        parts.append(libname)
-    parts.append("include")
-    idir = os.path.join(*parts)
-    if libname == "cccl":
+def _locate_in_anchor_layout(desc: HeaderDescriptor, anchor_point: str) -> str | None:
+    """Search for a header under *anchor_point* using the descriptor's layout fields."""
+    h_basename = desc.header_basename
+    for rel_dir in desc.anchor_include_rel_dirs:
+        idir = os.path.join(anchor_point, rel_dir)
         if IS_WINDOWS:
-            cdir_ctk12 = os.path.join(idir, "targets", "x64")  # conda has this anomaly
-            cdir_ctk13 = os.path.join(cdir_ctk12, "cccl")
-            if _joined_isfile(cdir_ctk13, h_basename):
-                return cdir_ctk13
-            if _joined_isfile(cdir_ctk12, h_basename):
-                return cdir_ctk12
-        cdir = os.path.join(idir, "cccl")  # CTK 13
-        if _joined_isfile(cdir, h_basename):
-            return cdir
-    if _joined_isfile(idir, h_basename):
-        return idir
+            for subdir in desc.include_subdirs_windows:
+                cdir = os.path.join(idir, subdir)
+                if _joined_isfile(cdir, h_basename):
+                    return cdir
+        for subdir in desc.include_subdirs:
+            cdir = os.path.join(idir, subdir)
+            if _joined_isfile(cdir, h_basename):
+                return cdir
+        if _joined_isfile(idir, h_basename):
+            return idir
     return None
 
 
-def _find_based_on_conda_layout(libname: str, h_basename: str, ctk_layout: bool) -> LocatedHeaderDir | None:
+def _find_in_conda(desc: HeaderDescriptor) -> LocatedHeaderDir | None:
     conda_prefix = os.environ.get("CONDA_PREFIX")
     if not conda_prefix:
         return None
@@ -77,25 +77,23 @@ def _find_based_on_conda_layout(libname: str, h_basename: str, ctk_layout: bool)
         if not os.path.isdir(anchor_point):
             return None
     else:
-        if ctk_layout:
+        if desc.packaged_with == "ctk":
             targets_include_path = glob.glob(os.path.join(conda_prefix, "targets", "*", "include"))
             if not targets_include_path:
                 return None
             if len(targets_include_path) != 1:
-                # Conda does not support multiple architectures.
-                # QUESTION(PR#956): Do we want to issue a warning?
                 return None
             include_path = targets_include_path[0]
         else:
             include_path = os.path.join(conda_prefix, "include")
         anchor_point = os.path.dirname(include_path)
-    found_header_path = _locate_based_on_ctk_layout(libname, h_basename, anchor_point)
+    found_header_path = _locate_in_anchor_layout(desc, anchor_point)
     if found_header_path:
         return LocatedHeaderDir(abs_path=found_header_path, found_via="conda")
     return None
 
 
-def _find_ctk_header_directory_via_canary(libname: str, h_basename: str) -> str | None:
+def _find_via_ctk_root_canary(desc: HeaderDescriptor) -> str | None:
     """Try CTK header lookup via CTK-root canary probing.
 
     Uses the same canary as dynamic-library CTK-root discovery: system-load
@@ -109,26 +107,43 @@ def _find_ctk_header_directory_via_canary(libname: str, h_basename: str) -> str
     ctk_root = derive_ctk_root(canary_abs_path)
     if ctk_root is None:
         return None
-    return _locate_based_on_ctk_layout(libname, h_basename, ctk_root)
+    return _locate_in_anchor_layout(desc, ctk_root)
+
+
+def _find_in_system_install_dirs(desc: HeaderDescriptor) -> LocatedHeaderDir | None:
+    """Search system install directories (glob patterns) for non-CTK headers."""
+    for pattern in desc.system_install_dirs:
+        for hdr_dir in sorted(glob.glob(pattern), reverse=True):
+            if _joined_isfile(hdr_dir, desc.header_basename):
+                return LocatedHeaderDir(abs_path=hdr_dir, found_via="supported_install_dir")
+    return None
 
 
-def _find_ctk_header_directory(libname: str) -> LocatedHeaderDir | None:
-    h_basename = supported_nvidia_headers.SUPPORTED_HEADERS_CTK[libname]
-    candidate_dirs = supported_nvidia_headers.SUPPORTED_SITE_PACKAGE_HEADER_DIRS_CTK[libname]
+def _locate_header_directory(desc: HeaderDescriptor) -> LocatedHeaderDir | None:
+    """Unified header search using a descriptor."""
+    h_basename = desc.header_basename
 
-    for cdir in candidate_dirs:
+    # 1. Site-packages (pip wheels)
+    for cdir in desc.site_packages_dirs:
         if hdr_dir := _locate_under_site_packages(cdir, h_basename):
             return hdr_dir
 
-    if hdr_dir := _find_based_on_conda_layout(libname, h_basename, True):
+    # 2. Conda
+    if hdr_dir := _find_in_conda(desc):
         return hdr_dir
 
-    cuda_home = get_cuda_home_or_path()
-    if cuda_home and (result := _locate_based_on_ctk_layout(libname, h_basename, cuda_home)):
-        return LocatedHeaderDir(abs_path=result, found_via="CUDA_HOME")
+    # CTK-only steps: CUDA_HOME and canary probe
+    if desc.packaged_with == "ctk":
+        cuda_home = get_cuda_home_or_path()
+        if cuda_home and (result := _locate_in_anchor_layout(desc, cuda_home)):
+            return LocatedHeaderDir(abs_path=result, found_via="CUDA_HOME")
 
-    if result := _find_ctk_header_directory_via_canary(libname, h_basename):
-        return LocatedHeaderDir(abs_path=result, found_via="system-ctk-root")
+        if result := _find_via_ctk_root_canary(desc):
+            return LocatedHeaderDir(abs_path=result, found_via="system-ctk-root")
+
+    # Non-CTK fallback: system install directories
+    if desc.system_install_dirs and (hdr_dir := _find_in_system_install_dirs(desc)):
+        return hdr_dir
 
     return None
 
@@ -160,41 +175,24 @@ def locate_nvidia_header_directory(libname: str) -> LocatedHeaderDir | None:
            - Check Conda-style installation prefixes, which use platform-specific
              include directory layouts.
 
-        3. **CUDA Toolkit environment variables**
+        3. **CUDA Toolkit environment variables** *(CTK headers only)*
 
            - Use ``CUDA_HOME`` or ``CUDA_PATH`` (in that order).
 
-        4. **CTK root canary probe**
+        4. **CTK root canary probe** *(CTK headers only)*
 
            - Probe a system-loaded ``cudart`` in a spawned child process,
              derive the CTK root from the resolved library path, then search
              CTK include layout under that root.
-    """
 
-    if libname in supported_nvidia_headers.SUPPORTED_HEADERS_CTK:
-        return _find_ctk_header_directory(libname)
+        5. **System install directories** *(non-CTK headers only)*
 
-    h_basename = supported_nvidia_headers.SUPPORTED_HEADERS_NON_CTK.get(libname)
-    if h_basename is None:
+           - Search well-known system install paths (e.g., ``/usr/include/nvshmem_*``).
+    """
+    desc = HEADER_DESCRIPTORS.get(libname)
+    if desc is None:
         raise RuntimeError(f"UNKNOWN {libname=}")
-
-    candidate_dirs = supported_nvidia_headers.SUPPORTED_SITE_PACKAGE_HEADER_DIRS_NON_CTK.get(libname, [])
-
-    for cdir in candidate_dirs:
-        if found_hdr := _locate_under_site_packages(cdir, h_basename):
-            return found_hdr
-
-    if found_hdr := _find_based_on_conda_layout(libname, h_basename, False):
-        return found_hdr
-
-    # Fall back to system install directories
-    candidate_dirs = supported_nvidia_headers.SUPPORTED_INSTALL_DIRS_NON_CTK.get(libname, [])
-    for cdir in candidate_dirs:
-        for hdr_dir in sorted(glob.glob(cdir), reverse=True):
-            if _joined_isfile(hdr_dir, h_basename):
-                # For system installs, we don't have a clear found_via, so use "system"
-                return LocatedHeaderDir(abs_path=hdr_dir, found_via="supported_install_dir")
-    return None
+    return _locate_header_directory(desc)
 
 
 def find_nvidia_header_directory(libname: str) -> str | None:
@@ -222,15 +220,19 @@ def find_nvidia_header_directory(libname: str) -> str | None:
            - Check Conda-style installation prefixes, which use platform-specific
              include directory layouts.
 
-        3. **CUDA Toolkit environment variables**
+        3. **CUDA Toolkit environment variables** *(CTK headers only)*
 
            - Use ``CUDA_HOME`` or ``CUDA_PATH`` (in that order).
 
-        4. **CTK root canary probe**
+        4. **CTK root canary probe** *(CTK headers only)*
 
            - Probe a system-loaded ``cudart`` in a spawned child process,
              derive the CTK root from the resolved library path, then search
              CTK include layout under that root.
+
+        5. **System install directories** *(non-CTK headers only)*
+
+           - Search well-known system install paths (e.g., ``/usr/include/nvshmem_*``).
     """
     found = locate_nvidia_header_directory(libname)
     return found.abs_path if found else None

cuda_pathfinder/cuda/pathfinder/_headers/header_descriptor.py

@@ -0,0 +1,22 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Per-header descriptor and registry.
+
+The canonical authored data lives in :mod:`header_descriptor_catalog`. This
+module provides a name-keyed registry consumed by the runtime search path.
+"""
+
+from __future__ import annotations
+
+from typing import TypeAlias
+
+from cuda.pathfinder._headers.header_descriptor_catalog import (
+    HEADER_DESCRIPTOR_CATALOG,
+    HeaderDescriptorSpec,
+)
+
+HeaderDescriptor: TypeAlias = HeaderDescriptorSpec
+
+#: Canonical registry of all known header libraries.
+HEADER_DESCRIPTORS: dict[str, HeaderDescriptor] = {desc.name: desc for desc in HEADER_DESCRIPTOR_CATALOG}