flwr-nightly 1.23.0.dev20250930__py3-none-any.whl → 1.26.0.dev20260121__py3-none-any.whl

flwr/common/typing.py

@@ -15,13 +15,17 @@
 """Flower type definitions."""
 
 
+from collections.abc import Callable
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Callable, Optional, Union
+from typing import Any
 
 import numpy as np
 import numpy.typing as npt
 
+from flwr.app.user_config import UserConfig
+from flwr.proto.node_pb2 import NodeInfo  # pylint: disable=E0611
+
 NDArray = npt.NDArray[Any]
 NDArrayInt = npt.NDArray[np.int_]
 NDArrayFloat = npt.NDArray[np.float64]
@@ -31,29 +35,29 @@ NDArrays = list[NDArray]
 # ProtoBuf considers to be "Scalar Value Types", even though some of them arguably do
 # not conform to other definitions of what a scalar is. Source:
 # https://developers.google.com/protocol-buffers/docs/overview#scalar
-Scalar = Union[bool, bytes, float, int, str]
-Value = Union[
-    bool,
-    bytes,
-    float,
-    int,
-    str,
-    list[bool],
-    list[bytes],
-    list[float],
-    list[int],
-    list[str],
-]
+Scalar = bool | bytes | float | int | str
+Value = (
+    bool
+    | bytes
+    | float
+    | int
+    | str
+    | list[bool]
+    | list[bytes]
+    | list[float]
+    | list[int]
+    | list[str]
+)
+
 
 # Value types for common.MetricRecord
-MetricScalar = Union[int, float]
-MetricScalarList = Union[list[int], list[float]]
-MetricRecordValues = Union[MetricScalar, MetricScalarList]
+MetricScalar = int | float
+MetricScalarList = list[int] | list[float]
+MetricRecordValues = MetricScalar | MetricScalarList
 # Value types for common.ConfigRecord
-ConfigScalar = Union[MetricScalar, str, bytes, bool]
-ConfigScalarList = Union[MetricScalarList, list[str], list[bytes], list[bool]]
-ConfigRecordValues = Union[ConfigScalar, ConfigScalarList]
-
+ConfigScalar = MetricScalar | str | bytes | bool
+ConfigScalarList = MetricScalarList | list[str] | list[bytes] | list[bool]
+ConfigRecordValues = ConfigScalar | ConfigScalarList
 Metrics = dict[str, Scalar]
 MetricsAggregationFn = Callable[[list[tuple[int, Metrics]]], Metrics]
 
@@ -61,8 +65,6 @@ Config = dict[str, Scalar]
 Properties = dict[str, Scalar]
 
 # Value type for user configs
-UserConfigValue = Union[bool, float, int, str]
-UserConfig = dict[str, UserConfigValue]
 
 
 class Code(Enum):
@@ -177,7 +179,7 @@ class GetPropertiesRes:
 class ReconnectIns:
     """ReconnectIns message from server to client."""
 
-    seconds: Optional[int]
+    seconds: int | None
 
 
 @dataclass
@@ -191,20 +193,20 @@ class DisconnectRes:
 class ServerMessage:
     """ServerMessage is a container used to hold one instruction message."""
 
-    get_properties_ins: Optional[GetPropertiesIns] = None
-    get_parameters_ins: Optional[GetParametersIns] = None
-    fit_ins: Optional[FitIns] = None
-    evaluate_ins: Optional[EvaluateIns] = None
+    get_properties_ins: GetPropertiesIns | None = None
+    get_parameters_ins: GetParametersIns | None = None
+    fit_ins: FitIns | None = None
+    evaluate_ins: EvaluateIns | None = None
 
 
 @dataclass
 class ClientMessage:
     """ClientMessage is a container used to hold one result message."""
 
