flwr 1.20.0__py3-none-any.whl → 1.22.0__py3-none-any.whl

flwr/clientapp/mod/localdp_mod.py

@@ -0,0 +1,169 @@
+# 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.
+# ==============================================================================
+"""Local DP modifier."""
+
+
+from collections import OrderedDict
+from logging import INFO
+
+import numpy as np
+
+from flwr.clientapp.typing import ClientAppCallable
+from flwr.common import Array, ArrayRecord
+from flwr.common.context import Context
+from flwr.common.differential_privacy import (
+    add_gaussian_noise_inplace,
+    compute_clip_model_update,
+)
+from flwr.common.logger import log
+from flwr.common.message import Message
+
+from .centraldp_mods import _handle_array_key_mismatch_err, _handle_multi_record_err
+
+
+class LocalDpMod:
+    """Modifier for local differential privacy.
+
+    This mod clips the client model updates and
+    adds noise to the params before sending them to the server.
+
+    It operates on messages of type `MessageType.TRAIN`.
+
+    Parameters
+    ----------
+    clipping_norm : float
+        The value of the clipping norm.
+    sensitivity : float
+        The sensitivity of the client model.
+    epsilon : float
+        The privacy budget.
+        Smaller value of epsilon indicates a higher level of privacy protection.
+    delta : float
+        The failure probability.
+        The probability that the privacy mechanism
+        fails to provide the desired level of privacy.
+        A smaller value of delta indicates a stricter privacy guarantee.
+
+    Examples
+    --------
+    Create an instance of the local DP mod and add it to the client-side mods::
+
+        local_dp_mod = LocalDpMod( ... )
+        app = fl.client.ClientApp(mods=[local_dp_mod])
+    """
+
+    def __init__(
+        self, clipping_norm: float, sensitivity: float, epsilon: float, delta: float
+    ) -> None:
+        if clipping_norm <= 0:
+            raise ValueError("The clipping norm should be a positive value.")
+
+        if sensitivity < 0:
+            raise ValueError("The sensitivity should be a non-negative value.")
+
+        if epsilon < 0:
+            raise ValueError("Epsilon should be a non-negative value.")
+
+        if delta < 0:
+            raise ValueError("Delta should be a non-negative value.")
+
+        self.clipping_norm = clipping_norm
+        self.sensitivity = sensitivity
+        self.epsilon = epsilon
+        self.delta = delta
+
+    def __call__(
+        self, msg: Message, ctxt: Context, call_next: ClientAppCallable
+    ) -> Message:
+        """Perform local DP on the client model parameters.
+
+        Parameters
+        ----------
+        msg : Message
+            The message received from the ServerApp.
+        ctxt : Context
+            The context of the ClientApp.
+        call_next : ClientAppCallable
+            The callable to call the next mod (or the ClientApp) in the chain.
+
+        Returns
+        -------
+        Message
+            The modified message to be sent back to the server.
+        """
+        if len(msg.content.array_records) != 1:
+            return _handle_multi_record_err("LocalDpMod", msg, ArrayRecord)
+
+        # Record array record communicated to client and clipping norm
+        original_array_record = next(iter(msg.content.array_records.values()))
+
+        # Call inner app
+        out_msg = call_next(msg, ctxt)
+
+        # Check if the msg has error
+        if out_msg.has_error():
+            return out_msg
+
+        # Ensure reply has a single ArrayRecord
+        if len(out_msg.content.array_records) != 1:
+            return _handle_multi_record_err("LocalDpMod", out_msg, ArrayRecord)
+
+        new_array_record_key, client_to_server_arrecord = next(
+            iter(out_msg.content.array_records.items())
+        )
+
+        # Ensure keys in returned ArrayRecord match those in the one sent from server
+        if list(original_array_record.keys()) != list(client_to_server_arrecord.keys()):
+            return _handle_array_key_mismatch_err("LocalDpMod", out_msg)
+
+        client_to_server_ndarrays = client_to_server_arrecord.to_numpy_ndarrays()
+
+        # Clip the client update
+        compute_clip_model_update(
+            client_to_server_ndarrays,
+            original_array_record.to_numpy_ndarrays(),
+            self.clipping_norm,
+        )
+        log(
+            INFO,
+            "LocalDpMod: parameters are clipped by value: %.4f.",
+            self.clipping_norm,
+        )
+
+        std_dev = (
+            self.sensitivity * np.sqrt(2 * np.log(1.25 / self.delta)) / self.epsilon
+        )
+        add_gaussian_noise_inplace(
+            client_to_server_ndarrays,
+            std_dev,
+        )
+        log(
+            INFO,
+            "LocalDpMod: local DP noise with %.4f stddev added to parameters",
+            std_dev,
+        )
+
+        # Replace outgoing ArrayRecord's Array while preserving their keys
+        out_msg.content[new_array_record_key] = ArrayRecord(
+            OrderedDict(
+                {
+                    k: Array(v)
+                    for k, v in zip(
+                        client_to_server_arrecord.keys(), client_to_server_ndarrays
+                    )
+                }
+            )
+        )
+        return out_msg

