Fix ruff check, format, and SPDX headers for program cache

cpcloud · claude · cpcloud · commit 4fffc192e53a · 2026-04-14T19:10:11.000-04:00
- SPDX: LicenseRef-NVIDIA-SOFTWARE-LICENSE -&gt; Apache-2.0 in tests
- B027: noqa for intentional no-op close()
- S301: noqa for pickle.loads (fundamental to cache design)
- B904: add 'from None' to re-raised KeyErrors
- SIM105: replace try-except-pass with contextlib.suppress
- ruff format applied

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/cuda_core/cuda/core/utils/_program_cache.py b/cuda_core/cuda/core/utils/_program_cache.py
@@ -18,19 +18,24 @@
 from __future__ import annotations
 
 import abc
+import contextlib
 import hashlib
 import os
 import pickle
 import tempfile
 import time
 from pathlib import Path
-from typing import Hashable, Iterable, Optional, Sequence
+from typing import Hashable, Iterable, Sequence
 
 from cuda.core._module import ObjectCode
 from cuda.core._program import ProgramOptions
 from cuda.core._utils.cuda_utils import (
     driver as _driver,
+)
+from cuda.core._utils.cuda_utils import (
     handle_return as _handle_return,
+)
+from cuda.core._utils.cuda_utils import (
     nvrtc as _nvrtc,
 )
 
@@ -47,9 +52,7 @@
 
 def _require_object_code(value: object) -> ObjectCode:
     if not isinstance(value, ObjectCode):
-        raise TypeError(
-            f"cache values must be ObjectCode instances, got {type(value).__name__}"
-        )
+        raise TypeError(f"cache values must be ObjectCode instances, got {type(value).__name__}")
     return value
 
 
@@ -131,10 +134,10 @@ def get(self, key: Hashable, default: ObjectCode | None = None) -> ObjectCode |
         except KeyError:
             return default
 
-    def close(self) -> None:
+    def close(self) -> None:  # noqa: B027
         """Release backend resources. No-op by default."""
 
-    def __enter__(self) -> "ProgramCacheResource":
+    def __enter__(self) -> ProgramCacheResource:
         return self
 
     def __exit__(self, exc_type, exc_value, traceback) -> None:
