cachify 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

cachify/storage/redis_storage.py

@@ -1,138 +1,138 @@
-import pickle
-import time
-from typing import Any, overload
-
-from cachify.redis.config import get_redis_config
-from cachify.config import logger
-from cachify.types import CacheEntry, Number
-
-
-class RedisCacheEntry(CacheEntry):
-    @classmethod
-    def time(cls) -> float:
-        return time.time()
-
-
-class RedisStorage:
-    """Redis cache storage implementing CacheStorage protocol."""
-
-    @classmethod
-    def _make_key(cls, cache_key: str) -> str:
-        """Create a Redis key from cache_key."""
-        config = get_redis_config()
-        return f"{config.key_prefix}:{cache_key}"
-
-    @classmethod
-    def _serialize(cls, entry: RedisCacheEntry) -> bytes:
-        """Serialize a cache entry to bytes."""
-        try:
-            return pickle.dumps(entry, protocol=pickle.HIGHEST_PROTOCOL)
-        except (pickle.PicklingError, TypeError, AttributeError) as exc:
-            raise TypeError(
-                f"Failed to serialize cache entry. Object of type {type(entry.result).__name__} "
-                f"cannot be pickled. Ensure the cached result is serializable."
-            ) from exc
-
-    @classmethod
-    def _deserialize(cls, data: bytes) -> RedisCacheEntry:
-        """Deserialize bytes to a cache entry."""
-        return pickle.loads(data)
-
-    @overload
-    @classmethod
-    def _prepare_set(cls, cache_key: str, result: Any, ttl: None) -> tuple[str, bytes, None]: ...
-
-    @overload
-    @classmethod
-    def _prepare_set(cls, cache_key: str, result: Any, ttl: Number) -> tuple[str, bytes, int]: ...
-
-    @classmethod
-    def _prepare_set(cls, cache_key: str, result: Any, ttl: Number | None) -> tuple[str, bytes, int | None]:
-        """Prepare key, data, and expiry in milliseconds for set operations."""
-        key = cls._make_key(cache_key)
-        data = cls._serialize(RedisCacheEntry(result, ttl))
-        if ttl is None:
-            return key, data, None
-
-        return key, data, int(ttl * 1000)
-
-    @classmethod
-    def _handle_error(cls, exc: Exception, operation: str, cache_key: str):
-        """Handle Redis errors based on config."""
-        config = get_redis_config()
-        if config.on_error == "raise":
-            raise
-
-        logger.debug(f"Redis operation error: {exc}", extra={"operation": operation, "cache_key": cache_key})
-
-    @classmethod
-    def _handle_get_result(cls, data: bytes | None) -> RedisCacheEntry | None:
-        """Process get result and return entry if valid."""
-        if data is None:
-            return None
-
-        entry = cls._deserialize(data)
-        if entry.is_expired():
-            return None
-
-        return entry
-
-    @classmethod
-    def set(cls, cache_key: str, result: Any, ttl: Number | None):
-        """Store a result in Redis cache."""
-        config = get_redis_config()
-        client = config.get_client(is_async=False)
-        key, data, expiry_ms = cls._prepare_set(cache_key, result, ttl)
-        try:
-            if expiry_ms is None:
-                client.set(key, data)
-                return
-
-            client.psetex(key, expiry_ms, data)
-        except Exception as exc:
-            cls._handle_error(exc, "set", cache_key)
-
-    @classmethod
-    def get(cls, cache_key: str, skip_cache: bool) -> RedisCacheEntry | None:
-        """Retrieve a cache entry from Redis."""
-        if skip_cache:
-            return None
-
-        config = get_redis_config()
-        client = config.get_client(is_async=False)
-        key = cls._make_key(cache_key)
-        try:
-            return cls._handle_get_result(client.get(key))  # type: ignore[arg-type]
-        except Exception as exc:
-            cls._handle_error(exc, "get", cache_key)
-            return None
-
-    @classmethod
-    async def aset(cls, cache_key: str, result: Any, ttl: Number | None):
-        """Store a result in Redis cache (async)."""
-        config = get_redis_config()
-        client = config.get_client(is_async=True)
-        key, data, expiry_ms = cls._prepare_set(cache_key, result, ttl)
-        try:
-            if expiry_ms is None:
-                await client.set(key, data)
-                return
-
-            await client.psetex(key, expiry_ms, data)
-        except Exception as exc:
-            cls._handle_error(exc, "aset", cache_key)
-
-    @classmethod
-    async def aget(cls, cache_key: str, skip_cache: bool) -> RedisCacheEntry | None:
-        """Retrieve a cache entry from Redis (async)."""
-        if skip_cache:
-            return None
-
-        config = get_redis_config()
-        client = config.get_client(is_async=True)
-        key = cls._make_key(cache_key)
-        try:
-            return cls._handle_get_result(await client.get(key))  # type: ignore[arg-type]
-        except Exception as exc:
-            cls._handle_error(exc, "aget", cache_key)
-            return None
+import pickle
+import time
+from typing import Any, overload
+
+from cachify.redis.config import get_redis_config
+from cachify.config import logger
+from cachify.types import CacheEntry, Number
+
+
+class RedisCacheEntry(CacheEntry):
+    @classmethod
+    def time(cls) -> float:
+        return time.time()
+
+
+class RedisStorage:
+    """Redis cache storage implementing CacheStorage protocol."""
+
+    @classmethod
+    def _make_key(cls, cache_key: str) -> str:
+        """Create a Redis key from cache_key."""
+        config = get_redis_config()
+        return f"{config.key_prefix}:{cache_key}"
+
+    @classmethod
+    def _serialize(cls, entry: RedisCacheEntry) -> bytes:
+        """Serialize a cache entry to bytes."""
+        try:
+            return pickle.dumps(entry, protocol=pickle.HIGHEST_PROTOCOL)
+        except (pickle.PicklingError, TypeError, AttributeError) as exc:
+            raise TypeError(
+                f"Failed to serialize cache entry. Object of type {type(entry.result).__name__} "
+                f"cannot be pickled. Ensure the cached result is serializable."
+            ) from exc
+
+    @classmethod
+    def _deserialize(cls, data: bytes) -> RedisCacheEntry:
+        """Deserialize bytes to a cache entry."""
+        return pickle.loads(data)
+
+    @overload
+    @classmethod
+    def _prepare_set(cls, cache_key: str, result: Any, ttl: None) -> tuple[str, bytes, None]: ...
+
+    @overload
+    @classmethod
+    def _prepare_set(cls, cache_key: str, result: Any, ttl: Number) -> tuple[str, bytes, int]: ...
+
+    @classmethod
+    def _prepare_set(cls, cache_key: str, result: Any, ttl: Number | None) -> tuple[str, bytes, int | None]:
+        """Prepare key, data, and expiry in milliseconds for set operations."""
+        key = cls._make_key(cache_key)
+        data = cls._serialize(RedisCacheEntry(result, ttl))
+        if ttl is None:
+            return key, data, None
+
+        return key, data, int(ttl * 1000)
+
+    @classmethod
+    def _handle_error(cls, exc: Exception, operation: str, cache_key: str):
+        """Handle Redis errors based on config."""
+        config = get_redis_config()
+        if config.on_error == "raise":
+            raise
+
+        logger.debug(f"Redis operation error: {exc}", extra={"operation": operation, "cache_key": cache_key})
+
+    @classmethod
+    def _handle_get_result(cls, data: bytes | None) -> RedisCacheEntry | None:
+        """Process get result and return entry if valid."""
+        if data is None:
+            return None
+
+        entry = cls._deserialize(data)
+        if entry.is_expired():
+            return None
+
+        return entry
+
+    @classmethod
+    def set(cls, cache_key: str, result: Any, ttl: Number | None):
+        """Store a result in Redis cache."""
+        config = get_redis_config()
+        client = config.get_client(is_async=False)
+        key, data, expiry_ms = cls._prepare_set(cache_key, result, ttl)
+        try:
+            if expiry_ms is None:
+                client.set(key, data)
+                return
+
+            client.psetex(key, expiry_ms, data)
+        except Exception as exc:
+            cls._handle_error(exc, "set", cache_key)
+
+    @classmethod
+    def get(cls, cache_key: str, skip_cache: bool) -> RedisCacheEntry | None:
+        """Retrieve a cache entry from Redis."""
+        if skip_cache:
+            return None
+
+        config = get_redis_config()
+        client = config.get_client(is_async=False)
+        key = cls._make_key(cache_key)
+        try:
+            return cls._handle_get_result(client.get(key))  # type: ignore[arg-type]
+        except Exception as exc:
+            cls._handle_error(exc, "get", cache_key)
+            return None
+
+    @classmethod
+    async def aset(cls, cache_key: str, result: Any, ttl: Number | None):
+        """Store a result in Redis cache (async)."""
+        config = get_redis_config()
+        client = config.get_client(is_async=True)
+        key, data, expiry_ms = cls._prepare_set(cache_key, result, ttl)
+        try:
+            if expiry_ms is None:
+                await client.set(key, data)
+                return
+
+            await client.psetex(key, expiry_ms, data)
+        except Exception as exc:
+            cls._handle_error(exc, "aset", cache_key)
+
+    @classmethod
+    async def aget(cls, cache_key: str, skip_cache: bool) -> RedisCacheEntry | None:
+        """Retrieve a cache entry from Redis (async)."""
+        if skip_cache:
+            return None
+
+        config = get_redis_config()
+        client = config.get_client(is_async=True)
+        key = cls._make_key(cache_key)
+        try:
+            return cls._handle_get_result(await client.get(key))  # type: ignore[arg-type]
+        except Exception as exc:
+            cls._handle_error(exc, "aget", cache_key)
+            return None

