redis 7.0.0b2__py3-none-any.whl → 7.0.1__py3-none-any.whl

redis/client.py

@@ -58,7 +58,6 @@ from redis.exceptions import (
 from redis.lock import Lock
 from redis.maint_notifications import (
     MaintNotificationsConfig,
-    MaintNotificationsPoolHandler,
 )
 from redis.retry import Retry
 from redis.utils import (
@@ -278,6 +277,17 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
         single_connection_client:
             if `True`, connection pool is not used. In that case `Redis`
             instance use is not thread safe.
+        decode_responses:
+            if `True`, the response will be decoded to utf-8.
+            Argument is ignored when connection_pool is provided.
+        maint_notifications_config:
+            configuration the pool to support maintenance notifications - see
+            `redis.maint_notifications.MaintNotificationsConfig` for details.
+            Only supported with RESP3
+            If not provided and protocol is RESP3, the maintenance notifications
+            will be enabled by default (logic is included in the connection pool
+            initialization).
+            Argument is ignored when connection_pool is provided.
         """
         if event_dispatcher is None:
             self._event_dispatcher = EventDispatcher()
@@ -354,6 +364,22 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
                             "cache_config": cache_config,
                         }
                     )
+                maint_notifications_enabled = (
+                    maint_notifications_config and maint_notifications_config.enabled
+                )
+                if maint_notifications_enabled and protocol not in [
+                    3,
+                    "3",
+                ]:
+                    raise RedisError(
+                        "Maintenance notifications handlers on connection are only supported with RESP version 3"
+                    )
+                if maint_notifications_config:
+                    kwargs.update(
+                        {
+                            "maint_notifications_config": maint_notifications_config,
+                        }
+                    )
             connection_pool = ConnectionPool(**kwargs)
             self._event_dispatcher.dispatch(
                 AfterPooledConnectionsInstantiationEvent(
@@ -377,23 +403,6 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
         ]:
             raise RedisError("Client caching is only supported with RESP version 3")
 
-        if maint_notifications_config and self.connection_pool.get_protocol() not in [
-            3,
-            "3",
-        ]:
-            raise RedisError(
-                "Push handlers on connection are only supported with RESP version 3"
-            )
-        if maint_notifications_config and maint_notifications_config.enabled:
-            self.maint_notifications_pool_handler = MaintNotificationsPoolHandler(
-                self.connection_pool, maint_notifications_config
-            )
-            self.connection_pool.set_maint_notifications_pool_handler(
-                self.maint_notifications_pool_handler
-            )
-        else:
-            self.maint_notifications_pool_handler = None
-
         self.single_connection_lock = threading.RLock()
         self.connection = None
         self._single_connection_client = single_connection_client
@@ -591,15 +600,9 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
         return Monitor(self.connection_pool)
 
     def client(self):
-        maint_notifications_config = (
-            None
-            if self.maint_notifications_pool_handler is None
-            else self.maint_notifications_pool_handler.config
-        )
         return self.__class__(
             connection_pool=self.connection_pool,
             single_connection_client=True,
-            maint_notifications_config=maint_notifications_config,
         )
 
     def __enter__(self):
@@ -1186,7 +1189,10 @@ class PubSub:
 
     def ping(self, message: Union[str, None] = None) -> bool:
         """
-        Ping the Redis server
+        Ping the Redis server to test connectivity.
+
+        Sends a PING command to the Redis server and returns True if the server
+        responds with "PONG".
         """
         args = ["PING", message] if message is not None else ["PING"]
         return self.execute_command(*args)
@@ -1271,6 +1277,8 @@ class PubSub:
         sleep_time: float = 0.0,
         daemon: bool = False,
         exception_handler: Optional[Callable] = None,
+        pubsub=None,
+        sharded_pubsub: bool = False,
     ) -> "PubSubWorkerThread":
         for channel, handler in self.channels.items():
             if handler is None:
@@ -1284,8 +1292,13 @@ class PubSub:
                     f"Shard Channel: '{s_channel}' has no handler registered"
                 )
 
+        pubsub = self if pubsub is None else pubsub
         thread = PubSubWorkerThread(
-            self, sleep_time, daemon=daemon, exception_handler=exception_handler
+            pubsub,
+            sleep_time,
+            daemon=daemon,
+            exception_handler=exception_handler,
+            sharded_pubsub=sharded_pubsub,
         )
         thread.start()
         return thread
@@ -1300,12 +1313,14 @@ class PubSubWorkerThread(threading.Thread):
         exception_handler: Union[
             Callable[[Exception, "PubSub", "PubSubWorkerThread"], None], None
         ] = None,
+        sharded_pubsub: bool = False,
     ):
         super().__init__()
         self.daemon = daemon
         self.pubsub = pubsub
         self.sleep_time = sleep_time
         self.exception_handler = exception_handler
+        self.sharded_pubsub = sharded_pubsub
         self._running = threading.Event()
 
     def run(self) -> None:
@@ -1316,7 +1331,14 @@ class PubSubWorkerThread(threading.Thread):
         sleep_time = self.sleep_time
         while self._running.is_set():
             try:
-                pubsub.get_message(ignore_subscribe_messages=True, timeout=sleep_time)
+                if not self.sharded_pubsub:
+                    pubsub.get_message(
+                        ignore_subscribe_messages=True, timeout=sleep_time
+                    )
+                else:
+                    pubsub.get_sharded_message(
+                        ignore_subscribe_messages=True, timeout=sleep_time
+                    )
             except BaseException as e:
                 if self.exception_handler is None:
                     raise

redis/cluster.py

@@ -50,6 +50,7 @@ from redis.exceptions import (
     WatchError,
 )
 from redis.lock import Lock
+from redis.maint_notifications import MaintNotificationsConfig
 from redis.retry import Retry
 from redis.utils import (
     deprecated_args,
@@ -695,6 +696,7 @@ class RedisCluster(AbstractRedisCluster, RedisClusterCommands):
             self._event_dispatcher = EventDispatcher()
         else:
             self._event_dispatcher = event_dispatcher
+        self.startup_nodes = startup_nodes
         self.nodes_manager = NodesManager(
             startup_nodes=startup_nodes,
             from_url=from_url,
@@ -1662,6 +1664,11 @@ class NodesManager:
             backoff=NoBackoff(), retries=0, supported_errors=(ConnectionError,)
         )
 
+        protocol = kwargs.get("protocol", None)
+        if protocol in [3, "3"]:
+            kwargs.update(
+                {"maint_notifications_config": MaintNotificationsConfig(enabled=False)}
+            )
         if self.from_url:
             # Create a redis node with a costumed connection pool
             kwargs.update({"host": host})
@@ -3164,7 +3171,8 @@ class TransactionStrategy(AbstractStrategy):
                 self._nodes_manager.initialize()
                 self.reinitialize_counter = 0
             else:
-                self._nodes_manager.update_moved_exception(error)
+                if isinstance(error, AskError):
+                    self._nodes_manager.update_moved_exception(error)
 
         self._executing = False
 

redis/commands/core.py

@@ -830,7 +830,7 @@ class ManagementCommands(CommandsProtocol):
 
         return self.execute_command("COMMAND LIST", *pieces)
 
-    def command_getkeysandflags(self, *args: List[str]) -> List[Union[str, List[str]]]:
+    def command_getkeysandflags(self, *args: str) -> List[Union[str, List[str]]]:
         """
         Returns array of keys from a full Redis command and their usage flags.
 
@@ -848,7 +848,7 @@ class ManagementCommands(CommandsProtocol):
         )
 
     def config_get(
-        self, pattern: PatternT = "*", *args: List[PatternT], **kwargs
+        self, pattern: PatternT = "*", *args: PatternT, **kwargs
     ) -> ResponseT:
         """
         Return a dictionary of configuration based on the ``pattern``
@@ -861,7 +861,7 @@ class ManagementCommands(CommandsProtocol):
         self,
         name: KeyT,
         value: EncodableT,
-        *args: List[Union[KeyT, EncodableT]],
+        *args: Union[KeyT, EncodableT],
         **kwargs,
     ) -> ResponseT:
         """Set config item ``name`` with ``value``
@@ -987,9 +987,7 @@ class ManagementCommands(CommandsProtocol):
         """
         return self.execute_command("SELECT", index, **kwargs)
 
-    def info(
-        self, section: Optional[str] = None, *args: List[str], **kwargs
-    ) -> ResponseT:
+    def info(self, section: Optional[str] = None, *args: str, **kwargs) -> ResponseT:
         """
         Returns a dictionary containing information about the Redis server
 
@@ -1210,11 +1208,18 @@ class ManagementCommands(CommandsProtocol):
         """
         return self.execute_command("LATENCY RESET", *events)
 
-    def ping(self, **kwargs) -> ResponseT:
+    def ping(self, **kwargs) -> Union[Awaitable[bool], bool]:
         """
-        Ping the Redis server
+        Ping the Redis server to test connectivity.
+
+        Sends a PING command to the Redis server and returns True if the server
+        responds with "PONG".
 
-        For more information, see https://redis.io/commands/ping
+        This command is useful for:
+        - Testing whether a connection is still alive
+        - Verifying the server's ability to serve data
+
+        For more information on the underlying ping command see https://redis.io/commands/ping
         """
         return self.execute_command("PING", **kwargs)
 
@@ -2599,7 +2604,7 @@ class ListCommands(CommandsProtocol):
         self,
         timeout: float,
         numkeys: int,
-        *args: List[str],
+        *args: str,
         direction: str,
         count: Optional[int] = 1,
     ) -> Optional[list]:
@@ -2612,14 +2617,14 @@ class ListCommands(CommandsProtocol):
 
         For more information, see https://redis.io/commands/blmpop
         """
-        args = [timeout, numkeys, *args, direction, "COUNT", count]
+        cmd_args = [timeout, numkeys, *args, direction, "COUNT", count]
 
-        return self.execute_command("BLMPOP", *args)
+        return self.execute_command("BLMPOP", *cmd_args)
 
     def lmpop(
         self,
         num_keys: int,
-        *args: List[str],
+        *args: str,
         direction: str,
         count: Optional[int] = 1,
     ) -> Union[Awaitable[list], list]:
@@ -2629,11 +2634,11 @@ class ListCommands(CommandsProtocol):
 
         For more information, see https://redis.io/commands/lmpop
         """
-        args = [num_keys] + list(args) + [direction]
+        cmd_args = [num_keys] + list(args) + [direction]
         if count != 1:
-            args.extend(["COUNT", count])
+            cmd_args.extend(["COUNT", count])
 
-        return self.execute_command("LMPOP", *args)
+        return self.execute_command("LMPOP", *cmd_args)
 
     def lindex(
         self, name: str, index: int
@@ -4771,6 +4776,7 @@ class SortedSetCommands(CommandsProtocol):
         name: KeyT,
         value: EncodableT,
         withscore: bool = False,
+        score_cast_func: Union[type, Callable] = float,
     ) -> ResponseT:
         """
         Returns a 0-based value indicating the rank of ``value`` in sorted set
@@ -4778,11 +4784,17 @@ class SortedSetCommands(CommandsProtocol):
         The optional WITHSCORE argument supplements the command's
         reply with the score of the element returned.
 
+        ``score_cast_func`` a callable used to cast the score return value
+
         For more information, see https://redis.io/commands/zrank
         """
+        pieces = ["ZRANK", name, value]
         if withscore:
-            return self.execute_command("ZRANK", name, value, "WITHSCORE", keys=[name])
-        return self.execute_command("ZRANK", name, value, keys=[name])
+            pieces.append("WITHSCORE")
+
+        options = {"withscore": withscore, "score_cast_func": score_cast_func}
+
+        return self.execute_command(*pieces, **options)
 
     def zrem(self, name: KeyT, *values: FieldT) -> ResponseT:
         """
@@ -4830,6 +4842,7 @@ class SortedSetCommands(CommandsProtocol):
         name: KeyT,
         value: EncodableT,
         withscore: bool = False,
+        score_cast_func: Union[type, Callable] = float,
     ) -> ResponseT:
         """
         Returns a 0-based value indicating the descending rank of
@@ -4837,13 +4850,17 @@ class SortedSetCommands(CommandsProtocol):
         The optional ``withscore`` argument supplements the command's
         reply with the score of the element returned.
 
+        ``score_cast_func`` a callable used to cast the score return value
+
         For more information, see https://redis.io/commands/zrevrank
         """
