redis 7.0.0b1__py3-none-any.whl → 7.0.0b3__py3-none-any.whl

redis/client.py

@@ -56,9 +56,9 @@ from redis.exceptions import (
     WatchError,
 )
 from redis.lock import Lock
-from redis.maintenance_events import (
-    MaintenanceEventPoolHandler,
-    MaintenanceEventsConfig,
+from redis.maint_notifications import (
+    MaintNotificationsConfig,
+    MaintNotificationsPoolHandler,
 )
 from redis.retry import Retry
 from redis.utils import (
@@ -224,6 +224,8 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
         ssl_keyfile: Optional[str] = None,
         ssl_certfile: Optional[str] = None,
         ssl_cert_reqs: Union[str, "ssl.VerifyMode"] = "required",
+        ssl_include_verify_flags: Optional[List["ssl.VerifyFlags"]] = None,
+        ssl_exclude_verify_flags: Optional[List["ssl.VerifyFlags"]] = None,
         ssl_ca_certs: Optional[str] = None,
         ssl_ca_path: Optional[str] = None,
         ssl_ca_data: Optional[str] = None,
@@ -248,7 +250,7 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
         cache: Optional[CacheInterface] = None,
         cache_config: Optional[CacheConfig] = None,
         event_dispatcher: Optional[EventDispatcher] = None,
-        maintenance_events_config: Optional[MaintenanceEventsConfig] = None,
+        maint_notifications_config: Optional[MaintNotificationsConfig] = None,
     ) -> None:
         """
         Initialize a new Redis client.
@@ -330,6 +332,8 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
                             "ssl_keyfile": ssl_keyfile,
                             "ssl_certfile": ssl_certfile,
                             "ssl_cert_reqs": ssl_cert_reqs,
+                            "ssl_include_verify_flags": ssl_include_verify_flags,
+                            "ssl_exclude_verify_flags": ssl_exclude_verify_flags,
                             "ssl_ca_certs": ssl_ca_certs,
                             "ssl_ca_data": ssl_ca_data,
                             "ssl_check_hostname": ssl_check_hostname,
@@ -373,22 +377,22 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
         ]:
             raise RedisError("Client caching is only supported with RESP version 3")
 
-        if maintenance_events_config and self.connection_pool.get_protocol() not in [
+        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 maintenance_events_config and maintenance_events_config.enabled:
-            self.maintenance_events_pool_handler = MaintenanceEventPoolHandler(
-                self.connection_pool, maintenance_events_config
+        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_maintenance_events_pool_handler(
-                self.maintenance_events_pool_handler
+            self.connection_pool.set_maint_notifications_pool_handler(
+                self.maint_notifications_pool_handler
             )
         else:
-            self.maintenance_events_pool_handler = None
+            self.maint_notifications_pool_handler = None
 
         self.single_connection_lock = threading.RLock()
         self.connection = None
@@ -587,15 +591,15 @@ class Redis(RedisModuleCommands, CoreCommands, SentinelCommands):
         return Monitor(self.connection_pool)
 
     def client(self):
-        maintenance_events_config = (
+        maint_notifications_config = (
             None
-            if self.maintenance_events_pool_handler is None
-            else self.maintenance_events_pool_handler.config
+            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,
-            maintenance_events_config=maintenance_events_config,
+            maint_notifications_config=maint_notifications_config,
         )
 
     def __enter__(self):
@@ -1182,7 +1186,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)
@@ -1267,6 +1274,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:
@@ -1280,8 +1289,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
@@ -1296,12 +1310,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:
@@ -1312,7 +1328,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

@@ -184,6 +184,8 @@ REDIS_ALLOWED_KEYS = (
     "ssl_ca_data",
     "ssl_certfile",
     "ssl_cert_reqs",
+    "ssl_include_verify_flags",
+    "ssl_exclude_verify_flags",
     "ssl_keyfile",
     "ssl_password",
     "ssl_check_hostname",
@@ -693,6 +695,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,
@@ -3162,7 +3165,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

@@ -1210,11 +1210,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.
 
-        For more information, see https://redis.io/commands/ping
+        Sends a PING command to the Redis server and returns True if the server
+        responds with "PONG".
+
+        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)