cachu 0.2.0__py3-none-any.whl → 0.2.2__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.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/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/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/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.dist-info → cachu-0.2.2.dist-info}/METADATA

@@ -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.dist-info → cachu-0.2.2.dist-info}/RECORD

@@ -1,9 +1,8 @@
-cachu/__init__.py,sha256=w2QlqHCWnPbnj_JL2zcW3Maa03PYuWU9IR3GABNiq8A,1286
-cachu/async_decorator.py,sha256=NSCOrgKPRyqQz-VaN1iq3fqjwWuJHDFS-15Dw3aFRP8,8938
+cachu/__init__.py,sha256=aJsGOKN5kfurhCuJjlefhO1yCZFxgf1P7JZk44Jxofc,1286
+cachu/async_decorator.py,sha256=Jx2fHESLlld7NZiD2-6kcozukJtp5efnt4cMhntDDRA,8939
 cachu/async_operations.py,sha256=eVqhZk3FVLNip_abjnCzG8AajzvJTtXbpL--dpMXBlc,5597
-cachu/cache.py,sha256=UOh1hsvo5wqpf-quU0glGZi5bgjF8gkaSmYIkAwWfUA,23362
 cachu/config.py,sha256=KtcDGpSTJmjRrcNLz9_Om3O814oJJ3p8gntB84Pd6Dk,5922
-cachu/decorator.py,sha256=aNI7tSr74BeZAGa3Wti0I3M8MVtuFa5HSuvfL4jLqs4,8164
+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
@@ -11,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=HbdV1ih-xMSfl8a4-S8xhyiFjkEBPwDlDkCT9AMe4Us,8143
 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.0.dist-info/METADATA,sha256=NTgzp45Dx6tQfD_xS_evTkYFAiiuKkSfinOsGGpocOI,11992
-cachu-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-cachu-0.2.0.dist-info/top_level.txt,sha256=g80nNoMvLMzhSwQWV-JotCBqtsLAHeFMBo_g8hCK8hQ,6
-cachu-0.2.0.dist-info/RECORD,,
+cachu-0.2.2.dist-info/METADATA,sha256=dZL33-xMXzoEepH7HJ1BhSYyS14NFQj8E4wTW6cVEk4,11992
+cachu-0.2.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cachu-0.2.2.dist-info/top_level.txt,sha256=g80nNoMvLMzhSwQWV-JotCBqtsLAHeFMBo_g8hCK8hQ,6
+cachu-0.2.2.dist-info/RECORD,,

cachu/cache.py

