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

redis/{maintenance_events.py → maint_notifications.py}

@@ -5,7 +5,7 @@ import re
 import threading
 import time
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, Literal, Optional, Union
 
 from redis.typing import Number
 
@@ -38,25 +38,25 @@ if TYPE_CHECKING:
     )
 
 
-class MaintenanceEvent(ABC):
+class MaintenanceNotification(ABC):
     """
-    Base class for maintenance events sent through push messages by Redis server.
+    Base class for maintenance notifications sent through push messages by Redis server.
 
-    This class provides common functionality for all maintenance events including
+    This class provides common functionality for all maintenance notifications including
     unique identification and TTL (Time-To-Live) functionality.
 
     Attributes:
-        id (int): Unique identifier for this event
+        id (int): Unique identifier for this notification
         ttl (int): Time-to-live in seconds for this notification
         creation_time (float): Timestamp when the notification was created/read
     """
 
     def __init__(self, id: int, ttl: int):
         """
-        Initialize a new MaintenanceEvent with unique ID and TTL functionality.
+        Initialize a new MaintenanceNotification with unique ID and TTL functionality.
 
         Args:
-            id (int): Unique identifier for this event
+            id (int): Unique identifier for this notification
             ttl (int): Time-to-live in seconds for this notification
         """
         self.id = id
@@ -66,60 +66,60 @@ class MaintenanceEvent(ABC):
 
     def is_expired(self) -> bool:
         """
-        Check if this event has expired based on its TTL
+        Check if this notification has expired based on its TTL
         and creation time.
 
         Returns:
-            bool: True if the event has expired, False otherwise
+            bool: True if the notification has expired, False otherwise
         """
         return time.monotonic() > (self.creation_time + self.ttl)
 
     @abstractmethod
     def __repr__(self) -> str:
         """
-        Return a string representation of the maintenance event.
+        Return a string representation of the maintenance notification.
 
         This method must be implemented by all concrete subclasses.
 
         Returns:
-            str: String representation of the event
+            str: String representation of the notification
         """
         pass
 
     @abstractmethod
     def __eq__(self, other) -> bool:
         """
-        Compare two maintenance events for equality.
+        Compare two maintenance notifications for equality.
 
         This method must be implemented by all concrete subclasses.
-        Events are typically considered equal if they have the same id
+        Notifications are typically considered equal if they have the same id
         and are of the same type.
 
         Args:
             other: The other object to compare with
 
         Returns:
-            bool: True if the events are equal, False otherwise
+            bool: True if the notifications are equal, False otherwise
         """
         pass
 
     @abstractmethod
     def __hash__(self) -> int:
         """
-        Return a hash value for the maintenance event.
+        Return a hash value for the maintenance notification.
 
         This method must be implemented by all concrete subclasses to allow
         instances to be used in sets and as dictionary keys.
 
         Returns:
-            int: Hash value for the event
+            int: Hash value for the notification
         """
         pass
 
 
-class NodeMovingEvent(MaintenanceEvent):
+class NodeMovingNotification(MaintenanceNotification):
     """
-    This event is received when a node is replaced with a new node
+    This notification is received when a node is replaced with a new node
     during cluster rebalancing or maintenance operations.
     """
 
@@ -131,10 +131,10 @@ class NodeMovingEvent(MaintenanceEvent):
         ttl: int,
     ):
         """
-        Initialize a new NodeMovingEvent.
+        Initialize a new NodeMovingNotification.
 
         Args:
-            id (int): Unique identifier for this event
+            id (int): Unique identifier for this notification
             new_node_host (str): Hostname or IP address of the new replacement node
             new_node_port (int): Port number of the new replacement node
             ttl (int): Time-to-live in seconds for this notification
@@ -162,10 +162,10 @@ class NodeMovingEvent(MaintenanceEvent):
 
     def __eq__(self, other) -> bool:
         """
-        Two NodeMovingEvent events are considered equal if they have the same
+        Two NodeMovingNotification notifications are considered equal if they have the same
         id, new_node_host, and new_node_port.
         """
-        if not isinstance(other, NodeMovingEvent):
+        if not isinstance(other, NodeMovingNotification):
             return False
         return (
             self.id == other.id
@@ -175,11 +175,11 @@ class NodeMovingEvent(MaintenanceEvent):
 
     def __hash__(self) -> int:
         """
