Merge branch 'master' into stale-issues-management

Author: petyaslavova

doctests/dt_bitmap.py

@@ -6,11 +6,13 @@
 """
 import redis
 
-r = redis.Redis(decode_responses=True)
+# Connect without the usual `decode_responses=True` to
+# see the binary values in the responses more easily.
+r = redis.Redis()
 # HIDE_END
 
 # REMOVE_START
-r.delete("pings:2024-01-01-00:00")
+r.delete("pings:2024-01-01-00:00", "A", "B", "C", "R")
 # REMOVE_END
 
 # STEP_START ping
@@ -38,3 +40,116 @@
 # REMOVE_START
 assert res4 == 1
 # REMOVE_END
+
+# STEP_START bitop_setup
+r.setbit("A", 0, 1)
+r.setbit("A", 1, 1)
+r.setbit("A", 3, 1)
+r.setbit("A", 4, 1)
+
+res5 = r.get("A")
+print("{:08b}".format(int.from_bytes(res5, "big")))
+# >>> 11011000
+
+r.setbit("B", 3, 1)
+r.setbit("B", 4, 1)
+r.setbit("B", 7, 1)
+
+res6 = r.get("B")
+print("{:08b}".format(int.from_bytes(res6, "big")))
+# >>> 00011001
+
+r.setbit("C", 1, 1)
+r.setbit("C", 2, 1)
+r.setbit("C", 4, 1)
+r.setbit("C", 5, 1)
+
+res7 = r.get("C")
+print("{:08b}".format(int.from_bytes(res7, "big")))
+# >>> 01101100
+# STEP_END
+# REMOVE_START
+assert int.from_bytes(res5, "big") == 0b11011000
+assert int.from_bytes(res6, "big") == 0b00011001
+assert int.from_bytes(res7, "big") == 0b01101100
+# REMOVE_END
+
+# STEP_START bitop_and
+r.bitop("AND", "R", "A", "B", "C")
+res8 = r.get("R")
+print("{:08b}".format(int.from_bytes(res8, "big")))
+# >>> 00001000
+# STEP_END
+# REMOVE_START
+assert int.from_bytes(res8, "big") == 0b00001000
+# REMOVE_END
+
+# STEP_START bitop_or
+r.bitop("OR", "R", "A", "B", "C")
+res9 = r.get("R")
+print("{:08b}".format(int.from_bytes(res9, "big")))
+# >>> 11111101
+# STEP_END
+# REMOVE_START
+assert int.from_bytes(res9, "big") == 0b11111101
+# REMOVE_END
+
+# STEP_START bitop_xor
+r.bitop("XOR", "R", "A", "B")
+res10 = r.get("R")
+print("{:08b}".format(int.from_bytes(res10, "big")))
+# >>> 11000001
+# STEP_END
+# REMOVE_START
+assert int.from_bytes(res10, "big") == 0b11000001
+# REMOVE_END
+
+# STEP_START bitop_not
+r.bitop("NOT", "R", "A")
+res11 = r.get("R")
+print("{:08b}".format(int.from_bytes(res11, "big")))
+# >>> 00100111
+# STEP_END
+# REMOVE_START
+assert int.from_bytes(res11, "big") == 0b00100111
+# REMOVE_END
+
+# STEP_START bitop_diff
+r.bitop("DIFF", "R", "A", "B", "C")
+res12 = r.get("R")
+print("{:08b}".format(int.from_bytes(res12, "big")))
+# >>> 10000000
+# STEP_END
+# REMOVE_START
+assert int.from_bytes(res12, "big") == 0b10000000
+# REMOVE_END
+
+# STEP_START bitop_diff1
+r.bitop("DIFF1", "R", "A", "B", "C")
+res13 = r.get("R")
+print("{:08b}".format(int.from_bytes(res13, "big")))
+# >>> 00100101
+# STEP_END
+# REMOVE_START
+assert int.from_bytes(res13, "big") == 0b00100101
+# REMOVE_END
+
+# STEP_START bitop_andor
+r.bitop("ANDOR", "R", "A", "B", "C")
+res14 = r.get("R")
+print("{:08b}".format(int.from_bytes(res14, "big")))
+# >>> 01011000
+# STEP_END
+# REMOVE_START
+assert int.from_bytes(res14, "big") == 0b01011000
+# REMOVE_END
+
+# STEP_START bitop_one
+r.bitop("ONE", "R", "A", "B", "C")
+res15 = r.get("R")
+print("{:08b}".format(int.from_bytes(res15, "big")))
+# >>> 10100101
+# STEP_END
+# REMOVE_START
+assert int.from_bytes(res15, "big") == 0b10100101
+# REMOVE_END

redis/_parsers/base.py

@@ -5,12 +5,12 @@
 from typing import Awaitable, Callable, List, Optional, Protocol, Union
 
 from redis.maintenance_events import (
-    MaintenanceEvent,
-    NodeFailedOverEvent,
-    NodeFailingOverEvent,
-    NodeMigratedEvent,
-    NodeMigratingEvent,
-    NodeMovingEvent,
+    MaintenanceNotification,
+    NodeFailedOverNotification,
+    NodeFailingOverNotification,
+    NodeMigratedNotification,
+    NodeMigratingNotification,
+    NodeMovingNotification,
 )
 
 if sys.version_info.major >= 3 and sys.version_info.minor >= 11:
@@ -175,14 +175,14 @@ class MaintenanceNotificationsParser:
 
     @staticmethod
     def parse_maintenance_start_msg(response, notification_type):
-        # Expected message format is: <event_type> <seq_number> <time>
+        # Expected message format is: <notification_type> <seq_number> <time>
         id = response[1]
         ttl = response[2]
         return notification_type(id, ttl)
 
     @staticmethod
     def parse_maintenance_completed_msg(response, notification_type):
-        # Expected message format is: <event_type> <seq_number>
+        # Expected message format is: <notification_type> <seq_number>
         id = response[1]
         return notification_type(id)
 
@@ -200,7 +200,7 @@ def parse_moving_msg(response):
             host, port = value.split(":")
             port = int(port) if port is not None else None
 
-        return NodeMovingEvent(id, host, port, ttl)
+        return NodeMovingNotification(id, host, port, ttl)
 
 
 _INVALIDATION_MESSAGE = "invalidate"
@@ -217,25 +217,27 @@ def parse_moving_msg(response):
     _FAILED_OVER_MESSAGE,
 )
 
-MSG_TYPE_TO_EVENT_PARSER_MAPPING: dict[str, tuple[type[MaintenanceEvent], Callable]] = {
+MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING: dict[
+    str, tuple[type[MaintenanceNotification], Callable]
+] = {
     _MIGRATING_MESSAGE: (
-        NodeMigratingEvent,
+        NodeMigratingNotification,
         MaintenanceNotificationsParser.parse_maintenance_start_msg,
     ),
     _MIGRATED_MESSAGE: (
-        NodeMigratedEvent,
+        NodeMigratedNotification,
         MaintenanceNotificationsParser.parse_maintenance_completed_msg,
     ),
     _FAILING_OVER_MESSAGE: (
-        NodeFailingOverEvent,
+        NodeFailingOverNotification,
         MaintenanceNotificationsParser.parse_maintenance_start_msg,
     ),
     _FAILED_OVER_MESSAGE: (
-        NodeFailedOverEvent,
+        NodeFailedOverNotification,
         MaintenanceNotificationsParser.parse_maintenance_completed_msg,
     ),
     _MOVING_MESSAGE: (
-        NodeMovingEvent,
+        NodeMovingNotification,
         MaintenanceNotificationsParser.parse_moving_msg,
     ),
 }
@@ -273,14 +275,20 @@ def handle_push_response(self, response, **kwargs):
                 return self.invalidation_push_handler_func(response)
 
             if msg_type == _MOVING_MESSAGE and self.node_moving_push_handler_func:
-                parser_function = MSG_TYPE_TO_EVENT_PARSER_MAPPING[msg_type][1]
+                parser_function = MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING[
+                    msg_type
+                ][1]
 
                 notification = parser_function(response)
                 return self.node_moving_push_handler_func(notification)
 
             if msg_type in _MAINTENANCE_MESSAGES and self.maintenance_push_handler_func:
-                parser_function = MSG_TYPE_TO_EVENT_PARSER_MAPPING[msg_type][1]
-                notification_type = MSG_TYPE_TO_EVENT_PARSER_MAPPING[msg_type][0]
+                parser_function = MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING[
+                    msg_type
+                ][1]
+                notification_type = MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING[
+                    msg_type
+                ][0]
                 notification = parser_function(response, notification_type)
 
                 if notification is not None:
@@ -342,13 +350,19 @@ async def handle_push_response(self, response, **kwargs):
                 msg_type = msg_type.decode()
 
             if msg_type == _MOVING_MESSAGE and self.node_moving_push_handler_func:
-                parser_function = MSG_TYPE_TO_EVENT_PARSER_MAPPING[msg_type][1]
+                parser_function = MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING[
+                    msg_type
+                ][1]
                 notification = parser_function(response)
                 return await self.node_moving_push_handler_func(notification)
 
             if msg_type in _MAINTENANCE_MESSAGES and self.maintenance_push_handler_func:
-                parser_function = MSG_TYPE_TO_EVENT_PARSER_MAPPING[msg_type][1]
-                notification_type = MSG_TYPE_TO_EVENT_PARSER_MAPPING[msg_type][0]
+                parser_function = MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING[
+                    msg_type
+                ][1]
+                notification_type = MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING[
+                    msg_type
+                ][0]
                 notification = parser_function(response, notification_type)
 
                 if notification is not None:

redis/client.py

@@ -57,8 +57,8 @@
 )
 from redis.lock import Lock
 from redis.maintenance_events import (
-    MaintenanceEventPoolHandler,
-    MaintenanceEventsConfig,
+    MaintNotificationsConfig,
+    MaintNotificationsPoolHandler,
 )
 from redis.retry import Retry
 from redis.utils import (
@@ -248,7 +248,7 @@ def __init__(
         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.
@@ -373,22 +373,22 @@ def __init__(
         ]:
             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 +587,15 @@ def monitor(self):
         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):