-    get_properties_res: Optional[GetPropertiesRes] = None
-    get_parameters_res: Optional[GetParametersRes] = None
-    fit_res: Optional[FitRes] = None
-    evaluate_res: Optional[EvaluateRes] = None
+    get_properties_res: GetPropertiesRes | None = None
+    get_parameters_res: GetParametersRes | None = None
+    fit_res: FitRes | None = None
+    evaluate_res: EvaluateRes | None = None
 
 
 @dataclass
@@ -231,6 +233,10 @@ class Run:  # pylint: disable=too-many-instance-attributes
     finished_at: str
     status: RunStatus
     flwr_aid: str
+    federation: str
+    bytes_sent: int
+    bytes_recv: int
+    clientapp_runtime: float
 
     @classmethod
     def create_empty(cls, run_id: int) -> "Run":
@@ -247,6 +253,10 @@ class Run:  # pylint: disable=too-many-instance-attributes
             finished_at="",
             status=RunStatus(status="", sub_status="", details=""),
             flwr_aid="",
+            federation="",
+            bytes_sent=0,
+            bytes_recv=0,
+            clientapp_runtime=0.0,
         )
 
 
@@ -256,6 +266,7 @@ class Fab:
 
     hash_str: str
     content: bytes
+    verifications: dict[str, str]
 
 
 class RunNotRunningException(BaseException):
@@ -270,12 +281,12 @@ class InvalidRunStatusException(BaseException):
         self.message = message
 
 
-# OIDC user authentication types
+# OIDC account authentication types
 @dataclass
-class UserAuthLoginDetails:
-    """User authentication login details."""
+class AccountAuthLoginDetails:
+    """Account authentication login details."""
 
-    auth_type: str
+    authn_type: str
     device_code: str
     verification_uri_complete: str
     expires_in: int
@@ -283,8 +294,8 @@ class UserAuthLoginDetails:
 
 
 @dataclass
-class UserAuthCredentials:
-    """User authentication tokens."""
+class AccountAuthCredentials:
+    """Account authentication tokens."""
 
     access_token: str
     refresh_token: str
@@ -294,16 +305,16 @@ class UserAuthCredentials:
 class AccountInfo:
     """User information for event log."""
 
-    flwr_aid: Optional[str]
-    account_name: Optional[str]
+    flwr_aid: str | None
+    account_name: str | None
 
 
 @dataclass
 class Actor:
     """Event log actor."""
 
-    actor_id: Optional[str]
-    description: Optional[str]
+    actor_id: str | None
+    description: str | None
     ip_address: str
 
 
@@ -312,8 +323,8 @@ class Event:
     """Event log description."""
 
     action: str
-    run_id: Optional[int]
-    fab_hash: Optional[str]
+    run_id: int | None
+    fab_hash: str | None
 
 
 @dataclass
@@ -324,3 +335,13 @@ class LogEntry:
     actor: Actor
     event: Event
     status: str
+
+
+@dataclass
+class Federation:
+    """Federation details."""
+
+    name: str
+    member_aids: list[str]
+    nodes: list[NodeInfo]
+    runs: list[Run]

flwr/compat/client/app.py

@@ -16,41 +16,39 @@
 
 
 import time
+from collections.abc import Callable
 from contextlib import AbstractContextManager
 from logging import ERROR, INFO, WARN
 from pathlib import Path
-from typing import Callable, Optional, Union
 
 from cryptography.hazmat.primitives.asymmetric import ec
 from grpc import RpcError
 
 from flwr.app.error import Error
+from flwr.app.user_config import UserConfig
 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.message_handler.message_handler import handle_control_message
 from flwr.client.numpy_client import NumPyClient
 from flwr.client.run_info_store import DeprecatedRunInfoStore
 from flwr.client.typing import ClientFnExt
+from flwr.clientapp.client_app import ClientApp, LoadClientAppError
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH, Context, EventType, Message, event
-from flwr.common.address import parse_address
-from flwr.common.constant import (
-    MAX_RETRY_DELAY,
-    TRANSPORT_TYPE_GRPC_BIDI,
-    TRANSPORT_TYPES,
-    ErrorCode,
-)
+from flwr.common.constant import MAX_RETRY_DELAY, ErrorCode
 from flwr.common.exit import ExitCode, flwr_exit
 from flwr.common.logger import log, warn_deprecated_feature
 from flwr.common.retry_invoker import RetryInvoker, RetryState, exponential
