simple-redis-cache 0.1.0__py3-none-any.whl

simple_redis_cache/cache.py

@@ -0,0 +1,146 @@
+import asyncio
+from functools import wraps
+import hashlib
+import inspect
+import json
+from logging import Logger, getLogger
+from typing import Callable, TypeVar, ParamSpec, cast
+
+from redis.asyncio import Redis
+
+from src.simple_redis_cache.encoder import CustomJSONEncoder
+from src.simple_redis_cache.key_generator import clean_args
+
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+class Cache:
+    __slots__ = ("redis_client", "logger")
+
+    def __init__(
+        self, redis_client: Redis, logger: Logger = getLogger(__name__)
+    ) -> None:
+        self.redis_client = redis_client
+        self.logger = logger
+
+    def _gen_cache_key(
+        self,
+        func: Callable,
+        args: tuple,
+        kwargs: dict,
+        prefix: str | None = None,
+    ) -> str:
+        cleaned_args = clean_args(args, func)
+        sorted_kwargs = dict(sorted(kwargs.items()))
+
+        data = {
+            "func_name": func.__name__,
+            "args": cleaned_args,
+            "kwargs": sorted_kwargs,
+        }
+
+        key_hash = hashlib.sha256(
+            json.dumps(data, cls=CustomJSONEncoder, sort_keys=True).encode()
+        ).hexdigest()
+
+        base_key = f"cache:{key_hash}"
+        if prefix:
+            return f"cache:{prefix}:{key_hash}"
+        return base_key
+
+    def cache(
+        self, ttl: int, prefix: str | None = None
+    ) -> Callable[[Callable[P, T]], Callable[P, T]]:
+        def wrapper(func: Callable[P, T]) -> Callable[P, T]:
+            if not inspect.iscoroutinefunction(func):
+                raise TypeError(
+                    f"@cache can only be used on async functions. "
+                    f"'{func.__name__}' is sync."
+                )
+
+            @wraps(func)
+            async def inner(*args: P.args, **kwargs: P.kwargs) -> T:
+                cache_key = self._gen_cache_key(func, args, kwargs, prefix)
+
+                try:
+                    cached = await self.redis_client.get(cache_key)
+                    if cached:
+                        self.logger.debug("Cache HIT: %s", cache_key)
+                        if cached == "__NULL__":
+                            return None  # type: ignore # pragma: no cover
+                        return json.loads(cached)
+                except Exception as exc:
+                    self.logger.warning(
+                        "Failed cache get for key: %s",
+                        cache_key,
+                        exc_info=exc,
+                    )
+
+                result = await func(*args, **kwargs)
+
+                try:
+                    if result is None:
+                        data_to_cache = "__NULL__"
+                    else:
+                        data_to_cache = json.dumps(result, cls=CustomJSONEncoder)
+                    await self.redis_client.set(cache_key, data_to_cache, ex=ttl)
+                    self.logger.debug("Cache saved: %s", cache_key)
+                except Exception as exc: # pragma: no cover
+                    self.logger.warning(
+                        "Failed cache set for key: %s",
+                        cache_key,
+                        exc_info=exc,
+                    )
+
+                return result
+
+            return cast(Callable[P, T], inner)
+
+        return wrapper
+
+    async def invalidate_cache(
+        self, prefix: str = "*", timeout_seconds: int = 30
+    ) -> int:
+        if prefix == "*":
+            pattern = "cache:*"
+        else:
+            pattern = f"cache:{prefix}:*"
+
+        self.logger.debug("Starting cache invalidation by pattern: %s", pattern)
+
+        deleted_count = 0
+        cursor = 0
+        start_time = asyncio.get_event_loop().time()
+
+        try:
+            while True:
+                if asyncio.get_event_loop().time() - start_time > timeout_seconds: # pragma: no cover
+                    self.logger.warning(
+                        "Cache invalidation timed out (%s)", timeout_seconds
+                    )
+                    break
+
+                cursor, keys = await self.redis_client.scan(
+                    cursor,
+                    match=pattern,
+                    count=100,
+                )
+
+                if keys:
+                    await self.redis_client.delete(*keys)
+                    deleted_count += len(keys)
+
+                if cursor == 0:
+                    break
+
+            self.logger.info("Cache invalidated (%s keys)", deleted_count)
+            return deleted_count
+
+        except Exception as exc: # pragma: no cover
+            self.logger.error(
+                "Failed to invalidate cache",
+                exc_info=exc,
+            )
+            return deleted_count