+        pieces = ["ZREVRANK", name, value]
         if withscore:
-            return self.execute_command(
-                "ZREVRANK", name, value, "WITHSCORE", keys=[name]
-            )
-        return self.execute_command("ZREVRANK", name, value, keys=[name])
+            pieces.append("WITHSCORE")
+
+        options = {"withscore": withscore, "score_cast_func": score_cast_func}
+
+        return self.execute_command(*pieces, **options)
 
     def zscore(self, name: KeyT, value: EncodableT) -> ResponseT:
         """
@@ -4858,6 +4875,7 @@ class SortedSetCommands(CommandsProtocol):
         keys: Union[Sequence[KeyT], Mapping[AnyKeyT, float]],
         aggregate: Optional[str] = None,
         withscores: bool = False,
+        score_cast_func: Union[type, Callable] = float,
     ) -> ResponseT:
         """
         Return the union of multiple sorted sets specified by ``keys``.
@@ -4865,9 +4883,18 @@ class SortedSetCommands(CommandsProtocol):
         Scores will be aggregated based on the ``aggregate``, or SUM if
         none is provided.
 
+        ``score_cast_func`` a callable used to cast the score return value
+
         For more information, see https://redis.io/commands/zunion
         """
-        return self._zaggregate("ZUNION", None, keys, aggregate, withscores=withscores)
+        return self._zaggregate(
+            "ZUNION",
+            None,
+            keys,
+            aggregate,
+            withscores=withscores,
+            score_cast_func=score_cast_func,
+        )
 
     def zunionstore(
         self,
@@ -5856,12 +5883,16 @@ class ScriptCommands(CommandsProtocol):
     """
 
     def _eval(
-        self, command: str, script: str, numkeys: int, *keys_and_args: str
+        self,
+        command: str,
+        script: str,
+        numkeys: int,
+        *keys_and_args: Union[KeyT, EncodableT],
     ) -> Union[Awaitable[str], str]:
         return self.execute_command(command, script, numkeys, *keys_and_args)
 
     def eval(
-        self, script: str, numkeys: int, *keys_and_args: str
+        self, script: str, numkeys: int, *keys_and_args: Union[KeyT, EncodableT]
     ) -> Union[Awaitable[str], str]:
         """
         Execute the Lua ``script``, specifying the ``numkeys`` the script
@@ -5876,7 +5907,7 @@ class ScriptCommands(CommandsProtocol):
         return self._eval("EVAL", script, numkeys, *keys_and_args)
 
     def eval_ro(
-        self, script: str, numkeys: int, *keys_and_args: str
+        self, script: str, numkeys: int, *keys_and_args: Union[KeyT, EncodableT]
     ) -> Union[Awaitable[str], str]:
         """
         The read-only variant of the EVAL command