-from flwr.common.typing import Fab, Run, RunNotRunningException, UserConfig
+from flwr.common.typing import Fab, Run, RunNotRunningException
 from flwr.compat.client.grpc_client.connection import grpc_connection
+from flwr.compat.common.constant import TRANSPORT_TYPE_GRPC_BIDI, TRANSPORT_TYPES_COMPAT
+from flwr.supercore.address import parse_address
+from flwr.supercore.object_store import ObjectStoreFactory
 from flwr.supernode.nodestate import NodeStateFactory
 
 
 def _check_actionable_client(
-    client: Optional[Client], client_fn: Optional[ClientFnExt]
+    client: Client | None, client_fn: ClientFnExt | None
 ) -> None:
     if client_fn is None and client is None:
         raise ValueError(
@@ -71,17 +69,17 @@ def _check_actionable_client(
 def start_client(
     *,
     server_address: str,
-    client_fn: Optional[ClientFnExt] = None,
-    client: Optional[Client] = None,
+    client_fn: ClientFnExt | None = None,
+    client: Client | None = None,
     grpc_max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
-    root_certificates: Optional[Union[bytes, str]] = None,
-    insecure: Optional[bool] = None,
-    transport: Optional[str] = None,
-    authentication_keys: Optional[
-        tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]
-    ] = None,
-    max_retries: Optional[int] = None,
-    max_wait_time: Optional[float] = None,
+    root_certificates: bytes | str | None = None,
+    insecure: bool | None = None,
+    transport: str | None = None,
+    authentication_keys: (
+        tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey] | None
+    ) = None,
+    max_retries: int | None = None,
+    max_wait_time: float | None = None,
 ) -> None:
     """Start a Flower client node which connects to a Flower server.
 
@@ -205,19 +203,19 @@ def start_client_internal(
     *,
     server_address: str,
     node_config: UserConfig,
-    load_client_app_fn: Optional[Callable[[str, str, str], ClientApp]] = None,
-    client_fn: Optional[ClientFnExt] = None,
-    client: Optional[Client] = None,
+    load_client_app_fn: Callable[[str, str, str], ClientApp] | None = None,
+    client_fn: ClientFnExt | None = None,
+    client: Client | None = None,
     grpc_max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
-    root_certificates: Optional[Union[bytes, str]] = None,
-    insecure: Optional[bool] = None,
-    transport: Optional[str] = None,
-    authentication_keys: Optional[
-        tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]
-    ] = None,
-    max_retries: Optional[int] = None,
-    max_wait_time: Optional[float] = None,
-    flwr_path: Optional[Path] = None,
+    root_certificates: bytes | str | None = None,
+    insecure: bool | None = None,
+    transport: str | None = None,
+    authentication_keys: (
+        tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey] | None
+    ) = None,
+    max_retries: int | None = None,
+    max_wait_time: float | None = None,
+    flwr_path: Path | None = None,
 ) -> None:
     """Start a Flower client node which connects to a Flower server.
 
@@ -342,8 +340,8 @@ def start_client_internal(
     )
 
     # DeprecatedRunInfoStore gets initialized when the first connection is established
-    run_info_store: Optional[DeprecatedRunInfoStore] = None
-    state_factory = NodeStateFactory()
+    run_info_store: DeprecatedRunInfoStore | None = None
+    state_factory = NodeStateFactory(objectstore_factory=ObjectStoreFactory())
     state = state_factory.state()
 
     runs: dict[int, Run] = {}
