flwr-nightly 1.15.0.dev20250109__tar.gz → 1.15.0.dev20250110__tar.gz

{flwr_nightly-1.15.0.dev20250109 → flwr_nightly-1.15.0.dev20250110}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.15.0.dev20250109
+Version: 1.15.0.dev20250110
 Summary: Flower: A Friendly Federated AI Framework
 Home-page: https://flower.ai
 License: Apache-2.0

{flwr_nightly-1.15.0.dev20250109 → flwr_nightly-1.15.0.dev20250110}/pyproject.toml

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

{flwr_nightly-1.15.0.dev20250109 → flwr_nightly-1.15.0.dev20250110}/src/py/flwr/client/app.py

@@ -15,13 +15,14 @@
 """Flower client app."""
 
 
+import multiprocessing
 import signal
-import subprocess
 import sys
 import time
 from contextlib import AbstractContextManager
 from dataclasses import dataclass
 from logging import ERROR, INFO, WARN
+from os import urandom
 from pathlib import Path
 from typing import Callable, Optional, Union, cast
 
@@ -33,6 +34,7 @@ from flwr.cli.config_utils import get_fab_metadata
 from flwr.cli.install import install_from_fab
 from flwr.client.client import Client
 from flwr.client.client_app import ClientApp, LoadClientAppError
+from flwr.client.clientapp.app import flwr_clientapp
 from flwr.client.nodestate.nodestate_factory import NodeStateFactory
 from flwr.client.typing import ClientFnExt
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH, Context, EventType, Message, event
@@ -53,13 +55,12 @@ from flwr.common.constant import (
     TRANSPORT_TYPES,
     ErrorCode,
 )
+from flwr.common.grpc import generic_create_grpc_server
 from flwr.common.logger import log, warn_deprecated_feature
 from flwr.common.message import Error
 from flwr.common.retry_invoker import RetryInvoker, RetryState, exponential
 from flwr.common.typing import Fab, Run, RunNotRunningException, UserConfig
 from flwr.proto.clientappio_pb2_grpc import add_ClientAppIoServicer_to_server
-from flwr.server.superlink.fleet.grpc_bidi.grpc_server import generic_create_grpc_server
-from flwr.server.superlink.linkstate.utils import generate_rand_int_from_bytes
 
 from .clientapp.clientappio_servicer import ClientAppInputs, ClientAppIoServicer
 from .grpc_adapter_client.connection import grpc_adapter