-        Return a hash value for the event to allow
+        Return a hash value for the notification to allow
         instances to be used in sets and as dictionary keys.
 
         Returns:
-            int: Hash value based on event type class name, id,
+            int: Hash value based on notification type class name, id,
             new_node_host and new_node_port
         """
         try:
@@ -197,15 +197,15 @@ class NodeMovingEvent(MaintenanceEvent):
         )
 
 
-class NodeMigratingEvent(MaintenanceEvent):
+class NodeMigratingNotification(MaintenanceNotification):
     """
-    Event for when a Redis cluster node is in the process of migrating slots.
+    Notification for when a Redis cluster node is in the process of migrating slots.
 
-    This event is received when a node starts migrating its slots to another node
+    This notification is received when a node starts migrating its slots to another node
     during cluster rebalancing or maintenance operations.
 
     Args:
-        id (int): Unique identifier for this event
+        id (int): Unique identifier for this notification
         ttl (int): Time-to-live in seconds for this notification
     """
 
@@ -228,39 +228,39 @@ class NodeMigratingEvent(MaintenanceEvent):
 
     def __eq__(self, other) -> bool:
         """
-        Two NodeMigratingEvent events are considered equal if they have the same
+        Two NodeMigratingNotification notifications are considered equal if they have the same
         id and are of the same type.
         """
-        if not isinstance(other, NodeMigratingEvent):
+        if not isinstance(other, NodeMigratingNotification):
             return False
         return self.id == other.id and type(self) is type(other)
 
     def __hash__(self) -> int:
         """
-        Return a hash value for the event to allow
+        Return a hash value for the notification to allow
         instances to be used in sets and as dictionary keys.
 
         Returns:
-            int: Hash value based on event type and id
+            int: Hash value based on notification type and id
         """
         return hash((self.__class__.__name__, int(self.id)))
 
 
-class NodeMigratedEvent(MaintenanceEvent):
+class NodeMigratedNotification(MaintenanceNotification):
     """
-    Event for when a Redis cluster node has completed migrating slots.
+    Notification for when a Redis cluster node has completed migrating slots.
 
-    This event is received when a node has finished migrating all its slots
+    This notification is received when a node has finished migrating all its slots
     to other nodes during cluster rebalancing or maintenance operations.
 
     Args:
-        id (int): Unique identifier for this event
+        id (int): Unique identifier for this notification
     """
 
     DEFAULT_TTL = 5
 
     def __init__(self, id: int):
-        super().__init__(id, NodeMigratedEvent.DEFAULT_TTL)
+        super().__init__(id, NodeMigratedNotification.DEFAULT_TTL)
 
     def __repr__(self) -> str:
         expiry_time = self.creation_time + self.ttl
@@ -278,33 +278,33 @@ class NodeMigratedEvent(MaintenanceEvent):
 
     def __eq__(self, other) -> bool:
         """
-        Two NodeMigratedEvent events are considered equal if they have the same
+        Two NodeMigratedNotification notifications are considered equal if they have the same
         id and are of the same type.
         """
-        if not isinstance(other, NodeMigratedEvent):
+        if not isinstance(other, NodeMigratedNotification):
             return False
         return self.id == other.id and type(self) is type(other)
 
     def __hash__(self) -> int:
         """
-        Return a hash value for the event to allow
+        Return a hash value for the notification to allow
         instances to be used in sets and as dictionary keys.
 
         Returns:
-            int: Hash value based on event type and id
+            int: Hash value based on notification type and id
         """
         return hash((self.__class__.__name__, int(self.id)))
 
 
-class NodeFailingOverEvent(MaintenanceEvent):
+class NodeFailingOverNotification(MaintenanceNotification):
     """
-    Event for when a Redis cluster node is in the process of failing over.
+    Notification for when a Redis cluster node is in the process of failing over.
 
-    This event is received when a node starts a failover process during
+    This notification is received when a node starts a failover process during
     cluster maintenance operations or when handling node failures.
 
     Args:
-        id (int): Unique identifier for this event
+        id (int): Unique identifier for this notification
         ttl (int): Time-to-live in seconds for this notification
     """
 
@@ -327,39 +327,39 @@ class NodeFailingOverEvent(MaintenanceEvent):
 
     def __eq__(self, other) -> bool:
         """
