cachify 0.2.1__py3-none-any.whl → 0.3.0__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_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.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachify
-Version: 0.2.1
+Version: 0.3.0
 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
 

{cachify-0.2.1.dist-info → cachify-0.3.0.dist-info}/RECORD

@@ -1,24 +1,24 @@
-cachify/__init__.py,sha256=OvqM85Qq3rO6-KilFjq4MO0rm_NBdTfzAo2uhBVksdU,550
-cachify/cache.py,sha256=zJM9J4DdBXyGquQUTDJJ_voC51p-RM_CQcC-4DM92Gg,4021
+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=NJvCJhHMjxxaVZCC5xrUATcBBm4OXXHdipOg6wjOfV4,7111
-cachify/memory_cache.py,sha256=2UEnYXSJJ0XlqVM7sJ2GkPW1reU7DRtfifHEdbJQrYY,1328
+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=Gvlj_hrUlsIGYqu50dghrv83R5UEOMJa4jVeK-nBAOs,3558
 cachify/redis/lock.py,sha256=XbE5GHZIWUs9gqyfgle3Bur5CfKJ1pLhgtLctmZLB94,7281
-cachify/redis_cache.py,sha256=WVc26EpAVSyQptD3guDD2LuPDgnuL72BCvhln-n84hc,873
+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=7NcuntqxK7G1UV4wrIaLNfxE0E7Gr-MmPWi9U-JyQ9o,2000
-cachify/utils/decorator_factory.py,sha256=brraPKR7ZJqdTbp8s5tEk6D517CKOlo9z1ZLoqhoz_s,1325
+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/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,,
+cachify/utils/hash.py,sha256=L95dFggFMKa-fQXXIwlRtPsJfWYKFlWzvbfTKlHR-o0,558
+cachify-0.3.0.dist-info/METADATA,sha256=o0QL_IVJif6GyK1iF72ewBzOApjbDLL7F4IDORdGNI4,7594
+cachify-0.3.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+cachify-0.3.0.dist-info/entry_points.txt,sha256=a8B7GSYgDPfUClqct0o7yyBbJ61AWgSSy1idL6YZLUM,45
+cachify-0.3.0.dist-info/licenses/LICENSE,sha256=zUzOFiuoPIQzGktjk4kL78hpi57iWD6-Kug_96OgUO0,1071
+cachify-0.3.0.dist-info/RECORD,,

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)