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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.8.0.dev20240226
+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.dev20240226 → 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-dev20240226"
+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.dev20240226 → 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.dev20240226 → 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.dev20240226 → 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.dev20240226 → 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.dev20240226 → 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.dev20240226 → 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.dev20240226 → 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.dev20240226 → 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

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

@@ -15,10 +15,12 @@
 """Ray backend for the Fleet API using the Simulation Engine."""
 
 import pathlib
-from logging import INFO
+from logging import ERROR, INFO
 from typing import Callable, Dict, List, Tuple, Union
 
-from flwr.client.clientapp import ClientApp
+import ray
+
+from flwr.client.client_app import ClientApp, LoadClientAppError
 from flwr.common.context import Context
 from flwr.common.logger import log
 from flwr.common.message import Message
@@ -46,6 +48,9 @@ class RayBackend(Backend):
         log(INFO, "Initialising: %s", self.__class__.__name__)
         log(INFO, "Backend config: %s", backend_config)
 
+        if not pathlib.Path(work_dir).exists():
+            raise ValueError(f"Specified work_dir {work_dir} does not exist.")
+
         # Init ray and append working dir if needed
         runtime_env = (
             self._configure_runtime_env(work_dir=work_dir) if work_dir else None
@@ -138,22 +143,34 @@ class RayBackend(Backend):
         """
         node_id = message.metadata.dst_node_id
 
-        # Submite a task to the pool
-        future = await self.pool.submit(
-            lambda a, a_fn, mssg, cid, state: a.run.remote(a_fn, mssg, cid, state),
-            (app, message, str(node_id), context),
-        )
+        try:
+            # Submite a task to the pool
+            future = await self.pool.submit(
+                lambda a, a_fn, mssg, cid, state: a.run.remote(a_fn, mssg, cid, state),
+                (app, message, str(node_id), context),
+            )
 
-        await future
+            await future
 
-        # Fetch result
-        (
-            out_mssg,
-            updated_context,
-        ) = await self.pool.fetch_result_and_return_actor_to_pool(future)
+            # Fetch result
+            (
+                out_mssg,
+                updated_context,
+            ) = await self.pool.fetch_result_and_return_actor_to_pool(future)
 
-        return out_mssg, updated_context
+            return out_mssg, updated_context
+
+        except LoadClientAppError as load_ex:
+            log(
+                ERROR,
+                "An exception was raised when processing a message. Terminating %s",
+                self.__class__.__name__,
+            )
+            await self.terminate()
+            raise load_ex
 
     async def terminate(self) -> None:
         """Terminate all actors in actor pool."""
         await self.pool.terminate_all_actors()
+        ray.shutdown()
+        log(INFO, "Terminated %s", self.__class__.__name__)

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

@@ -19,7 +19,7 @@ import json
 from logging import ERROR, INFO
 from typing import Dict, Optional
 
-from flwr.client.clientapp import ClientApp, load_client_app
+from flwr.client.client_app import ClientApp, load_client_app
 from flwr.client.node_state import NodeState
 from flwr.common.logger import log
 from flwr.server.superlink.state import StateFactory

{flwr_nightly-1.8.0.dev20240226 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/simulation/ray_transport/ray_actor.py

@@ -25,7 +25,7 @@ import ray
 from ray import ObjectRef
 from ray.util.actor_pool import ActorPool
 
-from flwr.client.clientapp import ClientApp
+from flwr.client.client_app import ClientApp, LoadClientAppError
 from flwr.common import Context, Message
 from flwr.common.logger import log
 
@@ -67,6 +67,9 @@ class VirtualClientEngineActor(ABC):
             # Handle task message
             out_message = app(message=message, context=context)
 
+        except LoadClientAppError as load_ex:
+            raise load_ex
+
         except Exception as ex:
             client_trace = traceback.format_exc()
             mssg = (

{flwr_nightly-1.8.0.dev20240226 → flwr_nightly-1.8.0.dev20240227}/src/py/flwr/simulation/ray_transport/ray_client_proxy.py

@@ -21,7 +21,7 @@ from typing import Optional
 
 from flwr import common
 from flwr.client import ClientFn
-from flwr.client.clientapp import ClientApp
+from flwr.client.client_app import ClientApp
 from flwr.client.node_state import NodeState
 from flwr.common import Message, Metadata, RecordSet
 from flwr.common.constant import (