fixup! drop stale pickle references in comments after raw-bytes refactor

Author: cpcloud

cuda_core/cuda/core/utils/_program_cache.py

@@ -1185,7 +1185,7 @@ def __init__(
             existing = self._schema_path.read_text().strip()
             if existing != expected:
                 # Schema mismatch: wipe incompatible entries. Losing cache
-                # contents is safe; returning stale/incompatible pickles is not.
+                # contents is safe; returning bytes from an old format is not.
                 for entry in list(self._iter_entry_paths()):
                     with contextlib.suppress(FileNotFoundError):
                         entry.unlink()
@@ -1201,9 +1201,10 @@ def _path_for_key(self, key: object) -> Path:
         k = _as_key_bytes(key)
         # Hash the key to a fixed-length identifier so arbitrary-length user
         # keys never exceed per-component filename limits (typically 255 on
-        # ext4 / NTFS). The original key is still stored inside the pickled
-        # record and verified on read, so two distinct keys cannot collide
-        # silently (hash collision would surface as KeyError via key mismatch).
+        # ext4 / NTFS). With a 256-bit blake2b digest, the cache relies on
+        # cryptographic collision resistance for key uniqueness -- two
+        # distinct keys hashing to the same path is astronomically unlikely
+        # (~2^-128 with the 32-byte digest in use here).
         digest = hashlib.blake2b(k, digest_size=32).hexdigest() if k else "empty"
         if len(digest) < 3:
             digest = digest.rjust(3, "0")

cuda_core/tests/test_program_cache.py

@@ -1471,7 +1471,7 @@ def test_filestream_cache_clear_does_not_break_concurrent_writer(tmp_path):
 
     # Stage a temp file that mimics an in-flight write.
     inflight_tmp = root / "tmp" / "entry-inflight"
-    inflight_tmp.write_bytes(b"\x80\x05fake-pickle")  # contents do not matter
+    inflight_tmp.write_bytes(b"in-flight payload")  # contents do not matter
 
     # Concurrent clear() from another cache handle.
     with FileStreamProgramCache(root) as other:
@@ -1502,8 +1502,8 @@ def test_filestream_cache_size_cap_does_not_unlink_replaced_file(tmp_path):
 
     from cuda.core.utils import FileStreamProgramCache
 
-    # Cap fits two entries (each ~2123 bytes on disk for a 2000-byte
-    # payload, including pickle overhead) but not three.
+    # Cap fits two 2000-byte entries (raw payload only -- no per-entry
+    # framing) but not three.
     cap = 5000
     root = tmp_path / "fc"
     with FileStreamProgramCache(root, max_size_bytes=cap) as cache:
@@ -1567,8 +1567,8 @@ def test_filestream_cache_size_cap_counts_tmp_files(tmp_path):
 
 def test_filestream_cache_handles_long_keys(tmp_path):
     """Arbitrary-length keys must not overflow per-component filename limits.
-    The filename is a fixed-length hash; the original key is verified from
-    the pickled record."""
+    The filename is a fixed-length 256-bit blake2b digest; key uniqueness
+    relies on the digest's collision resistance."""
     from cuda.core.utils import FileStreamProgramCache
 
     long_bytes_key = b"x" * 4096

cuda_core/tests/test_program_cache_multiprocess.py

@@ -144,7 +144,7 @@ def test_concurrent_eviction_does_not_delete_replaced_file(tmp_path):
 
     root = str(tmp_path / "fc")
     payload = b"X" * 2000
-    cap = 5000  # fits ~2 entries of 2000B + pickle-free overhead
+    cap = 5000  # fits 2 raw 2000B entries; the third write triggers eviction
 
     ctx = _mp.get_context("spawn")
     done_event = ctx.Event()