@@ -5890,12 +5921,16 @@ class ScriptCommands(CommandsProtocol):
         return self._eval("EVAL_RO", script, numkeys, *keys_and_args)
 
     def _evalsha(
-        self, command: str, sha: str, numkeys: int, *keys_and_args: list
+        self,
+        command: str,
+        sha: str,
+        numkeys: int,
+        *keys_and_args: Union[KeyT, EncodableT],
     ) -> Union[Awaitable[str], str]:
         return self.execute_command(command, sha, numkeys, *keys_and_args)
 
     def evalsha(
-        self, sha: str, numkeys: int, *keys_and_args: str
+        self, sha: str, numkeys: int, *keys_and_args: Union[KeyT, EncodableT]
     ) -> Union[Awaitable[str], str]:
         """
         Use the ``sha`` to execute a Lua script already registered via EVAL
@@ -5911,7 +5946,7 @@ class ScriptCommands(CommandsProtocol):
         return self._evalsha("EVALSHA", sha, numkeys, *keys_and_args)
 
     def evalsha_ro(
-        self, sha: str, numkeys: int, *keys_and_args: str
+        self, sha: str, numkeys: int, *keys_and_args: Union[KeyT, EncodableT]
     ) -> Union[Awaitable[str], str]:
         """
         The read-only variant of the EVALSHA command

