flwr 1.18.0__py3-none-any.whl → 1.19.0__py3-none-any.whl

flwr/client/rest_client/connection.py

@@ -14,33 +14,40 @@
 # ==============================================================================
 """Contextmanager for a REST request-response channel to the Flower server."""
 
-
-import random
-import threading
 from collections.abc import Iterator
 from contextlib import contextmanager
 from copy import copy
-from logging import ERROR, INFO, WARN
-from typing import Callable, Optional, TypeVar, Union
+from logging import DEBUG, ERROR, INFO, WARN
+from typing import Callable, Optional, TypeVar, Union, cast
 
 from cryptography.hazmat.primitives.asymmetric import ec
 from google.protobuf.message import Message as GrpcMessage
 from requests.exceptions import ConnectionError as RequestsConnectionError
 
-from flwr.client.heartbeat import start_ping_loop
+from flwr.app.metadata import Metadata
 from flwr.client.message_handler.message_handler import validate_out_message
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
-from flwr.common.constant import (
-    PING_BASE_MULTIPLIER,
-    PING_CALL_TIMEOUT,
-    PING_DEFAULT_INTERVAL,
-    PING_RANDOM_RANGE,
-)
+from flwr.common.constant import HEARTBEAT_DEFAULT_INTERVAL
 from flwr.common.exit import ExitCode, flwr_exit
+from flwr.common.heartbeat import HeartbeatSender
+from flwr.common.inflatable import (
+    get_all_nested_objects,
+    get_object_tree,
+    no_object_id_recompute,
+)
+from flwr.common.inflatable_rest_utils import (
+    make_pull_object_fn_rest,
+    make_push_object_fn_rest,
+)
+from flwr.common.inflatable_utils import (
+    inflate_object_from_contents,
+    pull_objects,
+    push_objects,
+)
 from flwr.common.logger import log
-from flwr.common.message import Message, Metadata
+from flwr.common.message import Message, remove_content_from_message
 from flwr.common.retry_invoker import RetryInvoker
-from flwr.common.serde import message_from_proto, message_to_proto, run_from_proto
+from flwr.common.serde import message_to_proto, run_from_proto
 from flwr.common.typing import Fab, Run
 from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
@@ -48,13 +55,23 @@ from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     CreateNodeResponse,
     DeleteNodeRequest,
     DeleteNodeResponse,
-    PingRequest,
-    PingResponse,
     PullMessagesRequest,
     PullMessagesResponse,
     PushMessagesRequest,
     PushMessagesResponse,
 )
+from flwr.proto.heartbeat_pb2 import (  # pylint: disable=E0611
+    SendNodeHeartbeatRequest,
+    SendNodeHeartbeatResponse,
+)
+from flwr.proto.message_pb2 import (  # pylint: disable=E0611
+    ConfirmMessageReceivedRequest,
+    ConfirmMessageReceivedResponse,
+    PullObjectRequest,
+    PullObjectResponse,
+    PushObjectRequest,
+    PushObjectResponse,
+)
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=E0611
 
@@ -68,9 +85,12 @@ PATH_CREATE_NODE: str = "api/v0/fleet/create-node"
 PATH_DELETE_NODE: str = "api/v0/fleet/delete-node"
 PATH_PULL_MESSAGES: str = "/api/v0/fleet/pull-messages"
 PATH_PUSH_MESSAGES: str = "/api/v0/fleet/push-messages"
-PATH_PING: str = "api/v0/fleet/ping"
+PATH_PULL_OBJECT: str = "/api/v0/fleet/pull-object"
+PATH_PUSH_OBJECT: str = "/api/v0/fleet/push-object"
+PATH_SEND_NODE_HEARTBEAT: str = "api/v0/fleet/send-node-heartbeat"
 PATH_GET_RUN: str = "/api/v0/fleet/get-run"
 PATH_GET_FAB: str = "/api/v0/fleet/get-fab"
+PATH_CONFIRM_MESSAGE_RECEIVED: str = "/api/v0/fleet/confirm-message-received"
 
 T = TypeVar("T", bound=GrpcMessage)
 
