flwr-nightly 1.9.0.dev20240606__tar.gz → 1.9.0.dev20240608__tar.gz

{flwr_nightly-1.9.0.dev20240606 → flwr_nightly-1.9.0.dev20240608}/PKG-INFO

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

{flwr_nightly-1.9.0.dev20240606 → flwr_nightly-1.9.0.dev20240608}/pyproject.toml

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

{flwr_nightly-1.9.0.dev20240606 → flwr_nightly-1.9.0.dev20240608}/src/py/flwr/client/__init__.py

@@ -28,6 +28,7 @@ __all__ = [
     "Client",
     "ClientApp",
     "ClientFn",
+    "mod",
     "NumPyClient",
     "run_client_app",
     "run_supernode",

{flwr_nightly-1.9.0.dev20240606 → flwr_nightly-1.9.0.dev20240608}/src/py/flwr/client/app.py

@@ -14,8 +14,10 @@
 # ==============================================================================
 """Flower client app."""
 
+import signal
 import sys
 import time
+from dataclasses import dataclass
 from logging import DEBUG, ERROR, INFO, WARN
 from typing import Callable, ContextManager, Optional, Tuple, Type, Union
 
@@ -37,7 +39,7 @@ from flwr.common.constant import (
 )
 from flwr.common.logger import log, warn_deprecated_feature
 from flwr.common.message import Error
-from flwr.common.retry_invoker import RetryInvoker, exponential
+from flwr.common.retry_invoker import RetryInvoker, RetryState, exponential
 
 from .grpc_client.connection import grpc_connection
 from .grpc_rere_client.connection import grpc_request_response
@@ -263,6 +265,29 @@ def _start_client_internal(
         transport, server_address
     )
 
+    run_tracker = _RunTracker()
+
+    def _on_sucess(retry_state: RetryState) -> None:
+        if retry_state.tries > 1:
+            log(
+                INFO,
+                "Connection successful after %.2f seconds and %s tries.",
+                retry_state.elapsed_time,
+                retry_state.tries,
+            )
+            if run_tracker.create_node:
+                run_tracker.create_node()
+
+    def _on_backoff(retry_state: RetryState) -> None:
+        if retry_state.tries == 1:
+            log(WARN, "Connection attempt failed, retrying...")
+        else:
+            log(
+                DEBUG,
+                "Connection attempt failed, retrying in %.2f seconds",
+                retry_state.actual_wait,
+            )
+
     retry_invoker = RetryInvoker(
         wait_gen_factory=exponential,
         recoverable_exceptions=connection_error_type,
@@ -278,25 +303,8 @@ def _start_client_internal(
             if retry_state.tries > 1
             else None
         ),
-        on_success=lambda retry_state: (
-            log(
-                INFO,
-                "Connection successful after %.2f seconds and %s tries.",
-                retry_state.elapsed_time,
-                retry_state.tries,
-            )
-            if retry_state.tries > 1
-            else None
-        ),
-        on_backoff=lambda retry_state: (
-            log(WARN, "Connection attempt failed, retrying...")
-            if retry_state.tries == 1
-            else log(
-                DEBUG,
-                "Connection attempt failed, retrying in %.2f seconds",
-                retry_state.actual_wait,
-            )
-        ),
+        on_success=_on_sucess,
+        on_backoff=_on_backoff,
     )
 
     node_state = NodeState()
@@ -579,3 +587,20 @@ def _init_connection(transport: Optional[str], server_address: str) -> Tuple[
         )
 
     return connection, address, error_type
+
+
+@dataclass
+class _RunTracker:
+    create_node: Optional[Callable[[], None]] = None
+    interrupt: bool = False
+
+    def register_signal_handler(self) -> None:
+        """Register handlers for exit signals."""
+
+        def signal_handler(sig, frame):  # type: ignore
+            # pylint: disable=unused-argument
+            self.interrupt = True
+            raise StopIteration from None
+
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)