redis/commands/json/commands.py

@@ -14,7 +14,7 @@ class JSONCommands:
     """json commands."""
 
     def arrappend(
-        self, name: str, path: Optional[str] = Path.root_path(), *args: List[JsonType]
+        self, name: str, path: Optional[str] = Path.root_path(), *args: JsonType
     ) -> List[Optional[int]]:
         """Append the objects ``args`` to the array under the
         ``path` in key ``name``.
@@ -52,7 +52,7 @@ class JSONCommands:
         return self.execute_command("JSON.ARRINDEX", *pieces, keys=[name])
 
     def arrinsert(
-        self, name: str, path: str, index: int, *args: List[JsonType]
+        self, name: str, path: str, index: int, *args: JsonType
     ) -> List[Optional[int]]:
         """Insert the objects ``args`` to the array at index ``index``
         under the ``path` in key ``name``.

redis/commands/search/__init__.py

@@ -1,4 +1,4 @@
-import redis
+from redis.client import Pipeline as RedisPipeline
 
 from ...asyncio.client import Pipeline as AsyncioPipeline
 from .commands import (
@@ -181,7 +181,7 @@ class AsyncSearch(Search, AsyncSearchCommands):
         return p
 
 
-class Pipeline(SearchCommands, redis.client.Pipeline):
+class Pipeline(SearchCommands, RedisPipeline):
     """Pipeline for the module."""
 
 

redis/commands/search/aggregation.py

@@ -1,4 +1,4 @@
-from typing import List, Union
+from typing import List, Optional, Tuple, Union
 
 from redis.commands.search.dialect import DEFAULT_DIALECT
 
@@ -27,9 +27,9 @@ class Reducer:
     NAME = None
 
     def __init__(self, *args: str) -> None:
-        self._args = args
-        self._field = None
-        self._alias = None
+        self._args: Tuple[str, ...] = args
+        self._field: Optional[str] = None
+        self._alias: Optional[str] = None
 
     def alias(self, alias: str) -> "Reducer":
         """
@@ -49,13 +49,14 @@ class Reducer:
         if alias is FIELDNAME:
             if not self._field:
                 raise ValueError("Cannot use FIELDNAME alias with no field")
-            # Chop off initial '@'
-            alias = self._field[1:]
+            else:
+                # Chop off initial '@'
+                alias = self._field[1:]
         self._alias = alias
         return self
 
     @property
-    def args(self) -> List[str]:
+    def args(self) -> Tuple[str, ...]:
         return self._args
 
 
@@ -64,7 +65,7 @@ class SortDirection:
     This special class is used to indicate sort direction.
     """
 
-    DIRSTRING = None
+    DIRSTRING: Optional[str] = None
 
     def __init__(self, field: str) -> None:
         self.field = field
@@ -104,17 +105,17 @@ class AggregateRequest:
         All member methods (except `build_args()`)
         return the object itself, making them useful for chaining.
         """
-        self._query = query
-        self._aggregateplan = []
-        self._loadfields = []
-        self._loadall = False
-        self._max = 0
-        self._with_schema = False
-        self._verbatim = False
-        self._cursor = []
-        self._dialect = DEFAULT_DIALECT
-        self._add_scores = False
-        self._scorer = "TFIDF"
+        self._query: str = query
+        self._aggregateplan: List[str] = []
+        self._loadfields: List[str] = []
+        self._loadall: bool = False
+        self._max: int = 0
+        self._with_schema: bool = False
+        self._verbatim: bool = False
+        self._cursor: List[str] = []
+        self._dialect: int = DEFAULT_DIALECT
+        self._add_scores: bool = False
+        self._scorer: str = "TFIDF"
 
     def load(self, *fields: str) -> "AggregateRequest":
         """
@@ -133,7 +134,7 @@ class AggregateRequest:
         return self
 
     def group_by(
-        self, fields: List[str], *reducers: Union[Reducer, List[Reducer]]
+        self, fields: Union[str, List[str]], *reducers: Reducer
     ) -> "AggregateRequest":
         """
         Specify by which fields to group the aggregation.
@@ -147,7 +148,6 @@ class AggregateRequest:
             `aggregation` module.
         """
         fields = [fields] if isinstance(fields, str) else fields
-        reducers = [reducers] if isinstance(reducers, Reducer) else reducers
 
         ret = ["GROUPBY", str(len(fields)), *fields]
         for reducer in reducers:
@@ -251,12 +251,10 @@ class AggregateRequest:
             .sort_by(Desc("@paid"), max=10)
         ```
         """
-        if isinstance(fields, (str, SortDirection)):
-            fields = [fields]
 
         fields_args = []
         for f in fields:
-            if isinstance(f, SortDirection):
+            if isinstance(f, (Asc, Desc)):
                 fields_args += [f.field, f.DIRSTRING]
             else:
                 fields_args += [f]
@@ -356,7 +354,7 @@ class AggregateRequest:
             ret.extend(self._loadfields)
 
         if self._dialect:
-            ret.extend(["DIALECT", self._dialect])
+            ret.extend(["DIALECT", str(self._dialect)])
 
         ret.extend(self._aggregateplan)
 
@@ -393,7 +391,7 @@ class AggregateResult:
         self.cursor = cursor
         self.schema = schema
 
-    def __repr__(self) -> (str, str):
+    def __repr__(self) -> str:
         cid = self.cursor.cid if self.cursor else -1
         return (
             f"<{self.__class__.__name__} at 0x{id(self):x} "

redis/commands/search/commands.py

@@ -221,7 +221,7 @@ class SearchCommands:
 
         return self.execute_command(*args)
 
-    def alter_schema_add(self, fields: List[str]):
+    def alter_schema_add(self, fields: Union[Field, List[Field]]):
         """
         Alter the existing search index by adding new fields. The index
         must already exist.