cachify/types/__init__.py

@@ -1,95 +1,95 @@
-import time
-from dataclasses import dataclass, field
-from typing import Any, AsyncContextManager, Callable, ContextManager, Hashable, Protocol, TypeAlias, TypedDict, TypeVar
-
-Number: TypeAlias = int | float
-CacheKeyFunction: TypeAlias = Callable[[tuple, dict], Hashable]
-
-F = TypeVar("F", bound=Callable[..., Any])
-
-
-@dataclass
-class CacheEntry:
-    """Base cache entry with TTL and expiration tracking."""
-
-    result: Any
-    ttl: float | None
-
-    cached_at: float = field(init=False)
-    expires_at: float = field(init=False)
-
-    @classmethod
-    def time(cls) -> float:
-        return time.monotonic()
-
-    def __post_init__(self):
-        self.cached_at = self.time()
-        self.expires_at = 0 if self.ttl is None else self.cached_at + self.ttl
-
-    def is_expired(self) -> bool:
-        if self.ttl is None:
-            return False
-
-        return self.time() > self.expires_at
-
-
-@dataclass(frozen=True, slots=True)
-class CacheConfig:
-    """Configuration for cache, grouping storage, lock, and never_die registration."""
-
-    storage: "CacheStorage"
-    sync_lock: Callable[[str], ContextManager]
-    async_lock: Callable[[str], AsyncContextManager]
-
-
-class CacheEntryProtocol(Protocol):
-    """Protocol for cache entry objects."""
-
-    result: Any
-
-    def is_expired(self) -> bool: ...
-
-
-class CacheStorage(Protocol):
-    """Protocol defining the interface for cache storage."""
-
-    def get(self, cache_key: str, skip_cache: bool) -> CacheEntryProtocol | None:
-        """Retrieve a cache entry. Returns None if not found, expired, or skip_cache is True."""
-        ...
-
-    def set(self, cache_key: str, result: Any, ttl: Number | None):
-        """Store a result in the cache with optional TTL."""
-        ...
-
-    async def aget(self, cache_key: str, skip_cache: bool) -> CacheEntryProtocol | None:
-        """Async version of get."""
-        ...
-
-    async def aset(self, cache_key: str, result: Any, ttl: Number | None):
-        """Async version of set."""
-        ...
-
-
-class CacheKwargs(TypedDict, total=False):
-    """
-    ### Description
-    This type can be used in conjuction with `Unpack` to provide static type
-    checking for the parameters added by the `@cache()` decorator.
-
-    This type is completely optional and `skip_cache` will work regardless
-    of what static type checkers complain about.
-
-    ### Example
-    ```
-    @cache()
-    def function_with_cache(**_: Unpack[CacheKwargs]): ...
-
-    # pylance/pyright should not complain
-    function_with_cache(skip_cache=True)
-    ```
-
-    ### Notes
-    Prior to Python 3.11, `Unpack` is only available with typing_extensions
-    """
-
-    skip_cache: bool
+import time
+from dataclasses import dataclass, field
+from typing import Any, AsyncContextManager, Callable, ContextManager, Hashable, Protocol, TypeAlias, TypedDict, TypeVar
+
+Number: TypeAlias = int | float
+CacheKeyFunction: TypeAlias = Callable[[tuple, dict], Hashable]
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+@dataclass
+class CacheEntry:
+    """Base cache entry with TTL and expiration tracking."""
+
+    result: Any
+    ttl: float | None
+
+    cached_at: float = field(init=False)
+    expires_at: float = field(init=False)
+
+    @classmethod
+    def time(cls) -> float:
+        return time.monotonic()
+
+    def __post_init__(self):
+        self.cached_at = self.time()
+        self.expires_at = 0 if self.ttl is None else self.cached_at + self.ttl
+
+    def is_expired(self) -> bool:
+        if self.ttl is None:
+            return False
+
+        return self.time() > self.expires_at
+
+
+@dataclass(frozen=True, slots=True)
+class CacheConfig:
+    """Configuration for cache, grouping storage, lock, and never_die registration."""
+
+    storage: "CacheStorage"
+    sync_lock: Callable[[str], ContextManager]
+    async_lock: Callable[[str], AsyncContextManager]
+
+
+class CacheEntryProtocol(Protocol):
+    """Protocol for cache entry objects."""
+
+    result: Any
+
+    def is_expired(self) -> bool: ...
+
+
+class CacheStorage(Protocol):
+    """Protocol defining the interface for cache storage."""
+
+    def get(self, cache_key: str, skip_cache: bool) -> CacheEntryProtocol | None:
+        """Retrieve a cache entry. Returns None if not found, expired, or skip_cache is True."""
+        ...
+
+    def set(self, cache_key: str, result: Any, ttl: Number | None):
+        """Store a result in the cache with optional TTL."""
+        ...
+
+    async def aget(self, cache_key: str, skip_cache: bool) -> CacheEntryProtocol | None:
+        """Async version of get."""
+        ...
+
+    async def aset(self, cache_key: str, result: Any, ttl: Number | None):
+        """Async version of set."""
+        ...
+
+
+class CacheKwargs(TypedDict, total=False):
+    """
+    ### Description
+    This type can be used in conjuction with `Unpack` to provide static type
+    checking for the parameters added by the `@cache()` decorator.
+
+    This type is completely optional and `skip_cache` will work regardless
+    of what static type checkers complain about.
+
+    ### Example
+    ```
+    @cache()
+    def function_with_cache(**_: Unpack[CacheKwargs]): ...
+
+    # pylance/pyright should not complain
+    function_with_cache(skip_cache=True)
+    ```
+
+    ### Notes
+    Prior to Python 3.11, `Unpack` is only available with typing_extensions
+    """
+
+    skip_cache: bool

