flwr-nightly 1.15.0.dev20250107__tar.gz → 1.15.0.dev20250112__tar.gz

{flwr_nightly-1.15.0.dev20250107 → flwr_nightly-1.15.0.dev20250112}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.15.0.dev20250107
+Version: 1.15.0.dev20250112
 Summary: Flower: A Friendly Federated AI Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -43,11 +43,11 @@ Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: ray (==2.10.0) ; (python_version >= "3.9" and python_version < "3.12") and (extra == "simulation")
 Requires-Dist: requests (>=2.31.0,<3.0.0)
 Requires-Dist: rich (>=13.5.0,<14.0.0)
-Requires-Dist: starlette (>=0.31.0,<0.32.0) ; extra == "rest"
+Requires-Dist: starlette (>=0.45.2,<0.46.0) ; extra == "rest"
 Requires-Dist: tomli (>=2.0.1,<3.0.0)
 Requires-Dist: tomli-w (>=1.0.0,<2.0.0)
 Requires-Dist: typer (>=0.12.5,<0.13.0)
-Requires-Dist: uvicorn[standard] (>=0.23.0,<0.24.0) ; extra == "rest"
+Requires-Dist: uvicorn[standard] (>=0.34.0,<0.35.0) ; extra == "rest"
 Project-URL: Documentation, https://flower.ai
 Project-URL: Repository, https://github.com/adap/flower
 Description-Content-Type: text/markdown
@@ -88,7 +88,7 @@ design of Flower is based on a few guiding principles:
 
 - **Framework-agnostic**: Different machine learning frameworks have different
   strengths. Flower can be used with any machine learning framework, for