@@ -537,9 +535,9 @@ def start_numpy_client(
     server_address: str,
     client: NumPyClient,
     grpc_max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
-    root_certificates: Optional[bytes] = None,
-    insecure: Optional[bool] = None,
-    transport: Optional[str] = None,
+    root_certificates: bytes | None = None,
+    insecure: bool | None = None,
+    transport: str | None = None,
 ) -> None:
     """Start a Flower NumPyClient which connects to a gRPC server.
 
@@ -631,24 +629,24 @@ def start_numpy_client(
     )
 
 
-def _init_connection(transport: Optional[str], server_address: str) -> tuple[
+def _init_connection(transport: str | None, server_address: str) -> tuple[
     Callable[
         [
             str,
             bool,
             RetryInvoker,
             int,
-            Union[bytes, str, None],
-            Optional[tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]],
+            bytes | str | None,
+            tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey] | None,
         ],
         AbstractContextManager[
             tuple[
-                Callable[[], Optional[Message]],
+                Callable[[], Message | None],
                 Callable[[Message], None],
-                Optional[Callable[[], Optional[int]]],
-                Optional[Callable[[], None]],
-                Optional[Callable[[int], Run]],
-                Optional[Callable[[str, int], Fab]],
+                Callable[[], int | None] | None,
+                Callable[[], None] | None,
+                Callable[[int], Run] | None,
+                Callable[[str, int], Fab] | None,
             ]
         ],
     ],
@@ -674,7 +672,7 @@ def _init_connection(transport: Optional[str], server_address: str) -> tuple[
         connection, error_type = grpc_connection, RpcError
     else:
         raise ValueError(
-            f"Unknown transport type: {transport} (possible: {TRANSPORT_TYPES})"
+            f"Unknown transport type: {transport} (possible: {TRANSPORT_TYPES_COMPAT})"
         )
 
     return connection, address, error_type

flwr/compat/client/grpc_client/connection.py

@@ -16,15 +16,16 @@
 
 
 import uuid
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from contextlib import contextmanager
 from logging import DEBUG, ERROR
 from pathlib import Path
 from queue import Queue
-from typing import Callable, Optional, Union, cast
+from typing import cast
 
 from cryptography.hazmat.primitives.asymmetric import ec
 
+from flwr.app.message_type import MessageType
 from flwr.common import (
     DEFAULT_TTL,
     GRPC_MAX_MESSAGE_LENGTH,
@@ -36,7 +37,7 @@ from flwr.common import (
 )
 from flwr.common import recorddict_compat as compat
 from flwr.common import serde
-from flwr.common.constant import MessageType, MessageTypeLegacy
+from flwr.common.constant import MessageTypeLegacy
 from flwr.common.grpc import create_channel, on_channel_state_change
 from flwr.common.logger import log
 from flwr.common.message import make_message
@@ -56,18 +57,18 @@ def grpc_connection(  # pylint: disable=R0913,R0915,too-many-positional-argument
     insecure: bool,
     retry_invoker: RetryInvoker,  # pylint: disable=unused-argument
     max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
-    root_certificates: Optional[Union[bytes, str]] = None,
-    authentication_keys: Optional[  # pylint: disable=unused-argument
-        tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]
-    ] = None,
+    root_certificates: bytes | str | None = None,
+    authentication_keys: (
+        tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey] | None
+    ) = None,
 ) -> Iterator[
     tuple[
-        Callable[[], Optional[Message]],
+        Callable[[], Message | None],
         Callable[[Message], None],
-        Optional[Callable[[], Optional[int]]],
-        Optional[Callable[[], None]],
-        Optional[Callable[[int], Run]],
-        Optional[Callable[[str, int], Fab]],
+        Callable[[], int | None] | None,
+        Callable[[], None] | None,
+        Callable[[int], Run] | None,
+        Callable[[str, int], Fab] | None,
     ]
 ]:
     """Establish a gRPC connection to a gRPC server.
