flwr-nightly 1.8.0.dev20240223__tar.gz → 1.8.0.dev20240227__tar.gz

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.8.0.dev20240223
+Version: 1.8.0.dev20240227
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.8.0-dev20240223"
+version = "1.8.0-dev20240227"
 description = "Flower: A Friendly Federated Learning Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/client/__init__.py

@@ -19,7 +19,7 @@ from .app import run_client_app as run_client_app
 from .app import start_client as start_client
 from .app import start_numpy_client as start_numpy_client
 from .client import Client as Client
-from .clientapp import ClientApp as ClientApp
+from .client_app import ClientApp as ClientApp
 from .numpy_client import NumPyClient as NumPyClient
 from .typing import ClientFn as ClientFn
 

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/client/app.py

@@ -23,7 +23,7 @@ from pathlib import Path
 from typing import Callable, ContextManager, Optional, Tuple, Union
 
 from flwr.client.client import Client
-from flwr.client.clientapp import ClientApp
+from flwr.client.client_app import ClientApp
 from flwr.client.typing import ClientFn
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH, EventType, Message, event
 from flwr.common.address import parse_address
@@ -34,9 +34,10 @@ from flwr.common.constant import (
     TRANSPORT_TYPE_REST,
     TRANSPORT_TYPES,
 )
+from flwr.common.exit_handlers import register_exit_handlers
 from flwr.common.logger import log, warn_deprecated_feature, warn_experimental_feature
 
-from .clientapp import load_client_app
+from .client_app import load_client_app
 from .grpc_client.connection import grpc_connection
 from .grpc_rere_client.connection import grpc_request_response
 from .message_handler.message_handler import handle_control_message
@@ -104,7 +105,7 @@ def run_client_app() -> None:
         root_certificates=root_certificates,
         insecure=args.insecure,
     )
-    event(EventType.RUN_CLIENT_APP_LEAVE)
+    register_exit_handlers(event_type=EventType.RUN_CLIENT_APP_LEAVE)
 
 
 def _parse_args_run_client_app() -> argparse.ArgumentParser:

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/client/message_handler/message_handler.py

@@ -98,7 +98,7 @@ def handle_legacy_message_from_msgtype(
     client_fn: ClientFn, message: Message, context: Context
 ) -> Message:
     """Handle legacy message in the inner most mod."""
-    client = client_fn(str(message.metadata.dst_node_id))
+    client = client_fn(str(message.metadata.partition_id))
 
     # Check if NumPyClient is returend
     if isinstance(client, NumPyClient):

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/client/mod/__init__.py

@@ -15,10 +15,12 @@
 """Mods."""
 
 
+from .centraldp_mods import fixedclipping_mod
 from .secure_aggregation.secaggplus_mod import secaggplus_mod
 from .utils import make_ffn
 
 __all__ = [
     "make_ffn",
     "secaggplus_mod",
+    "fixedclipping_mod",
 ]

flwr_nightly-1.8.0.dev20240227/src/py/flwr/client/mod/centraldp_mods.py

@@ -0,0 +1,76 @@
+# Copyright 2024 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.
+# ==============================================================================
+"""Clipping modifiers for central DP with client-side clipping."""
+
+
+from flwr.client.typing import ClientAppCallable
+from flwr.common import ndarrays_to_parameters, parameters_to_ndarrays
+from flwr.common import recordset_compat as compat
+from flwr.common.constant import MESSAGE_TYPE_FIT
+from flwr.common.context import Context
+from flwr.common.differential_privacy import compute_clip_model_update
+from flwr.common.differential_privacy_constants import KEY_CLIPPING_NORM
+from flwr.common.message import Message
+
+
+def fixedclipping_mod(
+    msg: Message, ctxt: Context, call_next: ClientAppCallable
+) -> Message:
+    """Client-side fixed clipping modifier.
+
+    This mod needs to be used with the DifferentialPrivacyClientSideFixedClipping
+    server-side strategy wrapper.
+
+    The wrapper sends the clipping_norm value to the client.
+
+    This mod clips the client model updates before sending them to the server.
+
+    It operates on messages with type MESSAGE_TYPE_FIT.
+
+    Notes
+    -----
+    Consider the order of mods when using multiple.
+
+    Typically, fixedclipping_mod should be the last to operate on params.
+    """
+    if msg.metadata.message_type != MESSAGE_TYPE_FIT:
+        return call_next(msg, ctxt)
+    fit_ins = compat.recordset_to_fitins(msg.content, keep_input=True)
+    if KEY_CLIPPING_NORM not in fit_ins.config:
+        raise KeyError(
+            f"The {KEY_CLIPPING_NORM} value is not supplied by the "
+            f"DifferentialPrivacyClientSideFixedClipping wrapper at"
+            f" the server side."
+        )
+
+    clipping_norm = float(fit_ins.config[KEY_CLIPPING_NORM])
+    server_to_client_params = parameters_to_ndarrays(fit_ins.parameters)
+
+    # Call inner app
+    out_msg = call_next(msg, ctxt)
+    fit_res = compat.recordset_to_fitres(out_msg.content, keep_input=True)
+
+    client_to_server_params = parameters_to_ndarrays(fit_res.parameters)
+
+    # Clip the client update
+    compute_clip_model_update(
+        client_to_server_params,
+        server_to_client_params,
+        clipping_norm,
+    )
+
+    fit_res.parameters = ndarrays_to_parameters(client_to_server_params)
+    out_msg.content = compat.fitres_to_recordset(fit_res, keep_input=True)
+    return out_msg

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/common/differential_privacy_constants.py