-  example, [PyTorch](https://pytorch.org), [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [MONAI](https://docs.monai.io/en/latest/index.html), [fastai](https://www.fast.ai/), [MLX](https://ml-explore.github.io/mlx/build/html/index.html), [XGBoost](https://xgboost.readthedocs.io/en/stable/), [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
+  example, [PyTorch](https://pytorch.org), [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [MONAI](https://docs.monai.io/en/latest/index.html), [fastai](https://www.fast.ai/), [MLX](https://ml-explore.github.io/mlx/build/html/index.html), [XGBoost](https://xgboost.readthedocs.io/en/stable/), [LeRobot](https://github.com/huggingface/lerobot) for federated robots, [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
   for users who enjoy computing gradients by hand.
 
 - **Understandable**: Flower is written with maintainability in mind. The

{flwr_nightly-1.15.0.dev20250107 → flwr_nightly-1.15.0.dev20250112}/README.md

@@ -34,7 +34,7 @@ design of Flower is based on a few guiding principles:
 
 - **Framework-agnostic**: Different machine learning frameworks have different
   strengths. Flower can be used with any machine learning framework, for
-  example, [PyTorch](https://pytorch.org), [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [MONAI](https://docs.monai.io/en/latest/index.html), [fastai](https://www.fast.ai/), [MLX](https://ml-explore.github.io/mlx/build/html/index.html), [XGBoost](https://xgboost.readthedocs.io/en/stable/), [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
+  example, [PyTorch](https://pytorch.org), [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [MONAI](https://docs.monai.io/en/latest/index.html), [fastai](https://www.fast.ai/), [MLX](https://ml-explore.github.io/mlx/build/html/index.html), [XGBoost](https://xgboost.readthedocs.io/en/stable/), [LeRobot](https://github.com/huggingface/lerobot) for federated robots, [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
   for users who enjoy computing gradients by hand.
 
 - **Understandable**: Flower is written with maintainability in mind. The

{flwr_nightly-1.15.0.dev20250107 → flwr_nightly-1.15.0.dev20250112}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.15.0.dev20250107"
+version = "1.15.0.dev20250112"
 description = "Flower: A Friendly Federated AI Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]
@@ -83,8 +83,8 @@ requests = "^2.31.0"
 # Optional dependencies (Simulation Engine)
 ray = { version = "==2.10.0", optional = true, python = ">=3.9,<3.12" }
 # Optional dependencies (REST transport layer)
-starlette = { version = "^0.31.0", optional = true }
-uvicorn = { version = "^0.23.0", extras = ["standard"], optional = true }
+starlette = { version = "^0.45.2", optional = true }
+uvicorn = { version = "^0.34.0", extras = ["standard"], optional = true }
 
 [tool.poetry.extras]
 simulation = ["ray"]

{flwr_nightly-1.15.0.dev20250107 → flwr_nightly-1.15.0.dev20250112}/src/py/flwr/cli/cli_user_auth_interceptor.py

@@ -54,8 +54,12 @@ class CliUserAuthInterceptor(
 
         response = continuation(details, request)
         if response.initial_metadata():
-            retrieved_metadata = dict(response.initial_metadata())
-            self.auth_plugin.store_tokens(retrieved_metadata)
+            credentials = self.auth_plugin.read_tokens_from_metadata(
+                response.initial_metadata()
+            )
+            # The metadata contains tokens only if they have been refreshed
+            if credentials is not None:
+                self.auth_plugin.store_tokens(credentials)
 
         return response
 

{flwr_nightly-1.15.0.dev20250107 → flwr_nightly-1.15.0.dev20250112}/src/py/flwr/cli/login/login.py

@@ -26,7 +26,7 @@ from flwr.cli.config_utils import (
     process_loaded_project_config,
     validate_federation_in_project_config,
 )
-from flwr.common.constant import AUTH_TYPE
+from flwr.common.typing import UserAuthLoginDetails
 from flwr.proto.exec_pb2 import (  # pylint: disable=E0611
     GetLoginDetailsRequest,
     GetLoginDetailsResponse,
@@ -64,7 +64,7 @@ def login(  # pylint: disable=R0914
     login_response: GetLoginDetailsResponse = stub.GetLoginDetails(login_request)
 
     # Get the auth plugin
-    auth_type = login_response.login_details.get(AUTH_TYPE)
+    auth_type = login_response.auth_type
     auth_plugin = try_obtain_cli_auth_plugin(app, federation, auth_type)
     if auth_plugin is None:
         typer.secho(
@@ -75,7 +75,14 @@ def login(  # pylint: disable=R0914
         raise typer.Exit(code=1)
 
     # Login
-    auth_config = auth_plugin.login(dict(login_response.login_details), stub)
+    details = UserAuthLoginDetails(
+        auth_type=login_response.auth_type,
+        device_code=login_response.device_code,
+        verification_uri_complete=login_response.verification_uri_complete,
+        expires_in=login_response.expires_in,
+        interval=login_response.interval,
+    )
+    credentials = auth_plugin.login(details, stub)
 
     # Store the tokens
-    auth_plugin.store_tokens(auth_config)
+    auth_plugin.store_tokens(credentials)

{flwr_nightly-1.15.0.dev20250107 → flwr_nightly-1.15.0.dev20250112}/src/py/flwr/cli/utils.py

@@ -223,19 +223,19 @@ def try_obtain_cli_auth_plugin(
     config_path = get_user_auth_config_path(root_dir, federation)
 
     # Load the config file if it exists
-    config: dict[str, Any] = {}
+    json_file: dict[str, Any] = {}
     if config_path.exists():
         with config_path.open("r", encoding="utf-8") as file:
-            config = json.load(file)
+            json_file = json.load(file)
     # This is the case when the user auth is not enabled
     elif auth_type is None:
         return None
 
     # Get the auth type from the config if not provided
     if auth_type is None:
-        if AUTH_TYPE not in config:
+        if AUTH_TYPE not in json_file:
             return None
-        auth_type = config[AUTH_TYPE]
+        auth_type = json_file[AUTH_TYPE]
 
     # Retrieve auth plugin class and instantiate it
     try:

{flwr_nightly-1.15.0.dev20250107 → flwr_nightly-1.15.0.dev20250112}/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.dev20250107 → flwr_nightly-1.15.0.dev20250112}/src/py/flwr/client/grpc_rere_client/client_interceptor.py

@@ -36,7 +36,9 @@ from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     CreateNodeRequest,
     DeleteNodeRequest,
     PingRequest,
+    PullMessagesRequest,
     PullTaskInsRequest,
+    PushMessagesRequest,
     PushTaskResRequest,
 )
 from flwr.proto.run_pb2 import GetRunRequest  # pylint: disable=E0611
@@ -52,6 +54,8 @@ Request = Union[
     GetRunRequest,
     PingRequest,
     GetFabRequest,
+    PullMessagesRequest,
+    PushMessagesRequest,
 ]
 
 
@@ -129,6 +133,8 @@ class AuthenticateClientInterceptor(grpc.UnaryUnaryClientInterceptor):  # type:
                 GetRunRequest,
                 PingRequest,
                 GetFabRequest,
+                PullMessagesRequest,
+                PushMessagesRequest,
             ),
         ):
             if self.shared_secret is None:

{flwr_nightly-1.15.0.dev20250107 → flwr_nightly-1.15.0.dev20250112}/src/py/flwr/client/grpc_rere_client/grpc_adapter.py

@@ -40,8 +40,12 @@ from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     DeleteNodeResponse,
     PingRequest,
     PingResponse,
+    PullMessagesRequest,
+    PullMessagesResponse,
     PullTaskInsRequest,
     PullTaskInsResponse,
+    PushMessagesRequest,
+    PushMessagesResponse,
     PushTaskResRequest,
     PushTaskResResponse,
 )
@@ -132,12 +136,24 @@ class GrpcAdapter:
         """."""
         return self._send_and_receive(request, PullTaskInsResponse, **kwargs)
 
+    def PullMessages(  # pylint: disable=C0103
+        self, request: PullMessagesRequest, **kwargs: Any
+    ) -> PullMessagesResponse:
+        """."""
+        return self._send_and_receive(request, PullMessagesResponse, **kwargs)
+
     def PushTaskRes(  # pylint: disable=C0103
         self, request: PushTaskResRequest, **kwargs: Any
     ) -> PushTaskResResponse:
         """."""
         return self._send_and_receive(request, PushTaskResResponse, **kwargs)
 
+    def PushMessages(  # pylint: disable=C0103
+        self, request: PushMessagesRequest, **kwargs: Any
+    ) -> PushMessagesResponse:
+        """."""
+        return self._send_and_receive(request, PushMessagesResponse, **kwargs)
+
     def GetRun(  # pylint: disable=C0103
         self, request: GetRunRequest, **kwargs: Any
     ) -> GetRunResponse:

{flwr_nightly-1.15.0.dev20250107 → flwr_nightly-1.15.0.dev20250112}/src/py/flwr/common/auth_plugin/auth_plugin.py

@@ -18,26 +18,31 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Optional, Union
 
 from flwr.proto.exec_pb2_grpc import ExecStub
 
+from ..typing import UserAuthCredentials, UserAuthLoginDetails
+
 
 class ExecAuthPlugin(ABC):
     """Abstract Flower Auth Plugin class for ExecServicer.
 
     Parameters
     ----------
-    config : dict[str, Any]
-        The authentication configuration loaded from a YAML file.
+    user_auth_config_path : Path
+        Path to the YAML file containing the authentication configuration.
     """
 
     @abstractmethod
-    def __init__(self, config: dict[str, Any]):
+    def __init__(
+        self,
+        user_auth_config_path: Path,
+    ):
         """Abstract constructor."""
 
     @abstractmethod
-    def get_login_details(self) -> dict[str, str]:
+    def get_login_details(self) -> Optional[UserAuthLoginDetails]:
         """Get the login details."""
 
     @abstractmethod
@@ -47,7 +52,7 @@ class ExecAuthPlugin(ABC):
         """Validate authentication tokens in the provided metadata."""
 
     @abstractmethod
-    def get_auth_tokens(self, auth_details: dict[str, str]) -> dict[str, str]:
+    def get_auth_tokens(self, device_code: str) -> Optional[UserAuthCredentials]:
         """Get authentication tokens."""
 
     @abstractmethod
@@ -62,50 +67,55 @@ class CliAuthPlugin(ABC):
 
     Parameters
     ----------
-    user_auth_config_path : Path
-        The path to the user's authentication configuration file.
+    credentials_path : Path
+        Path to the user's authentication credentials file.
     """
 
     @staticmethod
     @abstractmethod
     def login(
-        login_details: dict[str, str],
+        login_details: UserAuthLoginDetails,
         exec_stub: ExecStub,
-    ) -> dict[str, Any]:
-        """Authenticate the user with the SuperLink.
+    ) -> UserAuthCredentials:
+        """Authenticate the user and retrieve authentication credentials.
 
         Parameters
         ----------
-        login_details : dict[str, str]
-            A dictionary containing the user's login details.
+        login_details : UserAuthLoginDetails
+            An object containing the user's login details.
         exec_stub : ExecStub
-            An instance of `ExecStub` used for communication with the SuperLink.
+            A stub for executing RPC calls to the server.
 
         Returns
         -------
-        user_auth_config : dict[str, Any]
-            A dictionary containing the user's authentication configuration
-            in JSON format.
+        UserAuthCredentials
+            The authentication credentials obtained after login.
         """
 
     @abstractmethod
-    def __init__(self, user_auth_config_path: Path):
+    def __init__(self, credentials_path: Path):
         """Abstract constructor."""
 
     @abstractmethod
-    def store_tokens(self, user_auth_config: dict[str, Any]) -> None:
-        """Store authentication tokens from the provided user_auth_config.
+    def store_tokens(self, credentials: UserAuthCredentials) -> None:
+        """Store authentication tokens to the `credentials_path`.
 
-        The configuration, including tokens, will be saved as a JSON file
-        at `user_auth_config_path`.
+        The credentials, including tokens, will be saved as a JSON file
+        at `credentials_path`.
         """
 
     @abstractmethod
     def load_tokens(self) -> None:
-        """Load authentication tokens from the user_auth_config_path."""
+        """Load authentication tokens from the `credentials_path`."""
 
     @abstractmethod
     def write_tokens_to_metadata(
         self, metadata: Sequence[tuple[str, Union[str, bytes]]]
     ) -> Sequence[tuple[str, Union[str, bytes]]]:
         """Write authentication tokens to the provided metadata."""
+
+    @abstractmethod
+    def read_tokens_from_metadata(
+        self, metadata: Sequence[tuple[str, Union[str, bytes]]]
+    ) -> Optional[UserAuthCredentials]:
+        """Read authentication tokens from the provided metadata."""

{flwr_nightly-1.15.0.dev20250107 → flwr_nightly-1.15.0.dev20250112}/src/py/flwr/common/constant.py

@@ -114,6 +114,8 @@ MAX_RETRY_DELAY = 20  # Maximum delay duration between two consecutive retries.
 # Constants for user authentication
 CREDENTIALS_DIR = ".credentials"
 AUTH_TYPE = "auth_type"
+ACCESS_TOKEN_KEY = "access_token"
+REFRESH_TOKEN_KEY = "refresh_token"
 
 
 class MessageType:

flwr_nightly-1.15.0.dev20250107/src/py/flwr/server/superlink/fleet/grpc_bidi/grpc_server.py → flwr_nightly-1.15.0.dev20250112/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.dev20250107 → flwr_nightly-1.15.0.dev20250112}/src/py/flwr/common/typing.py

@@ -266,3 +266,23 @@ class InvalidRunStatusException(BaseException):
     def __init__(self, message: str) -> None:
         super().__init__(message)
         self.message = message
+
+
+# OIDC user authentication types
+@dataclass
+class UserAuthLoginDetails:
+    """User authentication login details."""
+
+    auth_type: str
+    device_code: str
+    verification_uri_complete: str
+    expires_in: int
+    interval: int
+
+
+@dataclass
+class UserAuthCredentials:
+    """User authentication tokens."""
+
+    access_token: str
+    refresh_token: str