-        Two NodeFailingOverEvent events are considered equal if they have the same
+        Two NodeFailingOverNotification notifications are considered equal if they have the same
         id and are of the same type.
         """
-        if not isinstance(other, NodeFailingOverEvent):
+        if not isinstance(other, NodeFailingOverNotification):
             return False
         return self.id == other.id and type(self) is type(other)
 
     def __hash__(self) -> int:
         """
-        Return a hash value for the event to allow
+        Return a hash value for the notification to allow
         instances to be used in sets and as dictionary keys.
 
         Returns:
-            int: Hash value based on event type and id
+            int: Hash value based on notification type and id
         """
         return hash((self.__class__.__name__, int(self.id)))
 
 
-class NodeFailedOverEvent(MaintenanceEvent):
+class NodeFailedOverNotification(MaintenanceNotification):
     """
-    Event for when a Redis cluster node has completed a failover.
+    Notification for when a Redis cluster node has completed a failover.
 
-    This event is received when a node has finished the failover process
+    This notification is received when a node has finished the failover process
     during cluster maintenance operations or after handling node failures.
 
     Args:
-        id (int): Unique identifier for this event
+        id (int): Unique identifier for this notification
     """
 
     DEFAULT_TTL = 5
 
     def __init__(self, id: int):
-        super().__init__(id, NodeFailedOverEvent.DEFAULT_TTL)
+        super().__init__(id, NodeFailedOverNotification.DEFAULT_TTL)
 
     def __repr__(self) -> str:
         expiry_time = self.creation_time + self.ttl
@@ -377,20 +377,20 @@ class NodeFailedOverEvent(MaintenanceEvent):
 
     def __eq__(self, other) -> bool:
         """
-        Two NodeFailedOverEvent events are considered equal if they have the same
+        Two NodeFailedOverNotification notifications are considered equal if they have the same
         id and are of the same type.
         """
-        if not isinstance(other, NodeFailedOverEvent):
+        if not isinstance(other, NodeFailedOverNotification):
             return False
         return self.id == other.id and type(self) is type(other)
 
     def __hash__(self) -> int:
         """
-        Return a hash value for the event to allow
+        Return a hash value for the notification to allow
         instances to be used in sets and as dictionary keys.
 
         Returns:
-            int: Hash value based on event type and id
+            int: Hash value based on notification type and id
         """
         return hash((self.__class__.__name__, int(self.id)))
 
@@ -435,9 +435,9 @@ def _is_private_fqdn(host: str) -> bool:
     return False
 
 
-class MaintenanceEventsConfig:
+class MaintNotificationsConfig:
     """
-    Configuration class for maintenance events handling behaviour. Events are received through
+    Configuration class for maintenance notifications handling behaviour. Notifications are received through
     push notifications.
 
     This class defines how the Redis client should react to different push notifications
@@ -447,21 +447,26 @@ class MaintenanceEventsConfig:
 
     def __init__(
         self,
-        enabled: bool = True,
+        enabled: Union[bool, Literal["auto"]] = "auto",
         proactive_reconnect: bool = True,
-        relax_timeout: Optional[Number] = 10,
+        relaxed_timeout: Optional[Number] = 10,
         endpoint_type: Optional[EndpointType] = None,
     ):
         """
-        Initialize a new MaintenanceEventsConfig.
+        Initialize a new MaintNotificationsConfig.
 
         Args:
-            enabled (bool): Whether to enable maintenance events handling.
-                Defaults to False.
+            enabled (bool | "auto"): Controls maintenance notifications handling behavior.
+                - True: The CLIENT MAINT_NOTIFICATIONS command must succeed during connection setup,
+                otherwise a ResponseError is raised.
+                - "auto": The CLIENT MAINT_NOTIFICATIONS command is attempted but failures are
+                gracefully handled - a warning is logged and normal operation continues.
+                - False: Maintenance notifications are completely disabled.
+                Defaults to "auto".
             proactive_reconnect (bool): Whether to proactively reconnect when a node is replaced.
                 Defaults to True.
-            relax_timeout (Number): The relax timeout to use for the connection during maintenance.
-                If -1 is provided - the relax timeout is disabled. Defaults to 20.
+            relaxed_timeout (Number): The relaxed timeout to use for the connection during maintenance.
+                If -1 is provided - the relaxed timeout is disabled. Defaults to 20.
             endpoint_type (Optional[EndpointType]): Override for the endpoint type to use in CLIENT MAINT_NOTIFICATIONS.
                 If None, the endpoint type will be automatically determined based on the host and TLS configuration.
                 Defaults to None.
@@ -470,7 +475,7 @@ class MaintenanceEventsConfig:
             ValueError: If endpoint_type is provided but is not a valid endpoint type.
         """
         self.enabled = enabled
