cachu 0.2.3__tar.gz → 0.2.5__tar.gz

{cachu-0.2.3 → cachu-0.2.5}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.4
 Name: cachu
-Version: 0.2.3
+Version: 0.2.5
 Summary: Flexible caching library with sync and async support for memory, file (SQLite), and Redis backends
 Author: bissli
 License-Expression: 0BSD
 Project-URL: Repository, https://github.com/bissli/cachu.git
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: dogpile.cache
 Requires-Dist: func-timeout
 Provides-Extra: async
 Requires-Dist: aiosqlite; extra == "async"
@@ -69,19 +68,17 @@ cachu.configure(
     key_prefix='v1:',           # Prefix for all cache keys
     file_dir='/var/cache/app',  # Directory for file cache
     redis_url='redis://localhost:6379/0',  # Redis connection URL
-    redis_distributed=False,    # Use distributed locks for Redis
 )
 ```
 
 ### Configuration Options
 
-| Option              | Default                      | Description                                       |
-| ------------------- | ---------------------------- | ------------------------------------------------- |
-| `backend`           | `'memory'`                   | Default backend type                              |
-| `key_prefix`        | `''`                         | Prefix for all cache keys (useful for versioning) |
-| `file_dir`          | `'/tmp'`                     | Directory for file-based caches                   |
-| `redis_url`         | `'redis://localhost:6379/0'` | Redis connection URL                              |
-| `redis_distributed` | `False`                      | Enable distributed locks for Redis                |
+| Option       | Default                      | Description                                       |
+| ------------ | ---------------------------- | ------------------------------------------------- |
+| `backend`    | `'memory'`                   | Default backend type                              |
+| `key_prefix` | `''`                         | Prefix for all cache keys (useful for versioning) |
+| `file_dir`   | `'/tmp'`                     | Directory for file-based caches                   |
+| `redis_url`  | `'redis://localhost:6379/0'` | Redis connection URL                              |
 
 ### Package Isolation
 

{cachu-0.2.3 → cachu-0.2.5}/README.md

@@ -46,19 +46,17 @@ cachu.configure(
     key_prefix='v1:',           # Prefix for all cache keys
     file_dir='/var/cache/app',  # Directory for file cache
     redis_url='redis://localhost:6379/0',  # Redis connection URL
-    redis_distributed=False,    # Use distributed locks for Redis
 )
 ```
 
 ### Configuration Options
 
-| Option              | Default                      | Description                                       |
-| ------------------- | ---------------------------- | ------------------------------------------------- |
-| `backend`           | `'memory'`                   | Default backend type                              |
-| `key_prefix`        | `''`                         | Prefix for all cache keys (useful for versioning) |
-| `file_dir`          | `'/tmp'`                     | Directory for file-based caches                   |
-| `redis_url`         | `'redis://localhost:6379/0'` | Redis connection URL                              |
-| `redis_distributed` | `False`                      | Enable distributed locks for Redis                |
+| Option       | Default                      | Description                                       |
+| ------------ | ---------------------------- | ------------------------------------------------- |
+| `backend`    | `'memory'`                   | Default backend type                              |
+| `key_prefix` | `''`                         | Prefix for all cache keys (useful for versioning) |
+| `file_dir`   | `'/tmp'`                     | Directory for file-based caches                   |
+| `redis_url`  | `'redis://localhost:6379/0'` | Redis connection URL                              |
 
 ### Package Isolation
 

{cachu-0.2.3 → cachu-0.2.5}/pyproject.toml

@@ -1,26 +1,25 @@
 [project]
 name = "cachu"