@@ -91,10 +111,10 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     tuple[
         Callable[[], Optional[Message]],
         Callable[[Message], None],
-        Optional[Callable[[], Optional[int]]],
-        Optional[Callable[[], None]],
-        Optional[Callable[[int], Run]],
-        Optional[Callable[[str, int], Fab]],
+        Callable[[], Optional[int]],
+        Callable[[], None],
+        Callable[[int], Run],
+        Callable[[str, int], Fab],
     ]
 ]:
     """Primitives for request/response-based interaction with a server.
@@ -160,11 +180,9 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     # Shared variables for inner functions
     metadata: Optional[Metadata] = None
     node: Optional[Node] = None
-    ping_thread: Optional[threading.Thread] = None
-    ping_stop_event = threading.Event()
 
     ###########################################################################
-    # ping/create_node/delete_node/receive/send/get_run functions
+    # heartbeat/create_node/delete_node/receive/send/get_run functions
     ###########################################################################
 
     def _request(
@@ -214,44 +232,47 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         grpc_res.ParseFromString(res.content)
         return grpc_res
 
-    def ping() -> None:
+    def send_node_heartbeat() -> bool:
         # Get Node
         if node is None:
             log(ERROR, "Node instance missing")
-            return
+            return False
 
-        # Construct the ping request
-        req = PingRequest(node=node, ping_interval=PING_DEFAULT_INTERVAL)
+        # Construct the heartbeat request
+        req = SendNodeHeartbeatRequest(
+            node=node, heartbeat_interval=HEARTBEAT_DEFAULT_INTERVAL
+        )
 
         # Send the request
-        res = _request(req, PingResponse, PATH_PING, retry=False)
+        res = _request(
+            req, SendNodeHeartbeatResponse, PATH_SEND_NODE_HEARTBEAT, retry=False
+        )
         if res is None:
-            return
+            return False
 
         # Check if success
         if not res.success:
-            raise RuntimeError("Ping failed unexpectedly.")
+            raise RuntimeError(
+                "Heartbeat failed unexpectedly. The SuperLink does not "
+                "recognize this SuperNode."
+            )
+        return True
 
-        # Wait
-        rd = random.uniform(*PING_RANDOM_RANGE)
-        next_interval: float = PING_DEFAULT_INTERVAL - PING_CALL_TIMEOUT
-        next_interval *= PING_BASE_MULTIPLIER + rd
-        if not ping_stop_event.is_set():
-            ping_stop_event.wait(next_interval)
+    heartbeat_sender = HeartbeatSender(send_node_heartbeat)
 
     def create_node() -> Optional[int]:
         """Set create_node."""
-        req = CreateNodeRequest(ping_interval=PING_DEFAULT_INTERVAL)
+        req = CreateNodeRequest(heartbeat_interval=HEARTBEAT_DEFAULT_INTERVAL)
 
         # Send the request
         res = _request(req, CreateNodeResponse, PATH_CREATE_NODE)
         if res is None:
             return None
 
-        # Remember the node and the ping-loop thread
-        nonlocal node, ping_thread
+        # Remember the node and start the heartbeat sender
+        nonlocal node
         node = res.node
-        ping_thread = start_ping_loop(ping, ping_stop_event)
+        heartbeat_sender.start()
         return node.node_id
 
     def delete_node() -> None:
@@ -261,10 +282,8 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
             log(ERROR, "Node instance missing")
             return
 
-        # Stop the ping-loop thread
-        ping_stop_event.set()
-        if ping_thread is not None:
-            ping_thread.join()
+        # Stop the heartbeat sender
+        heartbeat_sender.stop()
 
         # Send DeleteNode request
         req = DeleteNodeRequest(node=node)
@@ -301,14 +320,58 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         ):
             message_proto = None
 
-        # Return the Message if available
-        nonlocal metadata
-        message = None
-        if message_proto is not None:
-            message = message_from_proto(message_proto)
-            metadata = copy(message.metadata)
+        # Construct the Message
+        in_message: Optional[Message] = None
+
+        if message_proto:
             log(INFO, "[Node] POST /%s: success", PATH_PULL_MESSAGES)
-        return message
+            msg_id = message_proto.metadata.message_id
+            run_id = message_proto.metadata.run_id
+
+            def fn(request: PullObjectRequest) -> PullObjectResponse:
+                res = _request(
+                    req=request, res_type=PullObjectResponse, api_path=PATH_PULL_OBJECT
+                )
+                if res is None:
+                    raise ValueError("PushObjectResponse is None.")
+                return res
+
+            try:
+                all_object_contents = pull_objects(
+                    list(res.objects_to_pull[msg_id].object_ids) + [msg_id],
+                    pull_object_fn=make_pull_object_fn_rest(
+                        pull_object_rest=fn,
+                        node=node,
+                        run_id=run_id,
+                    ),
+                )
+
+                # Confirm that the message has been received
+                _request(
+                    req=ConfirmMessageReceivedRequest(
+                        node=node, run_id=run_id, message_object_id=msg_id
+                    ),
+                    res_type=ConfirmMessageReceivedResponse,
+                    api_path=PATH_CONFIRM_MESSAGE_RECEIVED,
+                )
+            except ValueError as e:
+                log(
+                    ERROR,
+                    "Pulling objects failed. Potential irrecoverable error: %s",
+                    str(e),
+                )
+            in_message = cast(
+                Message, inflate_object_from_contents(msg_id, all_object_contents)
+            )
+            # The deflated message doesn't contain the message_id (its own object_id)
+            # Inject
+            in_message.metadata.__dict__["_message_id"] = msg_id
+
+        # Remember `metadata` of the in message
+        nonlocal metadata
+        metadata = copy(in_message.metadata) if in_message else None
+
+        return in_message
 
     def send(message: Message) -> None:
         """Send Message result back to server."""
@@ -323,29 +386,72 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
             log(ERROR, "No current message")
             return
 
+        # Set message_id
+        message.metadata.__dict__["_message_id"] = message.object_id
         # Validate out message
         if not validate_out_message(message, metadata):
             log(ERROR, "Invalid out message")
             return
-        metadata = None
 
-        # Serialize ProtoBuf to bytes
-        message_proto = message_to_proto(message=message)
+        with no_object_id_recompute():
+            # Get all nested objects
+            all_objects = get_all_nested_objects(message)
+            object_tree = get_object_tree(message)
 
-        # Serialize ProtoBuf to bytes
-        req = PushMessagesRequest(node=node, messages_list=[message_proto])
+            # Serialize Message
+            message_proto = message_to_proto(
+                message=remove_content_from_message(message)
+            )
+            req = PushMessagesRequest(
+                node=node,
+                messages_list=[message_proto],
+                message_object_trees=[object_tree],
+            )
 
-        # Send the request
-        res = _request(req, PushMessagesResponse, PATH_PUSH_MESSAGES)
-        if res is None:
-            return
+            # Send the request
+            res = _request(req, PushMessagesResponse, PATH_PUSH_MESSAGES)
+            if res:
+                log(
+                    INFO,
+                    "[Node] POST /%s: success, created result %s",
+                    PATH_PUSH_MESSAGES,
+                    res.results,  # pylint: disable=no-member
+                )
+
+            if res and res.objects_to_push:
+                objs_to_push = set(res.objects_to_push[message.object_id].object_ids)
+
+                def fn(request: PushObjectRequest) -> PushObjectResponse:
+                    res = _request(
+                        req=request,
+                        res_type=PushObjectResponse,
+                        api_path=PATH_PUSH_OBJECT,
+                    )
+                    if res is None:
+                        raise ValueError("PushObjectResponse is None.")
+                    return res
+
+                try:
+                    push_objects(
+                        all_objects,
+                        push_object_fn=make_push_object_fn_rest(
+                            push_object_rest=fn,
+                            node=node,
+                            run_id=message_proto.metadata.run_id,
+                        ),
+                        object_ids_to_push=objs_to_push,
+                    )
+                    log(DEBUG, "Pushed %s objects to servicer.", len(objs_to_push))
+                except ValueError as e:
+                    log(
+                        ERROR,
+                        "Pushing objects failed. Potential irrecoverable error: %s",
+                        str(e),
+                    )
+                    log(ERROR, str(e))
 
-        log(
-            INFO,
-            "[Node] POST /%s: success, created result %s",
-            PATH_PUSH_MESSAGES,
-            res.results,  # pylint: disable=no-member
-        )
+        # Cleanup
+        metadata = None
 
     def get_run(run_id: int) -> Run:
         # Construct the request

flwr/clientapp/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Public Flower ClientApp APIs."""

