implement RedisCache raw mode

Author: Fabien Coelho

CacheToolsUtils.py

@@ -699,6 +699,7 @@ class RedisCache(MutableMapping):
 
     :param cache: actual redis cache.
     :param ttl: time-to-live in seconds, used as default expiration (``ex``), default is 600.
+    :param raw: whether to serialize keys and values, default is *False*.
 
     Keys and values are serialized in *JSON*.
 
@@ -710,24 +711,25 @@ class RedisCache(MutableMapping):
        cache = ctu.RedisCache(redis.Redis(host="localhost"), 3600)
     """
 
-    def __init__(self, cache, ttl=600):
+    def __init__(self, cache, ttl=600, raw=False):
         # import redis
         # assert isinstance(cache, redis.Redis)
         self._cache = cache
         self._ttl = ttl
+        self._raw = raw
 
     def clear(self):  # pragma: no cover
         """Flush Redis contents."""
         return self._cache.flushdb()
 
-    def _serialize(self, s) -> str:
-        return json.dumps(s, sort_keys=True, separators=(",", ":"))
+    def _serialize(self, s):
+        return s if self._raw else json.dumps(s, sort_keys=True, separators=(",", ":"))
 
-    def _deserialize(self, s: str):
-        return json.loads(s)
+    def _deserialize(self, s):
+        return s if self._raw else json.loads(s)
 
     def _key(self, key):
-        return json.dumps(key, sort_keys=True, separators=(",", ":"))
+        return key if self._raw else json.dumps(key, sort_keys=True, separators=(",", ":"))
 
     def __getitem__(self, index):
         val = self._cache.get(self._key(index))

docs/REFERENCE.md

@@ -103,13 +103,13 @@ pay for them?
 When used with `cached`, the key is expected to be simple bytes for encryption.
 Consider `ToBytesCache` to trigger byte conversions.
 The output is also bytes, which may or may not suit the underlying cache, consider
-`BytesCache` if necessary.
+`BytesCache` if necessary, or using the `raw` option on `RedisCache`.
 
 ```python
 actual = redis.Redis(…)
-c0 = ctu.BytesCache(actual)
-c1 = ctu.EncryptedCache(c0, b"…")
-cache = ctu.ToBytesCache(c1)
+red = ctu.RedisCache(actual, raw=True)
+enc = ctu.EncryptedCache(red, b"…")
+cache = ctu.ToBytesCache(enc)
 
 @cached(cache=PrefixedCache(cache, "foo."))
 def foo(what, ever):
@@ -155,7 +155,7 @@ pcache = ctu.PrefixedMemCached(mc_base, prefix="pic.")
 
 ## RedisCache
 
-TTL'ed Redis wrapper, default ttl is 10 minutes.
+TTL'ed Redis wrapper, default ttl is 10 minutes and key/value JSON serialization.
 Also adds a `hits()` method to compute the cache hit ratio with data taken
 from the Redis server.
 
@@ -168,6 +168,8 @@ cache = ctu.RedisCache(rd_base, ttl=60)
 
 Redis stores arbitrary bytes. Key and values can be up to 512 MiB.
 Keeping keys under 1 KiB seems reasonable.
+Option `raw` allows to skip the serialization step, if you know that
+keys and values are scalars.
 
 ## PrefixedRedisCache
 

test.py

@@ -243,12 +243,11 @@ def test_redis():
     c0 = redis.Redis(host="localhost")
     c0.flushdb()
 
-    c1 = ctu.RedisCache(c0)
-    c2 = ctu.BytesCache(c1)
-    c3 = ctu.EncryptedCache(c2, SECRET, hsize=24)
-    c4 = ctu.ToBytesCache(c3)
-    c5 = ctu.DebugCache(c4, log)
-    cache = ctu.LockedCache(c5, threading.RLock())
+    c1 = ctu.RedisCache(c0, raw=True)
+    c2 = ctu.EncryptedCache(c1, SECRET, hsize=24)
+    c3 = ctu.ToBytesCache(c2)
+    c4 = ctu.DebugCache(c3, log)
+    cache = ctu.LockedCache(c4, threading.RLock())
     run_cached(cache)
     assert len(cache) >= 50
     assert cache[(1, 'a', True)] == 111
@@ -574,3 +573,10 @@ def test_encrypted_cache():
     assert "Hello" in scache
     assert scache["Hello"] == "World!"
     del scache["Hello"]
+    # bytes again
+    bcache = ctu.BytesCache(scache)
+    bcache[b"Hello"] = b"World!"
+    assert b"Hello" in bcache
+    assert bcache[b"Hello"] == b"World!"
+    del bcache[b"Hello"]
+    assert b"Hello" not in bcache