@@ -1,636 +0,0 @@
-import dbm
-import inspect
-import logging
-import os
-import pathlib
-import threading
-from collections.abc import Callable
-from functools import partial, wraps
-from typing import Any
-
-from dogpile.cache import CacheRegion, make_region
-from dogpile.cache.backends.file import AbstractFileLock
-from dogpile.cache.region import DefaultInvalidationStrategy
-from dogpile.util.readwrite_lock import ReadWriteMutex
-
-from .config import _get_caller_package, config, get_config, is_disabled
-
-logger = logging.getLogger(__name__)
-
-
-def _is_connection_like(obj: Any) -> bool:
-    """Check if object appears to be a database connection.
-    """
-    if hasattr(obj, 'driver_connection'):
-        return True
-
-    if hasattr(obj, 'dialect'):
-        return True
-
-    if hasattr(obj, 'engine'):
-        return True
-
-    obj_type = str(type(obj))
-    connection_indicators = ('Connection', 'Engine', 'psycopg', 'pyodbc', 'sqlite3')
-
-    return any(indicator in obj_type for indicator in connection_indicators)
-
-
-def _normalize_namespace(namespace: str) -> str:
-    """Normalize namespace to always be wrapped in pipes.
-    """
-    if not namespace:
-        return ''
-    namespace = namespace.strip('|')
-    namespace = namespace.replace('|', '.')
-    return f'|{namespace}|'
-
-
-def _create_namespace_filter(namespace: str) -> Callable[[str], bool]:
-    """Create a filter function for namespace-based key matching.
-    """
-    debug_prefix = config.debug_key
-    normalized_ns = _normalize_namespace(namespace)
-    namespace_pattern = f'|{normalized_ns}|'
-
-    def matches_namespace(key: str) -> bool:
-        if not key.startswith(debug_prefix):
-            return False
-        key_after_prefix = key[len(debug_prefix):]
-        return namespace_pattern in key_after_prefix
-
-    return matches_namespace
-
-
-def key_generator(namespace: str, fn: Callable[..., Any], exclude_params: set[str] | None = None) -> Callable[..., str]:
-    """Generate a cache key for the given namespace and function.
-    """
-    exclude_params = exclude_params or set()
-    unwrapped_fn = getattr(fn, '__wrapped__', fn)
-    namespace = f'{unwrapped_fn.__name__}|{_normalize_namespace(namespace)}' if namespace else f'{unwrapped_fn.__name__}'
-
-    argspec = inspect.getfullargspec(unwrapped_fn)
-    _args_reversed = list(reversed(argspec.args or []))
-    _defaults_reversed = list(reversed(argspec.defaults or []))
-    args_with_defaults = { _args_reversed[i]: default for i, default in enumerate(_defaults_reversed)}
-
-    def generate_key(*args, **kwargs) -> str:
-        args, vargs = args[:len(argspec.args)], args[len(argspec.args):]
-        as_kwargs = dict(**args_with_defaults)
-        as_kwargs.update(dict(zip(argspec.args, args)))
-        as_kwargs.update({f'vararg{i+1}': varg for i, varg in enumerate(vargs)})
-        as_kwargs.update(**kwargs)
-        as_kwargs = {k: v for k, v in as_kwargs.items() if not _is_connection_like(v) and k not in {'self', 'cls'}}
-        as_kwargs = {k: v for k, v in as_kwargs.items() if not k.startswith('_') and k not in exclude_params}
-        as_str = ' '.join(f'{str(k)}={repr(v)}' for k, v in sorted(as_kwargs.items()))
-        return f'{namespace}|{as_str}'
-
-    return generate_key
-
-
-def key_mangler_default(key: str) -> str:
-    """Modify the key for debugging purposes by prefixing it with a debug marker.
-    """
-    return f'{config.debug_key}{key}'
-
-
-def key_mangler_region(key: str, region: str) -> str:
-    """Modify the key for a specific region for debugging purposes.
-    """
-    return f'{region}:{config.debug_key}{key}'
-
-
-def _make_key_mangler(debug_key: str) -> Callable[[str], str]:
-    """Create a key mangler with a captured debug_key.
-    """
-    def mangler(key: str) -> str:
-        return f'{debug_key}{key}'
-    return mangler
-
-
-def _make_region_key_mangler(debug_key: str, region_name: str) -> Callable[[str], str]:
-    """Create a region key mangler with captured debug_key and region name.
-    """
-    def mangler(key: str) -> str:
-        return f'{region_name}:{debug_key}{key}'
-    return mangler
-
-
-def should_cache_fn(value: Any) -> bool:
-    """Determine if the given value should be cached.
-    """
-    return bool(value)
-
-
-def _seconds_to_region_name(seconds: int) -> str:
-    """Convert seconds to a human-readable region name.
-    """
-    if seconds < 60:
-        return f'{seconds}s'
-    elif seconds < 3600:
-        return f'{seconds // 60}m'
-    elif seconds < 86400:
-        return f'{seconds // 3600}h'
-    else:
-        return f'{seconds // 86400}d'
-
-
-def get_redis_client(namespace: str | None = None) -> Any:
-    """Create a Redis client directly from config.
-    """
-    try:
-        import redis
-    except ImportError as e:
-        raise RuntimeError(
-            "Redis support requires the 'redis' package. Install with: pip install redis"
-        ) from e
-    if namespace is None:
-        namespace = _get_caller_package()
-    cfg = get_config(namespace)
-    connection_kwargs = {}
-    if cfg.redis_ssl:
-        connection_kwargs['ssl'] = True
-    return redis.Redis(
-        host=cfg.redis_host,
-        port=cfg.redis_port,
-        db=cfg.redis_db,
-        **connection_kwargs
-    )
-
-
-class CacheRegionWrapper:
-    """Wrapper for CacheRegion that adds exclude_params support.
-    """
-
-    def __init__(self, region: CacheRegion) -> None:
-        self._region = region
-        self._original_cache_on_arguments = region.cache_on_arguments
-
-    def cache_on_arguments(
-        self,
-        namespace: str = '',
-        should_cache_fn: Callable[[Any], bool] = should_cache_fn,
-        exclude_params: set[str] | None = None,
-        **kwargs) -> Callable:
-        """Cache function results based on arguments with optional parameter exclusion.
-        """
-        if exclude_params:
-            custom_key_gen = partial(key_generator, exclude_params=exclude_params)
-            cache_decorator = self._original_cache_on_arguments(
-                namespace=namespace,
-                should_cache_fn=should_cache_fn,
-                function_key_generator=custom_key_gen,
-                **kwargs
-            )
-        else:
-            cache_decorator = self._original_cache_on_arguments(
-                namespace=namespace,
-                should_cache_fn=should_cache_fn,
-                **kwargs
-            )
-
-        def decorator(fn: Callable) -> Callable:
-            cached_fn = cache_decorator(fn)
-
-            @wraps(fn)
-            def wrapper(*args, **kw):
-                if is_disabled():
-                    return fn(*args, **kw)
-                return cached_fn(*args, **kw)
-            return wrapper
-        return decorator
-
-    def __getattr__(self, name: str) -> Any:
-        """Delegate all other attributes to the wrapped region.
-        """
-        return getattr(self._region, name)
-
-
-def _wrap_cache_on_arguments(region: CacheRegion) -> CacheRegionWrapper:
-    """Wrap CacheRegion to add exclude_params support with proper IDE typing.
-    """
-    return CacheRegionWrapper(region)
-
-
-class CustomFileLock(AbstractFileLock):
-    """Implementation of a file lock using a read-write mutex.
-    """
-
-    def __init__(self, filename: str) -> None:
-        self.mutex = ReadWriteMutex()
-
-    def acquire_read_lock(self, wait: bool) -> bool:
-        """Acquire the read lock.
-        """
-        ret = self.mutex.acquire_read_lock(wait)
-        return wait or ret
-
-    def acquire_write_lock(self, wait: bool) -> bool:
-        """Acquire the write lock.
-        """
-        ret = self.mutex.acquire_write_lock(wait)
-        return wait or ret
-
-    def release_read_lock(self) -> bool:
-        """Release the read lock.
-        """
-        return self.mutex.release_read_lock()
-
-    def release_write_lock(self) -> bool:
-        """Release the write lock.
-        """
-        return self.mutex.release_write_lock()
-
-
-class RedisInvalidator(DefaultInvalidationStrategy):
-    """Redis invalidation strategy with optional key deletion.
-    """
-
-    def __init__(self, region: CacheRegion, delete_keys: bool = False) -> None:
-        """Initialize the RedisInvalidator for a given CacheRegion.
-        """
-        self.region = region
-        self.delete_keys = delete_keys
-        super().__init__()
-
-    def invalidate(self, hard: bool = True) -> None:
-        """Invalidate the cache region using timestamp-based invalidation.
-        """
-        super().invalidate(hard)
-        if self.delete_keys:
-            self._delete_backend_keys()
-
-    def _delete_backend_keys(self) -> None:
-        """Delete keys from Redis backend for this region.
-        """
-        try:
-            client = self.region.backend.writer_client
-            region_prefix = f'{self.region.name}:'
-            deleted_count = 0
-            for key in client.scan_iter(match=f'{region_prefix}*'):
-                client.delete(key)
-                deleted_count += 1
-            logger.debug(f'Deleted {deleted_count} Redis keys for region "{self.region.name}"')
-        except Exception as e:
-            logger.warning(f'Failed to delete Redis keys for region "{self.region.name}": {e}')
-
-
-def _handle_all_regions(regions_dict: dict[tuple[str | None, int], CacheRegionWrapper], log_level: str = 'warning') -> Callable:
-    """Decorator to handle clearing all cache regions when seconds=None.
-    """
-    def decorator(func: Callable) -> Callable:
-        @wraps(func)
-        def wrapper(
-            seconds: int | None = None,
-            namespace: str | None = None,
-            *,
-            package: str | None = None,
-        ) -> None:
-            resolved_ns = package if package is not None else _get_caller_package()
-            if seconds is None:
-                regions_to_clear = [
-                    (ns, secs) for (ns, secs) in regions_dict
-                    if ns == resolved_ns
-                ]
-                if not regions_to_clear:
-                    log_func = getattr(logger, log_level)
-                    cache_type = func.__name__.replace('clear_', '').replace('cache', ' cache')
-                    log_func(f'No{cache_type} regions exist for namespace "{resolved_ns}"')
-                    return
-                for _, region_seconds in regions_to_clear:
-                    func(region_seconds, namespace, _resolved_namespace=resolved_ns)
-                return
-            return func(seconds, namespace, _resolved_namespace=resolved_ns)
-        return wrapper
-    return decorator
-
-
-_region_lock = threading.Lock()
-_memory_cache_regions: dict[tuple[str | None, int], CacheRegionWrapper] = {}
-
-
-def memorycache(seconds: int, *, package: str | None = None) -> CacheRegionWrapper:
-    """Create or retrieve a memory cache region with a specified expiration time.
-    """
-    with _region_lock:
-        namespace = package if package is not None else _get_caller_package()
-        cfg = get_config(namespace)
-        key = (namespace, seconds)
-
-        if key not in _memory_cache_regions:
-            region = make_region(
-                function_key_generator=key_generator,
-                key_mangler=_make_key_mangler(cfg.debug_key),
-            ).configure(
-                cfg.memory,
-                expiration_time=seconds,
-            )
-            _memory_cache_regions[key] = _wrap_cache_on_arguments(region)
-            logger.debug(f"Created memory cache region for namespace '{namespace}', {seconds}s TTL")
-        return _memory_cache_regions[key]
-
-
-_file_cache_regions: dict[tuple[str | None, int], CacheRegionWrapper] = {}
-
-
-def filecache(seconds: int, *, package: str | None = None) -> CacheRegionWrapper:
-    """Create or retrieve a file cache region with a specified expiration time.
-    """
-    with _region_lock:
-        namespace = package if package is not None else _get_caller_package()
-        cfg = get_config(namespace)
-        key = (namespace, seconds)
-
-        if seconds < 60:
-            filename = f'cache{seconds}sec'
-        elif seconds < 3600:
-            filename = f'cache{seconds // 60}min'
-        else:
-            filename = f'cache{seconds // 3600}hour'
-
-        if namespace:
-            filename = f'{namespace}_{filename}'
-
-        if key not in _file_cache_regions:
-            if cfg.file == 'dogpile.cache.null':
-                logger.debug(
-                    f"filecache() called from '{namespace}' with null backend - "
-                    f"caching disabled for this region."
-                )
-                name = _seconds_to_region_name(seconds)
-                region = make_region(name=name, function_key_generator=key_generator,
-                                     key_mangler=_make_key_mangler(cfg.debug_key))
-                region.configure('dogpile.cache.null')
-            else:
-                region = make_region(
-                    function_key_generator=key_generator,
-                    key_mangler=_make_key_mangler(cfg.debug_key),
-                ).configure(
-                    cfg.file,
-                    expiration_time=seconds,
-                    arguments={
-                        'filename': os.path.join(cfg.tmpdir, filename),
-                        'lock_factory': CustomFileLock
-                    }
-                )
-                logger.debug(f"Created file cache region for namespace '{namespace}', {seconds}s TTL")
-            _file_cache_regions[key] = _wrap_cache_on_arguments(region)
-        return _file_cache_regions[key]
-
-
-_redis_cache_regions: dict[tuple[str | None, int], CacheRegionWrapper] = {}
-
-
-def rediscache(seconds: int, *, package: str | None = None) -> CacheRegionWrapper:
-    """Create or retrieve a Redis cache region with a specified expiration time.
-    """
-    with _region_lock:
-        namespace = package if package is not None else _get_caller_package()
-        cfg = get_config(namespace)
-        key = (namespace, seconds)
-
-        if key not in _redis_cache_regions:
-            name = _seconds_to_region_name(seconds)
-            region = make_region(name=name, function_key_generator=key_generator,
-                                 key_mangler=_make_region_key_mangler(cfg.debug_key, name))
-
-            if cfg.redis == 'dogpile.cache.null':
-                logger.debug(
-                    f"rediscache() called from '{namespace}' with null backend - "
-                    f"caching disabled for this region."
-                )
-                region.configure('dogpile.cache.null')
-            else:
-                connection_kwargs = {}
-                if cfg.redis_ssl:
-                    connection_kwargs['ssl'] = True
-
-                region.configure(
-                    cfg.redis,
-                    arguments={
-                        'host': cfg.redis_host,
-                        'port': cfg.redis_port,
-                        'db': cfg.redis_db,
-                        'redis_expiration_time': seconds,
-                        'distributed_lock': cfg.redis_distributed,
-                        'thread_local_lock': not cfg.redis_distributed,
-                        'connection_kwargs': connection_kwargs,
-                    },
-                    region_invalidator=RedisInvalidator(region)
-                )
-                logger.debug(f"Created redis cache region for namespace '{namespace}', {seconds}s TTL")
-            _redis_cache_regions[key] = _wrap_cache_on_arguments(region)
-        return _redis_cache_regions[key]
-
-
-@_handle_all_regions(_memory_cache_regions)
-def clear_memorycache(
-    seconds: int | None = None,
-    namespace: str | None = None,
-    *,
-    _resolved_namespace: str | None = None,
-) -> None:
-    """Clear a memory cache region.
-    """
-    pkg = _resolved_namespace if _resolved_namespace is not None else _get_caller_package()
-    region_key = (pkg, seconds)
-
-    if region_key not in _memory_cache_regions:
-        logger.warning(f'No memory cache region exists for namespace "{pkg}", {seconds} seconds')
-        return
-
-    cache_dict = _memory_cache_regions[region_key].actual_backend._cache
-
-    if namespace is None:
-        cache_dict.clear()
-        logger.debug(f'Cleared all memory cache keys for namespace "{pkg}", {seconds} second region')
-    else:
-        matches_namespace = _create_namespace_filter(namespace)
-        keys_to_delete = [key for key in list(cache_dict.keys()) if matches_namespace(key)]
-        for key in keys_to_delete:
-            del cache_dict[key]
-        logger.debug(f'Cleared {len(keys_to_delete)} memory cache keys for namespace "{namespace}"')
-
-
-@_handle_all_regions(_file_cache_regions)
-def clear_filecache(
-    seconds: int | None = None,
-    namespace: str | None = None,
-    *,
-    _resolved_namespace: str | None = None,
-) -> None:
-    """Clear a file cache region.
-    """
-    pkg = _resolved_namespace if _resolved_namespace is not None else _get_caller_package()
-    cfg = get_config(pkg)
-    region_key = (pkg, seconds)
-
-    if region_key not in _file_cache_regions:
-        logger.warning(f'No file cache region exists for namespace "{pkg}", {seconds} seconds')
-        return
-
-    filename = _file_cache_regions[region_key].actual_backend.filename
-    basename = pathlib.Path(filename).name
-    filepath = os.path.join(cfg.tmpdir, basename)
-
-    if namespace is None:
-        with dbm.open(filepath, 'n'):
-            pass
-        logger.debug(f'Cleared all file cache keys for namespace "{pkg}", {seconds} second region')
-    else:
-        matches_namespace = _create_namespace_filter(namespace)
-        with dbm.open(filepath, 'w') as db:
-            keys_to_delete = [
-                key for key in list(db.keys())
-                if matches_namespace(key.decode())
-            ]
-            for key in keys_to_delete:
-                del db[key]
-        logger.debug(f'Cleared {len(keys_to_delete)} file cache keys for namespace "{namespace}"')
-
-
-@_handle_all_regions(_redis_cache_regions)
-def clear_rediscache(
-    seconds: int | None = None,
-    namespace: str | None = None,
-    *,
-    _resolved_namespace: str | None = None,
-) -> None:
-    """Clear a redis cache region.
-    """
-    pkg = _resolved_namespace if _resolved_namespace is not None else _get_caller_package()
-    cfg = get_config(pkg)
-    client = get_redis_client(pkg)
-
-    try:
-        region_name = _seconds_to_region_name(seconds)
-        region_prefix = f'{region_name}:{cfg.debug_key}'
-        deleted_count = 0
-
-        if namespace is None:
-            for key in client.scan_iter(match=f'{region_prefix}*'):
-                client.delete(key)
-                deleted_count += 1
-            logger.debug(f'Cleared {deleted_count} Redis keys for region "{region_name}"')
-        else:
-            matches_namespace = _create_namespace_filter(namespace)
-            for key in client.scan_iter(match=f'{region_prefix}*'):
-                key_str = key.decode()
-                key_without_region = key_str[len(region_name) + 1:]
-                if matches_namespace(key_without_region):
-                    client.delete(key)
-                    deleted_count += 1
-            logger.debug(f'Cleared {deleted_count} Redis keys for namespace "{namespace}" in region "{region_name}"')
-    finally:
-        client.close()
-
-
-def set_memorycache_key(seconds: int, namespace: str, fn: Callable[..., Any], value: Any, **kwargs) -> None:
-    """Set a specific cached entry in memory cache.
-    """
-    region = memorycache(seconds)
-    cache_key = key_generator(namespace, fn)(**kwargs)
-    region.set(cache_key, value)
-    logger.debug(f'Set memory cache key for {fn.__name__} in namespace "{namespace}"')
-
-
-def delete_memorycache_key(seconds: int, namespace: str, fn: Callable[..., Any], **kwargs) -> None:
-    """Delete a specific cached entry from memory cache.
-    """
-    region = memorycache(seconds)
-    cache_key = key_generator(namespace, fn)(**kwargs)
-    region.delete(cache_key)
-    logger.debug(f'Deleted memory cache key for {fn.__name__} in namespace "{namespace}"')
-
-
-def set_filecache_key(seconds: int, namespace: str, fn: Callable[..., Any], value: Any, **kwargs) -> None:
-    """Set a specific cached entry in file cache.
-    """
-    region = filecache(seconds)
-    cache_key = key_generator(namespace, fn)(**kwargs)
-    region.set(cache_key, value)
-    logger.debug(f'Set file cache key for {fn.__name__} in namespace "{namespace}"')
-
-
-def delete_filecache_key(seconds: int, namespace: str, fn: Callable[..., Any], **kwargs) -> None:
-    """Delete a specific cached entry from file cache.
-    """
-    region = filecache(seconds)
-    cache_key = key_generator(namespace, fn)(**kwargs)
-    region.delete(cache_key)
-    logger.debug(f'Deleted file cache key for {fn.__name__} in namespace "{namespace}"')
-
-
-def set_rediscache_key(seconds: int, namespace: str, fn: Callable[..., Any], value: Any, **kwargs) -> None:
-    """Set a specific cached entry in redis cache.
-    """
-    region = rediscache(seconds)
-    cache_key = key_generator(namespace, fn)(**kwargs)
-    region.set(cache_key, value)
-    logger.debug(f'Set redis cache key for {fn.__name__} in namespace "{namespace}"')
-
-
-def delete_rediscache_key(seconds: int, namespace: str, fn: Callable[..., Any], **kwargs) -> None:
-    """Delete a specific cached entry from redis cache.
-    """
-    region = rediscache(seconds)
-    cache_key = key_generator(namespace, fn)(**kwargs)
-    region.delete(cache_key)
-    logger.debug(f'Deleted redis cache key for {fn.__name__} in namespace "{namespace}"')
-
-
-_BACKEND_MAP = {
-    'memory': (memorycache, clear_memorycache, set_memorycache_key, delete_memorycache_key),
-    'redis': (rediscache, clear_rediscache, set_rediscache_key, delete_rediscache_key),
-    'file': (filecache, clear_filecache, set_filecache_key, delete_filecache_key),
-}
-
-
-def defaultcache(seconds: int) -> CacheRegionWrapper:
-    """Return cache region based on configured default backend.
-    """
-    backend = config.default_backend
-    if backend not in _BACKEND_MAP:
-        raise ValueError(f'Unknown default_backend: {backend}. Must be one of: {list(_BACKEND_MAP.keys())}')
-    return _BACKEND_MAP[backend][0](seconds)
-
-
-def clear_defaultcache(seconds: int | None = None, namespace: str | None = None) -> None:
-    """Clear the default cache region.
-    """
-    return _BACKEND_MAP[config.default_backend][1](seconds, namespace)
-
-
-def set_defaultcache_key(seconds: int, namespace: str, fn: Callable[..., Any],
-                         value: Any, **kwargs) -> None:
-    """Set a specific cached entry in default cache.
-    """
-    return _BACKEND_MAP[config.default_backend][2](seconds, namespace, fn, value, **kwargs)
-
-
-def delete_defaultcache_key(seconds: int, namespace: str,
-                            fn: Callable[..., Any], **kwargs) -> None:
-    """Delete a specific cached entry from default cache.
-    """
-    return _BACKEND_MAP[config.default_backend][3](seconds, namespace, fn, **kwargs)
-
-
-def clear_cache_for_namespace(
-    namespace: str,
-    backend: str | None = None,
-    seconds: int | None = None,
-) -> None:
-    """Clear cache regions for a specific namespace (cross-module safe).
-    """
-    backends = [backend] if backend else ['memory', 'file', 'redis']
-    for b in backends:
-        if b == 'memory':
-            clear_memorycache(seconds=seconds, package=namespace)
-        elif b == 'file':
-            clear_filecache(seconds=seconds, package=namespace)
-        elif b == 'redis':
-            clear_rediscache(seconds=seconds, package=namespace)
-
-
-if __name__ == '__main__':
-    __import__('doctest').testmod(optionflags=4 | 8 | 32)