flwr/common/__init__.py

@@ -15,6 +15,8 @@
 """Common components shared between server and client."""
 
 
+from ..app.error import Error as Error
+from ..app.metadata import Metadata as Metadata
 from .constant import MessageType as MessageType
 from .constant import MessageTypeLegacy as MessageTypeLegacy
 from .context import Context as Context
@@ -23,9 +25,7 @@ from .grpc import GRPC_MAX_MESSAGE_LENGTH
 from .logger import configure as configure
 from .logger import log as log
 from .message import DEFAULT_TTL
-from .message import Error as Error
 from .message import Message as Message
-from .message import Metadata as Metadata
 from .parameter import bytes_to_ndarray as bytes_to_ndarray
 from .parameter import ndarray_to_bytes as ndarray_to_bytes
 from .parameter import ndarrays_to_parameters as ndarrays_to_parameters

flwr/common/auth_plugin/__init__.py

@@ -17,8 +17,10 @@
 
 from .auth_plugin import CliAuthPlugin as CliAuthPlugin
 from .auth_plugin import ExecAuthPlugin as ExecAuthPlugin
+from .auth_plugin import ExecAuthzPlugin as ExecAuthzPlugin
 
 __all__ = [
     "CliAuthPlugin",
     "ExecAuthPlugin",
+    "ExecAuthzPlugin",
 ]