-version = "0.2.3"
+version = "0.2.5"
 description = "Flexible caching library with sync and async support for memory, file (SQLite), and Redis backends"
 readme = "README.md"
 license = "0BSD"
 authors = [{ name = "bissli" }]
 requires-python = ">=3.10"
 dependencies = [
-    "dogpile.cache",
-    "func-timeout",
+  "func-timeout",
 ]
 
 [project.optional-dependencies]
 async = ["aiosqlite"]
 redis = ["redis>=4.2.0"]
 test = [
-    "pytest",
-    "pytest-asyncio",
-    "pytest-mock",
-    "redis>=4.2.0",
-    "testcontainers[redis]",
-    "aiosqlite",
+  "pytest",
+  "pytest-asyncio",
+  "pytest-mock",
+  "redis>=4.2.0",
+  "testcontainers[redis]",
+  "aiosqlite",
 ]
 
 [project.urls]

{cachu-0.2.3 → cachu-0.2.5}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.2.3
+current_version = 0.2.5
 commit = True
 tag = True
 

{cachu-0.2.3 → cachu-0.2.5}/src/cachu/__init__.py

@@ -1,19 +1,16 @@
 """Flexible caching library with support for memory, file, and Redis backends.
 """
-__version__ = '0.2.3'
+__version__ = '0.2.5'
 
-from .async_decorator import async_cache, clear_async_backends
-from .async_decorator import get_async_backend, get_async_cache_info
-from .async_operations import async_cache_clear, async_cache_delete
-from .async_operations import async_cache_get, async_cache_info
-from .async_operations import async_cache_set
-from .backends import AsyncBackend, Backend
+from .backends import Backend
 from .backends.redis import get_redis_client
 from .config import configure, disable, enable, get_all_configs, get_config
 from .config import is_disabled
