Fix test failures: use public API + skip sqlite when unavailable

- Replace private Cython attrs (_module/_name/_code_type) with public
  properties (code/name/code_type) — cdef attrs not accessible from Python
- Add @needs_sqlite3 skip decorator for sqlite tests when libsqlite3
  is missing from CI containers

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

Author: cpcloud

cuda_core/tests/test_program_cache.py

@@ -7,6 +7,15 @@
 
 import pytest
 
+try:
+    import sqlite3  # noqa: F401
+
+    _has_sqlite3 = True
+except ImportError:
+    _has_sqlite3 = False
+
+needs_sqlite3 = pytest.mark.skipif(not _has_sqlite3, reason="libsqlite3 not available")
+
 
 def test_program_cache_resource_is_abstract():
     from cuda.core.utils import ProgramCacheResource
@@ -240,6 +249,7 @@ def _fake_object_code(payload: bytes = b"fake-cubin", name: str = "unit"):
     return ObjectCode._init(payload, "cubin", name=name)
 
 
+@needs_sqlite3
 def test_sqlite_cache_empty_on_create(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
@@ -252,6 +262,7 @@ def test_sqlite_cache_empty_on_create(tmp_path):
         assert cache.get(b"nope") is None
 
 
+@needs_sqlite3
 def test_sqlite_cache_set_get_roundtrip(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
@@ -263,11 +274,12 @@ def test_sqlite_cache_set_get_roundtrip(tmp_path):
         assert key in cache
         assert len(cache) == 1
         got = cache[key]
-        assert bytes(got._module) == b"bytes-1"
-        assert got._name == "a"
-        assert got._code_type == "cubin"
+        assert bytes(got.code) == b"bytes-1"
+        assert got.name == "a"
+        assert got.code_type == "cubin"
 
 
+@needs_sqlite3
 def test_sqlite_cache_overwrite_same_key(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
@@ -276,9 +288,10 @@ def test_sqlite_cache_overwrite_same_key(tmp_path):
         cache[b"k"] = _fake_object_code(b"v1")
         cache[b"k"] = _fake_object_code(b"v2")
         assert len(cache) == 1
-        assert bytes(cache[b"k"]._module) == b"v2"
+        assert bytes(cache[b"k"].code) == b"v2"
 
 
+@needs_sqlite3
 def test_sqlite_cache_delete(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
@@ -292,6 +305,7 @@ def test_sqlite_cache_delete(tmp_path):
             del cache[b"k"]
 
 
+@needs_sqlite3
 def test_sqlite_cache_clear(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
@@ -303,16 +317,18 @@ def test_sqlite_cache_clear(tmp_path):
         assert len(cache) == 0
 
 
+@needs_sqlite3
 def test_sqlite_cache_persists_across_open(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
     db = tmp_path / "cache.db"
     with SQLiteProgramCache(db) as cache:
         cache[b"k"] = _fake_object_code(b"persisted")
     with SQLiteProgramCache(db) as cache:
-        assert bytes(cache[b"k"]._module) == b"persisted"
+        assert bytes(cache[b"k"].code) == b"persisted"
 
 
+@needs_sqlite3
 def test_sqlite_cache_corruption_is_reported_as_miss(tmp_path):
     import sqlite3
 
@@ -334,13 +350,15 @@ def test_sqlite_cache_corruption_is_reported_as_miss(tmp_path):
         assert b"k" not in cache  # corrupt entry was pruned
 
 
+@needs_sqlite3
 def test_sqlite_cache_rejects_non_object_code(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
     with SQLiteProgramCache(tmp_path / "cache.db") as cache, pytest.raises(TypeError, match="ObjectCode"):
         cache[b"k"] = b"not an ObjectCode"
 
 
+@needs_sqlite3
 def test_sqlite_cache_accepts_str_keys(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
@@ -352,6 +370,7 @@ def test_sqlite_cache_accepts_str_keys(tmp_path):
         assert b"str-key" in cache
 
 
+@needs_sqlite3
 def test_sqlite_cache_rejects_negative_size_cap(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
@@ -364,6 +383,7 @@ def test_sqlite_cache_rejects_negative_size_cap(tmp_path):
 # ---------------------------------------------------------------------------
 
 
+@needs_sqlite3
 def test_sqlite_cache_evicts_under_size_cap(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
@@ -380,6 +400,7 @@ def test_sqlite_cache_evicts_under_size_cap(tmp_path):
         assert b"c" in cache
 
 
+@needs_sqlite3
 def test_sqlite_cache_lru_order_respects_reads(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
@@ -399,6 +420,7 @@ def test_sqlite_cache_lru_order_respects_reads(tmp_path):
         assert b"c" in cache
 
 
+@needs_sqlite3
 def test_sqlite_cache_unbounded_by_default(tmp_path):
     from cuda.core.utils import SQLiteProgramCache
 
@@ -431,9 +453,9 @@ def test_filestream_cache_roundtrip(tmp_path):
         cache[b"k1"] = _fake_object_code(b"v1", name="x")
         assert b"k1" in cache
         got = cache[b"k1"]
-        assert bytes(got._module) == b"v1"
-        assert got._name == "x"
-        assert got._code_type == "cubin"
+        assert bytes(got.code) == b"v1"
+        assert got.name == "x"
+        assert got.code_type == "cubin"
 
 
 def test_filestream_cache_delete(tmp_path):
@@ -474,7 +496,7 @@ def test_filestream_cache_persists_across_reopen(tmp_path):
     with FileStreamProgramCache(root) as cache:
         cache[b"k"] = _fake_object_code(b"persisted")
     with FileStreamProgramCache(root) as cache:
-        assert bytes(cache[b"k"]._module) == b"persisted"
+        assert bytes(cache[b"k"].code) == b"persisted"
 
 
 def test_filestream_cache_atomic_no_half_written_file(tmp_path, monkeypatch):

cuda_core/tests/test_program_cache_multiprocess.py

@@ -62,7 +62,7 @@ def test_concurrent_writers_same_key_no_corruption(tmp_path):
 
     with FileStreamProgramCache(root) as cache:
         got = cache[b"shared"]  # must not raise; payload is one of the writers'
-        assert bytes(got._module).startswith(b"v")
+        assert bytes(got.code).startswith(b"v")
 
 
 def test_concurrent_writers_distinct_keys_all_survive(tmp_path):