simple-redis-cache 0.1.0__tar.gz

simple_redis_cache-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,53 @@
+# 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/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "simple-redis-cache"
+version = "0.1.0"
+description = "A library that simplifies working with Redis in Python"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "redis>=8.0.1",
+]
+
+[dependency-groups]
+dev = [
+    "fakeredis>=2.36.2",
+    "pytest-asyncio>=1.4.0",
+    "pytest-cov>=7.1.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"

simple_redis_cache-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

simple_redis_cache-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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/src/simple_redis_cache.egg-info/PKG-INFO

@@ -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/src/simple_redis_cache.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/__init__.py
+src/simple_redis_cache/__init__.py
+src/simple_redis_cache/cache.py
+src/simple_redis_cache/encoder.py
+src/simple_redis_cache/key_generator.py
+src/simple_redis_cache.egg-info/PKG-INFO
+src/simple_redis_cache.egg-info/SOURCES.txt
+src/simple_redis_cache.egg-info/dependency_links.txt
+src/simple_redis_cache.egg-info/requires.txt
+src/simple_redis_cache.egg-info/top_level.txt
+tests/test_cache.py
+tests/test_encoder.py
+tests/test_key_generator.py

simple_redis_cache-0.1.0/src/simple_redis_cache.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

simple_redis_cache-0.1.0/src/simple_redis_cache.egg-info/requires.txt

@@ -0,0 +1 @@
+redis>=8.0.1

simple_redis_cache-0.1.0/src/simple_redis_cache.egg-info/top_level.txt

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

simple_redis_cache-0.1.0/tests/test_cache.py

@@ -0,0 +1,221 @@
+import asyncio
+from unittest.mock import patch
+
+import pytest
+
+from src.simple_redis_cache.cache import Cache
+
+
+class TestCacheDecorator:
+    async def test_cache_hit(self, fake_cache: Cache) -> None:
+        @fake_cache.cache(ttl=60)
+        async def test_func(x: int) -> int:
+            return x * 2
+
+        result1 = await test_func(5)
+        assert result1 == 10
+
+        result2 = await test_func(5)
+        assert result2 == 10
+
+        keys = await fake_cache.redis_client.keys("cache:*")
+        assert len(keys) == 1
+
+    async def test_cache_different_args(self, fake_cache: Cache) -> None:
+        @fake_cache.cache(ttl=60)
+        async def test_func(x: int) -> int:
+            return x * 2
+
+        await test_func(5)
+        await test_func(10)
+
+        keys = await fake_cache.redis_client.keys("cache:*")
+        assert len(keys) == 2
+
+    async def test_cache_none(self, fake_cache: Cache) -> None:
+        @fake_cache.cache(ttl=60)
+        async def test_func(x: int):
+            if x == 0:
+                return None
+            return x * 2
+
+        result = await test_func(0)
+        assert result is None
+
+        keys = await fake_cache.redis_client.keys("cache:*")
+        assert len(keys) == 1
+
+        cached = await fake_cache.redis_client.get(keys[0])
+        assert cached == b"__NULL__"
+
+    async def test_cache_ttl(self, fake_cache: Cache) -> None:
+        @fake_cache.cache(ttl=1)
+        async def test_func(x: int) -> int:
+            return x * 2
+
+        await test_func(5)
+
+        keys = await fake_cache.redis_client.keys("cache:*")
+        assert len(keys) == 1
+
+        await asyncio.sleep(1.5)
+
+        keys = await fake_cache.redis_client.keys("cache:*")
+        assert len(keys) == 0
+
+    async def test_cache_prefix(self, fake_cache: Cache) -> None:
+        @fake_cache.cache(ttl=60, prefix="user")
+        async def test_func(x: int) -> int:
+            return x * 2
+
+        await test_func(5)
+
+        keys = await fake_cache.redis_client.keys("cache:user:*")
+        assert len(keys) == 1
+
+    async def test_cache_default_ttl(self, fake_cache: Cache) -> None:
+        @fake_cache.cache(ttl=10)
+        async def test_func(x: int) -> int:
+            return x * 2
+
+        await test_func(5)
+
+        keys = await fake_cache.redis_client.keys("cache:*")
+        assert len(keys) == 1
+
+        ttl = await fake_cache.redis_client.ttl(keys[0])
+        assert ttl == 10
+
+    async def test_cache_kwargs(self, fake_cache: Cache) -> None:
+        @fake_cache.cache(ttl=60)
+        async def test_func(a: int, b: int) -> int:
+            return a + b
+
+        await test_func(a=1, b=2)
+        await test_func(b=2, a=1)
+
+        keys = await fake_cache.redis_client.keys("cache:*")
+        assert len(keys) == 1
+
+    async def test_cache_method(self, fake_cache: Cache) -> None:
+        class TestClass:
+            async def method(self, x: int) -> int:
+                return x * 2
+
+        obj = TestClass()
+        decorated = fake_cache.cache(ttl=60)(obj.method)
+
+        await decorated(10)
+        await decorated(10)
+
+        keys = await fake_cache.redis_client.keys("cache:*")
+        assert len(keys) == 1
+
+    async def test_cache_redis_error(self, fake_cache: Cache) -> None:
+        @fake_cache.cache(ttl=60)
+        async def test_func(x: int) -> int:
+            return x * 2
+
+        original_get = fake_cache.redis_client.get
+
+        async def failing_get(*args, **kwargs):
+            raise Exception("Redis connection error")
+
+        fake_cache.redis_client.get = failing_get
+
+        result = await test_func(5)
+        assert result == 10
+
+        fake_cache.redis_client.get = original_get
+
+    def test_cache_sync_function_error(self, fake_cache: Cache) -> None:
+        def sync_func():
+            return 42
+
+        with pytest.raises(TypeError) as exc:
+            fake_cache.cache(ttl=60)(sync_func)
+
+        assert "async" in str(exc.value)
+
+
+class TestCacheInvalidation:
+    async def test_invalidate_by_prefix(self, fake_cache: Cache) -> None:
+        @fake_cache.cache(ttl=60, prefix="user")
+        async def user_func(x: int) -> int:
+            return x * 2
+
+        @fake_cache.cache(ttl=60, prefix="admin")
+        async def admin_func(x: int) -> int:
+            return x * 2
+
+        await user_func(5)
+        await admin_func(10)
+
+        user_keys = await fake_cache.redis_client.keys("cache:user:*")
+        admin_keys = await fake_cache.redis_client.keys("cache:admin:*")
+        assert len(user_keys) == 1
+        assert len(admin_keys) == 1
+
+        deleted = await fake_cache.invalidate_cache(prefix="user")
+        assert deleted == 1
+
+        user_keys = await fake_cache.redis_client.keys("cache:user:*")
+        admin_keys = await fake_cache.redis_client.keys("cache:admin:*")
+        assert len(user_keys) == 0
+        assert len(admin_keys) == 1
+
+    async def test_invalidate_all(self, fake_cache: Cache) -> None:
+        @fake_cache.cache(ttl=60, prefix="test")
+        async def test_func(x: int) -> int:
+            return x * 2
+
+        await test_func(5)
+        await test_func(10)
+
+        keys = await fake_cache.redis_client.keys("cache:*")
+        assert len(keys) == 2
+
+        deleted = await fake_cache.invalidate_cache()
+        assert deleted == 2
+
+        keys = await fake_cache.redis_client.keys("cache:*")
+        assert len(keys) == 0
+
+    async def test_invalidate_timeout(self, fake_cache: Cache) -> None:
+        @fake_cache.cache(ttl=60, prefix="test")
+        async def test_func(x: int) -> int:
+            return x * 2
+
+        for i in range(10):
+            await test_func(i)
+
+        async def slow_scan(*args, **kwargs):
+            await asyncio.sleep(1)
+            return 0, []
+
+        with patch.object(fake_cache.redis_client, "scan", side_effect=slow_scan):
+            deleted = await fake_cache.invalidate_cache(
+                prefix="test", timeout_seconds=1
+            )
+            assert deleted == 0
+
+    async def test_invalidate_empty(self, fake_cache: Cache) -> None:
+        deleted = await fake_cache.invalidate_cache(prefix="nonexistent")
+        assert deleted == 0
+
+    async def test_invalidate_no_prefix(self, fake_cache: Cache) -> None:
+        @fake_cache.cache(ttl=60)
+        async def test_func(x: int) -> int:
+            return x * 2
+
+        await test_func(5)
+        await test_func(10)
+
+        keys = await fake_cache.redis_client.keys("cache:*")
+        assert len(keys) == 2
+
+        deleted = await fake_cache.invalidate_cache()
+        assert deleted == 2
+
+        keys = await fake_cache.redis_client.keys("cache:*")
+        assert len(keys) == 0

simple_redis_cache-0.1.0/tests/test_encoder.py

@@ -0,0 +1,82 @@
+import json
+from datetime import datetime
+from decimal import Decimal
+from uuid import uuid4
+
+import pytest
+
+from src.simple_redis_cache.encoder import CustomJSONEncoder
+
+
+class TestCustomJSONEncoder:
+    def test_datetime_serialization(self):
+        dt = datetime(2026, 7, 10, 15, 30, 0)
+        result = json.dumps({"date": dt}, cls=CustomJSONEncoder)
+        assert result == '{"date": "2026-07-10T15:30:00"}'
+
+    def test_decimal_serialization(self):
+        dec = Decimal("10.5")
+        result = json.dumps({"price": dec}, cls=CustomJSONEncoder)
+        assert result == '{"price": 10.5}'
+
+    def test_uuid_serialization(self):
+        uid = uuid4()
+        result = json.dumps({"id": uid}, cls=CustomJSONEncoder)
+        expected = f'{{"id": "{str(uid)}"}}'
+        assert result == expected
+
+    def test_pydantic_model_serialization(self):
+        class TestModel:
+            def __init__(self, name: str, age: int):
+                self.name = name
+                self.age = age
+
+            def model_dump(self):
+                return {"name": self.name, "age": self.age}
+
+        obj = TestModel("Alice", 30)
+        result = json.dumps({"user": obj}, cls=CustomJSONEncoder)
+        assert result == '{"user": {"name": "Alice", "age": 30}}'
+
+    def test_dict_with_model_dump(self):
+        class TestModel:
+            def __init__(self, name: str):
+                self.name = name
+
+            def model_dump(self):
+                return {"name": self.name}
+
+        obj = TestModel("Bob")
+        result = json.dumps({"user": obj}, cls=CustomJSONEncoder)
+        assert result == '{"user": {"name": "Bob"}}'
+
+    def test_unknown_type_raises_error(self):
+        class UnknownType:
+            pass
+
+        obj = UnknownType()
+        with pytest.raises(TypeError) as exc:
+            json.dumps({"data": obj}, cls=CustomJSONEncoder)
+        assert "is not JSON serializable" in str(exc.value)
+
+    def test_none_serialization(self):
+        result = json.dumps({"value": None}, cls=CustomJSONEncoder)
+        assert result == '{"value": null}'
+
+    def test_list_of_mixed_types(self):
+        dt = datetime(2026, 7, 10, 15, 30, 0)
+        dec = Decimal("10.5")
+        data = [dt, dec, "text", 42]
+        result = json.dumps(data, cls=CustomJSONEncoder)
+        assert result == '["2026-07-10T15:30:00", 10.5, "text", 42]'
+
+    def test_nested_structures(self):
+        dt = datetime(2026, 7, 10, 15, 30, 0)
+        data = {
+            "user": {"name": "Alice", "created_at": dt, "balance": Decimal("100.50")}
+        }
+        result = json.dumps(data, cls=CustomJSONEncoder)
+        assert (
+            result
+            == '{"user": {"name": "Alice", "created_at": "2026-07-10T15:30:00", "balance": 100.5}}'
+        )

simple_redis_cache-0.1.0/tests/test_key_generator.py

@@ -0,0 +1,166 @@
+import pytest
+
+from src.simple_redis_cache.key_generator import clean_args, gen_cache_key
+
+
+class TestCleanArgs:
+    def test_clean_args_no_args(self):
+        def test_func():
+            pass
+
+        result = clean_args((), test_func)
+        assert result == ()
+
+    def test_clean_args_no_self(self):
+        def test_func(x: int, y: int) -> int:
+            return x + y
+
+        result = clean_args((1, 2), test_func)
+        assert result == (1, 2)
+
+    def test_clean_args_with_self(self):
+        class TestClass:
+            def method(self, x: int) -> int:
+                return x * 2
+
+        obj = TestClass()
+        result = clean_args((obj, 5), TestClass.method)
+        assert result == (5,)
+
+    def test_clean_args_with_cls(self):
+        class TestClass:
+            @classmethod
+            def class_method(cls, x: int) -> int:
+                return x * 2
+
+        result = clean_args((5,), TestClass.class_method)
+        assert result == (5,)
+
+    def test_clean_args_with_static_method(self):
+        class TestClass:
+            @staticmethod
+            def static_method(x: int) -> int:
+                return x * 2
+
+        result = clean_args((5,), TestClass.static_method)
+        assert result == (5,)
+
+    def test_clean_args_multiple_args(self):
+        def test_func(a: int, b: int, c: int) -> int:
+            return a + b + c
+
+        result = clean_args((1, 2, 3), test_func)
+        assert result == (1, 2, 3)
+
+    def test_clean_args_empty_tuple(self):
+        def test_func(x: int) -> int:
+            return x
+
+        result = clean_args((), test_func)
+        assert result == ()
+
+
+class TestGenCacheKey:
+    def test_gen_key_without_args(self):
+        def test_func() -> int:
+            return 42
+
+        key = gen_cache_key(test_func, (), {})
+        assert key.startswith("cache:")
+        assert len(key) > 10
+
+    def test_gen_key_with_positional_args(self):
+        def test_func(a: int, b: int) -> int:
+            return a + b
+
+        key1 = gen_cache_key(test_func, (1, 2), {})
+        key2 = gen_cache_key(test_func, (3, 4), {})
+        assert key1 != key2
+        assert key1.startswith("cache:")
+        assert key2.startswith("cache:")
+
+    def test_gen_key_with_kwargs(self):
+        def test_func(a: int, b: int) -> int:
+            return a + b
+
+        key1 = gen_cache_key(test_func, (), {"a": 1, "b": 2})
+        key2 = gen_cache_key(test_func, (), {"a": 3, "b": 4})
+        assert key1 != key2
+
+    def test_gen_key_with_mixed_args(self):
+        def test_func(a: int, b: int, c: int = 0) -> int:
+            return a + b + c
+
+        key1 = gen_cache_key(test_func, (1, 2), {"c": 3})
+        key2 = gen_cache_key(test_func, (1, 2), {"c": 4})
+        assert key1 != key2
+
+    def test_gen_key_with_prefix(self):
+        def test_func(x: int) -> int:
+            return x * 2
+
+        key = gen_cache_key(test_func, (5,), {}, prefix="test")
+        assert key.startswith("cache:test:")
+        assert len(key) > 10
+
+    def test_gen_key_without_prefix(self):
+        def test_func(x: int) -> int:
+            return x * 2
+
+        key = gen_cache_key(test_func, (5,), {})
+        assert key.startswith("cache:")
+        assert "test" not in key
+
+    def test_gen_key_consistency(self):
+        def test_func(x: int) -> int:
+            return x * 2
+
+        key1 = gen_cache_key(test_func, (5,), {})
+        key2 = gen_cache_key(test_func, (5,), {})
+        assert key1 == key2
+
+    def test_gen_key_different_functions(self):
+        def func1(x: int) -> int:
+            return x * 2
+
+        def func2(x: int) -> int:
+            return x * 3
+
+        key1 = gen_cache_key(func1, (5,), {})
+        key2 = gen_cache_key(func2, (5,), {})
+        assert key1 != key2
+
+    def test_gen_key_with_self(self):
+        class TestClass:
+            def method(self, x: int) -> int:
+                return x * 2
+
+        obj = TestClass()
+        method = obj.method
+
+        key = gen_cache_key(method, (5,), {})
+        assert key.startswith("cache:")
+
+    def test_gen_key_with_str_arg(self):
+        def test_func(name: str) -> str:
+            return f"Hello, {name}"
+
+        key1 = gen_cache_key(test_func, ("Alice",), {})
+        key2 = gen_cache_key(test_func, ("Bob",), {})
+        assert key1 != key2
+
+    def test_gen_key_with_bool_arg(self):
+        def test_func(flag: bool) -> bool:
+            return flag
+
+        key1 = gen_cache_key(test_func, (True,), {})
+        key2 = gen_cache_key(test_func, (False,), {})
+        assert key1 != key2
+
+    def test_gen_key_with_none_arg(self):
+        def test_func(value: int | None) -> int | None:
+            return value
+
+        key1 = gen_cache_key(test_func, (None,), {})
+        key2 = gen_cache_key(test_func, (5,), {})
+        assert key1 != key2