@@ -336,11 +336,11 @@ class SearchCommands:
         doc_id: str,
         nosave: bool = False,
         score: float = 1.0,
-        payload: bool = None,
+        payload: Optional[bool] = None,
         replace: bool = False,
         partial: bool = False,
         language: Optional[str] = None,
-        no_create: str = False,
+        no_create: bool = False,
         **fields: List[str],
     ):
         """
@@ -464,7 +464,7 @@ class SearchCommands:
         return self._parse_results(INFO_CMD, res)
 
     def get_params_args(
-        self, query_params: Union[Dict[str, Union[str, int, float, bytes]], None]
+        self, query_params: Optional[Dict[str, Union[str, int, float, bytes]]]
     ):
         if query_params is None:
             return []
@@ -478,7 +478,7 @@ class SearchCommands:
         return args
 
     def _mk_query_args(
-        self, query, query_params: Union[Dict[str, Union[str, int, float, bytes]], None]
+        self, query, query_params: Optional[Dict[str, Union[str, int, float, bytes]]]
     ):
         args = [self.index_name]
 
@@ -528,7 +528,7 @@ class SearchCommands:
     def explain(
         self,
         query: Union[str, Query],
-        query_params: Dict[str, Union[str, int, float]] = None,
+        query_params: Optional[Dict[str, Union[str, int, float, bytes]]] = None,
     ):
         """Returns the execution plan for a complex query.
 
