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

redis/client.py

@@ -1186,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)
@@ -1271,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:
@@ -1284,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
@@ -1300,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:
@@ -1316,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

@@ -695,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,
@@ -3164,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)
 

redis/data_structure.py

@@ -0,0 +1,81 @@
+import threading
+from typing import Any, Generic, List, TypeVar
+
+from redis.typing import Number
+
+T = TypeVar("T")
+
+
+class WeightedList(Generic[T]):
+    """
+    Thread-safe weighted list.
+    """
+
+    def __init__(self):
+        self._items: List[tuple[Any, Number]] = []
+        self._lock = threading.RLock()
+
+    def add(self, item: Any, weight: float) -> None:
+        """Add item with weight, maintaining sorted order"""
+        with self._lock:
+            # Find insertion point using binary search
+            left, right = 0, len(self._items)
+            while left < right:
+                mid = (left + right) // 2
+                if self._items[mid][1] < weight:
+                    right = mid
+                else:
+                    left = mid + 1
+
+            self._items.insert(left, (item, weight))
+
+    def remove(self, item):
+        """Remove first occurrence of item"""
+        with self._lock:
+            for i, (stored_item, weight) in enumerate(self._items):
+                if stored_item == item:
+                    self._items.pop(i)
+                    return weight
+            raise ValueError("Item not found")
+
+    def get_by_weight_range(
+        self, min_weight: float, max_weight: float
+    ) -> List[tuple[Any, Number]]:
+        """Get all items within weight range"""
+        with self._lock:
+            result = []
+            for item, weight in self._items:
+                if min_weight <= weight <= max_weight:
+                    result.append((item, weight))
+            return result
+
+    def get_top_n(self, n: int) -> List[tuple[Any, Number]]:
+        """Get top N the highest weighted items"""
+        with self._lock:
+            return [(item, weight) for item, weight in self._items[:n]]
+
+    def update_weight(self, item, new_weight: float):
+        with self._lock:
+            """Update weight of an item"""
+            old_weight = self.remove(item)
+            self.add(item, new_weight)
+            return old_weight
+
+    def __iter__(self):
+        """Iterate in descending weight order"""
+        with self._lock:
+            items_copy = (
+                self._items.copy()
+            )  # Create snapshot as lock released after each 'yield'
+
+        for item, weight in items_copy:
+            yield item, weight
+
+    def __len__(self):
+        with self._lock:
+            return len(self._items)
+
+    def __getitem__(self, index) -> tuple[Any, Number]:
+        with self._lock:
+            item, weight = self._items[index]
+            return item, weight

redis/event.py

@@ -2,7 +2,7 @@ import asyncio
 import threading
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import List, Optional, Union
+from typing import Dict, List, Optional, Type, Union
 
 from redis.auth.token import TokenInterface
 from redis.credentials import CredentialProvider, StreamingCredentialProvider
@@ -42,6 +42,17 @@ class EventDispatcherInterface(ABC):
     async def dispatch_async(self, event: object):
         pass
 
+    @abstractmethod
+    def register_listeners(
+        self,
+        mappings: Dict[
+            Type[object],
+            List[Union[EventListenerInterface, AsyncEventListenerInterface]],
+        ],
+    ):
+        """Register additional listeners."""
+        pass
+
 
 class EventException(Exception):
     """
@@ -56,11 +67,18 @@ class EventException(Exception):
 
 class EventDispatcher(EventDispatcherInterface):
     # TODO: Make dispatcher to accept external mappings.
-    def __init__(self):
+    def __init__(
+        self,
+        event_listeners: Optional[
+            Dict[Type[object], List[EventListenerInterface]]
+        ] = None,
+    ):
         """
-        Mapping should be extended for any new events or listeners to be added.
+        Dispatcher that dispatches events to listeners associated with given event.
         """
-        self._event_listeners_mapping = {
+        self._event_listeners_mapping: Dict[
+            Type[object], List[EventListenerInterface]
+        ] = {
             AfterConnectionReleasedEvent: [
                 ReAuthConnectionListener(),
             ],
@@ -77,17 +95,47 @@ class EventDispatcher(EventDispatcherInterface):
             ],
         }
 
+        self._lock = threading.Lock()
+        self._async_lock = None
+
+        if event_listeners:
+            self.register_listeners(event_listeners)
+
     def dispatch(self, event: object):
-        listeners = self._event_listeners_mapping.get(type(event))
+        with self._lock:
+            listeners = self._event_listeners_mapping.get(type(event), [])
 
-        for listener in listeners:
-            listener.listen(event)
+            for listener in listeners:
+                listener.listen(event)
 
     async def dispatch_async(self, event: object):
-        listeners = self._event_listeners_mapping.get(type(event))
+        if self._async_lock is None:
+            self._async_lock = asyncio.Lock()
+
+        async with self._async_lock:
+            listeners = self._event_listeners_mapping.get(type(event), [])
 
-        for listener in listeners:
-            await listener.listen(event)
+            for listener in listeners:
+                await listener.listen(event)
+
+    def register_listeners(
+        self,
+        mappings: Dict[
+            Type[object],
+            List[Union[EventListenerInterface, AsyncEventListenerInterface]],
+        ],
+    ):
+        with self._lock:
+            for event_type in mappings:
+                if event_type in self._event_listeners_mapping:
+                    self._event_listeners_mapping[event_type] = list(
+                        set(
+                            self._event_listeners_mapping[event_type]
+                            + mappings[event_type]
+                        )
+                    )
+                else:
+                    self._event_listeners_mapping[event_type] = mappings[event_type]
 
 
 class AfterConnectionReleasedEvent:
@@ -226,6 +274,32 @@ class AfterAsyncClusterInstantiationEvent:
         return self._credential_provider
 
 
+class OnCommandsFailEvent:
+    """
+    Event fired whenever a command fails during the execution.
+    """
+
+    def __init__(
+        self,
+        commands: tuple,
+        exception: Exception,
+    ):
+        self._commands = commands
+        self._exception = exception
+
+    @property
+    def commands(self) -> tuple:
+        return self._commands
+
+    @property
+    def exception(self) -> Exception:
+        return self._exception
+
+
+class AsyncOnCommandsFailEvent(OnCommandsFailEvent):
+    pass
+
+
 class ReAuthConnectionListener(EventListenerInterface):
     """
     Listener that performs re-authentication of given connection.