@@ -14,6 +14,8 @@
 # ==============================================================================
 """Constants for differential privacy."""
 
+
+KEY_CLIPPING_NORM = "clipping_norm"
 CLIENTS_DISCREPANCY_WARNING = (
     "The number of clients returning parameters (%s)"
     " differs from the number of sampled clients (%s)."

flwr_nightly-1.8.0.dev20240227/src/py/flwr/common/exit_handlers.py

@@ -0,0 +1,87 @@
+# Copyright 2024 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 for server and client."""
+
+
+import sys
+from signal import SIGINT, SIGTERM, signal
+from threading import Thread
+from types import FrameType
+from typing import List, Optional
+
+from grpc import Server
+
+from flwr.common.telemetry import EventType, event
+
+
+def register_exit_handlers(
+    event_type: EventType,
+    grpc_servers: Optional[List[Server]] = None,
+    bckg_threads: Optional[List[Thread]] = None,
+) -> None:
+    """Register exit handlers for `SIGINT` and `SIGTERM` signals.
+
+    Parameters
+    ----------
+    event_type : EventType
+        The telemetry event that should be logged before exit.
+    grpc_servers: Optional[List[Server]] (default: None)
+        An otpional list of gRPC servers that need to be gracefully
+        terminated before exiting.
+    bckg_threads: Optional[List[Thread]] (default: None)
+        An optional list of threads that need to be gracefully
+        terminated before exiting.
+    """
+    default_handlers = {
+        SIGINT: None,
+        SIGTERM: None,
+    }
+
+    def graceful_exit_handler(  # type: ignore
+        signalnum,
+        frame: FrameType,  # pylint: disable=unused-argument
+    ) -> None:
+        """Exit handler to be registered with `signal.signal`.
+
+        When called will reset signal handler to original signal handler from
+        default_handlers.
+        """
+        # Reset to default handler
+        signal(signalnum, default_handlers[signalnum])
+
+        event_res = event(event_type=event_type)
+
+        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 event has happend
+        event_res.result()
+
+        # Setup things for graceful exit
+        sys.exit(0)
+
+    default_handlers[SIGINT] = signal(  # type: ignore
+        SIGINT,
+        graceful_exit_handler,  # type: ignore
+    )
+    default_handlers[SIGTERM] = signal(  # type: ignore
+        SIGTERM,
+        graceful_exit_handler,  # type: ignore
+    )

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/common/message.py

@@ -14,7 +14,6 @@
 # ==============================================================================
 """Message."""
 
-
 from __future__ import annotations
 
 from dataclasses import dataclass
@@ -46,6 +45,10 @@ class Metadata:  # pylint: disable=too-many-instance-attributes
     message_type : str
         A string that encodes the action to be executed on
         the receiving end.
+    partition_id : Optional[int]
+        An identifier that can be used when loading a particular
+        data partition for a ClientApp. Making use of this identifier
+        is more relevant when conducting simulations.
     """
 
     _run_id: int
@@ -56,6 +59,7 @@ class Metadata:  # pylint: disable=too-many-instance-attributes
     _group_id: str
     _ttl: str
     _message_type: str
+    _partition_id: int | None
 
     def __init__(  # pylint: disable=too-many-arguments
         self,
@@ -67,6 +71,7 @@ class Metadata:  # pylint: disable=too-many-instance-attributes
         group_id: str,
         ttl: str,
         message_type: str,
+        partition_id: int | None = None,
     ) -> None:
         self._run_id = run_id
         self._message_id = message_id
@@ -76,6 +81,7 @@ class Metadata:  # pylint: disable=too-many-instance-attributes
         self._group_id = group_id
         self._ttl = ttl
         self._message_type = message_type
+        self._partition_id = partition_id
 
     @property
     def run_id(self) -> int:
@@ -137,6 +143,16 @@ class Metadata:  # pylint: disable=too-many-instance-attributes
         """Set message_type."""
         self._message_type = value
 
+    @property
+    def partition_id(self) -> int | None:
+        """An identifier telling which data partition a ClientApp should use."""
+        return self._partition_id
+
+    @partition_id.setter
+    def partition_id(self, value: int) -> None:
+        """Set patition_id."""
+        self._partition_id = value
+
 
 @dataclass
 class Message:
@@ -202,6 +218,7 @@ class Message:
                 group_id=self.metadata.group_id,
                 ttl=ttl,
                 message_type=self.metadata.message_type,
+                partition_id=self.metadata.partition_id,
             ),
             content=content,
         )

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/server/app.py

@@ -22,8 +22,6 @@ import threading
 from logging import ERROR, INFO, WARN
 from os.path import isfile
 from pathlib import Path
-from signal import SIGINT, SIGTERM, signal
-from types import FrameType
 from typing import List, Optional, Tuple
 
 import grpc
@@ -36,6 +34,7 @@ from flwr.common.constant import (
     TRANSPORT_TYPE_REST,
     TRANSPORT_TYPE_VCE,
 )
+from flwr.common.exit_handlers import register_exit_handlers
 from flwr.common.logger import log
 from flwr.proto.driver_pb2_grpc import (  # pylint: disable=E0611
     add_DriverServicer_to_server,
@@ -212,10 +211,10 @@ def run_driver_api() -> None:
     )
 
     # Graceful shutdown
-    _register_exit_handlers(
+    register_exit_handlers(
+        event_type=EventType.RUN_DRIVER_API_LEAVE,
         grpc_servers=[grpc_server],
         bckg_threads=[],
-        event_type=EventType.RUN_DRIVER_API_LEAVE,
     )
 
     # Block
@@ -280,10 +279,10 @@ def run_fleet_api() -> None:
         raise ValueError(f"Unknown fleet_api_type: {args.fleet_api_type}")
 
     # Graceful shutdown
-    _register_exit_handlers(
+    register_exit_handlers(
+        event_type=EventType.RUN_FLEET_API_LEAVE,
         grpc_servers=grpc_servers,
         bckg_threads=bckg_threads,
-        event_type=EventType.RUN_FLEET_API_LEAVE,
     )
 
     # Block
@@ -375,10 +374,10 @@ def run_superlink() -> None:
         raise ValueError(f"Unknown fleet_api_type: {args.fleet_api_type}")
 
     # Graceful shutdown
-    _register_exit_handlers(
+    register_exit_handlers(
+        event_type=EventType.RUN_SUPERLINK_LEAVE,
         grpc_servers=grpc_servers,
         bckg_threads=bckg_threads,
-        event_type=EventType.RUN_SUPERLINK_LEAVE,
     )
 
     # Block
@@ -413,52 +412,6 @@ def _try_obtain_certificates(
     return certificates
 
 
-def _register_exit_handlers(
-    grpc_servers: List[grpc.Server],
-    bckg_threads: List[threading.Thread],
-    event_type: EventType,
-) -> None:
-    default_handlers = {
-        SIGINT: None,
-        SIGTERM: None,
-    }
-
-    def graceful_exit_handler(  # type: ignore
-        signalnum,
-        frame: FrameType,  # pylint: disable=unused-argument
-    ) -> None:
-        """Exit handler to be registered with signal.signal.
-
-        When called will reset signal handler to original signal handler from
-        default_handlers.
-        """
-        # Reset to default handler
-        signal(signalnum, default_handlers[signalnum])
-
-        event_res = event(event_type=event_type)
-
-        for grpc_server in grpc_servers:
-            grpc_server.stop(grace=1)
-
-        for bckg_thread in bckg_threads:
-            bckg_thread.join()
-
-        # Ensure event has happend
-        event_res.result()
-
-        # Setup things for graceful exit
-        sys.exit(0)
-
-    default_handlers[SIGINT] = signal(  # type: ignore
-        SIGINT,
-        graceful_exit_handler,  # type: ignore
-    )
-    default_handlers[SIGTERM] = signal(  # type: ignore
-        SIGTERM,
-        graceful_exit_handler,  # type: ignore
-    )
-
-
 def _run_driver_api_grpc(
     address: str,
     state_factory: StateFactory,

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/server/driver/driver.py

@@ -44,6 +44,7 @@ class Driver:
         Tuple containing root certificate, server certificate, and private key
         to start a secure SSL-enabled server. The tuple is expected to have
         three bytes elements in the following order:
+
             * CA certificate.
             * server certificate.
             * server private key.

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/server/strategy/__init__.py

@@ -16,7 +16,10 @@
 
 
 from .bulyan import Bulyan as Bulyan
-from .dp_fixed_clipping import DifferentialPrivacyServerSideFixedClipping
+from .dp_fixed_clipping import (
+    DifferentialPrivacyClientSideFixedClipping,
+    DifferentialPrivacyServerSideFixedClipping,
+)
 from .dpfedavg_adaptive import DPFedAvgAdaptive as DPFedAvgAdaptive
 from .dpfedavg_fixed import DPFedAvgFixed as DPFedAvgFixed
 from .fault_tolerant_fedavg import FaultTolerantFedAvg as FaultTolerantFedAvg
@@ -59,4 +62,5 @@ __all__ = [
     "DPFedAvgFixed",
     "Strategy",
     "DifferentialPrivacyServerSideFixedClipping",
+    "DifferentialPrivacyClientSideFixedClipping",
 ]

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/server/strategy/dp_fixed_clipping.py

@@ -36,7 +36,10 @@ from flwr.common.differential_privacy import (
     add_gaussian_noise_to_params,
     compute_clip_model_update,
 )
-from flwr.common.differential_privacy_constants import CLIENTS_DISCREPANCY_WARNING
+from flwr.common.differential_privacy_constants import (
+    CLIENTS_DISCREPANCY_WARNING,
+    KEY_CLIPPING_NORM,
+)
 from flwr.common.logger import log
 from flwr.server.client_manager import ClientManager
 from flwr.server.client_proxy import ClientProxy
@@ -44,7 +47,8 @@ from flwr.server.strategy.strategy import Strategy
 
 
 class DifferentialPrivacyServerSideFixedClipping(Strategy):
-    """Wrapper for Central DP with Server Side Fixed Clipping.
+    """Strategy wrapper for central differential privacy with server-side fixed
+    clipping.
 
     Parameters
     ----------
@@ -185,3 +189,153 @@ class DifferentialPrivacyServerSideFixedClipping(Strategy):
     ) -> Optional[Tuple[float, Dict[str, Scalar]]]:
         """Evaluate model parameters using an evaluation function from the strategy."""
         return self.strategy.evaluate(server_round, parameters)
+
+
+class DifferentialPrivacyClientSideFixedClipping(Strategy):
+    """Strategy wrapper for central differential privacy with client-side fixed
+    clipping.
+
+    Use `fixedclipping_mod` modifier at the client side.
+
+    In comparison to `DifferentialPrivacyServerSideFixedClipping`,
+    which performs clipping on the server-side, `DifferentialPrivacyClientSideFixedClipping`
+    expects clipping to happen on the client-side, usually by using the built-in
+    `fixedclipping_mod `.
+
+    Parameters
+    ----------
+    strategy : Strategy
+        The strategy to which DP functionalities will be added by this wrapper.
+    noise_multiplier : float
+        The noise multiplier for the Gaussian mechanism for model updates.
+        A value of 1.0 or higher is recommended for strong privacy.
+    clipping_norm : float
+        The value of the clipping norm.
+    num_sampled_clients : int
+        The number of clients that are sampled on each round.
+
+    Examples
+    --------
+    Create a strategy:
+
+    >>> strategy = fl.server.strategy.FedAvg(...)
+
+    Wrap the strategy with the `DifferentialPrivacyServerSideFixedClipping` wrapper:
+
+    >>> DifferentialPrivacyClientSideFixedClipping(
+    >>>     strategy, cfg.noise_multiplier, cfg.clipping_norm, cfg.num_sampled_clients
+    >>> )
+
+    On the client, add the `fixedclipping_mod` to the client-side mods:
+
+    >>> app = fl.client.ClientApp(
+    >>>     client_fn=FlowerClient().to_client(), mods=[fixedclipping_mod]
+    >>> )
+    """
+
+    # pylint: disable=too-many-arguments,too-many-instance-attributes
+    def __init__(
+        self,
+        strategy: Strategy,
+        noise_multiplier: float,
+        clipping_norm: float,
+        num_sampled_clients: int,
+    ) -> None:
+        super().__init__()
+
+        self.strategy = strategy
+
+        if noise_multiplier < 0:
+            raise ValueError("The noise multiplier should be a non-negative value.")
+
+        if clipping_norm <= 0:
+            raise ValueError("The clipping threshold should be a positive value.")
+
+        if num_sampled_clients <= 0:
+            raise ValueError(
+                "The number of sampled clients should be a positive value."
+            )
+
+        self.noise_multiplier = noise_multiplier
+        self.clipping_norm = clipping_norm
+        self.num_sampled_clients = num_sampled_clients
+
+    def __repr__(self) -> str:
+        """Compute a string representation of the strategy."""
+        rep = "Differential Privacy Strategy Wrapper (Client-Side Fixed Clipping)"
+        return rep
+
+    def initialize_parameters(
+        self, client_manager: ClientManager
+    ) -> Optional[Parameters]:
+        """Initialize global model parameters using given strategy."""
+        return self.strategy.initialize_parameters(client_manager)
+
+    def configure_fit(
+        self, server_round: int, parameters: Parameters, client_manager: ClientManager
+    ) -> List[Tuple[ClientProxy, FitIns]]:
+        """Configure the next round of training."""
+        additional_config = {KEY_CLIPPING_NORM: self.clipping_norm}
+        inner_strategy_config_result = self.strategy.configure_fit(
+            server_round, parameters, client_manager
+        )
+        for _, fit_ins in inner_strategy_config_result:
+            fit_ins.config.update(additional_config)
+
+        return inner_strategy_config_result
+
+    def configure_evaluate(
+        self, server_round: int, parameters: Parameters, client_manager: ClientManager
+    ) -> List[Tuple[ClientProxy, EvaluateIns]]:
+        """Configure the next round of evaluation."""
+        return self.strategy.configure_evaluate(
+            server_round, parameters, client_manager
+        )
+
+    def aggregate_fit(
+        self,
+        server_round: int,
+        results: List[Tuple[ClientProxy, FitRes]],
+        failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
+    ) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
+        """Add noise to the aggregated parameters."""
+        if failures:
+            return None, {}
+
+        if len(results) != self.num_sampled_clients:
+            log(
+                WARNING,
+                CLIENTS_DISCREPANCY_WARNING,
+                len(results),
+                self.num_sampled_clients,
+            )
+
+        # Pass the new parameters for aggregation
+        aggregated_params, metrics = self.strategy.aggregate_fit(
+            server_round, results, failures
+        )
+
+        # Add Gaussian noise to the aggregated parameters
+        if aggregated_params:
+            aggregated_params = add_gaussian_noise_to_params(
+                aggregated_params,
+                self.noise_multiplier,
+                self.clipping_norm,
+                self.num_sampled_clients,
+            )
+        return aggregated_params, metrics
+
+    def aggregate_evaluate(
+        self,
+        server_round: int,
+        results: List[Tuple[ClientProxy, EvaluateRes]],
+        failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
+    ) -> Tuple[Optional[float], Dict[str, Scalar]]:
+        """Aggregate evaluation losses using the given strategy."""
+        return self.strategy.aggregate_evaluate(server_round, results, failures)
+
+    def evaluate(
+        self, server_round: int, parameters: Parameters
+    ) -> Optional[Tuple[float, Dict[str, Scalar]]]:
+        """Evaluate model parameters using an evaluation function from the strategy."""
+        return self.strategy.evaluate(server_round, parameters)

{flwr_nightly-1.8.0.dev20240223 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/server/superlink/fleet/vce/backend/backend.py

@@ -18,7 +18,7 @@
 from abc import ABC, abstractmethod
 from typing import Callable, Dict, Tuple
 
-from flwr.client.clientapp import ClientApp
+from flwr.client.client_app import ClientApp
 from flwr.common.context import Context
 from flwr.common.message import Message
 from flwr.common.typing import ConfigsRecordValues
@@ -53,6 +53,10 @@ class Backend(ABC):
     def is_worker_idle(self) -> bool:
         """Report whether a backend worker is idle and can therefore run a ClientApp."""
 
+    @abstractmethod
+    async def terminate(self) -> None:
+        """Terminate backend."""
+
     @abstractmethod
     async def process_message(
         self,