-from .decorator import cache, get_backend
-from .operations import cache_clear, cache_delete, cache_get, cache_info
-from .operations import cache_set
+from .decorator import aget_backend, cache, clear_async_backends
+from .decorator import get_async_backend, get_async_cache_info, get_backend
+from .operations import async_cache_clear, async_cache_delete, async_cache_get
+from .operations import async_cache_info, async_cache_set, cache_clear
+from .operations import cache_delete, cache_get, cache_info, cache_set
 
 __all__ = [
     'configure',
@@ -29,10 +26,9 @@ __all__ = [
     'cache_clear',
     'cache_info',
     'get_backend',
+    'aget_backend',
     'get_redis_client',
     'Backend',
-    'AsyncBackend',
-    'async_cache',
     'async_cache_get',
     'async_cache_set',
     'async_cache_delete',

cachu-0.2.5/src/cachu/backends/__init__.py

@@ -0,0 +1,112 @@
+"""Cache backend implementations.
+"""
+from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator, Iterator
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ..mutex import AsyncCacheMutex, CacheMutex
+
+NO_VALUE = object()
+
+
+class Backend(ABC):
+    """Abstract base class for cache backends with both sync and async interfaces.
+    """
+
+    # ===== Sync interface =====
+
+    @abstractmethod
+    def get(self, key: str) -> Any:
+        """Get value by key. Returns NO_VALUE if not found.
+        """
+
+    @abstractmethod
+    def get_with_metadata(self, key: str) -> tuple[Any, float | None]:
+        """Get value and creation timestamp. Returns (NO_VALUE, None) if not found.
+        """
+
+    @abstractmethod
+    def set(self, key: str, value: Any, ttl: int) -> None:
+        """Set value with TTL in seconds.
+        """
+
+    @abstractmethod
+    def delete(self, key: str) -> None:
+        """Delete value by key.
+        """
+
+    @abstractmethod
+    def clear(self, pattern: str | None = None) -> int:
+        """Clear entries matching pattern. Returns count of cleared entries.
+        """
+
+    @abstractmethod
+    def keys(self, pattern: str | None = None) -> Iterator[str]:
+        """Iterate over keys matching pattern.
+        """
+
+    @abstractmethod
+    def count(self, pattern: str | None = None) -> int:
+        """Count keys matching pattern.
+        """
+
+    @abstractmethod
+    def get_mutex(self, key: str) -> 'CacheMutex':
+        """Get a mutex for dogpile prevention on the given key.
+        """
+
+    # ===== Async interface =====
+
+    @abstractmethod
+    async def aget(self, key: str) -> Any:
+        """Async get value by key. Returns NO_VALUE if not found.
+        """
+
+    @abstractmethod
+    async def aget_with_metadata(self, key: str) -> tuple[Any, float | None]:
+        """Async get value and creation timestamp. Returns (NO_VALUE, None) if not found.
+        """
+
+    @abstractmethod
+    async def aset(self, key: str, value: Any, ttl: int) -> None:
+        """Async set value with TTL in seconds.
+        """
+
+    @abstractmethod
+    async def adelete(self, key: str) -> None:
+        """Async delete value by key.
+        """
+
+    @abstractmethod
+    async def aclear(self, pattern: str | None = None) -> int:
+        """Async clear entries matching pattern. Returns count of cleared entries.
+        """
+
+    @abstractmethod
+    def akeys(self, pattern: str | None = None) -> AsyncIterator[str]:
+        """Async iterate over keys matching pattern.
+        """
+
+    @abstractmethod
+    async def acount(self, pattern: str | None = None) -> int:
+        """Async count keys matching pattern.
+        """
+
+    @abstractmethod
+    def get_async_mutex(self, key: str) -> 'AsyncCacheMutex':
+        """Get an async mutex for dogpile prevention on the given key.
+        """
+
+    # ===== Lifecycle =====
+
+    def close(self) -> None:
+        """Close the backend and release resources.
+        """
+
+    async def aclose(self) -> None:
+        """Async close the backend and release resources.
+        """
+
+
+__all__ = ['Backend', 'NO_VALUE']

cachu-0.2.5/src/cachu/backends/memory.py

@@ -0,0 +1,204 @@
+"""Memory cache backend implementation.
+"""
+import asyncio
+import fnmatch
+import pickle
+import threading
+import time
+from collections.abc import AsyncIterator, Iterator
+from typing import Any
+
+from ..mutex import AsyncioMutex, CacheMutex, ThreadingMutex
+from . import NO_VALUE, Backend
+
+
+class MemoryBackend(Backend):
+    """Thread-safe in-memory cache backend with both sync and async interfaces.
+    """
+
+    def __init__(self) -> None:
+        self._cache: dict[str, tuple[bytes, float, float]] = {}
+        self._sync_lock = threading.RLock()
+        self._async_lock: asyncio.Lock | None = None
+
+    def _get_async_lock(self) -> asyncio.Lock:
+        """Lazy-create async lock (must be called from async context).
+        """
+        if self._async_lock is None:
+            self._async_lock = asyncio.Lock()
+        return self._async_lock
+
+    # ===== Core logic (no locking) =====
+
+    def _do_get(self, key: str) -> tuple[Any, float | None]:
+        """Get value and metadata without locking.
+        """
+        entry = self._cache.get(key)
+        if entry is None:
+            return NO_VALUE, None
+
+        pickled_value, created_at, expires_at = entry
+        if time.time() > expires_at:
+            del self._cache[key]
+            return NO_VALUE, None
+
+        return pickle.loads(pickled_value), created_at
+
+    def _do_set(self, key: str, value: Any, ttl: int) -> None:
+        """Set value without locking.
+        """
+        now = time.time()
+        pickled_value = pickle.dumps(value)
+        self._cache[key] = (pickled_value, now, now + ttl)
+
+    def _do_delete(self, key: str) -> None:
+        """Delete value without locking.
+        """
+        self._cache.pop(key, None)
+
+    def _do_clear(self, pattern: str | None = None) -> int:
+        """Clear entries matching pattern without locking.
+        """
+        if pattern is None:
+            count = len(self._cache)
+            self._cache.clear()
+            return count
+
+        keys_to_delete = [k for k in self._cache if fnmatch.fnmatch(k, pattern)]
+        for key in keys_to_delete:
+            del self._cache[key]
+        return len(keys_to_delete)
+
+    def _do_keys(self, pattern: str | None = None) -> list[str]:
+        """Get keys matching pattern without locking (returns snapshot).
+        """
+        now = time.time()
+        result = []
+        keys_to_delete = []
+
+        for key, entry in list(self._cache.items()):
+            _, _, expires_at = entry
+            if now > expires_at:
+                keys_to_delete.append(key)
+                continue
+            if pattern is None or fnmatch.fnmatch(key, pattern):
+                result.append(key)
+
+        for key in keys_to_delete:
+            self._cache.pop(key, None)
+
+        return result
+
+    # ===== Sync interface =====
+
+    def get(self, key: str) -> Any:
+        """Get value by key. Returns NO_VALUE if not found or expired.
+        """
+        with self._sync_lock:
+            value, _ = self._do_get(key)
+            return value
+
+    def get_with_metadata(self, key: str) -> tuple[Any, float | None]:
+        """Get value and creation timestamp. Returns (NO_VALUE, None) if not found.
+        """
+        with self._sync_lock:
+            return self._do_get(key)
+
+    def set(self, key: str, value: Any, ttl: int) -> None:
+        """Set value with TTL in seconds.
+        """
+        with self._sync_lock:
+            self._do_set(key, value, ttl)
+
+    def delete(self, key: str) -> None:
+        """Delete value by key.
+        """
+        with self._sync_lock:
+            self._do_delete(key)
+
+    def clear(self, pattern: str | None = None) -> int:
+        """Clear entries matching pattern. Returns count of cleared entries.
+        """
+        with self._sync_lock:
+            return self._do_clear(pattern)
+
+    def keys(self, pattern: str | None = None) -> Iterator[str]:
+        """Iterate over keys matching pattern.
+        """
+        with self._sync_lock:
+            all_keys = self._do_keys(pattern)
+        yield from all_keys
+
+    def count(self, pattern: str | None = None) -> int:
+        """Count keys matching pattern.
+        """
+        with self._sync_lock:
+            return len(self._do_keys(pattern))
+
+    def get_mutex(self, key: str) -> CacheMutex:
+        """Get a mutex for dogpile prevention on the given key.
+        """
+        return ThreadingMutex(f'memory:{key}')
+
+    # ===== Async interface =====
+
+    async def aget(self, key: str) -> Any:
+        """Async get value by key. Returns NO_VALUE if not found or expired.
+        """
+        async with self._get_async_lock():
+            value, _ = self._do_get(key)
+            return value
+
+    async def aget_with_metadata(self, key: str) -> tuple[Any, float | None]:
+        """Async get value and creation timestamp. Returns (NO_VALUE, None) if not found.
+        """
+        async with self._get_async_lock():
+            return self._do_get(key)
+
+    async def aset(self, key: str, value: Any, ttl: int) -> None:
+        """Async set value with TTL in seconds.
+        """
+        async with self._get_async_lock():
+            self._do_set(key, value, ttl)
+
+    async def adelete(self, key: str) -> None:
+        """Async delete value by key.
+        """
+        async with self._get_async_lock():
+            self._do_delete(key)
+
+    async def aclear(self, pattern: str | None = None) -> int:
+        """Async clear entries matching pattern. Returns count of cleared entries.
+        """
+        async with self._get_async_lock():
+            return self._do_clear(pattern)
+
+    async def akeys(self, pattern: str | None = None) -> AsyncIterator[str]:
+        """Async iterate over keys matching pattern.
+        """
+        async with self._get_async_lock():
+            all_keys = self._do_keys(pattern)
+
+        for key in all_keys:
+            yield key
+
+    async def acount(self, pattern: str | None = None) -> int:
+        """Async count keys matching pattern.
+        """
+        async with self._get_async_lock():
+            return len(self._do_keys(pattern))
+
+    def get_async_mutex(self, key: str) -> AsyncioMutex:
+        """Get an async mutex for dogpile prevention on the given key.
+        """
+        return AsyncioMutex(f'memory:{key}')
+
+    # ===== Lifecycle =====
+
+    def close(self) -> None:
+        """Close the backend (no-op for memory backend).
+        """
+
+    async def aclose(self) -> None:
+        """Async close the backend (no-op for memory backend).
+        """