flwr/common/auth_plugin/auth_plugin.py

@@ -20,7 +20,7 @@ from collections.abc import Sequence
 from pathlib import Path
 from typing import Optional, Union
 
-from flwr.common.typing import UserInfo
+from flwr.common.typing import AccountInfo
 from flwr.proto.exec_pb2_grpc import ExecStub
 
 from ..typing import UserAuthCredentials, UserAuthLoginDetails
@@ -33,6 +33,9 @@ class ExecAuthPlugin(ABC):
     ----------
     user_auth_config_path : Path
         Path to the YAML file containing the authentication configuration.
+    verify_tls_cert : bool
+        Boolean indicating whether to verify the TLS certificate
+        when making requests to the server.
     """
 
     @abstractmethod
@@ -50,7 +53,7 @@ class ExecAuthPlugin(ABC):
     @abstractmethod
     def validate_tokens_in_metadata(
         self, metadata: Sequence[tuple[str, Union[str, bytes]]]
-    ) -> tuple[bool, Optional[UserInfo]]:
+    ) -> tuple[bool, Optional[AccountInfo]]:
         """Validate authentication tokens in the provided metadata."""
 
     @abstractmethod
@@ -60,10 +63,33 @@ class ExecAuthPlugin(ABC):
     @abstractmethod
     def refresh_tokens(
         self, metadata: Sequence[tuple[str, Union[str, bytes]]]
-    ) -> Optional[Sequence[tuple[str, Union[str, bytes]]]]:
+    ) -> tuple[
+        Optional[Sequence[tuple[str, Union[str, bytes]]]], Optional[AccountInfo]
+    ]:
         """Refresh authentication tokens in the provided metadata."""
 
 
+class ExecAuthzPlugin(ABC):  # pylint: disable=too-few-public-methods
+    """Abstract Flower Authorization Plugin class for ExecServicer.
+
+    Parameters
+    ----------
+    user_auth_config_path : Path
+        Path to the YAML file containing the authorization configuration.
+    verify_tls_cert : bool
+        Boolean indicating whether to verify the TLS certificate
+        when making requests to the server.
+    """
+
+    @abstractmethod
+    def __init__(self, user_auth_config_path: Path, verify_tls_cert: bool):
+        """Abstract constructor."""
+
+    @abstractmethod
+    def verify_user_authorization(self, account_info: AccountInfo) -> bool:
+        """Verify user authorization request."""
+
+
 class CliAuthPlugin(ABC):
     """Abstract Flower Auth Plugin class for CLI.
 