@@ -543,7 +543,7 @@ class SearchCommands:
     def aggregate(
         self,
         query: Union[AggregateRequest, Cursor],
-        query_params: Dict[str, Union[str, int, float]] = None,
+        query_params: Optional[Dict[str, Union[str, int, float, bytes]]] = None,
     ):
         """
         Issue an aggregation query.
@@ -598,7 +598,7 @@ class SearchCommands:
         self,
         query: Union[Query, AggregateRequest],
         limited: bool = False,
-        query_params: Optional[Dict[str, Union[str, int, float]]] = None,
+        query_params: Optional[Dict[str, Union[str, int, float, bytes]]] = None,
     ):
         """
         Performs a search or aggregate command and collects performance
@@ -936,7 +936,7 @@ class AsyncSearchCommands(SearchCommands):
     async def search(
         self,
         query: Union[str, Query],
-        query_params: Dict[str, Union[str, int, float]] = None,
+        query_params: Optional[Dict[str, Union[str, int, float, bytes]]] = None,
     ):
         """
         Search the index for a given query, and return a result of documents
@@ -968,7 +968,7 @@ class AsyncSearchCommands(SearchCommands):
     async def aggregate(
         self,
         query: Union[AggregateResult, Cursor],
-        query_params: Dict[str, Union[str, int, float]] = None,
+        query_params: Optional[Dict[str, Union[str, int, float, bytes]]] = None,
     ):
         """
         Issue an aggregation query.