@@ -391,6 +392,7 @@ def start_client_internal(
     run_info_store: Optional[DeprecatedRunInfoStore] = None
     state_factory = NodeStateFactory()
     state = state_factory.state()
+    mp_spawn_context = multiprocessing.get_context("spawn")
 
     runs: dict[int, Run] = {}
 
@@ -513,7 +515,7 @@ def start_client_internal(
                             #    Docker container.
 
                             # Generate SuperNode token
-                            token: int = generate_rand_int_from_bytes(RUN_ID_NUM_BYTES)
+                            token = int.from_bytes(urandom(RUN_ID_NUM_BYTES), "little")
 
                             # Mode 1: SuperNode starts ClientApp as subprocess
                             start_subprocess = isolation == ISOLATION_MODE_SUBPROCESS
@@ -549,12 +551,13 @@ def start_client_internal(
                                 ]
                                 command.append("--insecure")
 
-                                subprocess.run(
-                                    command,
-                                    stdout=None,
-                                    stderr=None,
-                                    check=True,
+                                proc = mp_spawn_context.Process(
+                                    target=_run_flwr_clientapp,
+                                    args=(command,),
+                                    daemon=True,
                                 )
+                                proc.start()
+                                proc.join()
                             else:
                                 # Wait for output to become available
                                 while not clientappio_servicer.has_outputs():
@@ -826,6 +829,11 @@ class _AppStateTracker:
         signal.signal(signal.SIGTERM, signal_handler)
 
 
+def _run_flwr_clientapp(args: list[str]) -> None:
+    sys.argv = args
+    flwr_clientapp()
+
+
 def run_clientappio_api_grpc(
     address: str,
     certificates: Optional[tuple[bytes, bytes, bytes]],

flwr_nightly-1.15.0.dev20250109/src/py/flwr/server/superlink/fleet/grpc_bidi/grpc_server.py → flwr_nightly-1.15.0.dev20250110/src/py/flwr/common/grpc.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2022 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.
@@ -12,32 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Implements utility function to create a gRPC server."""
+"""Utility functions for gRPC."""
 
 
 import concurrent.futures
 import sys
 from collections.abc import Sequence
-from logging import ERROR
-from typing import Any, Callable, Optional, Union
+from logging import DEBUG, ERROR
+from typing import Any, Callable, Optional
 
 import grpc
 
-from flwr.common import GRPC_MAX_MESSAGE_LENGTH
-from flwr.common.address import is_port_in_use
-from flwr.common.logger import log
-from flwr.proto.transport_pb2_grpc import (  # pylint: disable=E0611
-    add_FlowerServiceServicer_to_server,
-)
-from flwr.server.client_manager import ClientManager
-from flwr.server.superlink.driver.serverappio_servicer import ServerAppIoServicer
-from flwr.server.superlink.fleet.grpc_adapter.grpc_adapter_servicer import (
-    GrpcAdapterServicer,
-)
-from flwr.server.superlink.fleet.grpc_bidi.flower_service_servicer import (
-    FlowerServiceServicer,
-)
-from flwr.server.superlink.fleet.grpc_rere.fleet_servicer import FleetServicer
+from .address import is_port_in_use
+from .logger import log
+
+GRPC_MAX_MESSAGE_LENGTH: int = 536_870_912  # == 512 * 1024 * 1024
 
 INVALID_CERTIFICATES_ERR_MSG = """
     When setting any of root_certificate, certificate, or private_key,
@@ -47,122 +36,63 @@ INVALID_CERTIFICATES_ERR_MSG = """
 AddServicerToServerFn = Callable[..., Any]
 
 
-def valid_certificates(certificates: tuple[bytes, bytes, bytes]) -> bool:
-    """Validate certificates tuple."""
-    is_valid = (
-        all(isinstance(certificate, bytes) for certificate in certificates)
-        and len(certificates) == 3
-    )
-
-    if not is_valid:
-        log(ERROR, INVALID_CERTIFICATES_ERR_MSG)
-
-    return is_valid
-
-
-def start_grpc_server(  # pylint: disable=too-many-arguments,R0917
-    client_manager: ClientManager,
+def create_channel(
     server_address: str,
-    max_concurrent_workers: int = 1000,
+    insecure: bool,
+    root_certificates: Optional[bytes] = None,
     max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
-    keepalive_time_ms: int = 210000,
-    certificates: Optional[tuple[bytes, bytes, bytes]] = None,
-) -> grpc.Server:
-    """Create and start a gRPC server running FlowerServiceServicer.
-
-    If used in a main function server.wait_for_termination(timeout=None)
-    should be called as otherwise the server will immediately stop.
-
-    **SSL**
-    To enable SSL you have to pass all of root_certificate, certificate,
-    and private_key. Setting only some will make the process exit with code 1.
-
-    Parameters
-    ----------
-    client_manager : ClientManager
-        Instance of ClientManager
-    server_address : str
-        Server address in the form of HOST:PORT e.g. "[::]:8080"
-    max_concurrent_workers : int
-        Maximum number of clients the server can process before returning
-        RESOURCE_EXHAUSTED status (default: 1000)
-    max_message_length : int
-        Maximum message length that the server can send or receive.
-        Int valued in bytes. -1 means unlimited. (default: GRPC_MAX_MESSAGE_LENGTH)
-    keepalive_time_ms : int
-        Flower uses a default gRPC keepalive time of 210000ms (3 minutes 30 seconds)
-        because some cloud providers (for example, Azure) agressively clean up idle
-        TCP connections by terminating them after some time (4 minutes in the case
-        of Azure). Flower does not use application-level keepalive signals and relies
-        on the assumption that the transport layer will fail in cases where the
-        connection is no longer active. `keepalive_time_ms` can be used to customize
-        the keepalive interval for specific environments. The default Flower gRPC
-        keepalive of 210000 ms (3 minutes 30 seconds) ensures that Flower can keep
-        the long running streaming connection alive in most environments. The actual
-        gRPC default of this setting is 7200000 (2 hours), which results in dropped
-        connections in some cloud environments.
-
-        These settings are related to the issue described here:
-        - https://github.com/grpc/proposal/blob/master/A8-client-side-keepalive.md
-        - https://github.com/grpc/grpc/blob/master/doc/keepalive.md
-        - https://grpc.io/docs/guides/performance/
+    interceptors: Optional[Sequence[grpc.UnaryUnaryClientInterceptor]] = None,
+) -> grpc.Channel:
+    """Create a gRPC channel, either secure or insecure."""
+    # Check for conflicting parameters
+    if insecure and root_certificates is not None:
+        raise ValueError(
+            "Invalid configuration: 'root_certificates' should not be provided "
+            "when 'insecure' is set to True. For an insecure connection, omit "
+            "'root_certificates', or set 'insecure' to False for a secure connection."
+        )
 
-        Mobile Flower clients may choose to increase this value if their server
-        environment allows long-running idle TCP connections.
-        (default: 210000)
-    certificates : Tuple[bytes, bytes, bytes] (default: None)
-        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:
+    # Possible options:
+    # https://github.com/grpc/grpc/blob/v1.43.x/include/grpc/impl/codegen/grpc_types.h
+    channel_options = [
+        ("grpc.max_send_message_length", max_message_length),
+        ("grpc.max_receive_message_length", max_message_length),
+    ]
 
-            * CA certificate.
-            * server certificate.
-            * server private key.
+    if insecure:
+        channel = grpc.insecure_channel(server_address, options=channel_options)
+        log(DEBUG, "Opened insecure gRPC connection (no certificates were passed)")
+    else:
+        try:
+            ssl_channel_credentials = grpc.ssl_channel_credentials(root_certificates)
+        except Exception as e:
+            raise ValueError(f"Failed to create SSL channel credentials: {e}") from e
+        channel = grpc.secure_channel(
+            server_address, ssl_channel_credentials, options=channel_options
+        )
+        log(DEBUG, "Opened secure gRPC connection using certificates")
 
-    Returns
-    -------
-    server : grpc.Server
-        An instance of a gRPC server which is already started
+    if interceptors is not None:
+        channel = grpc.intercept_channel(channel, interceptors)
 
-    Examples
-    --------
-    Starting a SSL-enabled server.
+    return channel
 
-    >>> from pathlib import Path
-    >>> start_grpc_server(
-    >>>     client_manager=ClientManager(),
-    >>>     server_address="localhost:8080",
-    >>>     certificates=(
-    >>>         Path("/crts/root.pem").read_bytes(),
-    >>>         Path("/crts/localhost.crt").read_bytes(),
-    >>>         Path("/crts/localhost.key").read_bytes(),
-    >>>     ),
-    >>> )
-    """
-    servicer = FlowerServiceServicer(client_manager)
-    add_servicer_to_server_fn = add_FlowerServiceServicer_to_server
 
-    server = generic_create_grpc_server(
-        servicer_and_add_fn=(servicer, add_servicer_to_server_fn),
-        server_address=server_address,
-        max_concurrent_workers=max_concurrent_workers,
-        max_message_length=max_message_length,
-        keepalive_time_ms=keepalive_time_ms,
-        certificates=certificates,
+def valid_certificates(certificates: tuple[bytes, bytes, bytes]) -> bool:
+    """Validate certificates tuple."""
+    is_valid = (
+        all(isinstance(certificate, bytes) for certificate in certificates)
+        and len(certificates) == 3
     )
 
-    server.start()
+    if not is_valid:
+        log(ERROR, INVALID_CERTIFICATES_ERR_MSG)
 
-    return server
+    return is_valid
 
 
 def generic_create_grpc_server(  # pylint: disable=too-many-arguments,R0917
-    servicer_and_add_fn: Union[
-        tuple[FleetServicer, AddServicerToServerFn],
-        tuple[GrpcAdapterServicer, AddServicerToServerFn],
-        tuple[FlowerServiceServicer, AddServicerToServerFn],
-        tuple[ServerAppIoServicer, AddServicerToServerFn],
-    ],
+    servicer_and_add_fn: tuple[Any, AddServicerToServerFn],
     server_address: str,
     max_concurrent_workers: int = 1000,
     max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,

{flwr_nightly-1.15.0.dev20250109 → flwr_nightly-1.15.0.dev20250110}/src/py/flwr/server/app.py

@@ -18,7 +18,8 @@
 import argparse
 import csv
 import importlib.util
-import subprocess
+import multiprocessing
+import multiprocessing.context
 import sys
 import threading
 from collections.abc import Sequence
@@ -59,6 +60,7 @@ from flwr.common.constant import (
     TRANSPORT_TYPE_REST,
 )
 from flwr.common.exit_handlers import register_exit_handlers
+from flwr.common.grpc import generic_create_grpc_server
 from flwr.common.logger import log, warn_deprecated_feature
 from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
     private_key_to_bytes,
@@ -68,6 +70,8 @@ from flwr.proto.fleet_pb2_grpc import (  # pylint: disable=E0611
     add_FleetServicer_to_server,
 )
 from flwr.proto.grpcadapter_pb2_grpc import add_GrpcAdapterServicer_to_server
+from flwr.server.serverapp.app import flwr_serverapp
+from flwr.simulation.app import flwr_simulation
 from flwr.superexec.app import load_executor
 from flwr.superexec.exec_grpc import run_exec_api_grpc
 
@@ -79,10 +83,7 @@ from .strategy import Strategy
 from .superlink.driver.serverappio_grpc import run_serverappio_api_grpc
 from .superlink.ffs.ffs_factory import FfsFactory
 from .superlink.fleet.grpc_adapter.grpc_adapter_servicer import GrpcAdapterServicer
-from .superlink.fleet.grpc_bidi.grpc_server import (
-    generic_create_grpc_server,
-    start_grpc_server,
-)
+from .superlink.fleet.grpc_bidi.grpc_server import start_grpc_server
 from .superlink.fleet.grpc_rere.fleet_servicer import FleetServicer
 from .superlink.fleet.grpc_rere.server_interceptor import AuthenticateServerInterceptor
 from .superlink.linkstate import LinkStateFactory
@@ -292,7 +293,7 @@ def run_superlink() -> None:
     # Determine Exec plugin
     # If simulation is used, don't start ServerAppIo and Fleet APIs
     sim_exec = executor.__class__.__qualname__ == "SimulationEngine"
-    bckg_threads = []
+    bckg_threads: list[threading.Thread] = []
 
     if sim_exec:
         simulationio_server: grpc.Server = run_simulationio_api_grpc(
@@ -360,6 +361,7 @@ def run_superlink() -> None:
                     ffs_factory,
                     num_workers,
                 ),
+                daemon=True,
             )
             fleet_thread.start()
             bckg_threads.append(fleet_thread)
@@ -426,6 +428,7 @@ def run_superlink() -> None:
                 address,
                 cmd,
             ),
+            daemon=True,
         )
         scheduler_th.start()
         bckg_threads.append(scheduler_th)
@@ -434,16 +437,24 @@ def run_superlink() -> None:
     register_exit_handlers(
         event_type=EventType.RUN_SUPERLINK_LEAVE,
         grpc_servers=grpc_servers,
-        bckg_threads=bckg_threads,
     )
 
-    # Block
-    while True:
-        if bckg_threads:
-            for thread in bckg_threads:
-                if not thread.is_alive():
-                    sys.exit(1)
-        exec_server.wait_for_termination(timeout=1)
+    # Block until a thread exits prematurely
+    while all(thread.is_alive() for thread in bckg_threads):
+        sleep(0.1)
+
+    # Exit if any thread has exited prematurely
+    sys.exit(1)
+
+
+def _run_flwr_command(args: list[str]) -> None:
+    sys.argv = args
+    if args[0] == "flwr-serverapp":
+        flwr_serverapp()
+    elif args[0] == "flwr-simulation":
+        flwr_simulation()
+    else:
+        raise ValueError(f"Unknown command: {args[0]}")
 
 
 def _flwr_scheduler(
@@ -453,15 +464,18 @@ def _flwr_scheduler(
     cmd: str,
 ) -> None:
     log(DEBUG, "Started %s scheduler thread.", cmd)
-
     state = state_factory.state()
+    run_id_to_proc: dict[int, multiprocessing.context.SpawnProcess] = {}
+
+    # Use the "spawn" start method for multiprocessing.
+    mp_spawn_context = multiprocessing.get_context("spawn")
 
     # Periodically check for a pending run in the LinkState
     while True:
-        sleep(3)
+        sleep(0.1)
         pending_run_id = state.get_pending_run_id()
 
-        if pending_run_id:
+        if pending_run_id and pending_run_id not in run_id_to_proc:
 
             log(
                 INFO,
@@ -478,10 +492,18 @@ def _flwr_scheduler(
                 "--insecure",
             ]
 
-            subprocess.Popen(  # pylint: disable=consider-using-with
-                command,
-                text=True,
+            proc = mp_spawn_context.Process(
+                target=_run_flwr_command, args=(command,), daemon=True
             )
+            proc.start()
+
+            # Store the process
+            run_id_to_proc[pending_run_id] = proc
+
+        # Clean up finished processes
+        for run_id, proc in list(run_id_to_proc.items()):
+            if not proc.is_alive():
+                del run_id_to_proc[run_id]
 
 
 def _format_address(address: str) -> tuple[str, str, int]:

{flwr_nightly-1.15.0.dev20250109 → flwr_nightly-1.15.0.dev20250110}/src/py/flwr/server/superlink/driver/serverappio_grpc.py

@@ -21,6 +21,7 @@ from typing import Optional
 import grpc
 
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
+from flwr.common.grpc import generic_create_grpc_server
 from flwr.common.logger import log
 from flwr.proto.serverappio_pb2_grpc import (  # pylint: disable=E0611
     add_ServerAppIoServicer_to_server,
@@ -28,7 +29,6 @@ from flwr.proto.serverappio_pb2_grpc import (  # pylint: disable=E0611
 from flwr.server.superlink.ffs.ffs_factory import FfsFactory
 from flwr.server.superlink.linkstate import LinkStateFactory
 
-from ..fleet.grpc_bidi.grpc_server import generic_create_grpc_server
 from .serverappio_servicer import ServerAppIoServicer
 
 

flwr_nightly-1.15.0.dev20250110/src/py/flwr/server/superlink/fleet/grpc_bidi/grpc_server.py

@@ -0,0 +1,126 @@
+# 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.
+# ==============================================================================
+"""Implements utility function to create a gRPC server."""
+
+
+from typing import Optional
+
+import grpc
+
+from flwr.common import GRPC_MAX_MESSAGE_LENGTH
+from flwr.common.grpc import generic_create_grpc_server
+from flwr.proto.transport_pb2_grpc import (  # pylint: disable=E0611
+    add_FlowerServiceServicer_to_server,
+)
+from flwr.server.client_manager import ClientManager
+from flwr.server.superlink.fleet.grpc_bidi.flower_service_servicer import (
+    FlowerServiceServicer,
+)
+
+
+def start_grpc_server(  # pylint: disable=too-many-arguments,R0917
+    client_manager: ClientManager,
+    server_address: str,
+    max_concurrent_workers: int = 1000,
+    max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
+    keepalive_time_ms: int = 210000,
+    certificates: Optional[tuple[bytes, bytes, bytes]] = None,
+) -> grpc.Server:
+    """Create and start a gRPC server running FlowerServiceServicer.
+
+    If used in a main function server.wait_for_termination(timeout=None)
+    should be called as otherwise the server will immediately stop.
+
+    **SSL**
+    To enable SSL you have to pass all of root_certificate, certificate,
+    and private_key. Setting only some will make the process exit with code 1.
+
+    Parameters
+    ----------
+    client_manager : ClientManager
+        Instance of ClientManager
+    server_address : str
+        Server address in the form of HOST:PORT e.g. "[::]:8080"
+    max_concurrent_workers : int
+        Maximum number of clients the server can process before returning
+        RESOURCE_EXHAUSTED status (default: 1000)
+    max_message_length : int
+        Maximum message length that the server can send or receive.
+        Int valued in bytes. -1 means unlimited. (default: GRPC_MAX_MESSAGE_LENGTH)
+    keepalive_time_ms : int
+        Flower uses a default gRPC keepalive time of 210000ms (3 minutes 30 seconds)
+        because some cloud providers (for example, Azure) agressively clean up idle
+        TCP connections by terminating them after some time (4 minutes in the case
+        of Azure). Flower does not use application-level keepalive signals and relies
+        on the assumption that the transport layer will fail in cases where the
+        connection is no longer active. `keepalive_time_ms` can be used to customize
+        the keepalive interval for specific environments. The default Flower gRPC
+        keepalive of 210000 ms (3 minutes 30 seconds) ensures that Flower can keep
+        the long running streaming connection alive in most environments. The actual
+        gRPC default of this setting is 7200000 (2 hours), which results in dropped
+        connections in some cloud environments.
+
+        These settings are related to the issue described here:
+        - https://github.com/grpc/proposal/blob/master/A8-client-side-keepalive.md
+        - https://github.com/grpc/grpc/blob/master/doc/keepalive.md
+        - https://grpc.io/docs/guides/performance/
+
+        Mobile Flower clients may choose to increase this value if their server
+        environment allows long-running idle TCP connections.
+        (default: 210000)
+    certificates : Tuple[bytes, bytes, bytes] (default: None)
+        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.
+
+    Returns
+    -------
+    server : grpc.Server
+        An instance of a gRPC server which is already started
+
+    Examples
+    --------
+    Starting a SSL-enabled server.
+
+    >>> from pathlib import Path
+    >>> start_grpc_server(
+    >>>     client_manager=ClientManager(),
+    >>>     server_address="localhost:8080",
+    >>>     certificates=(
+    >>>         Path("/crts/root.pem").read_bytes(),
+    >>>         Path("/crts/localhost.crt").read_bytes(),
+    >>>         Path("/crts/localhost.key").read_bytes(),
+    >>>     ),
+    >>> )
+    """
+    servicer = FlowerServiceServicer(client_manager)
+    add_servicer_to_server_fn = add_FlowerServiceServicer_to_server
+
+    server = generic_create_grpc_server(
+        servicer_and_add_fn=(servicer, add_servicer_to_server_fn),
+        server_address=server_address,
+        max_concurrent_workers=max_concurrent_workers,
+        max_message_length=max_message_length,
+        keepalive_time_ms=keepalive_time_ms,
+        certificates=certificates,
+    )
+
+    server.start()
+
+    return server

{flwr_nightly-1.15.0.dev20250109 → flwr_nightly-1.15.0.dev20250110}/src/py/flwr/server/superlink/simulation/simulationio_grpc.py

@@ -21,6 +21,7 @@ from typing import Optional
 import grpc
 
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
+from flwr.common.grpc import generic_create_grpc_server
 from flwr.common.logger import log
 from flwr.proto.simulationio_pb2_grpc import (  # pylint: disable=E0611
     add_SimulationIoServicer_to_server,
@@ -28,7 +29,6 @@ from flwr.proto.simulationio_pb2_grpc import (  # pylint: disable=E0611
 from flwr.server.superlink.ffs.ffs_factory import FfsFactory
 from flwr.server.superlink.linkstate import LinkStateFactory
 
-from ..fleet.grpc_bidi.grpc_server import generic_create_grpc_server
 from .simulationio_servicer import SimulationIoServicer
 
 

{flwr_nightly-1.15.0.dev20250109 → flwr_nightly-1.15.0.dev20250110}/src/py/flwr/superexec/exec_grpc.py

@@ -23,11 +23,11 @@ import grpc
 
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
 from flwr.common.auth_plugin import ExecAuthPlugin
+from flwr.common.grpc import generic_create_grpc_server
 from flwr.common.logger import log
 from flwr.common.typing import UserConfig
 from flwr.proto.exec_pb2_grpc import add_ExecServicer_to_server
 from flwr.server.superlink.ffs.ffs_factory import FfsFactory
-from flwr.server.superlink.fleet.grpc_bidi.grpc_server import generic_create_grpc_server
 from flwr.server.superlink.linkstate import LinkStateFactory
 from flwr.superexec.exec_user_auth_interceptor import ExecUserAuthInterceptor