address reviews

Author: brandon-b-miller

cuda_pathfinder/cuda/pathfinder/__init__.py

@@ -9,7 +9,7 @@
 from cuda.pathfinder._dynamic_libs.supported_nvidia_libs import (
     SUPPORTED_LIBNAMES as SUPPORTED_NVIDIA_LIBNAMES,  # noqa: F401
 )
-from cuda.pathfinder._headers.find_nvidia_headers import FoundHeaderDir as FoundHeaderDir
+from cuda.pathfinder._headers.find_nvidia_headers import LocatedHeaderDir as LocatedHeaderDir
 from cuda.pathfinder._headers.find_nvidia_headers import find_nvidia_header_directory as find_nvidia_header_directory
 from cuda.pathfinder._headers.find_nvidia_headers import (
     locate_nvidia_header_directory as locate_nvidia_header_directory,

cuda_pathfinder/cuda/pathfinder/_headers/find_nvidia_headers.py

@@ -15,7 +15,7 @@
 
 
 @dataclass
-class FoundHeaderDir:
+class LocatedHeaderDir:
     abs_path: str | None
     found_via: str
 
@@ -33,16 +33,16 @@ def _joined_isfile(dirpath: str, basename: str) -> bool:
     return os.path.isfile(os.path.join(dirpath, basename))
 
 
-def _find_under_site_packages(sub_dir: str, h_basename: str) -> FoundHeaderDir | None:
+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 FoundHeaderDir(abs_path=hdr_dir, found_via="site-packages")
+            return LocatedHeaderDir(abs_path=hdr_dir, found_via="site-packages")
     return None
 
 
-def _find_based_on_ctk_layout(libname: str, h_basename: str, anchor_point: str) -> str | 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)
@@ -64,7 +64,7 @@ def _find_based_on_ctk_layout(libname: str, h_basename: str, anchor_point: str)
     return None
 
 
-def _find_based_on_conda_layout(libname: str, h_basename: str, ctk_layout: bool) -> FoundHeaderDir | None:
+def _find_based_on_conda_layout(libname: str, h_basename: str, ctk_layout: bool) -> LocatedHeaderDir | None:
     conda_prefix = os.environ.get("CONDA_PREFIX")
     if not conda_prefix:
         return None
@@ -85,41 +85,41 @@ def _find_based_on_conda_layout(libname: str, h_basename: str, ctk_layout: bool)
         else:
             include_path = os.path.join(conda_prefix, "include")
         anchor_point = os.path.dirname(include_path)
-    found_header_path = _find_based_on_ctk_layout(libname, h_basename, anchor_point)
+    found_header_path = _locate_based_on_ctk_layout(libname, h_basename, anchor_point)
     if found_header_path:
-        return FoundHeaderDir(abs_path=found_header_path, found_via="conda")
+        return LocatedHeaderDir(abs_path=found_header_path, found_via="conda")
     return None
 
 
-def _find_ctk_header_directory(libname: str) -> FoundHeaderDir | 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]
 
     for cdir in candidate_dirs:
-        if hdr_dir := _find_under_site_packages(cdir, h_basename):
+        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):
         return hdr_dir
 
     cuda_home = get_cuda_home_or_path()
     if cuda_home:  # noqa: SIM102
-        if result := _find_based_on_ctk_layout(libname, h_basename, cuda_home):
-            return FoundHeaderDir(abs_path=result, found_via="CUDA_HOME")
+        if result := _locate_based_on_ctk_layout(libname, h_basename, cuda_home):
+            return LocatedHeaderDir(abs_path=result, found_via="CUDA_HOME")
 
     return None
 
 
 @functools.cache