-        self.relax_timeout = relax_timeout
+        self.relaxed_timeout = relaxed_timeout
         self.proactive_reconnect = proactive_reconnect
         self.endpoint_type = endpoint_type
 
@@ -479,21 +484,21 @@ class MaintenanceEventsConfig:
             f"{self.__class__.__name__}("
             f"enabled={self.enabled}, "
             f"proactive_reconnect={self.proactive_reconnect}, "
-            f"relax_timeout={self.relax_timeout}, "
+            f"relaxed_timeout={self.relaxed_timeout}, "
             f"endpoint_type={self.endpoint_type!r}"
             f")"
         )
 
-    def is_relax_timeouts_enabled(self) -> bool:
+    def is_relaxed_timeouts_enabled(self) -> bool:
         """
-        Check if the relax_timeout is enabled. The '-1' value is used to disable the relax_timeout.
-        If relax_timeout is set to None, it will make the operation blocking
+        Check if the relaxed_timeout is enabled. The '-1' value is used to disable the relaxed_timeout.
+        If relaxed_timeout is set to None, it will make the operation blocking
         and waiting until any response is received.
 
         Returns:
-            True if the relax_timeout is enabled, False otherwise.
+            True if the relaxed_timeout is enabled, False otherwise.
         """
-        return self.relax_timeout != -1
+        return self.relaxed_timeout != -1
 
     def get_endpoint_type(
         self, host: str, connection: "ConnectionInterface"
@@ -550,15 +555,15 @@ class MaintenanceEventsConfig:
         return EndpointType.INTERNAL_FQDN if is_private else EndpointType.EXTERNAL_FQDN
 
 
-class MaintenanceEventPoolHandler:
+class MaintNotificationsPoolHandler:
     def __init__(
         self,
         pool: Union["ConnectionPool", "BlockingConnectionPool"],
-        config: MaintenanceEventsConfig,
+        config: MaintNotificationsConfig,
     ) -> None:
         self.pool = pool
         self.config = config
-        self._processed_events = set()
+        self._processed_notifications = set()
         self._lock = threading.RLock()
         self.connection = None
 
@@ -567,35 +572,35 @@ class MaintenanceEventPoolHandler:
 
     def remove_expired_notifications(self):
         with self._lock:
-            for notification in tuple(self._processed_events):
+            for notification in tuple(self._processed_notifications):
                 if notification.is_expired():
-                    self._processed_events.remove(notification)
+                    self._processed_notifications.remove(notification)
 
-    def handle_event(self, notification: MaintenanceEvent):
+    def handle_notification(self, notification: MaintenanceNotification):
         self.remove_expired_notifications()
 
-        if isinstance(notification, NodeMovingEvent):
-            return self.handle_node_moving_event(notification)
+        if isinstance(notification, NodeMovingNotification):
+            return self.handle_node_moving_notification(notification)
         else:
             logging.error(f"Unhandled notification type: {notification}")
 
-    def handle_node_moving_event(self, event: NodeMovingEvent):
+    def handle_node_moving_notification(self, notification: NodeMovingNotification):
         if (
             not self.config.proactive_reconnect
-            and not self.config.is_relax_timeouts_enabled()
+            and not self.config.is_relaxed_timeouts_enabled()
         ):
             return
         with self._lock:
-            if event in self._processed_events:
+            if notification in self._processed_notifications:
                 # nothing to do in the connection pool handling
-                # the event has already been handled or is expired
+                # the notification has already been handled or is expired
                 # just return
                 return
 
             with self.pool._lock:
                 if (
                     self.config.proactive_reconnect
-                    or self.config.is_relax_timeouts_enabled()
+                    or self.config.is_relaxed_timeouts_enabled()
                 ):
                     # Get the current connected address - if any
                     # This is the address that is being moved
@@ -614,21 +619,21 @@ class MaintenanceEventPoolHandler:
                     # connection settings for matching connections
                     self.pool.update_connections_settings(
                         state=MaintenanceState.MOVING,
-                        maintenance_event_hash=hash(event),
-                        relax_timeout=self.config.relax_timeout,
-                        host_address=event.new_node_host,
+                        maintenance_notification_hash=hash(notification),
+                        relaxed_timeout=self.config.relaxed_timeout,
+                        host_address=notification.new_node_host,
                         matching_address=moving_address_src,
                         matching_pattern="connected_address",
-                        update_event_hash=True,
+                        update_notification_hash=True,
                         include_free_connections=True,
                     )
 
                     if self.config.proactive_reconnect:
-                        if event.new_node_host is not None:
+                        if notification.new_node_host is not None:
                             self.run_proactive_reconnect(moving_address_src)
                         else:
                             threading.Timer(
-                                event.ttl / 2,
+                                notification.ttl / 2,
                                 self.run_proactive_reconnect,
                                 args=(moving_address_src,),
                             ).start()
@@ -639,22 +644,22 @@ class MaintenanceEventPoolHandler:
                     # if relax timeouts are enabled - update timeouts
                     kwargs: dict = {
                         "maintenance_state": MaintenanceState.MOVING,
-                        "maintenance_event_hash": hash(event),
+                        "maintenance_notification_hash": hash(notification),
                     }
-                    if event.new_node_host is not None:
+                    if notification.new_node_host is not None:
                         # the host is not updated if the new node host is None
                         # this happens when the MOVING push notification does not contain
                         # the new node host - in this case we only update the timeouts
                         kwargs.update(
                             {
-                                "host": event.new_node_host,
+                                "host": notification.new_node_host,
                             }
                         )
-                    if self.config.is_relax_timeouts_enabled():
+                    if self.config.is_relaxed_timeouts_enabled():
                         kwargs.update(
                             {
-                                "socket_timeout": self.config.relax_timeout,
-                                "socket_connect_timeout": self.config.relax_timeout,
+                                "socket_timeout": self.config.relaxed_timeout,
+                                "socket_connect_timeout": self.config.relaxed_timeout,
                             }
                         )
                     self.pool.update_connection_kwargs(**kwargs)
@@ -663,10 +668,12 @@ class MaintenanceEventPoolHandler:
                         self.pool.set_in_maintenance(False)
 
             threading.Timer(
-                event.ttl, self.handle_node_moved_event, args=(event,)
+                notification.ttl,
+                self.handle_node_moved_notification,
+                args=(notification,),
             ).start()
 
-            self._processed_events.add(event)
+            self._processed_notifications.add(notification)
 
     def run_proactive_reconnect(self, moving_address_src: Optional[str] = None):
         """
@@ -687,17 +694,20 @@ class MaintenanceEventPoolHandler:
                     moving_address_src=moving_address_src,
                 )
 
-    def handle_node_moved_event(self, event: NodeMovingEvent):
+    def handle_node_moved_notification(self, notification: NodeMovingNotification):
         """
-        Handle the cleanup after a node moving event expires.
+        Handle the cleanup after a node moving notification expires.
         """
-        event_hash = hash(event)
+        notification_hash = hash(notification)
 
         with self._lock:
-            # if the current maintenance_event_hash in kwargs is not matching the event
-            # it means there has been a new moving event after this one
+            # if the current maintenance_notification_hash in kwargs is not matching the notification
+            # it means there has been a new moving notification after this one
             # and we don't need to revert the kwargs yet
-            if self.pool.connection_kwargs.get("maintenance_event_hash") == event_hash:
+            if (
+                self.pool.connection_kwargs.get("maintenance_notification_hash")
+                == notification_hash
+            ):
                 orig_host = self.pool.connection_kwargs.get("orig_host_address")
                 orig_socket_timeout = self.pool.connection_kwargs.get(
                     "orig_socket_timeout"
@@ -707,7 +717,7 @@ class MaintenanceEventPoolHandler:
                 )
                 kwargs: dict = {
                     "maintenance_state": MaintenanceState.NONE,
-                    "maintenance_event_hash": None,
+                    "maintenance_notification_hash": None,
                     "host": orig_host,
                     "socket_timeout": orig_socket_timeout,
                     "socket_connect_timeout": orig_connect_timeout,
@@ -715,71 +725,75 @@ class MaintenanceEventPoolHandler:
                 self.pool.update_connection_kwargs(**kwargs)
 
             with self.pool._lock:
-                reset_relax_timeout = self.config.is_relax_timeouts_enabled()
+                reset_relaxed_timeout = self.config.is_relaxed_timeouts_enabled()
                 reset_host_address = self.config.proactive_reconnect
 
                 self.pool.update_connections_settings(
-                    relax_timeout=-1,
+                    relaxed_timeout=-1,
                     state=MaintenanceState.NONE,
-                    maintenance_event_hash=None,
-                    matching_event_hash=event_hash,
-                    matching_pattern="event_hash",
-                    update_event_hash=True,
-                    reset_relax_timeout=reset_relax_timeout,
+                    maintenance_notification_hash=None,
+                    matching_notification_hash=notification_hash,
+                    matching_pattern="notification_hash",
+                    update_notification_hash=True,
+                    reset_relaxed_timeout=reset_relaxed_timeout,
                     reset_host_address=reset_host_address,
                     include_free_connections=True,
                 )
 
 
-class MaintenanceEventConnectionHandler:
-    # 1 = "starting maintenance" events, 0 = "completed maintenance" events
-    _EVENT_TYPES: dict[type["MaintenanceEvent"], int] = {
-        NodeMigratingEvent: 1,
-        NodeFailingOverEvent: 1,
-        NodeMigratedEvent: 0,
-        NodeFailedOverEvent: 0,
+class MaintNotificationsConnectionHandler:
+    # 1 = "starting maintenance" notifications, 0 = "completed maintenance" notifications
+    _NOTIFICATION_TYPES: dict[type["MaintenanceNotification"], int] = {
+        NodeMigratingNotification: 1,
+        NodeFailingOverNotification: 1,
+        NodeMigratedNotification: 0,
+        NodeFailedOverNotification: 0,
     }
 
     def __init__(
-        self, connection: "ConnectionInterface", config: MaintenanceEventsConfig
+        self, connection: "ConnectionInterface", config: MaintNotificationsConfig
     ) -> None:
         self.connection = connection
         self.config = config
 
-    def handle_event(self, event: MaintenanceEvent):
-        # get the event type by checking its class in the _EVENT_TYPES dict
-        event_type = self._EVENT_TYPES.get(event.__class__, None)
+    def handle_notification(self, notification: MaintenanceNotification):
+        # get the notification type by checking its class in the _NOTIFICATION_TYPES dict
+        notification_type = self._NOTIFICATION_TYPES.get(notification.__class__, None)
 
-        if event_type is None:
-            logging.error(f"Unhandled event type: {event}")
+        if notification_type is None:
+            logging.error(f"Unhandled notification type: {notification}")
             return
 
-        if event_type:
-            self.handle_maintenance_start_event(MaintenanceState.MAINTENANCE)
+        if notification_type:
+            self.handle_maintenance_start_notification(MaintenanceState.MAINTENANCE)
         else:
-            self.handle_maintenance_completed_event()
+            self.handle_maintenance_completed_notification()
 
-    def handle_maintenance_start_event(self, maintenance_state: MaintenanceState):
+    def handle_maintenance_start_notification(
+        self, maintenance_state: MaintenanceState
+    ):
         if (
             self.connection.maintenance_state == MaintenanceState.MOVING
-            or not self.config.is_relax_timeouts_enabled()
+            or not self.config.is_relaxed_timeouts_enabled()
         ):
             return
 
         self.connection.maintenance_state = maintenance_state
-        self.connection.set_tmp_settings(tmp_relax_timeout=self.config.relax_timeout)
+        self.connection.set_tmp_settings(
+            tmp_relaxed_timeout=self.config.relaxed_timeout
+        )
         # extend the timeout for all created connections
-        self.connection.update_current_socket_timeout(self.config.relax_timeout)
+        self.connection.update_current_socket_timeout(self.config.relaxed_timeout)
 
-    def handle_maintenance_completed_event(self):
-        # Only reset timeouts if state is not MOVING and relax timeouts are enabled
+    def handle_maintenance_completed_notification(self):
+        # Only reset timeouts if state is not MOVING and relaxed timeouts are enabled
         if (
             self.connection.maintenance_state == MaintenanceState.MOVING
-            or not self.config.is_relax_timeouts_enabled()
+            or not self.config.is_relaxed_timeouts_enabled()
         ):
             return
-        self.connection.reset_tmp_settings(reset_relax_timeout=True)
+        self.connection.reset_tmp_settings(reset_relaxed_timeout=True)
         # Maintenance completed - reset the connection
-        # timeouts by providing -1 as the relax timeout
+        # timeouts by providing -1 as the relaxed timeout
         self.connection.update_current_socket_timeout(-1)
         self.connection.maintenance_state = MaintenanceState.NONE