cachify 0.2.1__tar.gz → 0.3.1__tar.gz

{cachify-0.2.1 → cachify-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachify
-Version: 0.2.1
+Version: 0.3.1
 Summary: A simple cache library with sync/async support, Memory and Redis backend
 License: MIT
 License-File: LICENSE
@@ -86,12 +86,13 @@ async def another_calculation(url):
 
 ### Decorator Parameters
 
-| Parameter        | Type              | Default | Description                                          |
-| ---------------- | ----------------- | ------- | ---------------------------------------------------- |
-| `ttl`            | `int \| float`    | `300`   | Time to live for cached items in seconds             |
-| `never_die`      | `bool`            | `False` | If True, cache refreshes automatically in background |
-| `cache_key_func` | `Callable`        | `None`  | Custom function to generate cache keys               |
-| `ignore_fields`  | `tuple[str, ...]` | `()`    | Function parameters to exclude from cache key        |
+| Parameter        | Type            | Default | Description                                                    |
+| ---------------- | --------------- | ------- | -------------------------------------------------------------- |
+| `ttl`            | `int \| float`  | `300`   | Time to live for cached items in seconds                       |
+| `never_die`      | `bool`          | `False` | If True, cache refreshes automatically in background           |
+| `cache_key_func` | `Callable`      | `None`  | Custom function to generate cache keys                         |
+| `ignore_fields`  | `Sequence[str]` | `()`    | Function parameters to exclude from cache key                  |
+| `no_self`        | `bool`          | `False` | If True, ignores the first parameter (usually `self` or `cls`) |
 
 ### Custom Cache Key Function
 
@@ -134,7 +135,7 @@ from cachify import setup_redis_config, rcache
 # Configure Redis (call once at startup)
 setup_redis_config(
     sync_client=redis.from_url("redis://localhost:6379/0"),
-    key_prefix="myapp",       # default: "cachify", prefix searchable on redis "PREFIX:*"
+    key_prefix="{myapp}",       # default: "{cachify}", prefix searchable on redis "PREFIX:*"
     lock_timeout=10,          # default: 10, maximum lock lifetime in seconds
     on_error="silent",        # "silent" (default) or "raise" in case of redis errors
 )

{cachify-0.2.1 → cachify-0.3.1}/README.md

@@ -60,12 +60,13 @@ async def another_calculation(url):
 
 ### Decorator Parameters
 
-| Parameter        | Type              | Default | Description                                          |
-| ---------------- | ----------------- | ------- | ---------------------------------------------------- |
-| `ttl`            | `int \| float`    | `300`   | Time to live for cached items in seconds             |
-| `never_die`      | `bool`            | `False` | If True, cache refreshes automatically in background |
-| `cache_key_func` | `Callable`        | `None`  | Custom function to generate cache keys               |
-| `ignore_fields`  | `tuple[str, ...]` | `()`    | Function parameters to exclude from cache key        |
+| Parameter        | Type            | Default | Description                                                    |
+| ---------------- | --------------- | ------- | -------------------------------------------------------------- |
+| `ttl`            | `int \| float`  | `300`   | Time to live for cached items in seconds                       |
+| `never_die`      | `bool`          | `False` | If True, cache refreshes automatically in background           |
+| `cache_key_func` | `Callable`      | `None`  | Custom function to generate cache keys                         |
+| `ignore_fields`  | `Sequence[str]` | `()`    | Function parameters to exclude from cache key                  |
+| `no_self`        | `bool`          | `False` | If True, ignores the first parameter (usually `self` or `cls`) |
 
 ### Custom Cache Key Function
 
@@ -108,7 +109,7 @@ from cachify import setup_redis_config, rcache
 # Configure Redis (call once at startup)
 setup_redis_config(
     sync_client=redis.from_url("redis://localhost:6379/0"),
-    key_prefix="myapp",       # default: "cachify", prefix searchable on redis "PREFIX:*"
+    key_prefix="{myapp}",       # default: "{cachify}", prefix searchable on redis "PREFIX:*"
     lock_timeout=10,          # default: 10, maximum lock lifetime in seconds
     on_error="silent",        # "silent" (default) or "raise" in case of redis errors
 )

{cachify-0.2.1 → cachify-0.3.1}/cachify/__init__.py

@@ -12,12 +12,13 @@ rcache = redis_cache
 
 __all__ = [
     "__version__",
-    "cache",
     "rcache",
-    "redis_cache",
-    "setup_redis_config",
+    "clear_never_die_registry",
+    "cache",
+    "DEFAULT_KEY_PREFIX",
     "get_redis_config",
     "reset_redis_config",
-    "DEFAULT_KEY_PREFIX",
+    "setup_redis_config",
+    "redis_cache",
     "CacheKwargs",
 ]

{cachify-0.2.1 → cachify-0.3.1}/cachify/cache.py

@@ -1,6 +1,6 @@
 import functools
 import inspect
-from typing import Any, Callable, cast
+from typing import Any, Callable, Sequence, cast
 
 from cachify.features.never_die import register_never_die_function
 from cachify.types import CacheConfig, CacheKeyFunction, F, Number
@@ -73,7 +73,8 @@ def base_cache(
     ttl: Number,
     never_die: bool,
     cache_key_func: CacheKeyFunction | None,
-    ignore_fields: tuple[str, ...],
+    ignore_fields: Sequence[str],
+    no_self: bool,
     config: CacheConfig,
 ) -> Callable[[F], F]:
     """
@@ -83,7 +84,8 @@ def base_cache(
         ttl: Time to live for cached items in seconds
         never_die: If True, the cache will never expire and will be recalculated based on the ttl
         cache_key_func: Custom cache key function, used for more complex cache scenarios
-        ignore_fields: Tuple of strings with the function params to ignore when creating the cache key
+        ignore_fields: Sequence of strings with the function params to ignore when creating the cache key
+        no_self: if True, the first parameter (typically 'self' for methods) will be ignored when creating the cache key
         config: Cache configuration specifying storage, locks, and never_die registration
 
     Features:
@@ -91,17 +93,23 @@ def base_cache(
         - Only allows one execution at a time per function+args
         - Makes subsequent calls wait for the first call to complete
     """
-    if cache_key_func and ignore_fields:
+
+    if cache_key_func and (ignore_fields or no_self):
         raise ValueError("Either cache_key_func or ignore_fields can be provided, but not both")
 
     def decorator(function: F) -> F:
+        ignore = tuple(ignore_fields)
+
+        if no_self:
+            ignore += function.__code__.co_varnames[:1]
+
         if inspect.iscoroutinefunction(function):
             return _async_decorator(
                 function=function,
                 ttl=ttl,
                 never_die=never_die,
                 cache_key_func=cache_key_func,
-                ignore_fields=ignore_fields,
+                ignore_fields=ignore,
                 config=config,
             )
         return _sync_decorator(
@@ -109,7 +117,7 @@ def base_cache(
             ttl=ttl,
             never_die=never_die,
             cache_key_func=cache_key_func,
-            ignore_fields=ignore_fields,
+            ignore_fields=ignore,
             config=config,
         )
 

{cachify-0.2.1 → cachify-0.3.1}/cachify/features/never_die.py

@@ -140,19 +140,19 @@ def _refresh_never_die_caches():
 
                 if entry.loop.is_closed():
                     logger.debug(
-                        f"Loop is closed, skipping future creation",
+                        "Loop is closed, skipping future creation",
                         extra={"function": entry.function.__qualname__},
                         exc_info=True,
                     )
                     continue
 
+                coroutine = _run_async_function_and_cache(entry)
                 try:
-                    coroutine = _run_async_function_and_cache(entry)
                     future = asyncio.run_coroutine_threadsafe(coroutine, entry.loop)
                 except RuntimeError:
                     coroutine.close()
                     logger.debug(
-                        f"Loop is closed, skipping future creation",
+                        "Loop is closed, skipping future creation",
                         extra={"function": entry.function.__qualname__},
                         exc_info=True,
                     )

{cachify-0.2.1 → cachify-0.3.1}/cachify/memory_cache.py

@@ -1,18 +1,22 @@
+import asyncio
 import threading
-from typing import Callable
+from collections import defaultdict
+from typing import Callable, Sequence
 
 from cachify.cache import base_cache
 from cachify.storage.memory_storage import MemoryStorage
 from cachify.types import CacheConfig, CacheKeyFunction, F, Number
-from cachify.utils.locks import ASYNC_LOCKS, SYNC_LOCKS
 
 _CACHE_CLEAR_THREAD: threading.Thread | None = None
 _CACHE_CLEAR_LOCK: threading.Lock = threading.Lock()
 
+_ASYNC_LOCKS: defaultdict[str, asyncio.Lock] = defaultdict(asyncio.Lock)
+_SYNC_LOCKS: defaultdict[str, threading.Lock] = defaultdict(threading.Lock)
+
 _MEMORY_CONFIG = CacheConfig(
     storage=MemoryStorage,
-    sync_lock=lambda cache_key: SYNC_LOCKS[cache_key],
-    async_lock=lambda cache_key: ASYNC_LOCKS[cache_key],
+    sync_lock=_SYNC_LOCKS.__getitem__,
+    async_lock=_ASYNC_LOCKS.__getitem__,
 )
 
 
@@ -30,8 +34,9 @@ def cache(
     ttl: Number = 300,
     never_die: bool = False,
     cache_key_func: CacheKeyFunction | None = None,
-    ignore_fields: tuple[str, ...] = (),
+    ignore_fields: Sequence[str] = (),
+    no_self: bool = False,
 ) -> Callable[[F], F]:
     """In-memory cache decorator. See `base_cache` for full documentation."""
     _start_cache_clear_thread()
-    return base_cache(ttl, never_die, cache_key_func, ignore_fields, _MEMORY_CONFIG)
+    return base_cache(ttl, never_die, cache_key_func, ignore_fields, no_self, _MEMORY_CONFIG)

{cachify-0.2.1 → cachify-0.3.1}/cachify/redis/config.py

@@ -1,15 +1,20 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Literal, get_args, overload
+from typing import TYPE_CHECKING, Literal, TypeAlias, get_args, overload
 
 if TYPE_CHECKING:
     from redis import Redis
     from redis.asyncio import Redis as AsyncRedis
+    from redis.cluster import RedisCluster
+    from redis.asyncio.cluster import RedisCluster as AsyncRedisCluster
+
+SyncRedisClient: TypeAlias = "Redis | RedisCluster"
+AsyncRedisClient: TypeAlias = "AsyncRedis | AsyncRedisCluster"
 
 OnErrorType = Literal["silent", "raise"]
 
-DEFAULT_KEY_PREFIX = "cachify"
+DEFAULT_KEY_PREFIX = "{cachify}"
 DEFAULT_LOCK_TIMEOUT = 10
 
 
@@ -17,19 +22,19 @@ DEFAULT_LOCK_TIMEOUT = 10
 class RedisConfig:
     """Configuration for Redis cache backend."""
 
-    sync_client: Redis | None
-    async_client: AsyncRedis | None
+    sync_client: SyncRedisClient | None
+    async_client: AsyncRedisClient | None
     key_prefix: str
     lock_timeout: int
     on_error: OnErrorType
 
     @overload
-    def get_client(self, is_async: Literal[True]) -> AsyncRedis: ...
+    def get_client(self, is_async: Literal[True]) -> AsyncRedisClient: ...
 
     @overload
-    def get_client(self, is_async: Literal[False]) -> Redis: ...
+    def get_client(self, is_async: Literal[False]) -> SyncRedisClient: ...
 
-    def get_client(self, is_async: bool) -> Redis | AsyncRedis:
+    def get_client(self, is_async: bool) -> SyncRedisClient | AsyncRedisClient:
         """Get the appropriate Redis client based on is_async flag."""
         if is_async:
             client = self.async_client
@@ -49,8 +54,8 @@ _redis_config: RedisConfig | None = None
 
 
 def setup_redis_config(
-    sync_client: Redis | None = None,
-    async_client: AsyncRedis | None = None,
+    sync_client: SyncRedisClient | None = None,
+    async_client: AsyncRedisClient | None = None,
     key_prefix: str = DEFAULT_KEY_PREFIX,
     lock_timeout: int = DEFAULT_LOCK_TIMEOUT,
     on_error: OnErrorType = "silent",
@@ -64,7 +69,7 @@ def setup_redis_config(
     Args:
         sync_client: Redis sync client instance (redis.Redis)
         async_client: Redis async client instance (redis.asyncio.Redis)
-        key_prefix: Prefix for all cache keys in Redis (default: "cache")
+        key_prefix: Prefix for all cache keys in Redis (default: "{cachify}")
         lock_timeout: Timeout in seconds for distributed locks (default: 10)
         on_error: Error handling mode - "silent" treats errors as cache miss,
                   "raise" propagates exceptions (default: "silent")

{cachify-0.2.1 → cachify-0.3.1}/cachify/redis_cache.py

@@ -1,4 +1,4 @@
-from typing import Callable
+from typing import Callable, Sequence
 
 from cachify.cache import base_cache
 from cachify.redis.lock import RedisLockManager
@@ -16,7 +16,8 @@ def redis_cache(
     ttl: Number = 300,
     never_die: bool = False,
     cache_key_func: CacheKeyFunction | None = None,
-    ignore_fields: tuple[str, ...] = (),
+    ignore_fields: Sequence[str] = (),
+    no_self: bool = False,
 ) -> Callable[[F], F]:
     """
     Redis cache decorator. See `base_cache` for full documentation.
@@ -24,4 +25,4 @@ def redis_cache(
     Requires setup_redis_config() to be called before use.
     Uses Redis for distributed caching across multiple processes/machines.
     """
-    return base_cache(ttl, never_die, cache_key_func, ignore_fields, _REDIS_CONFIG)
+    return base_cache(ttl, never_die, cache_key_func, ignore_fields, no_self, _REDIS_CONFIG)

{cachify-0.2.1 → cachify-0.3.1}/cachify/utils/arguments.py

@@ -1,17 +1,12 @@
-import hashlib
 import inspect
-import pickle
 from collections.abc import Callable, Generator
 from inspect import Signature
 from typing import Any
 
 from cachify.types import CacheKeyFunction
+from cachify.utils.errors import CacheKeyError
 from cachify.utils.functions import get_function_id
-
-
-def _cache_key_fingerprint(value: object) -> str:
-    payload = pickle.dumps(value, protocol=pickle.HIGHEST_PROTOCOL)
-    return hashlib.blake2b(payload, digest_size=16).hexdigest()
+from cachify.utils.hash import object_hash
 
 
 def _iter_arguments(
@@ -54,12 +49,12 @@ def create_cache_key(
     if not cache_key_func:
         function_signature = inspect.signature(function)
         items = tuple(_iter_arguments(function_signature, args, kwargs, ignore_fields))
-        return f"{function_id}:{_cache_key_fingerprint(items)}"
+        return f"{function_id}:{object_hash(items)}"
 
     cache_key = cache_key_func(args, kwargs)
     try:
-        return f"{function_id}:{_cache_key_fingerprint(cache_key)}"
+        return f"{function_id}:{object_hash(cache_key)}"
     except TypeError as exc:
-        raise ValueError(
+        raise CacheKeyError(
             "Cache key function must return a hashable cache key - be careful with mutable types (list, dict, set) and non built-in types"
         ) from exc

cachify-0.3.1/cachify/utils/errors.py

@@ -0,0 +1,2 @@
+class CacheKeyError(ValueError):
+    pass

cachify-0.3.1/cachify/utils/hash.py

@@ -0,0 +1,18 @@
+import hashlib
+import pickle
+from typing import Any
+
+from cachify.utils.errors import CacheKeyError
+
+
+def object_hash(value: Any) -> str:
+    try:
+        payload = pickle.dumps(value, protocol=pickle.HIGHEST_PROTOCOL)
+
+    except Exception as exc:
+        raise CacheKeyError(
+            "Unable to serialize object for hashing - ensure all parts of the object are pickleable. "
+            "Hint: create a custom __reduce__ method for the suspected object if necessary."
+        ) from exc
+
+    return hashlib.blake2b(payload, digest_size=16).hexdigest()

{cachify-0.2.1 → cachify-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cachify"
-version = "0.2.1"
+version = "0.3.1"
 description = "A simple cache library with sync/async support, Memory and Redis backend"
 license = "MIT"
 readme = "README.md"

cachify-0.2.1/cachify/utils/decorator_factory.py

@@ -1,44 +0,0 @@
-import inspect
-from typing import Callable
-
-from cachify._async import async_decorator
-from cachify._sync import sync_decorator
-from cachify.types import CacheConfig, CacheKeyFunction, F, Number
-
-
-def create_cache_decorator(
-    ttl: Number,
-    never_die: bool,
-    cache_key_func: CacheKeyFunction | None,
-    ignore_fields: tuple[str, ...],
-    config: CacheConfig,
-) -> Callable[[F], F]:
-    """
-    Create a cache decorator with the given configuration.
-
-    This is a shared factory used by both memory_cache and redis_cache
-    to avoid code duplication.
-    """
-    if cache_key_func and ignore_fields:
-        raise ValueError("Either cache_key_func or ignore_fields can be provided, but not both")
-
-    def decorator(function: F) -> F:
-        if inspect.iscoroutinefunction(function):
-            return async_decorator(
-                function=function,
-                ttl=ttl,
-                never_die=never_die,
-                cache_key_func=cache_key_func,
-                ignore_fields=ignore_fields,
-                config=config,
-            )
-        return sync_decorator(
-            function=function,
-            ttl=ttl,
-            never_die=never_die,
-            cache_key_func=cache_key_func,
-            ignore_fields=ignore_fields,
-            config=config,
-        )
-
-    return decorator

cachify-0.2.1/cachify/utils/locks.py

@@ -1,6 +0,0 @@
-import asyncio
-import threading
-from collections import defaultdict
-
-ASYNC_LOCKS: defaultdict[str, asyncio.Lock] = defaultdict(asyncio.Lock)
-SYNC_LOCKS: defaultdict[str, threading.Lock] = defaultdict(threading.Lock)