flwr/common/constant.py

@@ -55,13 +55,14 @@ EXEC_API_DEFAULT_SERVER_ADDRESS = f"{SERVER_OCTET}:{EXEC_API_PORT}"
 SIMULATIONIO_API_DEFAULT_SERVER_ADDRESS = f"{SERVER_OCTET}:{SIMULATIONIO_PORT}"
 SIMULATIONIO_API_DEFAULT_CLIENT_ADDRESS = f"{CLIENT_OCTET}:{SIMULATIONIO_PORT}"
 
-# Constants for ping
-PING_DEFAULT_INTERVAL = 30
-PING_CALL_TIMEOUT = 5
-PING_BASE_MULTIPLIER = 0.8
-PING_RANDOM_RANGE = (-0.1, 0.1)
-PING_MAX_INTERVAL = 1e300
-PING_PATIENCE = 2
+# Constants for heartbeat
+HEARTBEAT_DEFAULT_INTERVAL = 30
+HEARTBEAT_CALL_TIMEOUT = 5
+HEARTBEAT_BASE_MULTIPLIER = 0.8
+HEARTBEAT_RANDOM_RANGE = (-0.1, 0.1)
+HEARTBEAT_MAX_INTERVAL = 1e300
+HEARTBEAT_PATIENCE = 2
+RUN_FAILURE_DETAILS_NO_HEARTBEAT = "No heartbeat received from the run."
 
 # IDs
 RUN_ID_NUM_BYTES = 8
@@ -114,6 +115,9 @@ AUTH_TYPE_YAML_KEY = "auth_type"  # For key name in YAML file
 ACCESS_TOKEN_KEY = "flwr-oidc-access-token"
 REFRESH_TOKEN_KEY = "flwr-oidc-refresh-token"
 
+# Constants for user authorization
+AUTHZ_TYPE_YAML_KEY = "authz_type"  # For key name in YAML file
+
 # Constants for node authentication
 PUBLIC_KEY_HEADER = "flwr-public-key-bin"  # Must end with "-bin" for binary data
 SIGNATURE_HEADER = "flwr-signature-bin"  # Must end with "-bin" for binary data
@@ -121,9 +125,34 @@ TIMESTAMP_HEADER = "flwr-timestamp"
 TIMESTAMP_TOLERANCE = 10  # General tolerance for timestamp verification
 SYSTEM_TIME_TOLERANCE = 5  # Allowance for system time drift
 
+# Constants for grpc retry
+GRPC_RETRY_MAX_DELAY = 20  # Maximum delay duration between two consecutive retries.
+
 # Constants for ArrayRecord
 GC_THRESHOLD = 200_000_000  # 200 MB
 
+# Constants for Inflatable
+HEAD_BODY_DIVIDER = b"\x00"
+HEAD_VALUE_DIVIDER = " "
+
+# Constants for serialization
+INT64_MAX_VALUE = 9223372036854775807  # (1 << 63) - 1
+
+# Constants for `flwr-serverapp` and `flwr-clientapp` CLI commands
+FLWR_APP_TOKEN_LENGTH = 128  # Length of the token used
+
+# Constants for object pushing and pulling
+MAX_CONCURRENT_PUSHES = 8  # Default maximum number of concurrent pushes
+MAX_CONCURRENT_PULLS = 8  # Default maximum number of concurrent pulls
+PULL_MAX_TIME = 7200  # Default maximum time to wait for pulling objects
+PULL_MAX_TRIES_PER_OBJECT = 500  # Default maximum number of tries to pull an object
+PULL_INITIAL_BACKOFF = 1  # Initial backoff time for pulling objects
+PULL_BACKOFF_CAP = 10  # Maximum backoff time for pulling objects
+
+
+# ExecServicer constants
+RUN_ID_NOT_FOUND_MESSAGE = "Run ID not found"
+
 
 class MessageType:
     """Message type."""

