Simplify cache namespace and key encoding logic for v1

CHANGES.rst

@@ -15,6 +15,10 @@ There are a number of backwards-incompatible changes. These points should help w
 * The ``key`` parameter has been removed from the ``cached`` decorator. The behaviour can be easily reimplemented with ``key_builder=lambda *a, **kw: "foo"``
 * When using the ``key_builder`` parameter in ``@multicached``, the function will now return the original, unmodified keys, only using the transformed keys in the cache (this has always been the documented behaviour, but not the implemented behaviour).
 * ``BaseSerializer`` is now an ``ABC``, so cannot be instantiated directly.
+* The logic for encoding a cache key and selecting the key's namespace is now encapsulated in
+the ``build_key(key, namespace)`` member of BaseCache (and its backend subclasses). Now
+creating a cache with a custom ``key_builder`` argument simply requires that function to
+return any string mapping from the ``key`` and optional ``namespace`` parameters.
 
 
 0.12.0 (2023-01-13)

aiocache/backends/memcached.py

@@ -147,8 +147,8 @@ def __init__(self, serializer=None, **kwargs):
     def parse_uri_path(cls, path):
         return {}
 
-    def _build_key(self, key, namespace=None):
-        ns_key = super()._build_key(key, namespace=namespace).replace(" ", "_")
+    def build_key(self, key, namespace=None):
+        ns_key = super().build_key(key, namespace=namespace).replace(" ", "_")
         return str.encode(ns_key)
 
     def __repr__(self):  # pragma: no cover

aiocache/backends/redis.py

@@ -4,7 +4,7 @@
 import redis.asyncio as redis
 from redis.exceptions import ResponseError as IncrbyException
 
-from aiocache.base import BaseCache, _ensure_key
+from aiocache.base import BaseCache
 from aiocache.serializers import JsonSerializer
 
 
@@ -218,14 +218,8 @@ def parse_uri_path(cls, path):
             options["db"] = db
         return options
 
-    def _build_key(self, key, namespace=None):
-        if namespace is not None:
-            return "{}{}{}".format(
-                namespace, ":" if namespace else "", _ensure_key(key))
-        if self.namespace is not None:
-            return "{}{}{}".format(
-                self.namespace, ":" if self.namespace else "", _ensure_key(key))
-        return key
+    def _build_key_default(self, key, namespace=None):
+        return "{}{}{}".format(namespace or "", ":" if namespace else "", key)
 
     def __repr__(self):  # pragma: no cover
         return "RedisCache ({}:{})".format(self.endpoint, self.port)

aiocache/base.py

@@ -99,7 +99,7 @@ class BaseCache:
     :param namespace: string to use as default prefix for the key used in all operations of
         the backend. Default is None
     :param key_builder: alternative callable to build the key. Receives the key and the namespace
-        as params and should return something that can be used as key by the underlying backend.
+        as params and should return a string that can be used as key by the underlying backend.
     :param timeout: int or float in seconds specifying maximum timeout for the operations to last.
         By default its 5. Use 0 or None if you want to disable it.
     :param ttl: int the expiration time in seconds to use as a default in all operations of
