rediscache 0.3.3__tar.gz → 1.0.1__tar.gz

{rediscache-0.3.3 → rediscache-1.0.1}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: rediscache
-Version: 0.3.3
+Version: 1.0.1
 Summary: Redis caching of functions evolving over time
-Home-page: https://github.com/AmadeusITGroup/RedisCache
 License: MIT
 Keywords: redis,performance,cache
 Author: Pierre Cart-Grandjean
@@ -20,9 +19,10 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: executiontime (>=0.3.6,<0.4.0)
-Requires-Dist: redis (>=5.0.1,<6.0.0)
+Requires-Dist: executiontime (>=0.4.3,<0.5.0)
+Requires-Dist: redis (>=5.2.1,<6.0.0)
 Project-URL: Repository, https://github.com/AmadeusITGroup/RedisCache
 Description-Content-Type: text/markdown
 
@@ -46,7 +46,7 @@ This is a great caching mechanism for functions that will give a consistent outp
 
 ## Installation
 
-Simply install the PyPi package:
+Simply install the PyPi package [rediscache](https://pypi.org/project/rediscache/):
 
 ```bash
 pip install rediscache
@@ -115,22 +115,6 @@ See `test_rediscache.py` for more examples.
 
 Note: when you choose to wait for the value, you do not have an absolute guarantee that you will not get the default value. For example if it takes more than the retry time to get an answer from the function, the decorator will give up.
 
-### `cache_raw` decorator helper
-
-No serializer or deserializer. This will only work if the cached function only returns `byte`, `str`, `int` or `float` types. Even `None` will fail.
-
-### `cache_raw_wait` decorator helper
-
-Same as above but waits for the value if not in the cache.
-
-### `cache_json` decorator helper
-
-Serialize the value with `json.dumps()` and deserialize the value with `json.loads()`.
-
-### `cache_json_wait` decorator helper
-
-Same as above but waits for the value if not in the cache.
-
 ### `get_stats(delete=False)`
 
 This will get the stats stored when using the cache. The `delete` option is to reset the counters after read.
@@ -138,6 +122,7 @@ The output is a dictionary with the following keys and values:
 
 - **Refresh**: Number of times the cached function was actually called.
 - **Wait**: Number of times we waited for the result when executing the function.
+- **Sleep**: Number of 1 seconds we waited for the results to be found in the cache.
 - **Failed**: Number of times the cached function raised an exception when called.
 - **Missed**: Number of times the functions result was not found in the cache.
 - **Success**: Number of times the function's result was found in the cache.
@@ -203,10 +188,10 @@ My development environment is handled by Poetry. I use `Python 3.11.7`.
 
 To make sure we use Redis properly, we do not mock it in the unit tess. So you will need a localhost default instance of Redis server without a password. This means that the unit tests are more like integration tests.
 
-The execution of the tests including coverage result can be done with `test.sh`. You can also run just `pytest`:
+The execution of the tests including coverage result is done with `pytest`:
 
 ```bash
-./test.sh
+poetry run pytest --cov=rediscache
 ```
 
 ## CI/CD
@@ -225,3 +210,21 @@ We get help from re-usable actions. Here is the [Marketplace](https://github.com
 
 For the moment the publish to PyPI is done manually with the `publish.sh` script. You will need a PyPI API token in `PYPI_API_TOKEN`, stored in a `secrets.sh`.
 
+## Demo application
+
+In the `demo` directory you will find a web application to test `RedisCache`.
+
+```bash
+poetry run webapp
+```
+
+Entry points:
+
+- Call to long function with parameter value `20` and using the cache but waiting for a result: [link](http://localhost:9090/cached/20)
+- Call to long function with parameter value `20` without using the cache: [link](http://localhost:9090/direct/20)
+- Get the stats stored in Redis database: [link](http://localhost:9090/stats)
+
+There is also a `Nginx` configuration file to further test if with a load balancing of workers. It is useful to demonstrate that many workers can share efficiently the same instance of `Redis`.
+
+Finally a `Gatling` configuration file can be used to test the performance.
+

{rediscache-0.3.3 → rediscache-1.0.1}/README.md

@@ -18,7 +18,7 @@ This is a great caching mechanism for functions that will give a consistent outp
 
 ## Installation
 
-Simply install the PyPi package:
+Simply install the PyPi package [rediscache](https://pypi.org/project/rediscache/):
 
 ```bash
 pip install rediscache
@@ -87,22 +87,6 @@ See `test_rediscache.py` for more examples.
 
 Note: when you choose to wait for the value, you do not have an absolute guarantee that you will not get the default value. For example if it takes more than the retry time to get an answer from the function, the decorator will give up.
 
-### `cache_raw` decorator helper
-
-No serializer or deserializer. This will only work if the cached function only returns `byte`, `str`, `int` or `float` types. Even `None` will fail.
-
-### `cache_raw_wait` decorator helper
-
-Same as above but waits for the value if not in the cache.
-
-### `cache_json` decorator helper
-
-Serialize the value with `json.dumps()` and deserialize the value with `json.loads()`.
-
-### `cache_json_wait` decorator helper
-
-Same as above but waits for the value if not in the cache.
-
 ### `get_stats(delete=False)`
 
 This will get the stats stored when using the cache. The `delete` option is to reset the counters after read.
@@ -110,6 +94,7 @@ The output is a dictionary with the following keys and values:
 
 - **Refresh**: Number of times the cached function was actually called.
 - **Wait**: Number of times we waited for the result when executing the function.
+- **Sleep**: Number of 1 seconds we waited for the results to be found in the cache.
 - **Failed**: Number of times the cached function raised an exception when called.
 - **Missed**: Number of times the functions result was not found in the cache.
 - **Success**: Number of times the function's result was found in the cache.
@@ -175,10 +160,10 @@ My development environment is handled by Poetry. I use `Python 3.11.7`.
 
 To make sure we use Redis properly, we do not mock it in the unit tess. So you will need a localhost default instance of Redis server without a password. This means that the unit tests are more like integration tests.
 
-The execution of the tests including coverage result can be done with `test.sh`. You can also run just `pytest`:
+The execution of the tests including coverage result is done with `pytest`:
 
 ```bash
-./test.sh
+poetry run pytest --cov=rediscache
 ```
 
 ## CI/CD
@@ -196,3 +181,21 @@ We get help from re-usable actions. Here is the [Marketplace](https://github.com
 ### Publish to PyPI
 
 For the moment the publish to PyPI is done manually with the `publish.sh` script. You will need a PyPI API token in `PYPI_API_TOKEN`, stored in a `secrets.sh`.
+
+## Demo application
+
+In the `demo` directory you will find a web application to test `RedisCache`.
+
+```bash
+poetry run webapp
+```
+
+Entry points:
+
+- Call to long function with parameter value `20` and using the cache but waiting for a result: [link](http://localhost:9090/cached/20)
+- Call to long function with parameter value `20` without using the cache: [link](http://localhost:9090/direct/20)
+- Get the stats stored in Redis database: [link](http://localhost:9090/stats)
+
+There is also a `Nginx` configuration file to further test if with a load balancing of workers. It is useful to demonstrate that many workers can share efficiently the same instance of `Redis`.
+
+Finally a `Gatling` configuration file can be used to test the performance.

{rediscache-0.3.3 → rediscache-1.0.1}/pyproject.toml

@@ -1,6 +1,7 @@
+# For more details on this file see: https://python-poetry.org/docs/pyproject/
 [tool.poetry]
 name = "rediscache"
-version = "0.3.3"
+version = "1.0.1"
 description = "Redis caching of functions evolving over time"
 authors = ["Pierre Cart-Grandjean <pcart-grandjean@amadeus.com>"]
 license = "MIT"
@@ -21,28 +22,35 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
+packages = [{ include = "rediscache" }]
 
 [tool.poetry.dependencies]
 python = "^3.9"
-redis = "^5.0.1"
-executiontime = "^0.3.6"
+redis = "^5.2.1"
+executiontime = "^0.4.3"
 
 [tool.poetry.group.dev.dependencies]
-pylint = "^3.0.3"
-pytest = "^8.0.1"
+pylint = "^3.3.5"
+pytest = "^8.3.5"
 pdbpp = "^0.10.3"
-coverage = "^7.4.2"
-mypy = "^1.8.0"
-safety = "^3.0.1"
-black = "^24.2.0"
+mypy = "^1.15.0"
+safety = "^3.3.1"
+black = "^25.1.0"
+pytest-cov = "^6.0.0"
+tornado = "^6.4.2"
+pip-audit = "^2.8.0"
 
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
+[tool.poetry.scripts]
+webapp = "demo.webapp:main"
+
 [tool.mypy]
 strict = true
 
 [tool.pylint.format]
 # Maximum number of characters on a single line.
 max-line-length = 160
+max-args = 10

{rediscache-0.3.3 → rediscache-1.0.1}/rediscache/__init__.py

@@ -35,15 +35,14 @@ TODO:
 """
 
 from functools import wraps
-from json import dumps, loads
 import logging
 import os
 import threading
 from time import sleep
-from typing import Any, Callable, Dict, List, Optional, ParamSpec, TypeVar
+from typing import Any, Callable, cast, Dict, List, Optional, ParamSpec, TypeVar
 
-import redis
 from executiontime import printexecutiontime, YELLOW, RED
+import redis
 
 PREFIX = "."
 REFRESH = "Refresh"  # Number of times the cached function was actually called.
@@ -56,7 +55,7 @@ DEFAULT = "Default"  # Number of times the default value was used because nothin
 STATS = [REFRESH, WAIT, SLEEP, FAILED, MISSED, SUCCESS, DEFAULT]
 
 P = ParamSpec("P")
-T = TypeVar("T")
+T = TypeVar("T", str, bytes)
 
 
 class RedisCache:
@@ -64,8 +63,6 @@ class RedisCache:
     Having the decorator provided by a class allows to have some context to improve performances.
     """
 
-    # pylint: disable=too-many-arguments
-
     def __init__(
         self,
         host: Optional[str] = None,
@@ -120,25 +117,18 @@ class RedisCache:
 
         return f"{name}({','.join(values)})"
 
-    # pylint: disable=line-too-long
     def cache(
         self,
         refresh: int,
         expire: int,
+        default: T,
         retry: Optional[int] = None,
-        default: Any = "",
         wait: bool = False,
-        serializer: Optional[Callable[..., Any]] = None,
-        deserializer: Optional[Callable[..., Any]] = None,
         use_args: Optional[List[int]] = None,
         use_kwargs: Optional[List[str]] = None,
     ) -> Callable[[Callable[P, T]], Callable[P, T]]:
         """
-        Full decorator will all possible parameters. Most of the time, you should use a specialized decorator below.
-
-        Specific examples when to use this decorator:
-        - Raw storage of byte string that you do not want to be decoded: use the decode=False.
-        - JSON dumps data that doesn't need to be loaded before it is sent by a REST API: use serializer=dumps but no deserializer.
+        Full decorator will all possible parameters.
         """
 
         logger = logging.getLogger(__name__)
@@ -188,11 +178,8 @@ class RedisCache:
                         self.server.incr(DEFAULT)
                         new_value = default
 
-                    # Serialize the value if requested
-                    if serializer:
-                        new_value = serializer(new_value)
                     # Store value in cache with expiration time
-                    self.server.set(key, new_value, ex=expire)  # type: ignore
+                    self.server.set(key, new_value, ex=expire)
                     # Set refresh key with refresh time
                     self.server.set(PREFIX + key, 1, ex=refresh)
                     return new_value
@@ -206,13 +193,7 @@ class RedisCache:
 
                 # If the cache is disabled, directly call the function
                 if not self.enabled:
-                    direct_value = function(*args, **kwargs)
-                    # If we have decided to serialize, we always do it to be consistent
-                    if serializer:
-                        direct_value = serializer(direct_value)
-                    if deserializer:
-                        direct_value = deserializer(direct_value)
-                    return direct_value
+                    return function(*args, **kwargs)
 
                 # 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)
@@ -225,7 +206,7 @@ class RedisCache:
 
                 # Get the value from the cache.
                 # If it is not there we will get None.
-                cached_value = self.server.get(key)
+                cached_value = cast(T, self.server.get(key))
 
                 # Time to update stats counters
                 if cached_value is None:
@@ -254,16 +235,16 @@ class RedisCache:
                         # Let's count how many times we wait 1s
                         self.server.incr(SLEEP)
                         sleep(1)
-                        cached_value = self.server.get(key)
+                        cached_value = cast(T, self.server.get(key))
 
                 # If the cache was empty, we have None in the cached_value.
                 if cached_value is None:
                     # We are going to return the default value
                     self.server.incr(DEFAULT)
-                    cached_value = serializer(default) if serializer else default
+                    cached_value = default
 
                 # Return whatever value we have at this point.
-                return deserializer(cached_value) if deserializer else cached_value  # type: ignore
+                return cached_value
 
             # If we want to bypass the cache at runtime, we need a reference to the decorated function
             wrapper.function = function  # type: ignore
@@ -272,45 +253,6 @@ class RedisCache:
 
         return decorator
 
-    def cache_raw(self, refresh: int, expire: int, retry: Optional[int] = None, default: Any = "") -> Callable[[Callable[P, T]], Callable[P, T]]:
-        """
-        Normal caching of values directly storable in redis: byte string, string, int, float.
-        """
-        return self.cache(refresh=refresh, expire=expire, retry=retry, default=default)
-
-    def cache_raw_wait(self, refresh: int, expire: int, retry: Optional[int] = None, default: Any = "") -> Callable[[Callable[P, T]], Callable[P, T]]:
-        """
-        Same as cache_raw() but will wait for the completion of the cached function if no value is found in redis.
-        """
-        return self.cache(refresh=refresh, expire=expire, retry=retry, default=default, wait=True)
-
-    def cache_json(self, refresh: int, expire: int, retry: Optional[int] = None, default: Any = "") -> Callable[[Callable[P, T]], Callable[P, T]]:
-        """
-        JSON dumps the values to be stored in redis and loads them again when returning them to the caller.
-        """
-        return self.cache(
-            refresh=refresh,
-            expire=expire,
-            retry=retry,
-            default=default,
-            serializer=dumps,
-            deserializer=loads,
-        )
-
-    def cache_json_wait(self, refresh: int, expire: int, retry: Optional[int] = None, default: Any = "") -> Callable[[Callable[P, T]], Callable[P, T]]:
-        """
-        Same as cache_json() but will wait for the completion of the cached function if no value is found in redis.
-        """
-        return self.cache(
-            refresh=refresh,
-            expire=expire,
-            retry=retry,
-            default=default,
-            wait=True,
-            serializer=dumps,
-            deserializer=loads,
-        )
-
     def get_stats(self, delete: bool = False) -> Dict[str, Any]:
         """
         Get the stats stored by RedisCache. See the list and definition at the top of this file.