-def locate_nvidia_header_directory(libname: str) -> FoundHeaderDir | None:
+def locate_nvidia_header_directory(libname: str) -> LocatedHeaderDir | None:
     """Locate the header directory for a supported NVIDIA library.
 
     Args:
         libname (str): The short name of the library whose headers are needed
             (e.g., ``"nvrtc"``, ``"cusolver"``, ``"nvshmem"``).
 
     Returns:
-        FoundHeaderDir or None: A FoundHeaderDir object containing the absolute path
+        LocatedHeaderDir or None: A LocatedHeaderDir object containing the absolute path
         to the discovered header directory and information about where it was found,
         or ``None`` if the headers cannot be found.
 
@@ -152,7 +152,7 @@ def locate_nvidia_header_directory(libname: str) -> FoundHeaderDir | None:
     candidate_dirs = supported_nvidia_headers.SUPPORTED_SITE_PACKAGE_HEADER_DIRS_NON_CTK.get(libname, [])
 
     for cdir in candidate_dirs:
-        if found_hdr := _find_under_site_packages(cdir, h_basename):
+        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):
@@ -164,7 +164,7 @@ def locate_nvidia_header_directory(libname: str) -> FoundHeaderDir | None:
         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 FoundHeaderDir(abs_path=hdr_dir, found_via="supported_install_dir")
+                return LocatedHeaderDir(abs_path=hdr_dir, found_via="supported_install_dir")
     return None
 
 

cuda_pathfinder/tests/test_find_nvidia_headers.py

@@ -19,7 +19,7 @@
 
 import pytest
 
-from cuda.pathfinder import FoundHeaderDir, find_nvidia_header_directory, locate_nvidia_header_directory
+from cuda.pathfinder import LocatedHeaderDir, find_nvidia_header_directory, locate_nvidia_header_directory
 from cuda.pathfinder._headers.supported_nvidia_headers import (
     SUPPORTED_HEADERS_CTK,
     SUPPORTED_HEADERS_CTK_ALL,
@@ -59,34 +59,33 @@ def have_distribution_for(libname: str) -> bool:
 
 @pytest.mark.parametrize("libname", SUPPORTED_HEADERS_NON_CTK.keys())
 def test_locate_non_ctk_headers(info_summary_append, libname):
-    found_header_dir = locate_nvidia_header_directory(libname)
-    info_summary_append(f"{None if not found_header_dir else found_header_dir.abs_path=!r}")
-    if found_header_dir:
-        assert isinstance(found_header_dir, FoundHeaderDir)
-        assert found_header_dir.found_via in ("site-packages", "conda", "CUDA_HOME")
-        # old api
-        hdr_dir = find_nvidia_header_directory(libname)
-        assert hdr_dir == found_header_dir.abs_path
-
-        assert os.path.isdir(found_header_dir.abs_path)
-        assert os.path.isfile(os.path.join(found_header_dir.abs_path, SUPPORTED_HEADERS_NON_CTK[libname]))
+    hdr_dir = find_nvidia_header_directory(libname)
+    located_hdr_dir = locate_nvidia_header_directory(libname)
+    assert hdr_dir is None if not located_hdr_dir else hdr_dir == located_hdr_dir.abs_path
+
+    info_summary_append(f"{hdr_dir=!r}")
+    if hdr_dir:
+        assert isinstance(located_hdr_dir, LocatedHeaderDir)
+        assert located_hdr_dir.found_via in ("site-packages", "conda", "CUDA_HOME")
+        assert os.path.isdir(hdr_dir)
+        assert os.path.isfile(os.path.join(hdr_dir, SUPPORTED_HEADERS_NON_CTK[libname]))
     if have_distribution_for(libname):
-        assert found_header_dir.abs_path is not None
-        found_header_dir_parts = found_header_dir.abs_path.split(os.path.sep)
-        assert "site-packages" in found_header_dir_parts
+        assert hdr_dir is not None
+        hdr_dir_parts = hdr_dir.split(os.path.sep)
+        assert "site-packages" in hdr_dir_parts
     elif STRICTNESS == "all_must_work":
-        assert found_header_dir is not None
+        assert hdr_dir is not None
         if conda_prefix := os.environ.get("CONDA_PREFIX"):
-            assert found_header_dir.abs_path.startswith(conda_prefix)
+            assert hdr_dir.startswith(conda_prefix)
         else:
             inst_dirs = SUPPORTED_INSTALL_DIRS_NON_CTK.get(libname)
             if inst_dirs is not None:
                 for inst_dir in inst_dirs:
                     globbed = glob.glob(inst_dir)
-                    if found_header_dir.abs_path in globbed:
+                    if hdr_dir in globbed:
                         break
                 else:
-                    raise RuntimeError(f"{found_header_dir.abs_path=} does not match any {inst_dirs=}")
+                    raise RuntimeError(f"{hdr_dir=} does not match any {inst_dirs=}")
 
 
 def test_supported_headers_site_packages_ctk_consistency():
@@ -95,15 +94,14 @@ def test_supported_headers_site_packages_ctk_consistency():
 
 @pytest.mark.parametrize("libname", SUPPORTED_HEADERS_CTK.keys())
 def test_locate_ctk_headers(info_summary_append, libname):
-    found_header_dir = locate_nvidia_header_directory(libname)
-    info_summary_append(f"{None if not found_header_dir else found_header_dir.abs_path=!r}")
-    if found_header_dir:
-        # old api
-        hdr_dir = find_nvidia_header_directory(libname)
-        assert hdr_dir == found_header_dir.abs_path
-
-        assert os.path.isdir(found_header_dir.abs_path)
+    hdr_dir = find_nvidia_header_directory(libname)
+    located_hdr_dir = locate_nvidia_header_directory(libname)
+    assert hdr_dir is None if not located_hdr_dir else hdr_dir == located_hdr_dir.abs_path
+
+    info_summary_append(f"{hdr_dir=!r}")
+    if hdr_dir:
+        assert os.path.isdir(hdr_dir)
         h_filename = SUPPORTED_HEADERS_CTK[libname]
-        assert os.path.isfile(os.path.join(found_header_dir.abs_path, h_filename))
+        assert os.path.isfile(os.path.join(hdr_dir, h_filename))
     if STRICTNESS == "all_must_work":
-        assert found_header_dir.abs_path is not None
+        assert hdr_dir is not None