@@ -114,7 +114,7 @@ def __init__(
         self.timeout = float(timeout) if timeout is not None else timeout
         self.namespace = namespace
         self.ttl = float(ttl) if ttl is not None else ttl
-        self.build_key = key_builder or self._build_key
+        self._build_key = key_builder or self._build_key_default
 
         self._serializer = None
         self.serializer = serializer or serializers.StringSerializer()
@@ -163,8 +163,7 @@ async def add(self, key, value, ttl=SENTINEL, dumps_fn=None, namespace=None, _co
         """
         start = time.monotonic()
         dumps = dumps_fn or self._serializer.dumps
-        ns = namespace if namespace is not None else self.namespace
-        ns_key = self.build_key(key, namespace=ns)
+        ns_key = self.build_key(key, namespace=namespace)
 
         await self._add(ns_key, dumps(value), ttl=self._get_ttl(ttl), _conn=_conn)
 
@@ -193,8 +192,7 @@ async def get(self, key, default=None, loads_fn=None, namespace=None, _conn=None
         """
         start = time.monotonic()
         loads = loads_fn or self._serializer.loads
-        ns = namespace if namespace is not None else self.namespace
-        ns_key = self.build_key(key, namespace=ns)
+        ns_key = self.build_key(key, namespace=namespace)
 
         value = loads(await self._get(ns_key, encoding=self.serializer.encoding, _conn=_conn))
 
@@ -225,9 +223,8 @@ async def multi_get(self, keys, loads_fn=None, namespace=None, _conn=None):
         """
         start = time.monotonic()
         loads = loads_fn or self._serializer.loads
-        ns = namespace if namespace is not None else self.namespace
 
-        ns_keys = [self.build_key(key, namespace=ns) for key in keys]
+        ns_keys = [self.build_key(key, namespace=namespace) for key in keys]
         values = [
             loads(value)
             for value in await self._multi_get(
@@ -270,8 +267,7 @@ async def set(
         """
         start = time.monotonic()
         dumps = dumps_fn or self._serializer.dumps
-        ns = namespace if namespace is not None else self.namespace
-        ns_key = self.build_key(key, namespace=ns)
+        ns_key = self.build_key(key, namespace=namespace)
 
         res = await self._set(
             ns_key, dumps(value), ttl=self._get_ttl(ttl), _cas_token=_cas_token, _conn=_conn
@@ -304,11 +300,10 @@ async def multi_set(self, pairs, ttl=SENTINEL, dumps_fn=None, namespace=None, _c
         """
         start = time.monotonic()
         dumps = dumps_fn or self._serializer.dumps
-        ns = namespace if namespace is not None else self.namespace
 
         tmp_pairs = []
         for key, value in pairs:
-            tmp_pairs.append((self.build_key(key, namespace=ns), dumps(value)))
+            tmp_pairs.append((self.build_key(key, namespace=namespace), dumps(value)))
 
         await self._multi_set(tmp_pairs, ttl=self._get_ttl(ttl), _conn=_conn)
 
@@ -339,8 +334,7 @@ async def delete(self, key, namespace=None, _conn=None):
         :raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
         """
         start = time.monotonic()
-        ns = namespace if namespace is not None else self.namespace
-        ns_key = self.build_key(key, namespace=ns)
+        ns_key = self.build_key(key, namespace=namespace)
         ret = await self._delete(ns_key, _conn=_conn)
         logger.debug("DELETE %s %d (%.4f)s", ns_key, ret, time.monotonic() - start)
         return ret
@@ -364,8 +358,7 @@ async def exists(self, key, namespace=None, _conn=None):
         :raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
         """
         start = time.monotonic()
-        ns = namespace if namespace is not None else self.namespace
-        ns_key = self.build_key(key, namespace=ns)
+        ns_key = self.build_key(key, namespace=namespace)
         ret = await self._exists(ns_key, _conn=_conn)
         logger.debug("EXISTS %s %d (%.4f)s", ns_key, ret, time.monotonic() - start)
         return ret
@@ -392,8 +385,7 @@ async def increment(self, key, delta=1, namespace=None, _conn=None):
         :raises: :class:`TypeError` if value is not incrementable
         """
         start = time.monotonic()
-        ns = namespace if namespace is not None else self.namespace
-        ns_key = self.build_key(key, namespace=ns)
+        ns_key = self.build_key(key, namespace=namespace)
         ret = await self._increment(ns_key, delta, _conn=_conn)
         logger.debug("INCREMENT %s %d (%.4f)s", ns_key, ret, time.monotonic() - start)
         return ret
@@ -418,8 +410,7 @@ async def expire(self, key, ttl, namespace=None, _conn=None):
         :raises: :class:`asyncio.TimeoutError` if it lasts more than self.timeout
         """
         start = time.monotonic()
-        ns = namespace if namespace is not None else self.namespace
-        ns_key = self.build_key(key, namespace=ns)
+        ns_key = self.build_key(key, namespace=namespace)
         ret = await self._expire(ns_key, ttl, _conn=_conn)
         logger.debug("EXPIRE %s %d (%.4f)s", ns_key, ret, time.monotonic() - start)
         return ret
@@ -498,12 +489,13 @@ async def close(self, *args, _conn=None, **kwargs):
     async def _close(self, *args, **kwargs):
         pass
 
-    def _build_key(self, key, namespace=None):
-        if namespace is not None:
-            return "{}{}".format(namespace, _ensure_key(key))
-        if self.namespace is not None:
-            return "{}{}".format(self.namespace, _ensure_key(key))
-        return key
+    def build_key(self, key, namespace=None):
+        key_name = key.value if isinstance(key, Enum) else key
+        ns = namespace if namespace is not None else self.namespace
+        return self._build_key(key_name, namespace=ns)
+
+    def _build_key_default(self, key, namespace=None):
+        return "{}{}".format(namespace or "", key)
 
     def _get_ttl(self, ttl):
         return ttl if ttl is not SENTINEL else self.ttl
@@ -550,12 +542,5 @@ async def _do_inject_conn(self, *args, **kwargs):
         return _do_inject_conn
 
 
-def _ensure_key(key):
-    if isinstance(key, Enum):
-        return key.value
-    else:
-        return key
-
-
 for cmd in API.CMDS:
     setattr(_Conn, cmd.__name__, _Conn._inject_conn(cmd.__name__))

tests/acceptance/test_decorators.py

@@ -5,8 +5,7 @@
 import pytest
 
 from aiocache import cached, cached_stampede, multi_cached
-from aiocache.base import _ensure_key
-from ..utils import Keys
+from ..utils import Keys, ensure_key
 
 
 async def return_dict(keys=None):
@@ -164,15 +163,15 @@ async def fn(keys):
 
     async def test_multi_cached_key_builder(self, cache):
         def build_key(key, f, self, keys, market="ES"):
-            return "{}_{}_{}".format(f.__name__, _ensure_key(key), market)
+            return "{}_{}_{}".format(f.__name__, ensure_key(key), market)
 
         @multi_cached(keys_from_attr="keys", key_builder=build_key)
         async def fn(self, keys, market="ES"):
             return {Keys.KEY: 1, Keys.KEY_1: 2}
 
         await fn("self", keys=[Keys.KEY, Keys.KEY_1])
-        assert await cache.exists("fn_" + _ensure_key(Keys.KEY) + "_ES") is True
-        assert await cache.exists("fn_" + _ensure_key(Keys.KEY_1) + "_ES") is True
+        assert await cache.exists("fn_" + ensure_key(Keys.KEY) + "_ES") is True
+        assert await cache.exists("fn_" + ensure_key(Keys.KEY_1) + "_ES") is True
 
     async def test_multi_cached_skip_keys(self, cache):
         @multi_cached(keys_from_attr="keys", skip_cache_func=lambda _, v: v is None)

tests/acceptance/test_lock.py

@@ -200,7 +200,7 @@ def lock(self, cache):
     async def test_acquire(self, cache, lock):
         await cache.set(Keys.KEY, "value")
         async with lock:
-            assert lock._token == await cache._gets(cache._build_key(Keys.KEY))
+            assert lock._token == await cache._gets(cache.build_key(Keys.KEY))
 
     async def test_release_does_nothing(self, lock):
         assert await lock.__aexit__("exc_type", "exc_value", "traceback") is None

tests/ut/backends/test_memcached.py

@@ -4,9 +4,9 @@
 import pytest
 
 from aiocache.backends.memcached import MemcachedBackend, MemcachedCache
-from aiocache.base import BaseCache, _ensure_key
+from aiocache.base import BaseCache
 from aiocache.serializers import JsonSerializer
-from ...utils import Keys
+from ...utils import Keys, ensure_key
 
 
 @pytest.fixture
@@ -249,7 +249,7 @@ def test_parse_uri_path(self):
 
     @pytest.mark.parametrize(
         "namespace, expected",
-        ([None, "test" + _ensure_key(Keys.KEY)], ["", _ensure_key(Keys.KEY)], ["my_ns", "my_ns" + _ensure_key(Keys.KEY)]),  # type: ignore[attr-defined]  # noqa: B950
+        ([None, "test" + ensure_key(Keys.KEY)], ["", ensure_key(Keys.KEY)], ["my_ns", "my_ns" + ensure_key(Keys.KEY)]),  # type: ignore[attr-defined]  # noqa: B950
     )
     def test_build_key_bytes(self, set_test_namespace, memcached_cache, namespace, expected):
         assert memcached_cache.build_key(Keys.KEY, namespace=namespace) == expected.encode()

tests/ut/backends/test_redis.py

@@ -5,9 +5,9 @@
 from redis.exceptions import ResponseError
 
 from aiocache.backends.redis import RedisBackend, RedisCache
-from aiocache.base import BaseCache, _ensure_key
+from aiocache.base import BaseCache
 from aiocache.serializers import JsonSerializer
-from ...utils import Keys
+from ...utils import Keys, ensure_key
 
 
 @pytest.fixture
@@ -253,7 +253,7 @@ def test_parse_uri_path(self, path, expected):
 
     @pytest.mark.parametrize(
         "namespace, expected",
-        ([None, "test:" + _ensure_key(Keys.KEY)], ["", _ensure_key(Keys.KEY)], ["my_ns", "my_ns:" + _ensure_key(Keys.KEY)]),  # noqa: B950
+        ([None, "test:" + ensure_key(Keys.KEY)], ["", ensure_key(Keys.KEY)], ["my_ns", "my_ns:" + ensure_key(Keys.KEY)]),  # noqa: B950
     )
     def test_build_key_double_dot(self, set_test_namespace, redis_cache, namespace, expected):
         assert redis_cache.build_key(Keys.KEY, namespace=namespace) == expected