redis 5.1.0b7__tar.gz → 5.2.0__tar.gz

{redis-5.1.0b7/redis.egg-info → redis-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: redis
-Version: 5.1.0b7
+Version: 5.2.0
 Summary: Python client for Redis database and key-value store
 Home-page: https://github.com/redis/redis-py
 Author: Redis Inc.
@@ -24,6 +24,7 @@ Classifier: Programming Language :: Python :: 3.8
 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 :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.8
@@ -88,7 +89,7 @@ Looking for a high-level library to handle object mapping? See [redis-om-python]
 
 ## Supported Redis Versions
 
-The most recent version of this library supports redis version [5.0](https://github.com/redis/redis/blob/5.0/00-RELEASENOTES), [6.0](https://github.com/redis/redis/blob/6.0/00-RELEASENOTES), [6.2](https://github.com/redis/redis/blob/6.2/00-RELEASENOTES), [7.0](https://github.com/redis/redis/blob/7.0/00-RELEASENOTES) and [7.2](https://github.com/redis/redis/blob/7.2/00-RELEASENOTES).
+The most recent version of this library supports redis version [5.0](https://github.com/redis/redis/blob/5.0/00-RELEASENOTES), [6.0](https://github.com/redis/redis/blob/6.0/00-RELEASENOTES), [6.2](https://github.com/redis/redis/blob/6.2/00-RELEASENOTES), [7.0](https://github.com/redis/redis/blob/7.0/00-RELEASENOTES), [7.2](https://github.com/redis/redis/blob/7.2/00-RELEASENOTES) and [7.4](https://github.com/redis/redis/blob/7.4/00-RELEASENOTES).
 
 The table below highlights version compatibility of the most-recent library versions and redis versions.
 

{redis-5.1.0b7 → redis-5.2.0}/README.md

@@ -54,7 +54,7 @@ Looking for a high-level library to handle object mapping? See [redis-om-python]
 
 ## Supported Redis Versions
 
-The most recent version of this library supports redis version [5.0](https://github.com/redis/redis/blob/5.0/00-RELEASENOTES), [6.0](https://github.com/redis/redis/blob/6.0/00-RELEASENOTES), [6.2](https://github.com/redis/redis/blob/6.2/00-RELEASENOTES), [7.0](https://github.com/redis/redis/blob/7.0/00-RELEASENOTES) and [7.2](https://github.com/redis/redis/blob/7.2/00-RELEASENOTES).
+The most recent version of this library supports redis version [5.0](https://github.com/redis/redis/blob/5.0/00-RELEASENOTES), [6.0](https://github.com/redis/redis/blob/6.0/00-RELEASENOTES), [6.2](https://github.com/redis/redis/blob/6.2/00-RELEASENOTES), [7.0](https://github.com/redis/redis/blob/7.0/00-RELEASENOTES), [7.2](https://github.com/redis/redis/blob/7.2/00-RELEASENOTES) and [7.4](https://github.com/redis/redis/blob/7.4/00-RELEASENOTES).
 
 The table below highlights version compatibility of the most-recent library versions and redis versions.
 

{redis-5.1.0b7 → redis-5.2.0}/redis/_parsers/helpers.py

@@ -445,9 +445,11 @@ def parse_cluster_info(response, **options):
 def _parse_node_line(line):
     line_items = line.split(" ")
     node_id, addr, flags, master_id, ping, pong, epoch, connected = line.split(" ")[:8]
-    addr = addr.split("@")[0]
+    ip = addr.split("@")[0]
+    hostname = addr.split("@")[1].split(",")[1] if "@" in addr and "," in addr else ""
     node_dict = {
         "node_id": node_id,
+        "hostname": hostname,
         "flags": flags,
         "master_id": master_id,
         "last_ping_sent": ping,
@@ -460,7 +462,7 @@ def _parse_node_line(line):
     if len(line_items) >= 9:
         slots, migrations = _parse_slots(line_items[8:])
         node_dict["slots"], node_dict["migrations"] = slots, migrations
-    return addr, node_dict
+    return ip, node_dict
 
 
 def _parse_slots(slot_ranges):
@@ -507,7 +509,7 @@ def parse_geosearch_generic(response, **options):
     except KeyError:  # it means the command was sent via execute_command
         return response
 
-    if type(response) != list:
+    if not isinstance(response, list):
         response_list = [response]
     else:
         response_list = response
@@ -830,6 +832,9 @@ _RedisCallbacksRESP2 = {
 
 
 _RedisCallbacksRESP3 = {
+    **string_keys_to_dict(
+        "SDIFF SINTER SMEMBERS SUNION", lambda r: r and set(r) or set()
+    ),
     **string_keys_to_dict(
         "ZRANGE ZINTER ZPOPMAX ZPOPMIN ZRANGEBYSCORE ZREVRANGE ZREVRANGEBYSCORE "
         "ZUNION HGETALL XREADGROUP",

{redis-5.1.0b7 → redis-5.2.0}/redis/_parsers/resp3.py

@@ -88,15 +88,11 @@ class _RESP3Parser(_RESPBase):
         # set response
         elif byte == b"~":
             # redis can return unhashable types (like dict) in a set,
-            # so we need to first convert to a list, and then try to convert it to a set
+            # so we return sets as list, all the time, for predictability
             response = [
                 self._read_response(disable_decoding=disable_decoding)
                 for _ in range(int(response))
             ]
-            try:
-                response = set(response)
-            except TypeError:
-                pass
         # map response
         elif byte == b"%":
             # We cannot use a dict-comprehension to parse stream.
@@ -120,6 +116,12 @@ class _RESP3Parser(_RESPBase):
             response = self.handle_push_response(
                 response, disable_decoding, push_request
             )
+            if not push_request:
+                return self._read_response(
+                    disable_decoding=disable_decoding, push_request=push_request
+                )
+            else:
+                return response
         else:
             raise InvalidResponse(f"Protocol Error: {raw!r}")
 
@@ -128,19 +130,10 @@ class _RESP3Parser(_RESPBase):
         return response
 
     def handle_push_response(self, response, disable_decoding, push_request):
-        if response[0] in _INVALIDATION_MESSAGE:
-            if self.invalidation_push_handler_func:
-                res = self.invalidation_push_handler_func(response)
-            else:
-                res = None
-        else:
-            res = self.pubsub_push_handler_func(response)
-        if not push_request:
-            return self._read_response(
-                disable_decoding=disable_decoding, push_request=push_request
-            )
-        else:
-            return res
+        if response[0] not in _INVALIDATION_MESSAGE:
+            return self.pubsub_push_handler_func(response)
+        if self.invalidation_push_handler_func:
+            return self.invalidation_push_handler_func(response)
 
     def set_pubsub_push_handler(self, pubsub_push_handler_func):
         self.pubsub_push_handler_func = pubsub_push_handler_func
@@ -155,7 +148,7 @@ class _AsyncRESP3Parser(_AsyncRESPBase):
         self.pubsub_push_handler_func = self.handle_pubsub_push_response
         self.invalidation_push_handler_func = None
 
-    def handle_pubsub_push_response(self, response):
+    async def handle_pubsub_push_response(self, response):
         logger = getLogger("push_response")
         logger.info("Push response: " + str(response))
         return response
@@ -233,15 +226,11 @@ class _AsyncRESP3Parser(_AsyncRESPBase):
         # set response
         elif byte == b"~":
             # redis can return unhashable types (like dict) in a set,
-            # so we need to first convert to a list, and then try to convert it to a set
+            # so we always convert to a list, to have predictable return types
             response = [
                 (await self._read_response(disable_decoding=disable_decoding))
                 for _ in range(int(response))
             ]
-            try:
-                response = set(response)
-            except TypeError:
-                pass
         # map response
         elif byte == b"%":
             # We cannot use a dict-comprehension to parse stream.
@@ -267,6 +256,12 @@ class _AsyncRESP3Parser(_AsyncRESPBase):
             response = await self.handle_push_response(
                 response, disable_decoding, push_request
             )
+            if not push_request:
+                return await self._read_response(
+                    disable_decoding=disable_decoding, push_request=push_request
+                )
+            else:
+                return response
         else:
             raise InvalidResponse(f"Protocol Error: {raw!r}")
 
@@ -275,19 +270,10 @@ class _AsyncRESP3Parser(_AsyncRESPBase):
         return response
 
     async def handle_push_response(self, response, disable_decoding, push_request):
-        if response[0] in _INVALIDATION_MESSAGE:
-            if self.invalidation_push_handler_func:
-                res = self.invalidation_push_handler_func(response)
-            else:
-                res = None
-        else:
-            res = self.pubsub_push_handler_func(response)
-        if not push_request:
-            return await self._read_response(
-                disable_decoding=disable_decoding, push_request=push_request
-            )
-        else:
-            return res
+        if response[0] not in _INVALIDATION_MESSAGE:
+            return await self.pubsub_push_handler_func(response)
+        if self.invalidation_push_handler_func:
+            return await self.invalidation_push_handler_func(response)
 
     def set_pubsub_push_handler(self, pubsub_push_handler_func):
         self.pubsub_push_handler_func = pubsub_push_handler_func

{redis-5.1.0b7 → redis-5.2.0}/redis/asyncio/client.py

@@ -26,12 +26,6 @@ from typing import (
     cast,
 )
 
-from redis._cache import (
-    DEFAULT_ALLOW_LIST,
-    DEFAULT_DENY_LIST,
-    DEFAULT_EVICTION_POLICY,
-    AbstractCache,
-)
 from redis._parsers.helpers import (
     _RedisCallbacks,
     _RedisCallbacksRESP2,
@@ -239,13 +233,6 @@ class Redis(
         redis_connect_func=None,
         credential_provider: Optional[CredentialProvider] = None,
         protocol: Optional[int] = 2,
-        cache_enabled: bool = False,
-        client_cache: Optional[AbstractCache] = None,
-        cache_max_size: int = 100,
-        cache_ttl: int = 0,
-        cache_policy: str = DEFAULT_EVICTION_POLICY,
-        cache_deny_list: List[str] = DEFAULT_DENY_LIST,
-        cache_allow_list: List[str] = DEFAULT_ALLOW_LIST,
     ):
         """
         Initialize a new Redis client.
@@ -295,13 +282,6 @@ class Redis(
                 "lib_version": lib_version,
                 "redis_connect_func": redis_connect_func,
                 "protocol": protocol,
-                "cache_enabled": cache_enabled,
-                "client_cache": client_cache,
-                "cache_max_size": cache_max_size,
-                "cache_ttl": cache_ttl,
-                "cache_policy": cache_policy,
-                "cache_deny_list": cache_deny_list,
-                "cache_allow_list": cache_allow_list,
             }
             # based on input, setup appropriate connection args
             if unix_socket_path is not None:
@@ -579,10 +559,12 @@ class Redis(
         """
         Closes Redis client connection
 
-        :param close_connection_pool: decides whether to close the connection pool used
-        by this Redis client, overriding Redis.auto_close_connection_pool. By default,
-        let Redis.auto_close_connection_pool decide whether to close the connection
-        pool.
+        Args:
+            close_connection_pool:
+                decides whether to close the connection pool used by this Redis client,
+                overriding Redis.auto_close_connection_pool.
+                By default, let Redis.auto_close_connection_pool decide
+                whether to close the connection pool.
         """
         conn = self.connection
         if conn:
@@ -624,31 +606,22 @@ class Redis(
     async def execute_command(self, *args, **options):
         """Execute a command and return a parsed response"""
         await self.initialize()
-        command_name = args[0]
-        keys = options.pop("keys", None)  # keys are used only for client side caching
         pool = self.connection_pool
+        command_name = args[0]
         conn = self.connection or await pool.get_connection(command_name, **options)
-        response_from_cache = await conn._get_from_local_cache(args)
+
+        if self.single_connection_client:
+            await self._single_conn_lock.acquire()
         try:
-            if response_from_cache is not None:
-                return response_from_cache
-            else:
-                try:
-                    if self.single_connection_client:
-                        await self._single_conn_lock.acquire()
-                    response = await conn.retry.call_with_retry(
-                        lambda: self._send_command_parse_response(
-                            conn, command_name, *args, **options
-                        ),
-                        lambda error: self._disconnect_raise(conn, error),
-                    )
-                    if keys:
-                        conn._add_to_local_cache(args, response, keys)
-                    return response
-                finally:
-                    if self.single_connection_client:
-                        self._single_conn_lock.release()
+            return await conn.retry.call_with_retry(
+                lambda: self._send_command_parse_response(
+                    conn, command_name, *args, **options
+                ),
+                lambda error: self._disconnect_raise(conn, error),
+            )
         finally:
+            if self.single_connection_client:
+                self._single_conn_lock.release()
             if not self.connection:
                 await pool.release(conn)
 
@@ -670,6 +643,9 @@ class Redis(
         if EMPTY_RESPONSE in options:
             options.pop(EMPTY_RESPONSE)
 
+        # Remove keys entry, it needs only for cache.
+        options.pop("keys", None)
+
         if command_name in self.response_callbacks:
             # Mypy bug: https://github.com/python/mypy/issues/10977
             command_name = cast(str, command_name)
@@ -677,24 +653,6 @@ class Redis(
             return await retval if inspect.isawaitable(retval) else retval
         return response
 
-    def flush_cache(self):
-        if self.connection:
-            self.connection.flush_cache()
-        else:
-            self.connection_pool.flush_cache()
-
-    def delete_command_from_cache(self, command):
-        if self.connection:
-            self.connection.delete_command_from_cache(command)
-        else:
-            self.connection_pool.delete_command_from_cache(command)
-
-    def invalidate_key_from_cache(self, key):
-        if self.connection:
-            self.connection.invalidate_key_from_cache(key)
-        else:
-            self.connection_pool.invalidate_key_from_cache(key)
-
 
 StrictRedis = Redis
 
@@ -1331,7 +1289,6 @@ class Pipeline(Redis):  # lgtm [py/init-calls-subclass]
     def execute_command(
         self, *args, **kwargs
     ) -> Union["Pipeline", Awaitable["Pipeline"]]:
-        kwargs.pop("keys", None)  # the keys are used only for client side caching
         if (self.watching or args[0] == "WATCH") and not self.explicit_transaction:
             return self.immediate_execute_command(*args, **kwargs)
         return self.pipeline_execute_command(*args, **kwargs)
@@ -1466,6 +1423,10 @@ class Pipeline(Redis):  # lgtm [py/init-calls-subclass]
             if not isinstance(r, Exception):
                 args, options = cmd
                 command_name = args[0]
+
+                # Remove keys entry, it needs only for cache.
+                options.pop("keys", None)
+
                 if command_name in self.response_callbacks:
                     r = self.response_callbacks[command_name](r, **options)
                     if inspect.isawaitable(r):

{redis-5.1.0b7 → redis-5.2.0}/redis/asyncio/cluster.py

@@ -19,12 +19,6 @@ from typing import (
     Union,
 )
 
-from redis._cache import (
-    DEFAULT_ALLOW_LIST,
-    DEFAULT_DENY_LIST,
-    DEFAULT_EVICTION_POLICY,
-    AbstractCache,
-)
 from redis._parsers import AsyncCommandsParser, Encoder
 from redis._parsers.helpers import (
     _RedisCallbacks,
@@ -276,13 +270,6 @@ class RedisCluster(AbstractRedis, AbstractRedisCluster, AsyncRedisClusterCommand
         ssl_ciphers: Optional[str] = None,
         protocol: Optional[int] = 2,
         address_remap: Optional[Callable[[Tuple[str, int]], Tuple[str, int]]] = None,
-        cache_enabled: bool = False,
-        client_cache: Optional[AbstractCache] = None,
-        cache_max_size: int = 100,
-        cache_ttl: int = 0,
-        cache_policy: str = DEFAULT_EVICTION_POLICY,
-        cache_deny_list: List[str] = DEFAULT_DENY_LIST,
-        cache_allow_list: List[str] = DEFAULT_ALLOW_LIST,
     ) -> None:
         if db:
             raise RedisClusterException(
@@ -326,14 +313,6 @@ class RedisCluster(AbstractRedis, AbstractRedisCluster, AsyncRedisClusterCommand
             "socket_timeout": socket_timeout,
             "retry": retry,
             "protocol": protocol,
-            # Client cache related kwargs
-            "cache_enabled": cache_enabled,
-            "client_cache": client_cache,
-            "cache_max_size": cache_max_size,
-            "cache_ttl": cache_ttl,
-            "cache_policy": cache_policy,
-            "cache_deny_list": cache_deny_list,
-            "cache_allow_list": cache_allow_list,
         }
 
         if ssl:
@@ -938,18 +917,6 @@ class RedisCluster(AbstractRedis, AbstractRedisCluster, AsyncRedisClusterCommand
             thread_local=thread_local,
         )
 
-    def flush_cache(self):
-        if self.nodes_manager:
-            self.nodes_manager.flush_cache()
-
-    def delete_command_from_cache(self, command):
-        if self.nodes_manager:
-            self.nodes_manager.delete_command_from_cache(command)
-
-    def invalidate_key_from_cache(self, key):
-        if self.nodes_manager:
-            self.nodes_manager.invalidate_key_from_cache(key)
-
 
 class ClusterNode:
     """
@@ -1067,6 +1034,9 @@ class ClusterNode:
         if EMPTY_RESPONSE in kwargs:
             kwargs.pop(EMPTY_RESPONSE)
 
+        # Remove keys entry, it needs only for cache.
+        kwargs.pop("keys", None)
+
         # Return response
         if command in self.response_callbacks:
             return self.response_callbacks[command](response, **kwargs)
@@ -1076,25 +1046,16 @@ class ClusterNode:
     async def execute_command(self, *args: Any, **kwargs: Any) -> Any:
         # Acquire connection
         connection = self.acquire_connection()
-        keys = kwargs.pop("keys", None)
 
-        response_from_cache = await connection._get_from_local_cache(args)
-        if response_from_cache is not None:
-            self._free.append(connection)
-            return response_from_cache
-        else:
-            # Execute command
-            await connection.send_packed_command(connection.pack_command(*args), False)
+        # Execute command
+        await connection.send_packed_command(connection.pack_command(*args), False)
 
-            # Read response
-            try:
-                response = await self.parse_response(connection, args[0], **kwargs)
-                if keys:
-                    connection._add_to_local_cache(args, response, keys)
-                return response
-            finally:
-                # Release connection
-                self._free.append(connection)
+        # Read response
+        try:
+            return await self.parse_response(connection, args[0], **kwargs)
+        finally:
+            # Release connection
+            self._free.append(connection)
 
     async def execute_pipeline(self, commands: List["PipelineCommand"]) -> bool:
         # Acquire connection
@@ -1121,18 +1082,6 @@ class ClusterNode:
 
         return ret
 
-    def flush_cache(self):
-        for connection in self._connections:
-            connection.flush_cache()
-
-    def delete_command_from_cache(self, command):
-        for connection in self._connections:
-            connection.delete_command_from_cache(command)
-
-    def invalidate_key_from_cache(self, key):
-        for connection in self._connections:
-            connection.invalidate_key_from_cache(key)
-
 
 class NodesManager:
     __slots__ = (
@@ -1317,6 +1266,8 @@ class NodesManager:
                 port = int(primary_node[1])
                 host, port = self.remap_host_port(host, port)
 
+                nodes_for_slot = []
+
                 target_node = tmp_nodes_cache.get(get_node_name(host, port))
                 if not target_node:
                     target_node = ClusterNode(
@@ -1324,30 +1275,26 @@ class NodesManager:
                     )
                 # add this node to the nodes cache
                 tmp_nodes_cache[target_node.name] = target_node
+                nodes_for_slot.append(target_node)
+
+                replica_nodes = slot[3:]
+                for replica_node in replica_nodes:
+                    host = replica_node[0]
+                    port = replica_node[1]
+                    host, port = self.remap_host_port(host, port)
+
+                    target_replica_node = tmp_nodes_cache.get(get_node_name(host, port))
+                    if not target_replica_node:
+                        target_replica_node = ClusterNode(
+                            host, port, REPLICA, **self.connection_kwargs
+                        )
+                    # add this node to the nodes cache
+                    tmp_nodes_cache[target_replica_node.name] = target_replica_node
+                    nodes_for_slot.append(target_replica_node)
 
                 for i in range(int(slot[0]), int(slot[1]) + 1):
                     if i not in tmp_slots:
-                        tmp_slots[i] = []
-                        tmp_slots[i].append(target_node)
-                        replica_nodes = [slot[j] for j in range(3, len(slot))]
-
-                        for replica_node in replica_nodes:
-                            host = replica_node[0]
-                            port = replica_node[1]
-                            host, port = self.remap_host_port(host, port)
-
-                            target_replica_node = tmp_nodes_cache.get(
-                                get_node_name(host, port)
-                            )
-                            if not target_replica_node:
-                                target_replica_node = ClusterNode(
-                                    host, port, REPLICA, **self.connection_kwargs
-                                )
-                            tmp_slots[i].append(target_replica_node)
-                            # add this node to the nodes cache
-                            tmp_nodes_cache[target_replica_node.name] = (
-                                target_replica_node
-                            )
+                        tmp_slots[i] = nodes_for_slot
                     else:
                         # Validate that 2 nodes want to use the same slot cache
                         # setup
@@ -1418,18 +1365,6 @@ class NodesManager:
             return self.address_remap((host, port))
         return host, port
 
-    def flush_cache(self):
-        for node in self.nodes_cache.values():
-            node.flush_cache()
-
-    def delete_command_from_cache(self, command):
-        for node in self.nodes_cache.values():
-            node.delete_command_from_cache(command)
-
-    def invalidate_key_from_cache(self, key):
-        for node in self.nodes_cache.values():
-            node.invalidate_key_from_cache(key)
-
 
 class ClusterPipeline(AbstractRedis, AbstractRedisCluster, AsyncRedisClusterCommands):
     """
@@ -1518,7 +1453,6 @@ class ClusterPipeline(AbstractRedis, AbstractRedisCluster, AsyncRedisClusterComm
               or List[:class:`~.ClusterNode`] or Dict[Any, :class:`~.ClusterNode`]
             - Rest of the kwargs are passed to the Redis connection
         """
-        kwargs.pop("keys", None)  # the keys are used only for client side caching
         self._command_stack.append(
             PipelineCommand(len(self._command_stack), *args, **kwargs)
         )