cachify 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

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/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/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/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/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/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/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/utils/errors.py

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

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.dist-info → cachify-0.3.1.dist-info}/METADATA

@@ -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.3.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+cachify/__init__.py,sha256=zzW2gPgLF6PNRMvUmGo-2V-vXsrpYFJitgRFPlp-RgU,582
+cachify/cache.py,sha256=Dg-vHIQrlXOMR4ueiTdw6fZYbfsJo8b95aTetPK-MUE,4288
+cachify/config/__init__.py,sha256=ZvLLEsprTbKai3-uUTbZ6Axbgf-xw-7sxmz8Y62YdT4,98
+cachify/features/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cachify/features/never_die.py,sha256=virRY8788D1fGmwQQYmbMhLIKRkWVYNPywR-kl18u9c,7105
+cachify/memory_cache.py,sha256=Ge1yU6fJfv_o3aCgU7ky5pHxvDSmfQ0xBFnJeC61jLQ,1485
+cachify/redis/__init__.py,sha256=geuYVjwJdddlhrnt45cHzkJ7Anrhttm2F3Q3r0TTMLk,410
+cachify/redis/config.py,sha256=QUlsZS5vOXZzyGjN75Lq2kkszPrV1U6e_mRUgyC5JFM,3870
+cachify/redis/lock.py,sha256=XbE5GHZIWUs9gqyfgle3Bur5CfKJ1pLhgtLctmZLB94,7281
+cachify/redis_cache.py,sha256=s9Uf2DdBwoZAFSld0fK18S70gz7B4APUB701_mfL-2A,917
+cachify/storage/__init__.py,sha256=8FJOYwjg8LHVoNkyupdgKOR61LPfX5Bpz_mvnn-T-oU,250
+cachify/storage/memory_storage.py,sha256=rsQqoymWczzkfXisF-9Tc9UGQem936U6_vd9Uo-sWnU,1481
+cachify/storage/redis_storage.py,sha256=wZaKg7h98cmESpqiOmh906D5wfNBxYN80x-LQDLtb-c,4767
+cachify/types/__init__.py,sha256=OataAgBEQXxpc376uZFM6cmdzJLUkzkj_H8XiKq5zpU,2641
+cachify/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cachify/utils/arguments.py,sha256=UJhcC8erS9h8sJTNlILK3uvr6Mg1BWkaI-2esV7-LNs,1858
+cachify/utils/errors.py,sha256=IuPQuOV0rfzeHUoLi5DrdmGSz3YnB1OF4URPdIy6qQI,42
+cachify/utils/functions.py,sha256=AA1GXJEEBsIr2NX9h6AslAdmqKaWUcjnf1q5kA216uY,312
+cachify/utils/hash.py,sha256=L95dFggFMKa-fQXXIwlRtPsJfWYKFlWzvbfTKlHR-o0,558
+cachify-0.3.1.dist-info/METADATA,sha256=dFcWvVCi8X4SSOVvpSGm8s5VvM_gVX59-MvXvonk5IY,7598
+cachify-0.3.1.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+cachify-0.3.1.dist-info/entry_points.txt,sha256=a8B7GSYgDPfUClqct0o7yyBbJ61AWgSSy1idL6YZLUM,45
+cachify-0.3.1.dist-info/licenses/LICENSE,sha256=zUzOFiuoPIQzGktjk4kL78hpi57iWD6-Kug_96OgUO0,1071
+cachify-0.3.1.dist-info/RECORD,,

{cachify-0.2.1.dist-info → cachify-0.3.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any

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/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)

cachify-0.2.1.dist-info/RECORD

@@ -1,24 +0,0 @@
-cachify/__init__.py,sha256=OvqM85Qq3rO6-KilFjq4MO0rm_NBdTfzAo2uhBVksdU,550
-cachify/cache.py,sha256=zJM9J4DdBXyGquQUTDJJ_voC51p-RM_CQcC-4DM92Gg,4021
-cachify/config/__init__.py,sha256=ZvLLEsprTbKai3-uUTbZ6Axbgf-xw-7sxmz8Y62YdT4,98
-cachify/features/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cachify/features/never_die.py,sha256=NJvCJhHMjxxaVZCC5xrUATcBBm4OXXHdipOg6wjOfV4,7111
-cachify/memory_cache.py,sha256=2UEnYXSJJ0XlqVM7sJ2GkPW1reU7DRtfifHEdbJQrYY,1328
-cachify/redis/__init__.py,sha256=geuYVjwJdddlhrnt45cHzkJ7Anrhttm2F3Q3r0TTMLk,410
-cachify/redis/config.py,sha256=Gvlj_hrUlsIGYqu50dghrv83R5UEOMJa4jVeK-nBAOs,3558
-cachify/redis/lock.py,sha256=XbE5GHZIWUs9gqyfgle3Bur5CfKJ1pLhgtLctmZLB94,7281
-cachify/redis_cache.py,sha256=WVc26EpAVSyQptD3guDD2LuPDgnuL72BCvhln-n84hc,873
-cachify/storage/__init__.py,sha256=8FJOYwjg8LHVoNkyupdgKOR61LPfX5Bpz_mvnn-T-oU,250
-cachify/storage/memory_storage.py,sha256=rsQqoymWczzkfXisF-9Tc9UGQem936U6_vd9Uo-sWnU,1481
-cachify/storage/redis_storage.py,sha256=wZaKg7h98cmESpqiOmh906D5wfNBxYN80x-LQDLtb-c,4767
-cachify/types/__init__.py,sha256=OataAgBEQXxpc376uZFM6cmdzJLUkzkj_H8XiKq5zpU,2641
-cachify/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cachify/utils/arguments.py,sha256=7NcuntqxK7G1UV4wrIaLNfxE0E7Gr-MmPWi9U-JyQ9o,2000
-cachify/utils/decorator_factory.py,sha256=brraPKR7ZJqdTbp8s5tEk6D517CKOlo9z1ZLoqhoz_s,1325
-cachify/utils/functions.py,sha256=AA1GXJEEBsIr2NX9h6AslAdmqKaWUcjnf1q5kA216uY,312
-cachify/utils/locks.py,sha256=7x-4XK27NiM_Eu04pftUgEgu91w8B3rE15jjAl0g1AE,216
-cachify-0.2.1.dist-info/METADATA,sha256=pl450wfErW4M_deswdy9thDYahuDHno6p1LfJ3kdmHU,7432
-cachify-0.2.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-cachify-0.2.1.dist-info/entry_points.txt,sha256=a8B7GSYgDPfUClqct0o7yyBbJ61AWgSSy1idL6YZLUM,45
-cachify-0.2.1.dist-info/licenses/LICENSE,sha256=zUzOFiuoPIQzGktjk4kL78hpi57iWD6-Kug_96OgUO0,1071
-cachify-0.2.1.dist-info/RECORD,,