Updated docs, convert getters function to properties, added dataclasses

Author: vladvildanov

docs/resp3_features.rst

@@ -72,7 +72,7 @@ Client-side caching
 -------------------
 
 Client-side caching is a technique used to create high performance services.
-It exploits the memory available on application servers, servers that are usually distinct computers compared to the database nodes, to store some subset of the database information directly in the application side.
+It utilizes the memory on application servers, typically separate from the database nodes, to cache a subset of the data directly on the application side.
 For more information please check `official Redis documentation <https://redis.io/docs/latest/develop/use/client-side-caching/>`_.
 Please notice that this feature only available with RESP3 protocol enabled in sync client only. Supported in standalone, Cluster and Sentinel clients.
 
@@ -98,4 +98,4 @@ Enable caching with custom cache implementation:
 
 CacheImpl should implement a `CacheInterface` specified in `redis.cache` package.
 
-More robust documentation soon will be available at `official Redis documentation <https://redis.io/docs/latest/>`_.
+More comprehensive documentation soon will be available at `official Redis documentation <https://redis.io/docs/latest/>`_.

redis/cache.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from collections import OrderedDict
+from dataclasses import dataclass
 from enum import Enum
 from typing import Any, List, Optional, Union
 
@@ -14,19 +15,10 @@ class EvictionPolicyType(Enum):
     frequency_based = "frequency_based"
 
 
+@dataclass(frozen=True)
 class CacheKey:
-    def __init__(self, command: str, redis_keys: tuple):
-        self.command = command
-        self.redis_keys = redis_keys
-
-    def get_redis_keys(self) -> tuple:
-        return self.redis_keys
-
-    def __hash__(self):
-        return hash((self.command, self.redis_keys))
-
-    def __eq__(self, other):
-        return hash(self) == hash(other)
+    command: str
+    redis_keys: tuple
 
 
 class CacheEntry:
@@ -102,20 +94,24 @@ def is_allowed_to_cache(self, command: str) -> bool:
 
 
 class CacheInterface(ABC):
+    @property
     @abstractmethod
-    def get_collection(self) -> OrderedDict:
+    def collection(self) -> OrderedDict:
         pass
 
+    @property
     @abstractmethod
-    def get_config(self) -> CacheConfigurationInterface:
+    def config(self) -> CacheConfigurationInterface:
         pass
 
+    @property
     @abstractmethod
-    def get_eviction_policy(self) -> EvictionPolicyInterface:
+    def eviction_policy(self) -> EvictionPolicyInterface:
         pass
 
+    @property
     @abstractmethod
-    def get_size(self) -> int:
+    def size(self) -> int:
         pass
 
     @abstractmethod
