cachu 0.2.0__tar.gz → 0.2.2__tar.gz

{cachu-0.2.0 → cachu-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachu
-Version: 0.2.0
+Version: 0.2.2
 Summary: Flexible caching library with sync and async support for memory, file (SQLite), and Redis backends
 Author: bissli
 License-Expression: 0BSD

{cachu-0.2.0 → cachu-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cachu"
-version = "0.2.0"
+version = "0.2.2"
 description = "Flexible caching library with sync and async support for memory, file (SQLite), and Redis backends"
 readme = "README.md"
 license = "0BSD"

{cachu-0.2.0 → cachu-0.2.2}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.2.0
+current_version = 0.2.2
 commit = True
 tag = True
 

{cachu-0.2.0 → cachu-0.2.2}/src/cachu/__init__.py

@@ -1,6 +1,6 @@
 """Flexible caching library with support for memory, file, and Redis backends.
 """
-__version__ = '0.2.0'
+__version__ = '0.2.2'
 
 from .async_decorator import async_cache, clear_async_backends
 from .async_decorator import get_async_backend, get_async_cache_info

{cachu-0.2.0 → cachu-0.2.2}/src/cachu/async_decorator.py

@@ -66,7 +66,8 @@ async def _get_async_backend(package: str | None, backend_type: str, ttl: int) -
 async def get_async_backend(
     backend_type: str | None = None,
     package: str | None = None,
-    ttl: int = 300,
+    *,
+    ttl: int,
 ) -> AsyncBackend:
     """Get an async backend instance.
 

{cachu-0.2.0 → cachu-0.2.2}/src/cachu/backends/async_sqlite.py

@@ -33,91 +33,89 @@ class AsyncSqliteBackend(AsyncBackend):
     def __init__(self, filepath: str) -> None:
         self._filepath = filepath
         self._connection: aiosqlite.Connection | None = None
-        self._lock = asyncio.Lock()
+        self._init_lock = asyncio.Lock()
+        self._write_lock = asyncio.Lock()
         self._initialized = False
 
     async def _ensure_initialized(self) -> 'aiosqlite.Connection':
         """Ensure database is initialized and return connection.
         """
-        if self._connection is None:
-            aiosqlite = _get_aiosqlite_module()
-            self._connection = await aiosqlite.connect(self._filepath)
-
-        if not self._initialized:
-            await self._connection.execute('''
-                CREATE TABLE IF NOT EXISTS cache (
-                    key TEXT PRIMARY KEY,
-                    value BLOB NOT NULL,
-                    created_at REAL NOT NULL,
-                    expires_at REAL NOT NULL
-                )
-            ''')
-            await self._connection.execute('''
-                CREATE INDEX IF NOT EXISTS idx_cache_expires
-                ON cache(expires_at)
-            ''')
-            await self._connection.commit()
-            self._initialized = True
+        async with self._init_lock:
+            if self._connection is None:
+                aiosqlite = _get_aiosqlite_module()
+                self._connection = await aiosqlite.connect(self._filepath)
+                await self._connection.execute('PRAGMA journal_mode=WAL')
+                await self._connection.execute('PRAGMA busy_timeout=5000')
+
+            if not self._initialized:
+                await self._connection.execute('''
+                    CREATE TABLE IF NOT EXISTS cache (
+                        key TEXT PRIMARY KEY,
+                        value BLOB NOT NULL,
+                        created_at REAL NOT NULL,
+                        expires_at REAL NOT NULL
+                    )
+                ''')
+                await self._connection.execute('''
+                    CREATE INDEX IF NOT EXISTS idx_cache_expires
+                    ON cache(expires_at)
+                ''')
+                await self._connection.commit()
+                self._initialized = True
 
         return self._connection
 
     async def get(self, key: str) -> Any:
         """Get value by key. Returns NO_VALUE if not found or expired.
         """
-        async with self._lock:
-            try:
-                conn = await self._ensure_initialized()
-                cursor = await conn.execute(
-                    'SELECT value, expires_at FROM cache WHERE key = ?',
-                    (key,),
-                )
-                row = await cursor.fetchone()
-
-                if row is None:
-                    return NO_VALUE
+        try:
+            conn = await self._ensure_initialized()
+            cursor = await conn.execute(
+                'SELECT value, expires_at FROM cache WHERE key = ?',
+                (key,),
+            )
+            row = await cursor.fetchone()
 
-                value_blob, expires_at = row
-                if time.time() > expires_at:
-                    await conn.execute('DELETE FROM cache WHERE key = ?', (key,))
-                    await conn.commit()
-                    return NO_VALUE
+            if row is None:
+                return NO_VALUE
 
-                return pickle.loads(value_blob)
-            except Exception:
+            value_blob, expires_at = row
+            if time.time() > expires_at:
                 return NO_VALUE
 
+            return pickle.loads(value_blob)
+        except Exception:
+            return NO_VALUE
+
     async def get_with_metadata(self, key: str) -> tuple[Any, float | None]:
         """Get value and creation timestamp. Returns (NO_VALUE, None) if not found.
         """
-        async with self._lock:
-            try:
-                conn = await self._ensure_initialized()
-                cursor = await conn.execute(
-                    'SELECT value, created_at, expires_at FROM cache WHERE key = ?',
-                    (key,),
-                )
-                row = await cursor.fetchone()
-
-                if row is None:
-                    return NO_VALUE, None
+        try:
+            conn = await self._ensure_initialized()
+            cursor = await conn.execute(
+                'SELECT value, created_at, expires_at FROM cache WHERE key = ?',
+                (key,),
+            )
+            row = await cursor.fetchone()
 
-                value_blob, created_at, expires_at = row
-                if time.time() > expires_at:
-                    await conn.execute('DELETE FROM cache WHERE key = ?', (key,))
-                    await conn.commit()
-                    return NO_VALUE, None
+            if row is None:
+                return NO_VALUE, None
 
-                return pickle.loads(value_blob), created_at
-            except Exception:
+            value_blob, created_at, expires_at = row
+            if time.time() > expires_at:
                 return NO_VALUE, None
 
+            return pickle.loads(value_blob), created_at
+        except Exception:
+            return NO_VALUE, None
+
     async def set(self, key: str, value: Any, ttl: int) -> None:
         """Set value with TTL in seconds.
         """
         now = time.time()
         value_blob = pickle.dumps(value)
 
-        async with self._lock:
+        async with self._write_lock:
             conn = await self._ensure_initialized()
             await conn.execute(
                 '''INSERT OR REPLACE INTO cache (key, value, created_at, expires_at)
@@ -129,7 +127,7 @@ class AsyncSqliteBackend(AsyncBackend):
     async def delete(self, key: str) -> None:
         """Delete value by key.
         """
-        async with self._lock:
+        async with self._write_lock:
             try:
                 conn = await self._ensure_initialized()
                 await conn.execute('DELETE FROM cache WHERE key = ?', (key,))
@@ -140,7 +138,7 @@ class AsyncSqliteBackend(AsyncBackend):
     async def clear(self, pattern: str | None = None) -> int:
         """Clear entries matching pattern. Returns count of cleared entries.
         """
-        async with self._lock:
+        async with self._write_lock:
             try:
                 conn = await self._ensure_initialized()
                 if pattern is None:
@@ -168,22 +166,21 @@ class AsyncSqliteBackend(AsyncBackend):
         """Iterate over keys matching pattern.
         """
         now = time.time()
+        conn = await self._ensure_initialized()
 
-        async with self._lock:
-            conn = await self._ensure_initialized()
-            if pattern is None:
-                cursor = await conn.execute(
-                    'SELECT key FROM cache WHERE expires_at > ?',
-                    (now,),
-                )
-            else:
-                glob_pattern = self._fnmatch_to_glob(pattern)
-                cursor = await conn.execute(
-                    'SELECT key FROM cache WHERE key GLOB ? AND expires_at > ?',
-                    (glob_pattern, now),
-                )
+        if pattern is None:
+            cursor = await conn.execute(
+                'SELECT key FROM cache WHERE expires_at > ?',
+                (now,),
+            )
+        else:
+            glob_pattern = self._fnmatch_to_glob(pattern)
+            cursor = await conn.execute(
+                'SELECT key FROM cache WHERE key GLOB ? AND expires_at > ?',
+                (glob_pattern, now),
+            )
 
-            all_keys = [row[0] for row in await cursor.fetchall()]
+        all_keys = [row[0] for row in await cursor.fetchall()]
 
         for key in all_keys:
             yield key
@@ -193,25 +190,24 @@ class AsyncSqliteBackend(AsyncBackend):
         """
         now = time.time()
 
-        async with self._lock:
-            try:
-                conn = await self._ensure_initialized()
-                if pattern is None:
-                    cursor = await conn.execute(
-                        'SELECT COUNT(*) FROM cache WHERE expires_at > ?',
-                        (now,),
-                    )
-                else:
-                    glob_pattern = self._fnmatch_to_glob(pattern)
-                    cursor = await conn.execute(
-                        'SELECT COUNT(*) FROM cache WHERE key GLOB ? AND expires_at > ?',
-                        (glob_pattern, now),
-                    )
+        try:
+            conn = await self._ensure_initialized()
+            if pattern is None:
+                cursor = await conn.execute(
+                    'SELECT COUNT(*) FROM cache WHERE expires_at > ?',
+                    (now,),
+                )
+            else:
+                glob_pattern = self._fnmatch_to_glob(pattern)
+                cursor = await conn.execute(
+                    'SELECT COUNT(*) FROM cache WHERE key GLOB ? AND expires_at > ?',
+                    (glob_pattern, now),
+                )
 
-                row = await cursor.fetchone()
-                return row[0]
-            except Exception:
-                return 0
+            row = await cursor.fetchone()
+            return row[0]
+        except Exception:
+            return 0
 
     def _fnmatch_to_glob(self, pattern: str) -> str:
         """Convert fnmatch pattern to SQLite GLOB pattern.
@@ -223,7 +219,7 @@ class AsyncSqliteBackend(AsyncBackend):
         """
         now = time.time()
 
-        async with self._lock:
+        async with self._write_lock:
             conn = await self._ensure_initialized()
             cursor = await conn.execute(
                 'SELECT COUNT(*) FROM cache WHERE expires_at <= ?',

{cachu-0.2.0 → cachu-0.2.2}/src/cachu/decorator.py

@@ -4,9 +4,9 @@ import logging
 import os
 import threading
 import time
+from collections.abc import Callable
 from functools import wraps
 from typing import Any
-from collections.abc import Callable
 
 from .backends import NO_VALUE, Backend
 from .backends.file import FileBackend
@@ -61,7 +61,7 @@ def _get_backend(package: str | None, backend_type: str, ttl: int) -> Backend:
         return backend
 
 
-def get_backend(backend_type: str | None = None, package: str | None = None, ttl: int = 300) -> Backend:
+def get_backend(backend_type: str | None = None, package: str | None = None, *, ttl: int) -> Backend:
     """Get a backend instance.
 
     Args:

{cachu-0.2.0 → cachu-0.2.2}/src/cachu.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachu
-Version: 0.2.0
+Version: 0.2.2
 Summary: Flexible caching library with sync and async support for memory, file (SQLite), and Redis backends
 Author: bissli
 License-Expression: 0BSD

{cachu-0.2.0 → cachu-0.2.2}/src/cachu.egg-info/SOURCES.txt

@@ -39,4 +39,5 @@ tests/test_namespace.py
 tests/test_namespace_isolation.py
 tests/test_redis_cache.py
 tests/test_set_keys.py
-tests/test_sqlite_backend.py
+tests/test_sqlite_backend.py
+tests/test_ttl_isolation.py

cachu-0.2.2/tests/test_ttl_isolation.py

@@ -0,0 +1,246 @@
+"""Tests for TTL-based backend isolation.
+
+These tests verify that different TTL values result in separate backends
+(and separate database files for file backend), documenting the behavior
+that can cause confusion when using get_async_backend() without matching TTL.
+"""
+import cachu
+import pytest
+from cachu.async_decorator import _get_async_backend, get_async_backend
+from cachu.decorator import _get_backend, clear_backends, get_backend
+
+
+@pytest.fixture(autouse=True)
+async def clear_async_backends():
+    """Clear async backends before and after each test.
+    """
+    await cachu.clear_async_backends()
+    yield
+    await cachu.clear_async_backends()
+
+
+@pytest.fixture(autouse=True)
+def clear_sync_backends():
+    """Clear sync backends before and after each test.
+    """
+    clear_backends()
+    yield
+    clear_backends()
+
+
+async def test_different_ttl_creates_separate_backends_memory(temp_cache_dir):
+    """Verify different TTLs create separate memory backend instances.
+    """
+    backend_5min = await _get_async_backend(None, 'memory', 300)
+    backend_24h = await _get_async_backend(None, 'memory', 86400)
+
+    assert backend_5min is not backend_24h
+
+
+async def test_same_ttl_reuses_backend(temp_cache_dir):
+    """Verify same TTL reuses the same backend instance.
+    """
+    backend1 = await _get_async_backend(None, 'memory', 300)
+    backend2 = await _get_async_backend(None, 'memory', 300)
+
+    assert backend1 is backend2
+
+
+async def test_ttl_to_filename_seconds(temp_cache_dir):
+    """Verify TTL < 60s maps to cache{ttl}sec.db filename.
+    """
+    backend = await _get_async_backend(None, 'file', 30)
+    assert 'cache30sec.db' in backend._filepath
+
+
+async def test_ttl_to_filename_minutes(temp_cache_dir):
+    """Verify TTL 60-3599s maps to cache{minutes}min.db filename.
+    """
+    backend = await _get_async_backend(None, 'file', 300)
+    assert 'cache5min.db' in backend._filepath
+
+
+async def test_ttl_to_filename_hours(temp_cache_dir):
+    """Verify TTL >= 3600s maps to cache{hours}hour.db filename.
+    """
+    backend = await _get_async_backend(None, 'file', 86400)
+    assert 'cache24hour.db' in backend._filepath
+
+
+async def test_different_ttl_uses_different_files(temp_cache_dir):
+    """Verify different TTLs create backends with different database files.
+    """
+    backend_5min = await _get_async_backend(None, 'file', 300)
+    backend_24h = await _get_async_backend(None, 'file', 86400)
+
+    assert backend_5min._filepath != backend_24h._filepath
+    assert 'cache5min.db' in backend_5min._filepath
+    assert 'cache24hour.db' in backend_24h._filepath
+
+
+async def test_count_returns_zero_with_wrong_ttl(temp_cache_dir):
+    """Document gotcha: count() returns 0 when querying with wrong TTL.
+
+    This test documents the behavior that caused the kynex-proxy bug:
+    caching with ttl=86400 but querying count with ttl=300 returns 0
+    because they use different database files.
+    """
+    backend_cache = await _get_async_backend(None, 'file', 86400)
+    await backend_cache.set('key1', 'value1', 86400)
+    await backend_cache.set('key2', 'value2', 86400)
+
+    backend_query = await _get_async_backend(None, 'file', 300)
+    wrong_ttl_count = await backend_query.count()
+
+    correct_ttl_count = await backend_cache.count()
+
+    assert wrong_ttl_count == 0
+    assert correct_ttl_count == 2
+
+
+async def test_get_async_backend_public_api_with_ttl(temp_cache_dir):
+    """Verify public get_async_backend() respects TTL parameter.
+    """
+    backend1 = await get_async_backend(backend_type='file', ttl=300)
+    backend2 = await get_async_backend(backend_type='file', ttl=86400)
+
+    assert backend1 is not backend2
+    assert 'cache5min.db' in backend1._filepath
+    assert 'cache24hour.db' in backend2._filepath
+
+
+async def test_async_get_backend_requires_ttl(temp_cache_dir):
+    """Verify get_async_backend() requires ttl parameter.
+    """
+    with pytest.raises(TypeError, match='ttl'):
+        await get_async_backend(backend_type='file')
+
+
+async def test_decorator_and_get_backend_must_match_ttl(temp_cache_dir):
+    """Demonstrate correct pattern: decorator TTL must match get_backend TTL.
+    """
+    call_count = 0
+
+    @cachu.async_cache(ttl=86400, backend='file')
+    async def cached_func(x: int) -> int:
+        nonlocal call_count
+        call_count += 1
+        return x * 2
+
+    await cached_func(5)
+    assert call_count == 1
+
+    backend_correct = await get_async_backend(backend_type='file', ttl=86400)
+    correct_count = await backend_correct.count()
+    assert correct_count >= 1
+
+    backend_wrong = await get_async_backend(backend_type='file', ttl=300)
+    wrong_count = await backend_wrong.count()
+    assert wrong_count == 0
+
+
+def test_sync_different_ttl_creates_separate_backends_memory(temp_cache_dir):
+    """Verify different TTLs create separate memory backend instances.
+    """
+    backend_5min = _get_backend(None, 'memory', 300)
+    backend_24h = _get_backend(None, 'memory', 86400)
+
+    assert backend_5min is not backend_24h
+
+
+def test_sync_same_ttl_reuses_backend(temp_cache_dir):
+    """Verify same TTL reuses the same backend instance.
+    """
+    backend1 = _get_backend(None, 'memory', 300)
+    backend2 = _get_backend(None, 'memory', 300)
+
+    assert backend1 is backend2
+
+
+def test_sync_ttl_to_filename_seconds(temp_cache_dir):
+    """Verify TTL < 60s maps to cache{ttl}sec.db filename.
+    """
+    backend = _get_backend(None, 'file', 30)
+    assert 'cache30sec.db' in backend._filepath
+
+
+def test_sync_ttl_to_filename_minutes(temp_cache_dir):
+    """Verify TTL 60-3599s maps to cache{minutes}min.db filename.
+    """
+    backend = _get_backend(None, 'file', 300)
+    assert 'cache5min.db' in backend._filepath
+
+
+def test_sync_ttl_to_filename_hours(temp_cache_dir):
+    """Verify TTL >= 3600s maps to cache{hours}hour.db filename.
+    """
+    backend = _get_backend(None, 'file', 86400)
+    assert 'cache24hour.db' in backend._filepath
+
+
+def test_sync_different_ttl_uses_different_files(temp_cache_dir):
+    """Verify different TTLs create backends with different database files.
+    """
+    backend_5min = _get_backend(None, 'file', 300)
+    backend_24h = _get_backend(None, 'file', 86400)
+
+    assert backend_5min._filepath != backend_24h._filepath
+    assert 'cache5min.db' in backend_5min._filepath
+    assert 'cache24hour.db' in backend_24h._filepath
+
+
+def test_sync_count_returns_zero_with_wrong_ttl(temp_cache_dir):
+    """Document gotcha: count() returns 0 when querying with wrong TTL.
+    """
+    backend_cache = _get_backend(None, 'file', 86400)
+    backend_cache.set('key1', 'value1', 86400)
+    backend_cache.set('key2', 'value2', 86400)
+
+    backend_query = _get_backend(None, 'file', 300)
+    wrong_ttl_count = backend_query.count()
+
+    correct_ttl_count = backend_cache.count()
+
+    assert wrong_ttl_count == 0
+    assert correct_ttl_count == 2
+
+
+def test_sync_get_backend_public_api_with_ttl(temp_cache_dir):
+    """Verify public get_backend() respects TTL parameter.
+    """
+    backend1 = get_backend(backend_type='file', ttl=300)
+    backend2 = get_backend(backend_type='file', ttl=86400)
+
+    assert backend1 is not backend2
+    assert 'cache5min.db' in backend1._filepath
+    assert 'cache24hour.db' in backend2._filepath
+
+
+def test_sync_get_backend_requires_ttl(temp_cache_dir):
+    """Verify get_backend() requires ttl parameter.
+    """
+    with pytest.raises(TypeError, match='ttl'):
+        get_backend(backend_type='file')
+
+
+def test_sync_decorator_and_get_backend_must_match_ttl(temp_cache_dir):
+    """Demonstrate correct pattern: decorator TTL must match get_backend TTL.
+    """
+    call_count = 0
+
+    @cachu.cache(ttl=86400, backend='file')
+    def cached_func(x: int) -> int:
+        nonlocal call_count
+        call_count += 1
+        return x * 2
+
+    cached_func(5)
+    assert call_count == 1
+
+    backend_correct = get_backend(backend_type='file', ttl=86400)
+    correct_count = backend_correct.count()
+    assert correct_count >= 1
+
+    backend_wrong = get_backend(backend_type='file', ttl=300)
+    wrong_count = backend_wrong.count()
+    assert wrong_count == 0