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

cachu/backends/async_redis.py

@@ -1,141 +0,0 @@
-"""Async Redis cache backend implementation using redis.asyncio.
-"""
-import pickle
-import struct
-import time
-from collections.abc import AsyncIterator
-from typing import TYPE_CHECKING, Any
-
-from . import NO_VALUE
-from .async_base import AsyncBackend
-
-if TYPE_CHECKING:
-    import redis.asyncio as aioredis
-
-
-_METADATA_FORMAT = 'd'
-_METADATA_SIZE = struct.calcsize(_METADATA_FORMAT)
-
-
-def _get_async_redis_module() -> Any:
-    """Import redis.asyncio module, raising helpful error if not installed.
-    """
-    try:
-        import redis.asyncio as aioredis
-        return aioredis
-    except ImportError as e:
-        raise RuntimeError(
-            "Async Redis support requires the 'redis' package (>=4.2.0). "
-            "Install with: pip install cachu[redis]"
-        ) from e
-
-
-async def get_async_redis_client(url: str) -> 'aioredis.Redis':
-    """Create an async Redis client from URL.
-
-    Args:
-        url: Redis URL (e.g., 'redis://localhost:6379/0')
-    """
-    aioredis = _get_async_redis_module()
-    return aioredis.from_url(url)
-
-
-class AsyncRedisBackend(AsyncBackend):
-    """Async Redis cache backend using redis.asyncio.
-    """
-
-    def __init__(self, url: str, distributed_lock: bool = False) -> None:
-        self._url = url
-        self._distributed_lock = distributed_lock
-        self._client: aioredis.Redis | None = None
-
-    async def _get_client(self) -> 'aioredis.Redis':
-        """Lazy-load async Redis client.
-        """
-        if self._client is None:
-            self._client = await get_async_redis_client(self._url)
-        return self._client
-
-    def _pack_value(self, value: Any, created_at: float) -> bytes:
-        """Pack value with creation timestamp.
-        """
-        metadata = struct.pack(_METADATA_FORMAT, created_at)
-        pickled = pickle.dumps(value)
-        return metadata + pickled
-
-    def _unpack_value(self, data: bytes) -> tuple[Any, float]:
-        """Unpack value and creation timestamp.
-        """
-        created_at = struct.unpack(_METADATA_FORMAT, data[:_METADATA_SIZE])[0]
-        value = pickle.loads(data[_METADATA_SIZE:])
-        return value, created_at
-
-    async def get(self, key: str) -> Any:
-        """Get value by key. Returns NO_VALUE if not found.
-        """
-        client = await self._get_client()
-        data = await client.get(key)
-        if data is None:
-            return NO_VALUE
-        value, _ = self._unpack_value(data)
-        return 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.
-        """
-        client = await self._get_client()
-        data = await client.get(key)
-        if data is None:
-            return NO_VALUE, None
-        value, created_at = self._unpack_value(data)
-        return value, created_at
-
-    async def set(self, key: str, value: Any, ttl: int) -> None:
-        """Set value with TTL in seconds.
-        """
-        client = await self._get_client()
-        now = time.time()
-        packed = self._pack_value(value, now)
-        await client.setex(key, ttl, packed)
-
-    async def delete(self, key: str) -> None:
-        """Delete value by key.
-        """
-        client = await self._get_client()
-        await client.delete(key)
-
-    async def clear(self, pattern: str | None = None) -> int:
-        """Clear entries matching pattern. Returns count of cleared entries.
-        """
-        client = await self._get_client()
-        if pattern is None:
-            pattern = '*'
-
-        count = 0
-        async for key in client.scan_iter(match=pattern):
-            await client.delete(key)
-            count += 1
-        return count
-
-    async def keys(self, pattern: str | None = None) -> AsyncIterator[str]:
-        """Iterate over keys matching pattern.
-        """
-        client = await self._get_client()
-        redis_pattern = pattern or '*'
-        async for key in client.scan_iter(match=redis_pattern):
-            yield key.decode() if isinstance(key, bytes) else key
-
-    async def count(self, pattern: str | None = None) -> int:
-        """Count keys matching pattern.
-        """
-        count = 0
-        async for _ in self.keys(pattern):
-            count += 1
-        return count
-
-    async def close(self) -> None:
-        """Close the Redis connection.
-        """
-        if self._client is not None:
-            await self._client.close()
-            self._client = None

cachu/backends/async_sqlite.py

@@ -1,256 +0,0 @@
-"""Async SQLite-based cache backend using aiosqlite.
-"""
-import asyncio
-import pickle
-import time
-from collections.abc import AsyncIterator
-from typing import TYPE_CHECKING, Any
-
-from . import NO_VALUE
-from .async_base import AsyncBackend
-
-if TYPE_CHECKING:
-    import aiosqlite
-
-
-def _get_aiosqlite_module() -> Any:
-    """Import aiosqlite module, raising helpful error if not installed.
-    """
-    try:
-        import aiosqlite
-        return aiosqlite
-    except ImportError as e:
-        raise RuntimeError(
-            "Async SQLite support requires the 'aiosqlite' package. "
-            "Install with: pip install cachu[async]"
-        ) from e
-
-
-class AsyncSqliteBackend(AsyncBackend):
-    """Async SQLite file-based cache backend using aiosqlite.
-    """
-
-    def __init__(self, filepath: str) -> None:
-        self._filepath = filepath
-        self._connection: aiosqlite.Connection | None = None
-        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.
-        """
-        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
-
-    def _schedule_delete(self, key: str) -> None:
-        """Schedule a background deletion task (fire-and-forget).
-        """
-        async def _delete() -> None:
-            try:
-                async with self._write_lock:
-                    conn = await self._ensure_initialized()
-                    await conn.execute('DELETE FROM cache WHERE key = ?', (key,))
-                    await conn.commit()
-            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.
-        """
-        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
-
-            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._write_lock:
-            conn = await self._ensure_initialized()
-            await conn.execute(
-                """INSERT OR REPLACE INTO cache (key, value, created_at, expires_at)
-                   VALUES (?, ?, ?, ?)""",
-                (key, value_blob, now, now + ttl),
-            )
-            await conn.commit()
-
-    async def delete(self, key: str) -> None:
-        """Delete value by key.
-        """
-        async with self._write_lock:
-            try:
-                conn = await self._ensure_initialized()
-                await conn.execute('DELETE FROM cache WHERE key = ?', (key,))
-                await conn.commit()
-            except Exception:
-                pass
-
-    async def clear(self, pattern: str | None = None) -> int:
-        """Clear entries matching pattern. Returns count of cleared entries.
-        """
-        async with self._write_lock:
-            try:
-                conn = await self._ensure_initialized()
-                if pattern is None:
-                    cursor = await conn.execute('SELECT COUNT(*) FROM cache')
-                    row = await cursor.fetchone()
-                    count = row[0]
-                    await conn.execute('DELETE FROM cache')
-                    await conn.commit()
-                    return count
-
-                glob_pattern = self._fnmatch_to_glob(pattern)
-                cursor = await conn.execute(
-                    'SELECT COUNT(*) FROM cache WHERE key GLOB ?',
-                    (glob_pattern,),
-                )
-                row = await cursor.fetchone()
-                count = row[0]
-                await conn.execute('DELETE FROM cache WHERE key GLOB ?', (glob_pattern,))
-                await conn.commit()
-                return count
-            except Exception:
-                return 0
-
-    async def keys(self, pattern: str | None = None) -> AsyncIterator[str]:
-        """Iterate over keys matching pattern.
-        """
-        now = time.time()
-        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),
-            )
-
-        all_keys = [row[0] for row in await cursor.fetchall()]
-
-        for key in all_keys:
-            yield key
-
-    async def count(self, pattern: str | None = None) -> int:
-        """Count keys matching pattern.
-        """
-        now = time.time()
-
-        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
-
-    def _fnmatch_to_glob(self, pattern: str) -> str:
-        """Convert fnmatch pattern to SQLite GLOB pattern.
-        """
-        return pattern
-
-    async def cleanup_expired(self) -> int:
-        """Remove expired entries. Returns count of removed entries.
-        """
-        now = time.time()
-
-        async with self._write_lock:
-            conn = await self._ensure_initialized()
-            cursor = await conn.execute(
-                'SELECT COUNT(*) FROM cache WHERE expires_at <= ?',
-                (now,),
-            )
-            row = await cursor.fetchone()
-            count = row[0]
-            await conn.execute('DELETE FROM cache WHERE expires_at <= ?', (now,))
-            await conn.commit()
-            return count
-
-    async def close(self) -> None:
-        """Close the database connection.
-        """
-        if self._connection is not None:
-            await self._connection.close()
-            self._connection = None
-            self._initialized = False

cachu/backends/file.py

@@ -1,10 +0,0 @@
-"""File-based cache backend using SQLite.
-
-Note: This module previously used DBM. Migration to SQLite happened in v0.2.0.
-Existing DBM cache files will be ignored - clear your cache directory on upgrade.
-"""
-from .sqlite import SqliteBackend
-
-FileBackend = SqliteBackend
-
-__all__ = ['FileBackend']

cachu-0.2.3.dist-info/RECORD

@@ -1,21 +0,0 @@
-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
-cachu/decorator.py,sha256=RHwDRZxZfOkBgEK1XgRyis22bxQ0ba0X4NtHBd9FTb4,8161
-cachu/keys.py,sha256=fwwNOpnDJFCIWZoQ5UGJWhJa6xu36hsBsURI-n2NJKU,3557
-cachu/operations.py,sha256=t42_Er-O59vrwFa5jdf4yq3Jr4li2l7php4yMVJnxPs,5588
-cachu/types.py,sha256=FghBN5GhxnrpuT4WUL9iNnAfdoH__cw9_Ag4kHbIXq4,723
-cachu/backends/__init__.py,sha256=Jn2yBAMmJ8d0J_NyjOtxRt7UTyMLf1rlY8QJ049hXE8,1318
-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=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.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,,