@@ -153,16 +149,20 @@ def __init__(
         self._eviction_policy = self._cache_config.get_eviction_policy().value()
         self._eviction_policy.cache = self
 
-    def get_collection(self) -> OrderedDict:
+    @property
+    def collection(self) -> OrderedDict:
         return self._cache
 
-    def get_config(self) -> CacheConfigurationInterface:
+    @property
+    def config(self) -> CacheConfigurationInterface:
         return self._cache_config
 
-    def get_eviction_policy(self) -> EvictionPolicyInterface:
+    @property
+    def eviction_policy(self) -> EvictionPolicyInterface:
         return self._eviction_policy
 
-    def get_size(self) -> int:
+    @property
+    def size(self) -> int:
         return len(self._cache)
 
     def set(self, entry: CacheEntry) -> bool:
@@ -206,7 +206,7 @@ def delete_by_redis_keys(self, redis_keys: List[bytes]) -> List[bool]:
             if isinstance(redis_key, bytes):
                 redis_key = redis_key.decode()
             for cache_key in self._cache:
-                if redis_key in cache_key.get_redis_keys():
+                if redis_key in cache_key.redis_keys:
                     keys_to_delete.append(cache_key)
                     response.append(True)
 
@@ -242,29 +242,29 @@ def type(self) -> EvictionPolicyType:
 
     def evict_next(self) -> CacheKey:
         self._assert_cache()
-        popped_entry = self._cache.get_collection().popitem(last=False)
+        popped_entry = self._cache.collection.popitem(last=False)
         return popped_entry[0]
 
     def evict_many(self, count: int) -> List[CacheKey]:
         self._assert_cache()
-        if count > len(self._cache.get_collection()):
+        if count > len(self._cache.collection):
             raise ValueError("Evictions count is above cache size")
 
         popped_keys = []
 
         for _ in range(count):
-            popped_entry = self._cache.get_collection().popitem(last=False)
+            popped_entry = self._cache.collection.popitem(last=False)
             popped_keys.append(popped_entry[0])
 
         return popped_keys
 
     def touch(self, cache_key: CacheKey) -> None:
         self._assert_cache()
 
-        if self._cache.get_collection().get(cache_key) is None:
+        if self._cache.collection.get(cache_key) is None:
             raise ValueError("Given entry does not belong to the cache")
 
-        self._cache.get_collection().move_to_end(cache_key)
+        self._cache.collection.move_to_end(cache_key)
 
     def _assert_cache(self):
         if self.cache is None or not isinstance(self.cache, CacheInterface):

tests/test_cache.py

@@ -41,7 +41,7 @@ def r(request):
 
 @pytest.mark.skipif(HIREDIS_AVAILABLE, reason="PythonParser only")
 @pytest.mark.onlynoncluster
-@skip_if_resp_version(2)
+# @skip_if_resp_version(2)
 @skip_if_server_version_lt("7.4.0")
 class TestCache:
     @pytest.mark.parametrize(
@@ -109,8 +109,8 @@ def test_get_from_given_cache(self, r, r2):
     @pytest.mark.onlynoncluster
     def test_get_from_default_cache(self, r, r2):
         cache = r.get_cache()
-        assert isinstance(cache.get_eviction_policy(), LRUPolicy)
-        assert cache.get_config().get_max_size() == 128
+        assert isinstance(cache.eviction_policy, LRUPolicy)
+        assert cache.config.get_max_size() == 128
 
         # add key to redis
         r.set("foo", "bar")
@@ -161,7 +161,7 @@ def test_cache_clears_on_disconnect(self, r, cache):
         # Force disconnection
         r.connection_pool.get_connection("_").disconnect()
         # Make sure cache is empty
-        assert cache.get_size() == 0
+        assert cache.size == 0
 
     @pytest.mark.parametrize(
         "r",
@@ -207,7 +207,7 @@ def test_cache_lru_eviction(self, r, cache):
         assert r.get("foo4") == b"bar4"
         # the first key is not in the local cache anymore
         assert cache.get(CacheKey(command="GET", redis_keys=("foo",))) is None
-        assert cache.get_size() == 3
+        assert cache.size == 3
 
     @pytest.mark.parametrize(
         "r",
@@ -321,7 +321,7 @@ def test_cache_flushed_on_server_flush(self, r):
         # Flush server and trying to access cached entry
         assert r.flushall()
         assert r.get("foo") is None
-        assert cache.get_size() == 0
+        assert cache.size == 0
 
 
 @pytest.mark.skipif(HIREDIS_AVAILABLE, reason="PythonParser only")
@@ -383,8 +383,8 @@ def test_get_from_cache(self, r):
     )
     def test_get_from_custom_cache(self, r, r2):
         cache = r.nodes_manager.get_node_from_slot(12000).redis_connection.get_cache()
-        assert isinstance(cache.get_eviction_policy(), LRUPolicy)
-        assert cache.get_config().get_max_size() == 128
+        assert isinstance(cache.eviction_policy, LRUPolicy)
+        assert cache.config.get_max_size() == 128
 
         # add key to redis
         assert r.set("foo", "bar")
@@ -431,7 +431,7 @@ def test_cache_clears_on_disconnect(self, r, r2):
             12000
         ).redis_connection.connection_pool.get_connection("_").disconnect()
         # Make sure cache is empty
-        assert cache.get_size() == 0
+        assert cache.size == 0
 
     @pytest.mark.parametrize(
         "r",
@@ -564,7 +564,7 @@ def test_cache_flushed_on_server_flush(self, r, cache):
         # Flush server and trying to access cached entry
         assert r.flushall()
         assert r.get("foo{slot}") is None
-        assert cache.get_size() == 0
+        assert cache.size == 0
 
 
 @pytest.mark.skipif(HIREDIS_AVAILABLE, reason="PythonParser only")
@@ -623,7 +623,7 @@ def test_get_from_cache(self, master):
     )
     def test_get_from_default_cache(self, r, r2):
         cache = r.get_cache()
-        assert isinstance(cache.get_eviction_policy(), LRUPolicy)
+        assert isinstance(cache.eviction_policy, LRUPolicy)
 
         # add key to redis
         r.set("foo", "bar")
@@ -669,7 +669,7 @@ def test_cache_clears_on_disconnect(self, master, cache):
         # Force disconnection
         master.connection_pool.get_connection("_").disconnect()
         # Make sure cache_data is empty
-        assert cache.get_size() == 0
+        assert cache.size == 0
 
 
 @pytest.mark.skipif(HIREDIS_AVAILABLE, reason="PythonParser only")
@@ -734,7 +734,7 @@ def test_get_from_cache(self, r, r2, cache):
     )
     def test_get_from_custom_cache(self, r, r2):
         cache = r.get_cache()
-        assert isinstance(cache.get_eviction_policy(), LRUPolicy)
+        assert isinstance(cache.eviction_policy, LRUPolicy)
 
         # add key to redis
         r.set("foo", "bar")
@@ -798,15 +798,15 @@ def test_cache_invalidate_all_related_responses(self, r):
 class TestUnitDefaultCache:
     def test_get_eviction_policy(self):
         cache = DefaultCache(CacheConfig(max_size=5))
-        assert isinstance(cache.get_eviction_policy(), LRUPolicy)
+        assert isinstance(cache.eviction_policy, LRUPolicy)
 
     def test_get_max_size(self):
         cache = DefaultCache(CacheConfig(max_size=5))
-        assert cache.get_config().get_max_size() == 5
+        assert cache.config.get_max_size() == 5
 
     def test_get_size(self):
         cache = DefaultCache(CacheConfig(max_size=5))
-        assert cache.get_size() == 0
+        assert cache.size == 0
 
     @pytest.mark.parametrize(
         "cache_key", [{"command": "GET", "redis_keys": ("bar",)}], indirect=True
@@ -988,7 +988,7 @@ def test_delete_by_cache_keys_removes_associated_entries(self, mock_connection):
             True,
             False,
         ]
-        assert len(cache.get_collection()) == 1
+        assert len(cache.collection) == 1
         assert cache.get(cache_key3).cache_value == b"bar2"
 
     def test_delete_by_redis_keys_removes_associated_entries(self, mock_connection):
@@ -1034,7 +1034,7 @@ def test_delete_by_redis_keys_removes_associated_entries(self, mock_connection):
         )
 
         assert cache.delete_by_redis_keys([b"foo", b"foo1"]) == [True, True, True]
