rediscache 1.0.3__tar.gz → 1.0.5__tar.gz

{rediscache-1.0.3 → rediscache-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rediscache
-Version: 1.0.3
+Version: 1.0.5
 Summary: Redis caching of functions evolving over time
 License: MIT
 Keywords: redis,performance,cache
@@ -92,11 +92,9 @@ This is the main decorator. All the parameters are available. The mandatory ones
 
 - refresh: The amount of seconds before it would be a good idea to refresh the cached value.
 - expire: How many seconds that the value in the cache is still considered good enough to be sent back to the caller.
-- retry: While a value is being refreshed, we want to avoid to refresh it in parallel. But if it is taking too long, after the number of seconds provided here, we may want to try our luck again. If not specified, we will take the `refresh` value.
 - default: If we do not have the value in the cache and we do not want to wait, what shall we send back to the caller? It has to be serializable because it will also be stored in the cache. [`''`]
+- retry: While a value is being refreshed, we want to avoid to refresh it in parallel. But if it is taking too long, after the number of seconds provided here, we may want to try our luck again. If not specified, we will take the `refresh` value.
 - wait: If the value is not in the cache, do we wait for the return of the function? [`False`]
-- serializer: The only type of data that can be stored directly in the Redis database are `byte`, `str`, `int` and `float`. Any other will have to be serialized with the function provided here. [`None`]
-- deserializer: If the value was serialized to be stored in the cache, it needs to deserialized when it is retrieved. [`None`]
 - use_args: This is the list of positional parameters (a list of integers) to be taken into account to generate the key that will be used in Redis. If `None`, they will all be used. [`None`]
 - use_kwargs: This is the list of named parameters (a list of names) to be taken into account to generate the key that will be used in Redis. If `None`, they will all be used. [`None`]
 

{rediscache-1.0.3 → rediscache-1.0.5}/README.md

@@ -64,11 +64,9 @@ This is the main decorator. All the parameters are available. The mandatory ones
 
 - refresh: The amount of seconds before it would be a good idea to refresh the cached value.
 - expire: How many seconds that the value in the cache is still considered good enough to be sent back to the caller.
-- retry: While a value is being refreshed, we want to avoid to refresh it in parallel. But if it is taking too long, after the number of seconds provided here, we may want to try our luck again. If not specified, we will take the `refresh` value.
 - default: If we do not have the value in the cache and we do not want to wait, what shall we send back to the caller? It has to be serializable because it will also be stored in the cache. [`''`]
+- retry: While a value is being refreshed, we want to avoid to refresh it in parallel. But if it is taking too long, after the number of seconds provided here, we may want to try our luck again. If not specified, we will take the `refresh` value.
 - wait: If the value is not in the cache, do we wait for the return of the function? [`False`]
-- serializer: The only type of data that can be stored directly in the Redis database are `byte`, `str`, `int` and `float`. Any other will have to be serialized with the function provided here. [`None`]
-- deserializer: If the value was serialized to be stored in the cache, it needs to deserialized when it is retrieved. [`None`]
 - use_args: This is the list of positional parameters (a list of integers) to be taken into account to generate the key that will be used in Redis. If `None`, they will all be used. [`None`]
 - use_kwargs: This is the list of named parameters (a list of names) to be taken into account to generate the key that will be used in Redis. If `None`, they will all be used. [`None`]
 

{rediscache-1.0.3 → rediscache-1.0.5}/pyproject.toml

@@ -1,7 +1,7 @@
 # For more details on this file see: https://python-poetry.org/docs/pyproject/
 [tool.poetry]
 name = "rediscache"
-version = "1.0.3"
+version = "1.0.5"
 description = "Redis caching of functions evolving over time"
 authors = ["Pierre Cart-Grandjean <pcart-grandjean@amadeus.com>"]
 license = "MIT"

{rediscache-1.0.3 → rediscache-1.0.5}/rediscache/__init__.py

@@ -63,7 +63,7 @@ class RedisCache:
     Having the decorator provided by a class allows to have some context to improve performances.
     """
 
-    def __init__(
+    def __init__(  # pylint: disable=too-many-positional-arguments
         self,
         host: Optional[str] = None,
         port: Optional[int] = None,
@@ -72,6 +72,16 @@ class RedisCache:
         decode: bool = True,
         enabled: bool = True,
     ):
+        """
+        Provide configuration parameter to a RedisCache instance.
+
+        Args:
+            host: The host of the Redis server instance to be used.
+            port: The port the Redis server listens to.
+            db: The name of the database to be used if not default.
+            decode: If true, decode the data stored in the cache as byte string.
+            enabled: When False it allows to programmatically disable the cache.
+        """
         self.enabled = enabled
         if self.enabled:
             # If environment variables are set for redis server, they supersede the default values.
@@ -87,7 +97,7 @@ class RedisCache:
                 password = os.environ.get("REDIS_SERVICE_PASSWORD")
             self.server = redis.StrictRedis(host=host, port=port, db=db, password=password, decode_responses=decode)
 
-    def _create_key(
+    def _create_key(  # pylint: disable=too-many-positional-arguments
         self,
         name: str,
         args: Optional[tuple[Any, ...]] = None,
@@ -117,7 +127,7 @@ class RedisCache:
 
         return f"{name}({','.join(values)})"
 
-    def cache(
+    def cache(  # pylint: disable=too-many-positional-arguments
         self,
         refresh: int,
         expire: int,
@@ -128,7 +138,19 @@ class RedisCache:
         use_kwargs: Optional[List[str]] = None,
     ) -> Callable[[Callable[P, T]], Callable[P, T]]:
         """
-        Full decorator will all possible parameters.
+        Full decorator with all possible parameters.
+
+        Args:
+            refresh: The amount of seconds before it would be a good idea to refresh the cached value.
+            expire: How many seconds that the value in the cache is still considered good enough to be sent back to the caller.
+            default: If we do not have the value in the cache and we do not want to wait, what shall we send back to the caller?
+                It has to be serializable because it will also be stored in the cache.
+            retry: While a value is being refreshed, we want to avoid to refresh it in parallel.
+                But if it is taking too long, after the number of seconds provided here, we may want to try our luck again.
+                If not specified, we will take the `refresh` value.
+            wait: If the value is not in the cache, do we wait for the return of the function?
+            use_args: This is the list of positional parameters (a list of integers) to be taken into account to generate the key that will be used in Redis.
+            use_kwargs: This is the list of named parameters (a list of names) to be taken into account to generate the key that will be used in Redis.
         """
 
         logger = logging.getLogger(__name__)
@@ -197,12 +219,6 @@ class RedisCache:
 
                 # Lets create a key from the function's name and its parameters values
                 key = self._create_key(name=function.__name__, args=args, use_args=use_args, kwargs=kwargs, use_kwargs=use_kwargs)
-                values = ",".join([str(value) for value in args])
-                dict_values = ",".join([str(key) + "='" + str(value) + "'" for key, value in kwargs.items()])
-                all_args = values
-                if values and dict_values:
-                    all_args += ","
-                all_args += dict_values
 
                 # Get the value from the cache.
                 # If it is not there we will get None.
@@ -259,6 +275,12 @@ class RedisCache:
         If delete is set to True we delete the stats from Redis after read.
         From Redis 6.2, it is possible to GETDEL, making sure that we do not lose some data between
         the 'get' and the 'delete'. But it is not available in the Redis (v3.5.3) python interface yet.
+
+        Args:
+            delete: Reset the counters after read.
+
+        Returns:
+            dict: Dictionary of all the counters and their value.
         """
         stats = {stat: self.server.get(stat) for stat in STATS}
         if delete:

{rediscache-1.0.3 → rediscache-1.0.5}/rediscache/tools.py

@@ -17,6 +17,10 @@ def decorate(transform: Callable[[InT], OutT]) -> Callable[[Callable[P, InT]], C
     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.
+
+    Args:
+        transform: the function that will take the output of the decorated function and transform it,
+            usually to a new type.
     """
 
     def decorator(function: Callable[P, InT]) -> Callable[P, OutT]: