rediscache 0.3.0__tar.gz → 0.3.2__tar.gz

{rediscache-0.3.0 → rediscache-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rediscache
-Version: 0.3.0
+Version: 0.3.2
 Summary: Redis caching of functions evolving over time
 Home-page: https://github.com/AmadeusITGroup/RedisCache
 License: MIT
@@ -158,6 +158,41 @@ def myfunc():
 print(myfunc.function())
 ```
 
+## The `decorate` decorator
+
+In the `tools` submodule, the `decorate` decorator is a little helper to transform a serializer or deserializer function into a decorator.
+The transformation function is expected to take a single argument of a certain type and transform it into another type.
+For example, a typical serializer would transform a dictionary into a string.
+
+```python
+from json import dumps
+
+from rediscache.tools import decorate
+
+@decorate(dumps)
+def myfunc():
+    return {"toto": 42}
+
+assert isinstance(myfunc(), str)
+```
+
+You may use partial functions if your transformation function requires extra parameters.
+
+```python
+from datetime import date
+from functools import partial
+from json import dumps
+
+from rediscache.tools import decorate
+
+@decorate(partial(dumps, skipkeys=True))
+def func_with_id():
+    """My func_with_id"""
+    return {"name": "Toto", "age": 25, date.today(): "today"}
+
+assert func_with_id() == '{"name": "Toto", "age": 25}'
+```
+
 ## Development
 
 ### Poetry

{rediscache-0.3.0 → rediscache-0.3.2}/README.md

@@ -130,6 +130,41 @@ def myfunc():
 print(myfunc.function())
 ```
 
+## The `decorate` decorator
+
+In the `tools` submodule, the `decorate` decorator is a little helper to transform a serializer or deserializer function into a decorator.
+The transformation function is expected to take a single argument of a certain type and transform it into another type.
+For example, a typical serializer would transform a dictionary into a string.
+
+```python
+from json import dumps
+
+from rediscache.tools import decorate
+
+@decorate(dumps)
+def myfunc():
+    return {"toto": 42}
+
+assert isinstance(myfunc(), str)
+```
+
+You may use partial functions if your transformation function requires extra parameters.
+
+```python
+from datetime import date
+from functools import partial
+from json import dumps
+
+from rediscache.tools import decorate
+
+@decorate(partial(dumps, skipkeys=True))
+def func_with_id():
+    """My func_with_id"""
+    return {"name": "Toto", "age": 25, date.today(): "today"}
+
+assert func_with_id() == '{"name": "Toto", "age": 25}'
+```
+
 ## Development
 
 ### Poetry

{rediscache-0.3.0 → rediscache-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rediscache"
-version = "0.3.0"
+version = "0.3.2"
 description = "Redis caching of functions evolving over time"
 authors = ["Pierre Cart-Grandjean <pcart-grandjean@amadeus.com>"]
 license = "MIT"

rediscache-0.3.2/rediscache/tools.py

@@ -0,0 +1,30 @@
+"""
+Extra tools provided to help with the cache main purpose.
+"""
+
+from functools import wraps
+from typing import Callable, ParamSpec, TypeVar
+
+P = ParamSpec("P")
+InT = TypeVar("InT")
+OutT = TypeVar("OutT")
+
+
+def decorate(transform: Callable[[InT], OutT]) -> Callable[[Callable[P, InT]], Callable[P, OutT]]:
+    """
+    This decorator helps to transform the output of a function from type InT to type OuT providing the
+    appropriate function.
+    It is especially meant to be used to serialize the output of a function to be cached.
+    It can also be used to deserialize the cached value, but this should be used with great caution
+    since it could be worse than not caching the function at all.
+    """
+
+    def decorator(function: Callable[P, InT]) -> Callable[P, OutT]:
+        @wraps(function)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> OutT:
+            value = function(*args, **kwargs)
+            return transform(value)
+
+        return wrapper
+
+    return decorator