@@ -214,24 +217,16 @@ def make_program_cache_key(
         A 32-byte blake2b digest suitable for use as a cache key.
     """
     if code_type not in _VALID_CODE_TYPES:
-        raise ValueError(
-            f"code_type={code_type!r} is not supported "
-            f"(must be one of {sorted(_VALID_CODE_TYPES)})"
-        )
+        raise ValueError(f"code_type={code_type!r} is not supported (must be one of {sorted(_VALID_CODE_TYPES)})")
     if target_type not in _VALID_TARGET_TYPES:
-        raise ValueError(
-            f"target_type={target_type!r} is not supported "
-            f"(must be one of {sorted(_VALID_TARGET_TYPES)})"
-        )
+        raise ValueError(f"target_type={target_type!r} is not supported (must be one of {sorted(_VALID_TARGET_TYPES)})")
 
     if isinstance(code, str):
         code_bytes = code.encode("utf-8")
     elif isinstance(code, (bytes, bytearray)):
         code_bytes = bytes(code)
     else:
-        raise TypeError(
-            f"code must be str or bytes, got {type(code).__name__}"
-        )
+        raise TypeError(f"code must be str or bytes, got {type(code).__name__}")
 
     backend = _backend_for_code_type(code_type)
     # ProgramOptions.as_bytes may or may not accept target_type depending on
@@ -328,7 +323,7 @@ def __init__(
         self,
         path: str | os.PathLike,
         *,
-        max_size_bytes: Optional[int] = None,
+        max_size_bytes: int | None = None,
     ) -> None:
         if max_size_bytes is not None and max_size_bytes < 0:
             raise ValueError("max_size_bytes must be non-negative or None")
@@ -338,7 +333,7 @@ def __init__(
         import sqlite3
 
         self._sqlite3 = sqlite3
-        self._conn: Optional[sqlite3.Connection] = None
+        self._conn: sqlite3.Connection | None = None
         self._open()
 
     # -- lifecycle -----------------------------------------------------------
@@ -396,29 +391,25 @@ def _require_open(self):
 
     def __contains__(self, key: object) -> bool:
         k = _as_key_bytes(key)
-        row = self._require_open().execute(
-            "SELECT 1 FROM entries WHERE key = ?", (k,)
-        ).fetchone()
+        row = self._require_open().execute("SELECT 1 FROM entries WHERE key = ?", (k,)).fetchone()
         return row is not None
 
     def __getitem__(self, key: object) -> ObjectCode:
         k = _as_key_bytes(key)
         conn = self._require_open()
-        row = conn.execute(
-            "SELECT payload FROM entries WHERE key = ?", (k,)
-        ).fetchone()
+        row = conn.execute("SELECT payload FROM entries WHERE key = ?", (k,)).fetchone()
         if row is None:
             raise KeyError(key)
         payload = row[0]
         try:
-            value = pickle.loads(payload)
+            value = pickle.loads(payload)  # noqa: S301
         except Exception:
             # Corrupt entry -- delete and treat as a miss.
             conn.execute("DELETE FROM entries WHERE key = ?", (k,))
-            raise KeyError(key)
+            raise KeyError(key) from None
         if not isinstance(value, ObjectCode):
             conn.execute("DELETE FROM entries WHERE key = ?", (k,))
-            raise KeyError(key)
+            raise KeyError(key) from None
         conn.execute(
             "UPDATE entries SET accessed_at = ? WHERE key = ?",
             (time.time(), k),
@@ -452,9 +443,7 @@ def __delitem__(self, key: object) -> None:
             raise KeyError(key)
 
     def __len__(self) -> int:
-        (n,) = self._require_open().execute(
-            "SELECT COUNT(*) FROM entries"
-        ).fetchone()
+        (n,) = self._require_open().execute("SELECT COUNT(*) FROM entries").fetchone()
         return int(n)
 
     def clear(self) -> None:
@@ -466,9 +455,7 @@ def _enforce_size_cap(self) -> None:
         if self._max_size_bytes is None:
             return
         conn = self._require_open()
-        (total,) = conn.execute(
-            "SELECT COALESCE(SUM(size_bytes), 0) FROM entries"
-        ).fetchone()
+        (total,) = conn.execute("SELECT COALESCE(SUM(size_bytes), 0) FROM entries").fetchone()
         if total <= self._max_size_bytes:
             return
         # Delete oldest (least-recently-used) until at or under the cap.
@@ -514,7 +501,7 @@ def __init__(
         self,
         path: str | os.PathLike,
         *,
-        max_size_bytes: Optional[int] = None,
+        max_size_bytes: int | None = None,
     ) -> None:
         if max_size_bytes is not None and max_size_bytes < 0:
             raise ValueError("max_size_bytes must be non-negative or None")
@@ -548,29 +535,25 @@ def __getitem__(self, key: object) -> ObjectCode:
         try:
             data = path.read_bytes()
         except FileNotFoundError:
-            raise KeyError(key)
+            raise KeyError(key) from None
         k = _as_key_bytes(key)
         try:
-            record = pickle.loads(data)
+            record = pickle.loads(data)  # noqa: S301
             schema, stored_key, payload, _created_at = record
             if schema != _FILESTREAM_SCHEMA_VERSION:
                 raise ValueError(f"unknown schema {schema}")
             if stored_key != k:
                 raise ValueError("key mismatch")
-            value = pickle.loads(payload)
+            value = pickle.loads(payload)  # noqa: S301
         except Exception:
             # Corrupt entry -- delete and treat as a miss.
-            try:
+            with contextlib.suppress(FileNotFoundError):
                 path.unlink()
-            except FileNotFoundError:
-                pass
-            raise KeyError(key)
+            raise KeyError(key) from None
         if not isinstance(value, ObjectCode):
-            try:
+            with contextlib.suppress(FileNotFoundError):
                 path.unlink()
-            except FileNotFoundError:
-                pass
-            raise KeyError(key)
+            raise KeyError(key) from None
         return value
 
     def __setitem__(self, key: object, value: object) -> None:
@@ -594,10 +577,8 @@ def __setitem__(self, key: object, value: object) -> None:
                 os.fsync(fh.fileno())
             os.replace(tmp_path, target)
         except BaseException:
-            try:
+            with contextlib.suppress(FileNotFoundError):
                 tmp_path.unlink()
-            except FileNotFoundError:
-                pass
             raise
         self._enforce_size_cap()
 
@@ -606,7 +587,7 @@ def __delitem__(self, key: object) -> None:
         try:
             path.unlink()
         except FileNotFoundError:
-            raise KeyError(key)
+            raise KeyError(key) from None
 
     def __len__(self) -> int:
         count = 0
@@ -616,18 +597,14 @@ def __len__(self) -> int:
 
     def clear(self) -> None:
         for path in list(self._iter_entry_paths()):
-            try:
+            with contextlib.suppress(FileNotFoundError):
                 path.unlink()
-            except FileNotFoundError:
-                pass
         # Remove empty subdirs (best-effort; concurrent writers may re-create).
         if self._entries.exists():
             for sub in sorted(self._entries.iterdir(), reverse=True):
                 if sub.is_dir():
-                    try:
+                    with contextlib.suppress(OSError):
                         sub.rmdir()
-                    except OSError:
-                        pass
 
     # -- internals -----------------------------------------------------------
 
@@ -659,8 +636,6 @@ def _enforce_size_cap(self) -> None:
         for _mtime, size, path in entries:
             if total <= self._max_size_bytes:
                 return
-            try:
+            with contextlib.suppress(FileNotFoundError):
                 path.unlink()
                 total -= size
-            except FileNotFoundError:
-                pass
diff --git a/cuda_core/tests/test_program_cache.py b/cuda_core/tests/test_program_cache.py
@@ -1,6 +1,6 @@
 # SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 #
-# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+# SPDX-License-Identifier: Apache-2.0
 
 import abc
 import time
@@ -131,48 +131,32 @@ def test_make_program_cache_key_returns_bytes():
 def test_make_program_cache_key_is_deterministic():
     from cuda.core.utils import make_program_cache_key
 
-    k1 = make_program_cache_key(
-        code="void k(){}", code_type="c++", options=_opts(), target_type="cubin"
-    )
-    k2 = make_program_cache_key(
-        code="void k(){}", code_type="c++", options=_opts(), target_type="cubin"
-    )
+    k1 = make_program_cache_key(code="void k(){}", code_type="c++", options=_opts(), target_type="cubin")
+    k2 = make_program_cache_key(code="void k(){}", code_type="c++", options=_opts(), target_type="cubin")
     assert k1 == k2
 
 
 def test_make_program_cache_key_changes_with_code():
     from cuda.core.utils import make_program_cache_key
 
-    k1 = make_program_cache_key(
-        code="a", code_type="c++", options=_opts(), target_type="cubin"
-    )
-    k2 = make_program_cache_key(
-        code="b", code_type="c++", options=_opts(), target_type="cubin"
-    )
+    k1 = make_program_cache_key(code="a", code_type="c++", options=_opts(), target_type="cubin")
+    k2 = make_program_cache_key(code="b", code_type="c++", options=_opts(), target_type="cubin")
     assert k1 != k2
 
 
 def test_make_program_cache_key_changes_with_target_type():
     from cuda.core.utils import make_program_cache_key
 
-    k1 = make_program_cache_key(
-        code="a", code_type="c++", options=_opts(), target_type="ptx"
-    )
-    k2 = make_program_cache_key(
-        code="a", code_type="c++", options=_opts(), target_type="cubin"
-    )
+    k1 = make_program_cache_key(code="a", code_type="c++", options=_opts(), target_type="ptx")
+    k2 = make_program_cache_key(code="a", code_type="c++", options=_opts(), target_type="cubin")
     assert k1 != k2
 
 
 def test_make_program_cache_key_changes_with_arch():
     from cuda.core.utils import make_program_cache_key
 
-    k1 = make_program_cache_key(
-        code="a", code_type="c++", options=_opts(arch="sm_80"), target_type="cubin"
-    )
-    k2 = make_program_cache_key(
-        code="a", code_type="c++", options=_opts(arch="sm_90"), target_type="cubin"
-    )
+    k1 = make_program_cache_key(code="a", code_type="c++", options=_opts(arch="sm_80"), target_type="cubin")
+    k2 = make_program_cache_key(code="a", code_type="c++", options=_opts(arch="sm_90"), target_type="cubin")
     assert k1 != k2
 
 
@@ -218,40 +202,30 @@ def test_make_program_cache_key_accepts_bytes_code():
     from cuda.core.utils import make_program_cache_key
 
     # NVVM IR is bytes; accept both str and bytes equivalently (str is UTF-8).
-    k_str = make_program_cache_key(
-        code="abc", code_type="nvvm", options=_opts(), target_type="ptx"
-    )
-    k_bytes = make_program_cache_key(
-        code=b"abc", code_type="nvvm", options=_opts(), target_type="ptx"
-    )
+    k_str = make_program_cache_key(code="abc", code_type="nvvm", options=_opts(), target_type="ptx")
+    k_bytes = make_program_cache_key(code=b"abc", code_type="nvvm", options=_opts(), target_type="ptx")
     assert k_str == k_bytes
 
 
 def test_make_program_cache_key_rejects_unknown_code_type():
     from cuda.core.utils import make_program_cache_key
 
     with pytest.raises(ValueError, match="code_type"):
-        make_program_cache_key(
-            code="a", code_type="fortran", options=_opts(), target_type="cubin"
-        )
+        make_program_cache_key(code="a", code_type="fortran", options=_opts(), target_type="cubin")
 
 
 def test_make_program_cache_key_rejects_unknown_target_type():
     from cuda.core.utils import make_program_cache_key
 
     with pytest.raises(ValueError, match="target_type"):
-        make_program_cache_key(
-            code="a", code_type="c++", options=_opts(), target_type="exe"
-        )
+        make_program_cache_key(code="a", code_type="c++", options=_opts(), target_type="exe")
 
 
 def test_make_program_cache_key_rejects_non_str_bytes_code():
     from cuda.core.utils import make_program_cache_key
 
     with pytest.raises(TypeError, match="code"):
-        make_program_cache_key(
-            code=12345, code_type="c++", options=_opts(), target_type="cubin"
-        )
+        make_program_cache_key(code=12345, code_type="c++", options=_opts(), target_type="cubin")
 
 
 # ---------------------------------------------------------------------------
@@ -363,9 +337,8 @@ def test_sqlite_cache_corruption_is_reported_as_miss(tmp_path):
 def test_sqlite_cache_rejects_non_object_code(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
-    with SQLiteProgramCache(tmp_path / "cache.db") as cache:
-        with pytest.raises(TypeError, match="ObjectCode"):
-            cache[b"k"] = b"not an ObjectCode"
+    with SQLiteProgramCache(tmp_path / "cache.db") as cache, pytest.raises(TypeError, match="ObjectCode"):
+        cache[b"k"] = b"not an ObjectCode"
 
 
 def test_sqlite_cache_accepts_str_keys(tmp_path):
@@ -511,6 +484,7 @@ def test_filestream_cache_atomic_no_half_written_file(tmp_path, monkeypatch):
     from cuda.core.utils import FileStreamProgramCache
 
     with FileStreamProgramCache(tmp_path / "fc") as cache:
+
         def _boom(src, dst):
             raise RuntimeError("crash during replace")
 
@@ -540,9 +514,8 @@ def test_filestream_cache_corruption_is_reported_as_miss(tmp_path):
 def test_filestream_cache_rejects_non_object_code(tmp_path):
     from cuda.core.utils import FileStreamProgramCache
 
-    with FileStreamProgramCache(tmp_path / "fc") as cache:
-        with pytest.raises(TypeError, match="ObjectCode"):
-            cache[b"k"] = b"not an ObjectCode"
+    with FileStreamProgramCache(tmp_path / "fc") as cache, pytest.raises(TypeError, match="ObjectCode"):
+        cache[b"k"] = b"not an ObjectCode"
 
 
 def test_filestream_cache_rejects_negative_size_cap(tmp_path):
diff --git a/cuda_core/tests/test_program_cache_multiprocess.py b/cuda_core/tests/test_program_cache_multiprocess.py
