cachu 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

cachu/__init__.py

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

cachu/backends/async_sqlite.py

@@ -33,95 +33,109 @@ 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.
+    def _schedule_delete(self, key: str) -> None:
+        """Schedule a background deletion task (fire-and-forget).
         """
-        async with self._lock:
+        async def _delete() -> None:
             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
-
-                value_blob, expires_at = row
-                if time.time() > expires_at:
+                async with self._write_lock:
+                    conn = await self._ensure_initialized()
                     await conn.execute('DELETE FROM cache WHERE key = ?', (key,))
                     await conn.commit()
-                    return NO_VALUE
-
-                return pickle.loads(value_blob)
             except Exception:
+                pass
+
+        asyncio.create_task(_delete())
+
+    async def get(self, key: str) -> Any:
+        """Get value by key. Returns NO_VALUE if not found or expired.
+        """
+        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
+
+            value_blob, expires_at = row
+            if time.time() > expires_at:
+                self._schedule_delete(key)
                 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:
+                self._schedule_delete(key)
                 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)
-                   VALUES (?, ?, ?, ?)''',
+                """INSERT OR REPLACE INTO cache (key, value, created_at, expires_at)
+                   VALUES (?, ?, ?, ?)""",
                 (key, value_blob, now, now + ttl),
             )
             await conn.commit()
@@ -129,7 +143,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 +154,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 +182,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 +206,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 +235,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.1.dist-info → cachu-0.2.3.dist-info}/METADATA

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

{cachu-0.2.1.dist-info → cachu-0.2.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-cachu/__init__.py,sha256=-eqMY3cCuepixdZ-FefQsRXPufVSgrEMlYkYwylSlTM,1286
+cachu/__init__.py,sha256=vMcuJYvSfRUsMwlFrpjS8FOuQiqPBP9e4dRlJbsvpZ0,1286
 cachu/async_decorator.py,sha256=Jx2fHESLlld7NZiD2-6kcozukJtp5efnt4cMhntDDRA,8939
 cachu/async_operations.py,sha256=eVqhZk3FVLNip_abjnCzG8AajzvJTtXbpL--dpMXBlc,5597
 cachu/config.py,sha256=KtcDGpSTJmjRrcNLz9_Om3O814oJJ3p8gntB84Pd6Dk,5922
@@ -10,12 +10,12 @@ cachu/backends/__init__.py,sha256=Jn2yBAMmJ8d0J_NyjOtxRt7UTyMLf1rlY8QJ049hXE8,13
 cachu/backends/async_base.py,sha256=oZ3K3PhsYkbgZxFLFk3_NbxBxtNopqS90HZBizwg_q8,1394
 cachu/backends/async_memory.py,sha256=SQvSHeWbySa52BnQLF75nhVXgsydubNu84a8hvSzQSc,3457
 cachu/backends/async_redis.py,sha256=8kefPIoIJDAZ6C6HJCvHqKFMDS10sJYh8YcJMpXpQm8,4455
-cachu/backends/async_sqlite.py,sha256=r-c1cNVl6JEApMGhw8Qw7843Vuj_LVRAM-MGgoIjah0,8423
+cachu/backends/async_sqlite.py,sha256=iS1YaVakzK7msKL3BVmnZc_n73-V5fUz1wCQJxEY0ak,8730
 cachu/backends/file.py,sha256=Pu01VtgHDgK6ev5hqyZXuJRCSB2VbNKHQ4w4nNKNyeI,298
 cachu/backends/memory.py,sha256=kIgrVU8k_3Aquyj2PDf8IPbTjCITM_0V5GU47m3fJmo,3138
 cachu/backends/redis.py,sha256=yE5rEBgOij9QOeC1VhWdIbGCgi442q-aWfmbbG4aNSE,3858
 cachu/backends/sqlite.py,sha256=whduN5G_bN6ZJNuCBwbraDcadv_sg0j-OEiFnP8EEsk,7803
-cachu-0.2.1.dist-info/METADATA,sha256=XZxtIkb4Mqd3Mbbw0DAlyfW5N1NJeUKiEPP6ybzIS8Q,11992
-cachu-0.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-cachu-0.2.1.dist-info/top_level.txt,sha256=g80nNoMvLMzhSwQWV-JotCBqtsLAHeFMBo_g8hCK8hQ,6
-cachu-0.2.1.dist-info/RECORD,,
+cachu-0.2.3.dist-info/METADATA,sha256=UXittsVjHwFjAGq6Fl8LAS_2zTKs14BYc9KvOEJHX9I,11992
+cachu-0.2.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cachu-0.2.3.dist-info/top_level.txt,sha256=g80nNoMvLMzhSwQWV-JotCBqtsLAHeFMBo_g8hCK8hQ,6
+cachu-0.2.3.dist-info/RECORD,,