cachify/utils/arguments.py

@@ -1,65 +1,65 @@
-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.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()
-
-
-def _iter_arguments(
-    function_signature: Signature,
-    args: tuple,
-    kwargs: dict,
-    ignore_fields: tuple[str, ...],
-) -> Generator[Any, None, None]:
-    bound = function_signature.bind_partial(*args, **kwargs)
-    bound.apply_defaults()
-
-    for name, value in bound.arguments.items():
-        if name in ignore_fields:
-            continue
-
-        param = function_signature.parameters[name]
-
-        # Positional variable arguments can just be yielded like so
-        if param.kind == param.VAR_POSITIONAL:
-            yield from value
-            continue
-
-        # Keyword variable arguments need to be unpacked from .items()
-        if param.kind == param.VAR_KEYWORD:
-            yield from value.items()
-            continue
-
-        yield name, value
-
-
-def create_cache_key(
-    function: Callable[..., Any],
-    cache_key_func: CacheKeyFunction | None,
-    ignore_fields: tuple[str, ...],
-    args: tuple,
-    kwargs: dict,
-) -> str:
-    function_id = get_function_id(function)
-
-    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)}"
-
-    cache_key = cache_key_func(args, kwargs)
-    try:
-        return f"{function_id}:{_cache_key_fingerprint(cache_key)}"
-    except TypeError as exc:
-        raise ValueError(
-            "Cache key function must return a hashable cache key - be careful with mutable types (list, dict, set) and non built-in types"
-        ) from exc
+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.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()
+
+
+def _iter_arguments(
+    function_signature: Signature,
+    args: tuple,
+    kwargs: dict,
+    ignore_fields: tuple[str, ...],
+) -> Generator[Any, None, None]:
+    bound = function_signature.bind_partial(*args, **kwargs)
+    bound.apply_defaults()
+
+    for name, value in bound.arguments.items():
+        if name in ignore_fields:
+            continue
+
+        param = function_signature.parameters[name]
+
+        # Positional variable arguments can just be yielded like so
+        if param.kind == param.VAR_POSITIONAL:
+            yield from value
+            continue
+
+        # Keyword variable arguments need to be unpacked from .items()
+        if param.kind == param.VAR_KEYWORD:
+            yield from value.items()
+            continue
+
+        yield name, value
+
+
+def create_cache_key(
+    function: Callable[..., Any],
+    cache_key_func: CacheKeyFunction | None,
+    ignore_fields: tuple[str, ...],
+    args: tuple,
+    kwargs: dict,
+) -> str:
+    function_id = get_function_id(function)
+
+    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)}"
+
+    cache_key = cache_key_func(args, kwargs)
+    try:
+        return f"{function_id}:{_cache_key_fingerprint(cache_key)}"
+    except TypeError as exc:
+        raise ValueError(
+            "Cache key function must return a hashable cache key - be careful with mutable types (list, dict, set) and non built-in types"
+        ) from exc