simple_redis_cache/encoder.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+from decimal import Decimal
+import json
+from typing import Any
+
+
+class CustomJSONEncoder(json.JSONEncoder):
+    def default(self, obj: Any) -> Any:
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        if hasattr(obj, "model_dump"):
+            return obj.model_dump()
+        if hasattr(obj, "hex"):
+            return str(obj)
+        if isinstance(obj, Decimal):
+            return float(obj)
+        return super().default(obj)

simple_redis_cache/key_generator.py

@@ -0,0 +1,45 @@
+import hashlib
+import inspect
+import json
+from typing import Callable
+
+from src.simple_redis_cache.encoder import CustomJSONEncoder
+
+
+def clean_args(args: tuple, func: Callable) -> tuple:
+    """Remove 'self/cls/mcs' from args"""
+    if not args:
+        return args
+
+    sig = inspect.signature(func)
+    params = list(sig.parameters.keys())
+
+    if params and params[0] in ("self", "cls", "mcs"):
+        return args[1:]
+
+    return args
+
+
+def gen_cache_key(
+    func: Callable,
+    args: tuple,
+    kwargs: dict,
+    prefix: str | None = None,
+) -> str:
+    cleaned_args = clean_args(args, func)
+    sorted_kwargs = dict(sorted(kwargs.items()))
+
+    data = {
+        "func_name": func.__name__,
+        "args": cleaned_args,
+        "kwargs": sorted_kwargs,
+    }
+
+    key_hash = hashlib.sha256(
+        json.dumps(data, cls=CustomJSONEncoder, sort_keys=True).encode()
+    ).hexdigest()
+
+    base_key = f"cache:{key_hash}"
+    if prefix:
+        return f"cache:{prefix}:{key_hash}"
+    return base_key

simple_redis_cache-0.1.0.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: simple-redis-cache
+Version: 0.1.0
+Summary: A library that simplifies working with Redis in Python
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: redis>=8.0.1
+Dynamic: license-file
+
+# simple-redis-cache
+
+[![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://hotpotato89.github.io/simple-redis-cache/coverage/)
+
+Простой декоратор для кэширования асинхронных функций в Redis.
+
+
+## Особенности
+
+- **Автоматическая генерация ключей** — ключи создаются на основе имени функции и аргументов
+- **Инвалидация по префиксу** — очищайте кэш группами
+- **Кастомный JSON-энкодер** — поддерживает `datetime`, `Decimal`, `UUID`, Pydantic-модели
+- **Устойчивость к ошибкам** — ошибки Redis не ломают приложение
+- **Гибкая настройка** — можно передать свой логгер
+
+
+
+## Установка
+
+```bash
+pip install simple-redis-cache
+```
+
+## Пример
+
+```python
+from redis.asyncio import Redis
+from simple_redis_cache import Cache
+
+redis = Redis()
+cache = Cache(redis)
+
+@cache.cache(ttl=60, prefix="user")
+async def get_user(user_id: int):
+    return {"id": user_id, "name": "Alice"}
+
+# Первый вызов — вычисляется, второй — из кэша
+r1 = await get_user(1)
+r2 = await get_user(1)
+
+# Одинаковый результат
+print(r1 == r2)
+```
+
+## Инвалидация
+```python
+await cache.invalidate_cache(prefix="user")
+```
+
+## Лицензия
+[**MIT**](LICENSE) 
+## Автор
+[**hotpotato89**](https://github.com/hotpotato89)

simple_redis_cache-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+simple_redis_cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+simple_redis_cache/cache.py,sha256=RWYzIpW_pd6P7kFmFrQf96odyfn-cJ5yMk10uZVjF7k,4601
+simple_redis_cache/encoder.py,sha256=91hcQAN-abedsDadE4V8_CIrx-Du1ejzxzZ-H4FvHYU,489
+simple_redis_cache/key_generator.py,sha256=WyE6j6Kh5TiCsIu97r_O_QyodFqMYtn4tiRQGgLSbJ0,1005
+simple_redis_cache-0.1.0.dist-info/licenses/LICENSE,sha256=0RgGruNnQUXRffWn19iCDQjEsfq9objR3dD59F1sbAA,1068
+simple_redis_cache-0.1.0.dist-info/METADATA,sha256=vJjEqhpT9Equm0t2RUH9toE9TMuvlosVtrp-o6nEwgw,1858
+simple_redis_cache-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+simple_redis_cache-0.1.0.dist-info/top_level.txt,sha256=6EVX-_yUvZjX5AVXsOWxDLWaZHMBiB1Fy2eGAtAqojM,28
+simple_redis_cache-0.1.0.dist-info/RECORD,,

simple_redis_cache-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simple_redis_cache-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hotpotato89
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simple_redis_cache-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+__init__
+simple_redis_cache