flwr/clientapp/typing.py

@@ -0,0 +1,22 @@
+# 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.
+# ==============================================================================
+"""Custom types for Flower clients."""
+
+
+from typing import Callable
+
+from flwr.common import Context, Message
+
+ClientAppCallable = Callable[[Message, Context], Message]

flwr/common/args.py

@@ -17,7 +17,7 @@
 
 import argparse
 import sys
-from logging import DEBUG, ERROR, WARN
+from logging import DEBUG, ERROR, INFO, WARN
 from os.path import isfile
 from pathlib import Path
 from typing import Optional, Union
@@ -28,6 +28,12 @@ from flwr.common.logger import log
 
 def add_args_flwr_app_common(parser: argparse.ArgumentParser) -> None:
     """Add common Flower arguments for flwr-*app to the provided parser."""
+    parser.add_argument(
+        "--token",
+        type=str,
+        required=False,
+        help="Unique token generated by AppIo API for each app execution",
+    )
     parser.add_argument(
         "--flwr-dir",
         default=None,
@@ -47,6 +53,18 @@ def add_args_flwr_app_common(parser: argparse.ArgumentParser) -> None:
         "is not encrypted. By default, the server runs with HTTPS enabled. "
         "Use this flag only if you understand the risks.",
     )
+    parser.add_argument(
+        "--parent-pid",
+        type=int,
+        default=None,
+        help="The PID of the parent process. When set, the process will terminate "
+        "when the parent process exits.",
+    )
+    parser.add_argument(
+        "--run-once",
+        action="store_true",
+        help="This flag is deprecated and will be removed in a future release.",
+    )
 
 
 def try_obtain_root_certificates(
@@ -72,11 +90,7 @@ def try_obtain_root_certificates(
     else:
         # Load the certificates if provided, or load the system certificates
         if root_cert_path is None:
-            log(
-                WARN,
-                "Both `--insecure` and `--root-certificates` were not set. "
-                "Using system certificates.",
-            )
+            log(INFO, "Using system certificates")
             root_certificates = None
         elif not isfile(root_cert_path):
             log(ERROR, "Path argument `--root-certificates` does not point to a file.")

flwr/common/auth_plugin/__init__.py

@@ -16,11 +16,11 @@
 
 
 from .auth_plugin import CliAuthPlugin as CliAuthPlugin
-from .auth_plugin import ExecAuthPlugin as ExecAuthPlugin
-from .auth_plugin import ExecAuthzPlugin as ExecAuthzPlugin
+from .auth_plugin import ControlAuthPlugin as ControlAuthPlugin
+from .auth_plugin import ControlAuthzPlugin as ControlAuthzPlugin
 
 __all__ = [
     "CliAuthPlugin",
-    "ExecAuthPlugin",
-    "ExecAuthzPlugin",
+    "ControlAuthPlugin",
+    "ControlAuthzPlugin",
 ]

flwr/common/auth_plugin/auth_plugin.py

@@ -21,13 +21,13 @@ from pathlib import Path
 from typing import Optional, Union
 
 from flwr.common.typing import AccountInfo
-from flwr.proto.exec_pb2_grpc import ExecStub
+from flwr.proto.control_pb2_grpc import ControlStub
 
 from ..typing import UserAuthCredentials, UserAuthLoginDetails
 
 
-class ExecAuthPlugin(ABC):
-    """Abstract Flower Auth Plugin class for ExecServicer.
+class ControlAuthPlugin(ABC):
+    """Abstract Flower Auth Plugin class for ControlServicer.
 
     Parameters
     ----------
@@ -69,8 +69,8 @@ class ExecAuthPlugin(ABC):
         """Refresh authentication tokens in the provided metadata."""
 
 
-class ExecAuthzPlugin(ABC):  # pylint: disable=too-few-public-methods
-    """Abstract Flower Authorization Plugin class for ExecServicer.
+class ControlAuthzPlugin(ABC):  # pylint: disable=too-few-public-methods
+    """Abstract Flower Authorization Plugin class for ControlServicer.
 
     Parameters
     ----------
@@ -103,7 +103,7 @@ class CliAuthPlugin(ABC):
     @abstractmethod
     def login(
         login_details: UserAuthLoginDetails,
-        exec_stub: ExecStub,
+        control_stub: ControlStub,
     ) -> UserAuthCredentials:
         """Authenticate the user and retrieve authentication credentials.
 
@@ -111,7 +111,7 @@ class CliAuthPlugin(ABC):
         ----------
         login_details : UserAuthLoginDetails
             An object containing the user's login details.
-        exec_stub : ExecStub
+        control_stub : ControlStub
             A stub for executing RPC calls to the server.
 
         Returns

flwr/common/constant.py

@@ -35,7 +35,7 @@ CLIENTAPPIO_PORT = "9094"
 SERVERAPPIO_PORT = "9091"
 FLEETAPI_GRPC_RERE_PORT = "9092"
 FLEETAPI_PORT = "9095"
-EXEC_API_PORT = "9093"
+CONTROL_API_PORT = "9093"
 SIMULATIONIO_PORT = "9096"
 # Octets
 SERVER_OCTET = "0.0.0.0"
@@ -51,7 +51,7 @@ FLEET_API_GRPC_BIDI_DEFAULT_ADDRESS = (
     "[::]:8080"  # IPv6 to keep start_server compatible
 )
 FLEET_API_REST_DEFAULT_ADDRESS = f"{SERVER_OCTET}:{FLEETAPI_PORT}"
-EXEC_API_DEFAULT_SERVER_ADDRESS = f"{SERVER_OCTET}:{EXEC_API_PORT}"
+CONTROL_API_DEFAULT_SERVER_ADDRESS = f"{SERVER_OCTET}:{CONTROL_API_PORT}"
 SIMULATIONIO_API_DEFAULT_SERVER_ADDRESS = f"{SERVER_OCTET}:{SIMULATIONIO_PORT}"
 SIMULATIONIO_API_DEFAULT_CLIENT_ADDRESS = f"{CLIENT_OCTET}:{SIMULATIONIO_PORT}"
 
@@ -103,7 +103,7 @@ ISOLATION_MODE_PROCESS = "process"
 # Log streaming configurations
 CONN_REFRESH_PERIOD = 60  # Stream connection refresh period
 CONN_RECONNECT_INTERVAL = 0.5  # Reconnect interval between two stream connections
-LOG_STREAM_INTERVAL = 0.5  # Log stream interval for `ExecServicer.StreamLogs`
+LOG_STREAM_INTERVAL = 0.5  # Log stream interval for `ControlServicer.StreamLogs`
 LOG_UPLOAD_INTERVAL = 0.2  # Minimum interval between two log uploads
 
 # Retry configurations
@@ -152,8 +152,11 @@ PULL_INITIAL_BACKOFF = 1  # Initial backoff time for pulling objects
 PULL_BACKOFF_CAP = 10  # Maximum backoff time for pulling objects
 
 
-# ExecServicer constants
+# ControlServicer constants
 RUN_ID_NOT_FOUND_MESSAGE = "Run ID not found"
+NO_USER_AUTH_MESSAGE = "ControlServicer initialized without user authentication"
+NO_ARTIFACT_PROVIDER_MESSAGE = "ControlServicer initialized without artifact provider"
+PULL_UNFINISHED_RUN_MESSAGE = "Cannot pull artifacts for an unfinished run"
 
 
 class MessageType:
@@ -199,6 +202,7 @@ class ErrorCode:
     MESSAGE_UNAVAILABLE = 3
     REPLY_MESSAGE_UNAVAILABLE = 4
     NODE_UNAVAILABLE = 5
+    MOD_FAILED_PRECONDITION = 6
 
     def __new__(cls) -> ErrorCode:
         """Prevent instantiation."""
@@ -259,3 +263,21 @@ class EventLogWriterType:
     def __new__(cls) -> EventLogWriterType:
         """Prevent instantiation."""
         raise TypeError(f"{cls.__name__} cannot be instantiated.")
+
+
+class ExecPluginType:
+    """SuperExec plugin types."""
+
+    CLIENT_APP = "clientapp"
+    SERVER_APP = "serverapp"
+    SIMULATION = "simulation"
+
+    def __new__(cls) -> ExecPluginType:
+        """Prevent instantiation."""
+        raise TypeError(f"{cls.__name__} cannot be instantiated.")
+
+    @staticmethod
+    def all() -> list[str]:
+        """Return all SuperExec plugin types."""
+        # Filter all constants (uppercase) of the class
+        return [v for k, v in vars(ExecPluginType).items() if k.isupper()]

flwr/common/event_log_plugin/event_log_plugin.py

@@ -25,7 +25,7 @@ from flwr.common.typing import AccountInfo, LogEntry
 
 
 class EventLogWriterPlugin(ABC):
-    """Abstract Flower Event Log Writer Plugin class for ExecServicer."""
+    """Abstract Flower Event Log Writer Plugin class for ControlServicer."""
 
     @abstractmethod
     def __init__(self) -> None:

flwr/common/exit/__init__.py

@@ -17,8 +17,12 @@
 
 from .exit import flwr_exit
 from .exit_code import ExitCode
+from .exit_handler import add_exit_handler
+from .signal_handler import register_signal_handlers
 
 __all__ = [
     "ExitCode",
+    "add_exit_handler",
     "flwr_exit",
+    "register_signal_handlers",
 ]

flwr/common/exit/exit.py

@@ -22,11 +22,15 @@ from logging import ERROR, INFO
 from typing import Any, NoReturn
 
 from flwr.common import EventType, event
+from flwr.common.version import package_version
 
 from ..logger import log
 from .exit_code import EXIT_CODE_HELP
+from .exit_handler import trigger_exit_handlers
 
-HELP_PAGE_URL = "https://flower.ai/docs/framework/ref-exit-codes/"
+HELP_PAGE_URL = (
+    f"https://flower.ai/docs/framework/v{package_version}/en/ref-exit-codes/"
+)
 
 
 def flwr_exit(
@@ -77,6 +81,9 @@ def flwr_exit(
     # Log the exit message
     log(log_level, exit_message)
 
+    # Trigger exit handlers
+    trigger_exit_handlers()
+
     # Exit
     sys.exit(sys_exit_code)
 

flwr/common/exit/exit_code.py

@@ -32,19 +32,22 @@ class ExitCode:
     SUPERLINK_LICENSE_INVALID = 101
     SUPERLINK_LICENSE_MISSING = 102
     SUPERLINK_LICENSE_URL_INVALID = 103
+    SUPERLINK_INVALID_ARGS = 104
 
     # ServerApp-specific exit codes (200-299)
+    SERVERAPP_STRATEGY_PRECONDITION_UNMET = 200
+    SERVERAPP_EXCEPTION = 201
+    SERVERAPP_STRATEGY_AGGREGATION_ERROR = 202
 
     # SuperNode-specific exit codes (300-399)
     SUPERNODE_REST_ADDRESS_INVALID = 300
     SUPERNODE_NODE_AUTH_KEYS_REQUIRED = 301
     SUPERNODE_NODE_AUTH_KEYS_INVALID = 302
 
-    # ClientApp-specific exit codes (400-499)
+    # SuperExec-specific exit codes (400-499)
+    SUPEREXEC_INVALID_PLUGIN_CONFIG = 400
 
-    # Simulation-specific exit codes (500-599)
-
-    # Common exit codes (600-)
+    # Common exit codes (600-699)
     COMMON_ADDRESS_INVALID = 600
     COMMON_MISSING_EXTRA_REST = 601
     COMMON_TLS_NOT_SUPPORTED = 602
@@ -75,7 +78,25 @@ EXIT_CODE_HELP = {
         "The license URL is invalid. Please ensure that the `FLWR_LICENSE_URL` "
         "environment variable is set to a valid URL."
     ),
+    ExitCode.SUPERLINK_INVALID_ARGS: (
+        "Invalid arguments provided to SuperLink. Use `--help` check for the correct "
+        "usage. Alternatively, check the documentation."
+    ),
     # ServerApp-specific exit codes (200-299)
+    ExitCode.SERVERAPP_STRATEGY_PRECONDITION_UNMET: (
+        "The strategy received replies that cannot be aggregated. Please ensure all "
+        "replies returned by ClientApps have one `ArrayRecord` (none when replies are "
+        "from a round of federated evaluation, i.e. when message type is "
+        "`MessageType.EVALUATE`) and one `MetricRecord`. The records in all replies "
+        "must use identical keys. In addition, if the strategy expects a key to "
+        "perform weighted average (e.g. in FedAvg) please ensure the returned "
+        "MetricRecord from ClientApps do include this key."
+    ),
+    ExitCode.SERVERAPP_EXCEPTION: "An unhandled exception occurred in the ServerApp.",
+    ExitCode.SERVERAPP_STRATEGY_AGGREGATION_ERROR: (
+        "The strategy encountered an error during aggregation. Please check the logs "
+        "for more details."
+    ),
     # SuperNode-specific exit codes (300-399)
     ExitCode.SUPERNODE_REST_ADDRESS_INVALID: (
         "When using the REST API, please provide `https://` or "
@@ -91,9 +112,11 @@ EXIT_CODE_HELP = {
         "Please ensure that the file path points to a valid private/public key "
         "file and try again."
     ),
-    # ClientApp-specific exit codes (400-499)
-    # Simulation-specific exit codes (500-599)
-    # Common exit codes (600-)
+    # SuperExec-specific exit codes (400-499)
+    ExitCode.SUPEREXEC_INVALID_PLUGIN_CONFIG: (
+        "The YAML configuration for the SuperExec plugin is invalid."
+    ),
+    # Common exit codes (600-699)
     ExitCode.COMMON_ADDRESS_INVALID: (
         "Please provide a valid URL, IPv4 or IPv6 address."
     ),

flwr/common/exit/exit_handler.py

@@ -0,0 +1,62 @@
+# 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.
+# ==============================================================================
+"""Common function to register exit handlers."""
+
+
+import signal
+import threading
+from typing import Callable
+
+from .exit_code import ExitCode
+
+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]] = []
+_lock_handlers = threading.Lock()
+
+# SIGQUIT is not available on Windows
+if hasattr(signal, "SIGQUIT"):
+    SIGNAL_TO_EXIT_CODE[signal.SIGQUIT] = ExitCode.GRACEFUL_EXIT_SIGQUIT
+
+
+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 `flwr_exit` is called.
+
+    Parameters
+    ----------
+    exit_handler : Callable[[], None]
+        A callable that takes no arguments and performs cleanup or
+        other actions before the application exits.
+
+    Notes
+    -----
+    The registered exit handlers will be called in LIFO order, i.e.,
+    the last registered handler will be the first to be called.
+    """
+    with _lock_handlers:
+        registered_exit_handlers.append(exit_handler)
+
+
+def trigger_exit_handlers() -> None:
+    """Trigger all registered exit handlers in LIFO order."""
+    with _lock_handlers:
+        for handler in reversed(registered_exit_handlers):
+            handler()
+        registered_exit_handlers.clear()

flwr/common/{exit_handlers.py → exit/signal_handler.py}

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Common function to register exit handlers for server and client."""
+"""Common function to register signal handlers."""
 
 
 import signal
@@ -24,20 +24,21 @@ from grpc import Server
 
 from flwr.common.telemetry import EventType
 
-from .exit import ExitCode, flwr_exit
+from .exit import flwr_exit
+from .exit_code import ExitCode
+from .exit_handler import add_exit_handler
 
 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"):
     SIGNAL_TO_EXIT_CODE[signal.SIGQUIT] = ExitCode.GRACEFUL_EXIT_SIGQUIT
 
 
-def register_exit_handlers(
+def register_signal_handlers(
     event_type: EventType,
     exit_message: Optional[str] = None,
     grpc_servers: Optional[list[Server]] = None,
@@ -63,7 +64,21 @@ def register_exit_handlers(
         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 _wait_to_stop() -> None:
+        if grpc_servers is not None:
+            for grpc_server in grpc_servers:
+                grpc_server.stop(grace=1)
+
+        if bckg_threads is not None:
+            for bckg_thread in bckg_threads:
+                bckg_thread.join()
+
+    # Ensure that `_wait_to_stop` is the last handler called on exit
+    add_exit_handler(_wait_to_stop)
+
+    for handler in exit_handlers or []:
+        add_exit_handler(handler)
 
     def graceful_exit_handler(signalnum: int, _frame: FrameType) -> None:
         """Exit handler to be registered with `signal.signal`.
@@ -74,17 +89,6 @@ 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)
-
-        if bckg_threads is not None:
-            for bckg_thread in bckg_threads:
-                bckg_thread.join()
-
         # Setup things for graceful exit
         flwr_exit(
             code=SIGNAL_TO_EXIT_CODE[signalnum],
@@ -96,24 +100,3 @@ 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)