-        assert len(cache.get_collection()) == 1
+        assert len(cache.collection) == 1
         assert cache.get(cache_key4).cache_value == b"bar3"
 
     def test_flush(self, mock_connection):
@@ -1071,7 +1071,7 @@ def test_flush(self, mock_connection):
         )
 
         assert cache.flush() == 3
-        assert len(cache.get_collection()) == 0
+        assert len(cache.collection) == 0
 
 
 class TestUnitLRUPolicy:
@@ -1083,7 +1083,7 @@ def test_evict_next(self, mock_connection):
         cache = DefaultCache(
             CacheConfig(max_size=5, eviction_policy=EvictionPolicy.LRU)
         )
-        policy = cache.get_eviction_policy()
+        policy = cache.eviction_policy
 
         cache_key1 = CacheKey(command="GET", redis_keys=("foo",))
         cache_key2 = CacheKey(command="GET", redis_keys=("bar",))
@@ -1112,7 +1112,7 @@ def test_evict_many(self, mock_connection):
         cache = DefaultCache(
             CacheConfig(max_size=5, eviction_policy=EvictionPolicy.LRU)
         )
-        policy = cache.get_eviction_policy()
+        policy = cache.eviction_policy
         cache_key1 = CacheKey(command="GET", redis_keys=("foo",))
         cache_key2 = CacheKey(command="GET", redis_keys=("bar",))
         cache_key3 = CacheKey(command="GET", redis_keys=("baz",))
@@ -1153,7 +1153,7 @@ def test_touch(self, mock_connection):
         cache = DefaultCache(
             CacheConfig(max_size=5, eviction_policy=EvictionPolicy.LRU)
         )
-        policy = cache.get_eviction_policy()
+        policy = cache.eviction_policy
 
         cache_key1 = CacheKey(command="GET", redis_keys=("foo",))
         cache_key2 = CacheKey(command="GET", redis_keys=("bar",))
@@ -1175,7 +1175,7 @@ def test_touch(self, mock_connection):
             )
         )
 
-        assert cache.get_collection().popitem(last=True)[0] == cache_key2
+        assert cache.collection.popitem(last=True)[0] == cache_key2
         cache.set(
             CacheEntry(
                 cache_key=cache_key2,
@@ -1186,7 +1186,7 @@ def test_touch(self, mock_connection):
         )
 
         policy.touch(cache_key1)
-        assert cache.get_collection().popitem(last=True)[0] == cache_key1
+        assert cache.collection.popitem(last=True)[0] == cache_key1
 
     def test_throws_error_on_invalid_cache(self):
         policy = LRUPolicy()

tests/test_connection.py

@@ -411,8 +411,8 @@ def test_creates_cache_with_given_configuration(self, mock_cache):
         )
 
         assert isinstance(connection_pool.cache, CacheInterface)
-        assert connection_pool.cache.get_config().get_max_size() == 100
-        assert isinstance(connection_pool.cache.get_eviction_policy(), LRUPolicy)
+        assert connection_pool.cache.config.get_max_size() == 100
+        assert isinstance(connection_pool.cache.eviction_policy, LRUPolicy)
         connection_pool.disconnect()
 
     def test_make_connection_proxy_connection_on_given_cache(self):
@@ -447,7 +447,7 @@ def test_clears_cache_on_disconnect(self, mock_connection, cache_conf):
         )
         proxy_connection.disconnect()
 
-        assert len(cache.get_collection()) == 0
+        assert len(cache.collection) == 0
 
     @pytest.mark.skipif(
         platform.python_implementation() == "PyPy",