@@ -96,7 +97,7 @@ def grpc_connection(  # pylint: disable=R0913,R0915,too-many-positional-argument
         If provided, a secure connection using the certificates will be
         established to an SSL-enabled Flower server.
     authentication_keys : Optional[Tuple[PrivateKey, PublicKey]] (default: None)
-        Client authentication is not supported for this transport type.
+        SuperNode authentication is not supported for this transport type.
 
     Returns
     -------
@@ -120,7 +121,7 @@ def grpc_connection(  # pylint: disable=R0913,R0915,too-many-positional-argument
     if isinstance(root_certificates, str):
         root_certificates = Path(root_certificates).read_bytes()
     if authentication_keys is not None:
-        log(ERROR, "Client authentication is not supported for this transport type.")
+        log(ERROR, "SuperNode authentication is not supported for this transport type.")
 
     channel = create_channel(
         server_address=server_address,

flwr/compat/common/constant.py

@@ -0,0 +1,29 @@
+# Copyright 2025 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.
+# ==============================================================================
+"""Flower constants."""
+
+from flwr.common.constant import (
+    TRANSPORT_TYPE_GRPC_RERE,
+    TRANSPORT_TYPE_REST,
+    TRANSPORT_TYPE_VCE,
+)
+
+TRANSPORT_TYPE_GRPC_BIDI = "grpc-bidi"
+TRANSPORT_TYPES_COMPAT = [
+    TRANSPORT_TYPE_GRPC_BIDI,
+    TRANSPORT_TYPE_GRPC_RERE,
+    TRANSPORT_TYPE_REST,
+    TRANSPORT_TYPE_VCE,
+]

flwr/compat/server/app.py

@@ -17,10 +17,8 @@
 
 import sys
 from logging import INFO
-from typing import Optional
 
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH, EventType, event
-from flwr.common.address import parse_address
 from flwr.common.constant import FLEET_API_GRPC_BIDI_DEFAULT_ADDRESS
 from flwr.common.exit import register_signal_handlers
 from flwr.common.logger import log, warn_deprecated_feature
@@ -30,17 +28,18 @@ from flwr.server.server import Server, init_defaults, run_fl
 from flwr.server.server_config import ServerConfig
 from flwr.server.strategy import Strategy
 from flwr.server.superlink.fleet.grpc_bidi.grpc_server import start_grpc_server
+from flwr.supercore.address import parse_address
 
 
 def start_server(  # pylint: disable=too-many-arguments,too-many-locals
     *,
     server_address: str = FLEET_API_GRPC_BIDI_DEFAULT_ADDRESS,
-    server: Optional[Server] = None,
-    config: Optional[ServerConfig] = None,
-    strategy: Optional[Strategy] = None,
-    client_manager: Optional[ClientManager] = None,
+    server: Server | None = None,
+    config: ServerConfig | None = None,
+    strategy: Strategy | None = None,
+    client_manager: ClientManager | None = None,
     grpc_max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
-    certificates: Optional[tuple[bytes, bytes, bytes]] = None,
+    certificates: tuple[bytes, bytes, bytes] | None = None,
 ) -> History:
     """Start a Flower server using the gRPC transport layer.
 

flwr/proto/appio_pb2.py

@@ -1,12 +1,22 @@
 # -*- coding: utf-8 -*-
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
 # source: flwr/proto/appio.proto
-# Protobuf Python Version: 4.25.1
+# Protobuf Python Version: 5.29.0
 """Generated protocol buffer code."""
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
 from google.protobuf import symbol_database as _symbol_database
 from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    29,
+    0,
+    '',
+    'flwr/proto/appio.proto'
+)
 # @@protoc_insertion_point(imports)
 
 _sym_db = _symbol_database.Default()
@@ -22,8 +32,8 @@ DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x16\x66lwr/proto/
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
 _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flwr.proto.appio_pb2', _globals)
-if _descriptor._USE_C_DESCRIPTORS == False:
-  DESCRIPTOR._options = None
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
   _globals['_LISTAPPSTOLAUNCHREQUEST']._serialized_start=108
   _globals['_LISTAPPSTOLAUNCHREQUEST']._serialized_end=133
   _globals['_LISTAPPSTOLAUNCHRESPONSE']._serialized_start=135