{flwr_nightly-1.9.0.dev20240606 → flwr_nightly-1.9.0.dev20240608}/src/py/flwr/client/mod/__init__.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Mods."""
+"""Flower Built-in Mods."""
 
 
 from .centraldp_mods import adaptiveclipping_mod, fixedclipping_mod

{flwr_nightly-1.9.0.dev20240606 → flwr_nightly-1.9.0.dev20240608}/src/py/flwr/client/supernode/app.py

@@ -30,11 +30,13 @@ from cryptography.hazmat.primitives.serialization import (
 from flwr.client.client_app import ClientApp, LoadClientAppError
 from flwr.common import EventType, event
 from flwr.common.exit_handlers import register_exit_handlers
-from flwr.common.logger import log
+from flwr.common.logger import log, warn_deprecated_feature
 from flwr.common.object_ref import load_app, validate
 
 from ..app import _start_client_internal
 
+ADDRESS_FLEET_API_GRPC_RERE = "0.0.0.0:9092"
+
 
 def run_supernode() -> None:
     """Run Flower SuperNode."""
@@ -63,6 +65,23 @@ def run_client_app() -> None:
 
     args = _parse_args_run_client_app().parse_args()
 
+    if args.server != ADDRESS_FLEET_API_GRPC_RERE:
+        warn = "Passing flag --server is deprecated. Use --superlink instead."
+        warn_deprecated_feature(warn)
+
+        if args.superlink != ADDRESS_FLEET_API_GRPC_RERE:
+            # if `--superlink` also passed, then
+            # warn user that this argument overrides what was passed with `--server`
+            log(
+                WARN,
+                "Both `--server` and `--superlink` were passed. "
+                "`--server` will be ignored. Connecting to the Superlink Fleet API "
+                "at %s.",
+                args.superlink,
+            )
+        else:
+            args.superlink = args.server
+
     root_certificates = _get_certificates(args)
     log(
         DEBUG,
@@ -73,7 +92,7 @@ def run_client_app() -> None:
     authentication_keys = _try_setup_client_authentication(args)
 
     _start_client_internal(
-        server_address=args.server,
+        server_address=args.superlink,
         load_client_app_fn=load_fn,
         transport="rest" if args.rest else "grpc-rere",
         root_certificates=root_certificates,
@@ -100,7 +119,7 @@ def _get_certificates(args: argparse.Namespace) -> Optional[bytes]:
             WARN,
             "Option `--insecure` was set. "
             "Starting insecure HTTP client connected to %s.",
-            args.server,
+            args.superlink,
         )
         root_certificates = None
     else:
@@ -114,7 +133,7 @@ def _get_certificates(args: argparse.Namespace) -> Optional[bytes]:
             DEBUG,
             "Starting secure HTTPS client connected to %s "
             "with the following certificates: %s.",
-            args.server,
+            args.superlink,
             cert_path,
         )
     return root_certificates
@@ -213,9 +232,14 @@ def _parse_args_common(parser: argparse.ArgumentParser) -> None:
     )
     parser.add_argument(
         "--server",
-        default="0.0.0.0:9092",
+        default=ADDRESS_FLEET_API_GRPC_RERE,
         help="Server address",
     )
+    parser.add_argument(
+        "--superlink",
+        default=ADDRESS_FLEET_API_GRPC_RERE,
+        help="SuperLink Fleet API (gRPC-rere) address (IPv4, IPv6, or a domain name)",
+    )
     parser.add_argument(
         "--max-retries",
         type=int,

{flwr_nightly-1.9.0.dev20240606 → flwr_nightly-1.9.0.dev20240608}/src/py/flwr/server/app.py

@@ -230,6 +230,7 @@ def run_driver_api() -> None:
     grpc_server.wait_for_termination()
 
 
+# pylint: disable=too-many-locals
 def run_fleet_api() -> None:
     """Run Flower server (Fleet API)."""
     log(INFO, "Starting Flower server (Fleet API)")
@@ -248,6 +249,25 @@ def run_fleet_api() -> None:
     grpc_servers = []
     bckg_threads = []
 
+    address_arg = args.fleet_api_address
+    parsed_address = parse_address(address_arg)
+    if not parsed_address:
+        sys.exit(f"Fleet IP address ({address_arg}) cannot be parsed.")
+    host, port, is_v6 = parsed_address
+    address = f"[{host}]:{port}" if is_v6 else f"{host}:{port}"
+
+    num_workers = args.fleet_api_num_workers
+    if num_workers != 1:
+        log(
+            WARN,
+            "The Fleet API currently supports only 1 worker. "
+            "You have specified %d workers. "
+            "Support for multiple workers will be added in future releases. "
+            "Proceeding with a single worker.",
+            args.fleet_api_num_workers,
+        )
+        num_workers = 1
+
     # Start Fleet API
     if args.fleet_api_type == TRANSPORT_TYPE_REST:
         if (
@@ -256,20 +276,19 @@ def run_fleet_api() -> None:
             and importlib.util.find_spec("uvicorn")
         ) is None:
             sys.exit(MISSING_EXTRA_REST)
-        address_arg = args.rest_fleet_api_address
-        parsed_address = parse_address(address_arg)
-        if not parsed_address:
-            sys.exit(f"Fleet IP address ({address_arg}) cannot be parsed.")
-        host, port, _ = parsed_address
+
+        _, ssl_certfile, ssl_keyfile = (
+            certificates if certificates is not None else (None, None, None)
+        )
         fleet_thread = threading.Thread(
             target=_run_fleet_api_rest,
             args=(
                 host,
                 port,
-                args.ssl_keyfile,
-                args.ssl_certfile,
+                ssl_keyfile,
+                ssl_certfile,
                 state_factory,
-                args.rest_fleet_api_workers,
+                num_workers,
             ),
         )
         fleet_thread.start()
@@ -314,11 +333,15 @@ def run_superlink() -> None:
     args = _parse_args_run_superlink().parse_args()
 
     # Parse IP address
-    parsed_address = parse_address(args.driver_api_address)
-    if not parsed_address:
+    parsed_driver_address = parse_address(args.driver_api_address)
+    if not parsed_driver_address:
         sys.exit(f"Driver IP address ({args.driver_api_address}) cannot be parsed.")
-    host, port, is_v6 = parsed_address
-    address = f"[{host}]:{port}" if is_v6 else f"{host}:{port}"
+    driver_host, driver_port, driver_is_v6 = parsed_driver_address
+    driver_address = (
+        f"[{driver_host}]:{driver_port}"
+        if driver_is_v6
+        else f"{driver_host}:{driver_port}"
+    )
 
     # Obtain certificates
     certificates = _try_obtain_certificates(args)
@@ -328,13 +351,38 @@ def run_superlink() -> None:
 
     # Start Driver API
     driver_server: grpc.Server = run_driver_api_grpc(
-        address=address,
+        address=driver_address,
         state_factory=state_factory,
         certificates=certificates,
     )
 
     grpc_servers = [driver_server]
     bckg_threads = []
+    if not args.fleet_api_address:
+        args.fleet_api_address = (
+            ADDRESS_FLEET_API_GRPC_RERE
+            if args.fleet_api_type == TRANSPORT_TYPE_GRPC_RERE
+            else ADDRESS_FLEET_API_REST
+        )
+    parsed_fleet_address = parse_address(args.fleet_api_address)
+    if not parsed_fleet_address:
+        sys.exit(f"Fleet IP address ({args.fleet_api_address}) cannot be parsed.")
+    fleet_host, fleet_port, fleet_is_v6 = parsed_fleet_address
+    fleet_address = (
+        f"[{fleet_host}]:{fleet_port}" if fleet_is_v6 else f"{fleet_host}:{fleet_port}"
+    )
+
+    num_workers = args.fleet_api_num_workers
+    if num_workers != 1:
+        log(
+            WARN,
+            "The Fleet API currently supports only 1 worker. "
+            "You have specified %d workers. "
+            "Support for multiple workers will be added in future releases. "
+            "Proceeding with a single worker.",
+            args.fleet_api_num_workers,
+        )
+        num_workers = 1
 
     # Start Fleet API
     if args.fleet_api_type == TRANSPORT_TYPE_REST:
@@ -344,35 +392,25 @@ def run_superlink() -> None:
             and importlib.util.find_spec("uvicorn")
         ) is None:
             sys.exit(MISSING_EXTRA_REST)
-        address_arg = args.rest_fleet_api_address
-        parsed_address = parse_address(address_arg)
+
         _, ssl_certfile, ssl_keyfile = (
             certificates if certificates is not None else (None, None, None)
         )
-        if not parsed_address:
-            sys.exit(f"Fleet IP address ({address_arg}) cannot be parsed.")
-        host, port, _ = parsed_address
+
         fleet_thread = threading.Thread(
             target=_run_fleet_api_rest,
             args=(
-                host,
-                port,
+                fleet_host,
+                fleet_port,
                 ssl_keyfile,
                 ssl_certfile,
                 state_factory,
-                args.rest_fleet_api_workers,
+                num_workers,
             ),
         )
         fleet_thread.start()
         bckg_threads.append(fleet_thread)
     elif args.fleet_api_type == TRANSPORT_TYPE_GRPC_RERE:
-        address_arg = args.grpc_rere_fleet_api_address
-        parsed_address = parse_address(address_arg)
-        if not parsed_address:
-            sys.exit(f"Fleet IP address ({address_arg}) cannot be parsed.")
-        host, port, is_v6 = parsed_address
-        address = f"[{host}]:{port}" if is_v6 else f"{host}:{port}"
-
         maybe_keys = _try_setup_client_authentication(args, certificates)
         interceptors: Optional[Sequence[grpc.ServerInterceptor]] = None
         if maybe_keys is not None:
@@ -395,7 +433,7 @@ def run_superlink() -> None:
             interceptors = [AuthenticateServerInterceptor(state)]
 
         fleet_server = _run_fleet_api_grpc_rere(
-            address=address,
+            address=fleet_address,
             state_factory=state_factory,
             certificates=certificates,
             interceptors=interceptors,
@@ -596,7 +634,7 @@ def _run_fleet_api_rest(
     ssl_keyfile: Optional[str],
     ssl_certfile: Optional[str],
     state_factory: StateFactory,
-    workers: int,
+    num_workers: int,
 ) -> None:
     """Run Driver API (REST-based)."""
     try:
@@ -605,12 +643,7 @@ def _run_fleet_api_rest(
         from flwr.server.superlink.fleet.rest_rere.rest_api import app as fast_api_app
     except ModuleNotFoundError:
         sys.exit(MISSING_EXTRA_REST)
-    if workers != 1:
-        raise ValueError(
-            f"The supported number of workers for the Fleet API (REST server) is "
-            f"1. Instead given {workers}. The functionality of >1 workers will be "
-            f"added in the future releases."
-        )
+
     log(INFO, "Starting Flower REST server")
 
     # See: https://www.starlette.io/applications/#accessing-the-app-instance
@@ -624,7 +657,7 @@ def _run_fleet_api_rest(
         access_log=True,
         ssl_keyfile=ssl_keyfile,
         ssl_certfile=ssl_certfile,
-        workers=workers,
+        workers=num_workers,
     )
 
 
@@ -732,50 +765,27 @@ def _add_args_common(parser: argparse.ArgumentParser) -> None:
 def _add_args_driver_api(parser: argparse.ArgumentParser) -> None:
     parser.add_argument(
         "--driver-api-address",
-        help="Driver API (gRPC) server address (IPv4, IPv6, or a domain name)",
+        help="Driver API (gRPC) server address (IPv4, IPv6, or a domain name).",
         default=ADDRESS_DRIVER_API,
     )
 
 
 def _add_args_fleet_api(parser: argparse.ArgumentParser) -> None:
     # Fleet API transport layer type
-    ex_group = parser.add_mutually_exclusive_group()
-    ex_group.add_argument(
-        "--grpc-rere",
-        action="store_const",
-        dest="fleet_api_type",
-        const=TRANSPORT_TYPE_GRPC_RERE,
+    parser.add_argument(
+        "--fleet-api-type",
         default=TRANSPORT_TYPE_GRPC_RERE,
-        help="Start a Fleet API server (gRPC-rere)",
-    )
-    ex_group.add_argument(
-        "--rest",
-        action="store_const",
-        dest="fleet_api_type",
-        const=TRANSPORT_TYPE_REST,
-        help="Start a Fleet API server (REST, experimental)",
-    )
-
-    # Fleet API gRPC-rere options
-    grpc_rere_group = parser.add_argument_group(
-        "Fleet API (gRPC-rere) server options", ""
-    )
-    grpc_rere_group.add_argument(
-        "--grpc-rere-fleet-api-address",
-        help="Fleet API (gRPC-rere) server address (IPv4, IPv6, or a domain name)",
-        default=ADDRESS_FLEET_API_GRPC_RERE,
+        type=str,
+        choices=[TRANSPORT_TYPE_GRPC_RERE, TRANSPORT_TYPE_REST],
+        help="Start a gRPC-rere or REST (experimental) Fleet API server.",
     )
-
-    # Fleet API REST options
-    rest_group = parser.add_argument_group("Fleet API (REST) server options", "")
-    rest_group.add_argument(
-        "--rest-fleet-api-address",
-        help="Fleet API (REST) server address (IPv4, IPv6, or a domain name)",
-        default=ADDRESS_FLEET_API_REST,
+    parser.add_argument(
+        "--fleet-api-address",
+        help="Fleet API server address (IPv4, IPv6, or a domain name).",
     )
-    rest_group.add_argument(
-        "--rest-fleet-api-workers",
-        help="Set the number of concurrent workers for the Fleet API REST server.",
-        type=int,
+    parser.add_argument(
+        "--fleet-api-num-workers",
         default=1,
+        type=int,
+        help="Set the number of concurrent workers for the Fleet API server.",
     )

{flwr_nightly-1.9.0.dev20240606 → flwr_nightly-1.9.0.dev20240608}/src/py/flwr/server/run_serverapp.py

@@ -22,12 +22,14 @@ from pathlib import Path
 from typing import Optional
 
 from flwr.common import Context, EventType, RecordSet, event
-from flwr.common.logger import log, update_console_handler
+from flwr.common.logger import log, update_console_handler, warn_deprecated_feature
 from flwr.common.object_ref import load_app
 
 from .driver import Driver, GrpcDriver
 from .server_app import LoadServerAppError, ServerApp
 
+ADDRESS_DRIVER_API = "0.0.0.0:9091"
+
 
 def run(
     driver: Driver,
@@ -76,6 +78,23 @@ def run_server_app() -> None:
 
     args = _parse_args_run_server_app().parse_args()
 
+    if args.server != ADDRESS_DRIVER_API:
+        warn = "Passing flag --server is deprecated. Use --superlink instead."
+        warn_deprecated_feature(warn)
+
+        if args.superlink != ADDRESS_DRIVER_API:
+            # if `--superlink` also passed, then
+            # warn user that this argument overrides what was passed with `--server`
+            log(
+                WARN,
+                "Both `--server` and `--superlink` were passed. "
+                "`--server` will be ignored. Connecting to the Superlink Driver API "
+                "at %s.",
+                args.superlink,
+            )
+        else:
+            args.superlink = args.server
+
     update_console_handler(
         level=DEBUG if args.verbose else INFO,
         timestamps=args.verbose,
@@ -95,7 +114,7 @@ def run_server_app() -> None:
             WARN,
             "Option `--insecure` was set. "
             "Starting insecure HTTP client connected to %s.",
-            args.server,
+            args.superlink,
         )
         root_certificates = None
     else:
@@ -109,7 +128,7 @@ def run_server_app() -> None:
             DEBUG,
             "Starting secure HTTPS client connected to %s "
             "with the following certificates: %s.",
-            args.server,
+            args.superlink,
             cert_path,
         )
 
@@ -130,7 +149,7 @@ def run_server_app() -> None:
 
     # Initialize GrpcDriver
     driver = GrpcDriver(
-        driver_service_address=args.server,
+        driver_service_address=args.superlink,
         root_certificates=root_certificates,
         fab_id=args.fab_id,
         fab_version=args.fab_version,
@@ -175,9 +194,14 @@ def _parse_args_run_server_app() -> argparse.ArgumentParser:
     )
     parser.add_argument(
         "--server",
-        default="0.0.0.0:9091",
+        default=ADDRESS_DRIVER_API,
         help="Server address",
     )
+    parser.add_argument(
+        "--superlink",
+        default=ADDRESS_DRIVER_API,
+        help="SuperLink Driver API (gRPC-rere) address (IPv4, IPv6, or a domain name)",
+    )
     parser.add_argument(
         "--dir",
         default="",