flwr/common/event_log_plugin/event_log_plugin.py

@@ -21,7 +21,7 @@ from typing import Optional, Union
 import grpc
 from google.protobuf.message import Message as GrpcMessage
 
-from flwr.common.typing import LogEntry, UserInfo
+from flwr.common.typing import AccountInfo, LogEntry
 
 
 class EventLogWriterPlugin(ABC):
@@ -36,7 +36,7 @@ class EventLogWriterPlugin(ABC):
         self,
         request: GrpcMessage,
         context: grpc.ServicerContext,
-        user_info: Optional[UserInfo],
+        account_info: Optional[AccountInfo],
         method_name: str,
     ) -> LogEntry:
         """Compose pre-event log entry from the provided request and context."""
@@ -46,7 +46,7 @@ class EventLogWriterPlugin(ABC):
         self,
         request: GrpcMessage,
         context: grpc.ServicerContext,
-        user_info: Optional[UserInfo],
+        account_info: Optional[AccountInfo],
         method_name: str,
         response: Optional[Union[GrpcMessage, BaseException]],
     ) -> LogEntry:

flwr/common/exit_handlers.py

@@ -30,6 +30,7 @@ SIGNAL_TO_EXIT_CODE: dict[int, int] = {
     signal.SIGINT: ExitCode.GRACEFUL_EXIT_SIGINT,
     signal.SIGTERM: ExitCode.GRACEFUL_EXIT_SIGTERM,
 }
+registered_exit_handlers: list[Callable[[], None]] = []
 
 # SIGQUIT is not available on Windows
 if hasattr(signal, "SIGQUIT"):
@@ -41,6 +42,7 @@ def register_exit_handlers(
     exit_message: Optional[str] = None,
     grpc_servers: Optional[list[Server]] = None,
     bckg_threads: Optional[list[Thread]] = None,
+    exit_handlers: Optional[list[Callable[[], None]]] = None,
 ) -> None:
     """Register exit handlers for `SIGINT`, `SIGTERM` and `SIGQUIT` signals.
 
@@ -56,8 +58,12 @@ def register_exit_handlers(
     bckg_threads: Optional[List[Thread]] (default: None)
         An optional list of threads that need to be gracefully
         terminated before exiting.
+    exit_handlers: Optional[List[Callable[[], None]]] (default: None)
+        An optional list of exit handlers to be called before exiting.
+        Additional exit handlers can be added using `add_exit_handler`.
     """
     default_handlers: dict[int, Callable[[int, FrameType], None]] = {}
+    registered_exit_handlers.extend(exit_handlers or [])
 
     def graceful_exit_handler(signalnum: int, _frame: FrameType) -> None:
         """Exit handler to be registered with `signal.signal`.
@@ -68,6 +74,9 @@ def register_exit_handlers(
         # Reset to default handler
         signal.signal(signalnum, default_handlers[signalnum])  # type: ignore
 
+        for handler in registered_exit_handlers:
+            handler()
+
         if grpc_servers is not None:
             for grpc_server in grpc_servers:
                 grpc_server.stop(grace=1)
@@ -87,3 +96,24 @@ def register_exit_handlers(
     for sig in SIGNAL_TO_EXIT_CODE:
         default_handler = signal.signal(sig, graceful_exit_handler)  # type: ignore
         default_handlers[sig] = default_handler  # type: ignore
+
+
+def add_exit_handler(exit_handler: Callable[[], None]) -> None:
+    """Add an exit handler to be called on graceful exit.
+
+    This function allows you to register additional exit handlers
+    that will be executed when the application exits gracefully,
+    if `register_exit_handlers` was called.
+
+    Parameters
+    ----------
+    exit_handler : Callable[[], None]
+        A callable that takes no arguments and performs cleanup or
+        other actions before the application exits.
+
+    Notes
+    -----
+    This method is not thread-safe, and it allows you to add the
+    same exit handler multiple times.
+    """
+    registered_exit_handlers.append(exit_handler)