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

flwr/common/recorddict_compat.py

@@ -15,9 +15,8 @@
 """RecordDict utilities."""
 
 
-from collections import OrderedDict
 from collections.abc import Mapping
-from typing import Union, cast, get_args
+from typing import cast, get_args
 
 from . import Array, ArrayRecord, ConfigRecord, MetricRecord, RecordDict
 from .typing import (
@@ -104,25 +103,23 @@ def parameters_to_arrayrecord(parameters: Parameters, keep_input: bool) -> Array
     tensor_type = parameters.tensor_type
 
     num_arrays = len(parameters.tensors)
-    ordered_dict = OrderedDict()
+    array_dict = {}
     for idx in range(num_arrays):
         if keep_input:
             tensor = parameters.tensors[idx]
         else:
             tensor = parameters.tensors.pop(0)
-        ordered_dict[str(idx)] = Array(
-            data=tensor, dtype="", stype=tensor_type, shape=()
-        )
+        array_dict[str(idx)] = Array(data=tensor, dtype="", stype=tensor_type, shape=())
 
     if num_arrays == 0:
-        ordered_dict[EMPTY_TENSOR_KEY] = Array(
+        array_dict[EMPTY_TENSOR_KEY] = Array(
             data=b"", dtype="", stype=tensor_type, shape=()
         )
-    return ArrayRecord(ordered_dict, keep_input=keep_input)
+    return ArrayRecord(array_dict, keep_input=keep_input)
 
 
 def _check_mapping_from_recordscalartype_to_scalar(
-    record_data: Mapping[str, Union[ConfigRecordValues, MetricRecordValues]]
+    record_data: Mapping[str, ConfigRecordValues | MetricRecordValues],
 ) -> dict[str, Scalar]:
     """Check mapping `common.*RecordValues` into `common.Scalar` is possible."""
     for value in record_data.values():
@@ -157,7 +154,7 @@ def _recorddict_to_fit_or_evaluate_ins_components(
 
 
 def _fit_or_evaluate_ins_to_recorddict(
-    ins: Union[FitIns, EvaluateIns], keep_input: bool
+    ins: FitIns | EvaluateIns, keep_input: bool
 ) -> RecordDict:
     recorddict = RecordDict()
 

flwr/common/retry_invoker.py

@@ -19,10 +19,10 @@ import itertools
 import random
 import threading
 import time
-from collections.abc import Generator, Iterable
+from collections.abc import Callable, Generator, Iterable
 from dataclasses import dataclass
 from logging import INFO, WARN
-from typing import Any, Callable, Optional, Union, cast
+from typing import Any, cast
 
 import grpc
 
@@ -39,7 +39,7 @@ from flwr.proto.simulationio_pb2_grpc import SimulationIoStub
 def exponential(
     base_delay: float = 1,
     multiplier: float = 2,
-    max_delay: Optional[int] = None,
+    max_delay: int | None = None,
 ) -> Generator[float, None, None]:
     """Wait time generator for exponential backoff strategy.
 
@@ -66,7 +66,7 @@ def exponential(
 
 
 def constant(
-    interval: Union[float, Iterable[float]] = 1,
+    interval: float | Iterable[float] = 1,
 ) -> Generator[float, None, None]:
     """Wait time generator for specified intervals.
 
@@ -114,8 +114,8 @@ class RetryState:
     kwargs: dict[str, Any]
     tries: int
     elapsed_time: float
-    exception: Optional[Exception] = None
-    actual_wait: Optional[float] = None
+    exception: Exception | None = None
+    actual_wait: float | None = None
 
 
 # pylint: disable-next=too-many-instance-attributes
@@ -184,16 +184,16 @@ class RetryInvoker:
     def __init__(
         self,
         wait_gen_factory: Callable[[], Generator[float, None, None]],
-        recoverable_exceptions: Union[type[Exception], tuple[type[Exception], ...]],
-        max_tries: Optional[int],
-        max_time: Optional[float],
+        recoverable_exceptions: type[Exception] | tuple[type[Exception], ...],
+        max_tries: int | None,
+        max_time: float | None,
         *,
-        on_success: Optional[Callable[[RetryState], None]] = None,
-        on_backoff: Optional[Callable[[RetryState], None]] = None,
-        on_giveup: Optional[Callable[[RetryState], None]] = None,
-        jitter: Optional[Callable[[float], float]] = full_jitter,
-        should_giveup: Optional[Callable[[Exception], bool]] = None,
-        wait_function: Optional[Callable[[float], None]] = None,
+        on_success: Callable[[RetryState], None] | None = None,
+        on_backoff: Callable[[RetryState], None] | None = None,
+        on_giveup: Callable[[RetryState], None] | None = None,
+        jitter: Callable[[float], float] | None = full_jitter,
+        should_giveup: Callable[[Exception], bool] | None = None,
+        wait_function: Callable[[float], None] | None = None,
     ) -> None:
         self.wait_gen_factory = wait_gen_factory
         self.recoverable_exceptions = recoverable_exceptions
@@ -253,7 +253,7 @@ class RetryInvoker:
         """
 
         def try_call_event_handler(
-            handler: Optional[Callable[[RetryState], None]]
+            handler: Callable[[RetryState], None] | None,
         ) -> None:
             if handler is not None:
                 handler(cast(RetryState, ref_state[0]))
@@ -261,7 +261,7 @@ class RetryInvoker:
         try_cnt = 0
         wait_generator = self.wait_gen_factory()
         start = time.monotonic()
-        ref_state: list[Optional[RetryState]] = [None]
+        ref_state: list[RetryState | None] = [None]
 
         while True:
             try_cnt += 1
@@ -387,9 +387,9 @@ def _make_simple_grpc_retry_invoker() -> RetryInvoker:
 
 
 def _wrap_stub(
-    stub: Union[
-        ServerAppIoStub, ClientAppIoStub, SimulationIoStub, FleetStub, GrpcAdapter
-    ],
+    stub: (
+        ServerAppIoStub | ClientAppIoStub | SimulationIoStub | FleetStub | GrpcAdapter
+    ),
     retry_invoker: RetryInvoker,
 ) -> None:
     """Wrap a gRPC stub with a retry invoker."""

flwr/common/secure_aggregation/crypto/symmetric_encryption.py

@@ -16,57 +16,14 @@
 
 
 import base64
-from typing import cast
 
 from cryptography.exceptions import InvalidSignature
 from cryptography.fernet import Fernet
-from cryptography.hazmat.primitives import hashes, hmac, serialization
+from cryptography.hazmat.primitives import hashes, hmac
 from cryptography.hazmat.primitives.asymmetric import ec
 from cryptography.hazmat.primitives.kdf.hkdf import HKDF
 
 
-def generate_key_pairs() -> (
-    tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]
-):
-    """Generate private and public key pairs with Cryptography."""
-    private_key = ec.generate_private_key(ec.SECP384R1())
-    public_key = private_key.public_key()
-    return private_key, public_key
-
-
-def private_key_to_bytes(private_key: ec.EllipticCurvePrivateKey) -> bytes:
-    """Serialize private key to bytes."""
-    return private_key.private_bytes(
-        encoding=serialization.Encoding.PEM,
-        format=serialization.PrivateFormat.PKCS8,
-        encryption_algorithm=serialization.NoEncryption(),
-    )
-
-
-def bytes_to_private_key(private_key_bytes: bytes) -> ec.EllipticCurvePrivateKey:
-    """Deserialize private key from bytes."""
-    return cast(
-        ec.EllipticCurvePrivateKey,
-        serialization.load_pem_private_key(data=private_key_bytes, password=None),
-    )
-
-
-def public_key_to_bytes(public_key: ec.EllipticCurvePublicKey) -> bytes:
-    """Serialize public key to bytes."""
-    return public_key.public_bytes(
-        encoding=serialization.Encoding.PEM,
-        format=serialization.PublicFormat.SubjectPublicKeyInfo,
-    )
-
-
-def bytes_to_public_key(public_key_bytes: bytes) -> ec.EllipticCurvePublicKey:
-    """Deserialize public key from bytes."""
-    return cast(
-        ec.EllipticCurvePublicKey,
-        serialization.load_pem_public_key(data=public_key_bytes),
-    )
-
-
 def generate_shared_key(
     private_key: ec.EllipticCurvePrivateKey, public_key: ec.EllipticCurvePublicKey
 ) -> bytes:
@@ -117,48 +74,3 @@ def verify_hmac(key: bytes, message: bytes, hmac_value: bytes) -> bool:
         return True
     except InvalidSignature:
         return False
-
-
-def sign_message(private_key: ec.EllipticCurvePrivateKey, message: bytes) -> bytes:
-    """Sign a message using the provided EC private key.
-
-    Parameters
-    ----------
-    private_key : ec.EllipticCurvePrivateKey
-        The EC private key to sign the message with.
-    message : bytes
-        The message to be signed.
-
-    Returns
-    -------
-    bytes
-        The signature of the message.
-    """
-    signature = private_key.sign(message, ec.ECDSA(hashes.SHA256()))
-    return signature
-
-
-def verify_signature(
-    public_key: ec.EllipticCurvePublicKey, message: bytes, signature: bytes
-) -> bool:
-    """Verify a signature against a message using the provided EC public key.
-
-    Parameters
-    ----------
-    public_key : ec.EllipticCurvePublicKey
-        The EC public key to verify the signature.
-    message : bytes
-        The original message.
-    signature : bytes
-        The signature to verify.
-
-    Returns
-    -------
-    bool
-        True if the signature is valid, False otherwise.
-    """
-    try:
-        public_key.verify(signature, message, ec.ECDSA(hashes.SHA256()))
-        return True
-    except InvalidSignature:
-        return False

flwr/common/secure_aggregation/ndarrays_arithmetic.py

@@ -15,10 +15,10 @@
 """Utility functions for performing operations on Numpy NDArrays."""
 
 
-from typing import Any, Union
+from typing import Any
 
 import numpy as np
-from numpy.typing import DTypeLike, NDArray
+from numpy.typing import NDArray
 
 
 def factor_combine(factor: int, parameters: list[NDArray[Any]]) -> list[NDArray[Any]]:
@@ -38,8 +38,11 @@ def get_parameters_shape(parameters: list[NDArray[Any]]) -> list[tuple[int, ...]
     return [arr.shape for arr in parameters]
 
 
+default_numpy_dtype = np.dtype(np.int64)
+
+
 def get_zero_parameters(
-    dimensions_list: list[tuple[int, ...]], dtype: DTypeLike = np.int64
+    dimensions_list: list[tuple[int, ...]], dtype: np.dtype[Any] = default_numpy_dtype
 ) -> list[NDArray[Any]]:
     """Generate zero parameters based on the dimensions list."""
     return [np.zeros(dimensions, dtype=dtype) for dimensions in dimensions_list]
@@ -68,14 +71,14 @@ def parameters_mod(parameters: list[NDArray[Any]], divisor: int) -> list[NDArray
 
 
 def parameters_multiply(
-    parameters: list[NDArray[Any]], multiplier: Union[int, float]
+    parameters: list[NDArray[Any]], multiplier: int | float
 ) -> list[NDArray[Any]]:
     """Multiply parameters by an integer/float multiplier."""
     return [parameters[idx] * multiplier for idx in range(len(parameters))]
 
 
 def parameters_divide(
-    parameters: list[NDArray[Any]], divisor: Union[int, float]
+    parameters: list[NDArray[Any]], divisor: int | float
 ) -> list[NDArray[Any]]:
     """Divide weight by an integer/float divisor."""
     return [parameters[idx] / divisor for idx in range(len(parameters))]

flwr/common/serde.py

@@ -15,9 +15,10 @@
 """ProtoBuf serialization and deserialization."""
 
 
-from collections import OrderedDict
 from typing import Any, cast
 
+from flwr.app.user_config import UserConfig, UserConfigValue
+
 # pylint: disable=E0611
 from flwr.proto.fab_pb2 import Fab as ProtoFab
 from flwr.proto.message_pb2 import Context as ProtoContext
@@ -410,9 +411,9 @@ def array_record_from_proto(
 ) -> ArrayRecord:
     """Deserialize ArrayRecord from ProtoBuf."""
     return ArrayRecord(
-        array_dict=OrderedDict(
-            {item.key: array_from_proto(item.value) for item in record_proto.items}
-        ),
+        array_dict={
+            item.key: array_from_proto(item.value) for item in record_proto.items
+        },
         keep_input=False,
     )
 
@@ -501,18 +502,20 @@ def recorddict_from_proto(recorddict_proto: ProtoRecordDict) -> RecordDict:
 
 def fab_to_proto(fab: typing.Fab) -> ProtoFab:
     """Create a proto Fab object from a Python Fab."""
-    return ProtoFab(hash_str=fab.hash_str, content=fab.content)
+    return ProtoFab(
+        hash_str=fab.hash_str, content=fab.content, verifications=fab.verifications
+    )
 
 
 def fab_from_proto(fab: ProtoFab) -> typing.Fab:
     """Create a Python Fab object from a proto Fab."""
-    return typing.Fab(fab.hash_str, fab.content)
+    return typing.Fab(fab.hash_str, fab.content, dict(fab.verifications))
 
 
 # === User configs ===
 
 
-def user_config_to_proto(user_config: typing.UserConfig) -> Any:
+def user_config_to_proto(user_config: UserConfig) -> Any:
     """Serialize `UserConfig` to ProtoBuf."""
     proto = {}
     for key, value in user_config.items():
@@ -520,7 +523,7 @@ def user_config_to_proto(user_config: typing.UserConfig) -> Any:
     return proto
 
 
-def user_config_from_proto(proto: Any) -> typing.UserConfig:
+def user_config_from_proto(proto: Any) -> UserConfig:
     """Deserialize `UserConfig` from ProtoBuf."""
     metrics = {}
     for key, value in proto.items():
@@ -528,7 +531,7 @@ def user_config_from_proto(proto: Any) -> typing.UserConfig:
     return metrics
 
 
-def user_config_value_to_proto(user_config_value: typing.UserConfigValue) -> Scalar:
+def user_config_value_to_proto(user_config_value: UserConfigValue) -> Scalar:
     """Serialize `UserConfigValue` to ProtoBuf."""
     if isinstance(user_config_value, bool):
         return Scalar(bool=user_config_value)
@@ -547,11 +550,11 @@ def user_config_value_to_proto(user_config_value: typing.UserConfigValue) -> Sca
     )
 
 
-def user_config_value_from_proto(scalar_msg: Scalar) -> typing.UserConfigValue:
+def user_config_value_from_proto(scalar_msg: Scalar) -> UserConfigValue:
     """Deserialize `UserConfigValue` from ProtoBuf."""
     scalar_field = scalar_msg.WhichOneof("scalar")
     scalar = getattr(scalar_msg, cast(str, scalar_field))
-    return cast(typing.UserConfigValue, scalar)
+    return cast(UserConfigValue, scalar)
 
 
 # === Message messages ===
@@ -630,6 +633,10 @@ def run_to_proto(run: typing.Run) -> ProtoRun:
         finished_at=run.finished_at,
         status=run_status_to_proto(run.status),
         flwr_aid=run.flwr_aid,
+        federation=run.federation,
+        bytes_sent=run.bytes_sent,
+        bytes_recv=run.bytes_recv,
+        clientapp_runtime=run.clientapp_runtime,
     )
     return proto
 
@@ -648,6 +655,10 @@ def run_from_proto(run_proto: ProtoRun) -> typing.Run:
         finished_at=run_proto.finished_at,
         status=run_status_from_proto(run_proto.status),
         flwr_aid=run_proto.flwr_aid,
+        federation=run_proto.federation,
+        bytes_sent=run_proto.bytes_sent,
+        bytes_recv=run_proto.bytes_recv,
+        clientapp_runtime=run_proto.clientapp_runtime,
     )
     return run
 

flwr/common/serde_utils.py

@@ -114,7 +114,7 @@ def record_value_dict_to_proto(
     Note: `bool` MUST be put in the front of allowd_types if it exists.
     """
     # Move bool to the front
-    if bool in allowed_types and allowed_types[0] != bool:
+    if bool in allowed_types and allowed_types[0] is not bool:
         allowed_types.remove(bool)
         allowed_types.insert(0, bool)
 
@@ -125,7 +125,7 @@ def record_value_dict_to_proto(
 
 
 def record_value_dict_from_proto(
-    value_dict_proto: MutableMapping[str, Any]
+    value_dict_proto: MutableMapping[str, Any],
 ) -> dict[str, Any]:
     """Deserialize the record value dict from ProtoBuf."""
     return {k: _record_value_from_proto(v) for k, v in value_dict_proto.items()}

flwr/common/telemetry.py

@@ -25,10 +25,10 @@ import uuid
 from concurrent.futures import Future, ThreadPoolExecutor
 from enum import Enum, auto
 from pathlib import Path
-from typing import Any, Optional, Union, cast
+from typing import Any, cast
 
 from flwr.common.constant import FLWR_DIR
-from flwr.common.version import package_name, package_version
+from flwr.supercore.version import package_name, package_version
 
 FLWR_TELEMETRY_ENABLED = os.getenv("FLWR_TELEMETRY_ENABLED", "1")
 FLWR_TELEMETRY_LOGGING = os.getenv("FLWR_TELEMETRY_LOGGING", "0")
@@ -56,7 +56,7 @@ def _configure_logger(log_level: int) -> None:
 _configure_logger(LOGGER_LEVEL)
 
 
-def log(msg: Union[str, Exception]) -> None:
+def log(msg: str | Exception) -> None:
     """Log message using logger at DEBUG level."""
     logging.getLogger(LOGGER_NAME).log(LOGGER_LEVEL, msg)
 
@@ -161,6 +161,10 @@ class EventType(str, Enum):
     FLWR_SERVERAPP_RUN_ENTER = auto()
     FLWR_SERVERAPP_RUN_LEAVE = auto()
 
+    # CLI: flwr-clientapp
+    FLWR_CLIENTAPP_RUN_ENTER = auto()
+    FLWR_CLIENTAPP_RUN_LEAVE = auto()
+
     # --- Simulation Engine ------------------------------------------------------------
 
     # CLI: flower-simulation
@@ -188,7 +192,7 @@ class EventType(str, Enum):
 
 # Use the ThreadPoolExecutor with max_workers=1 to have a queue
 # and also ensure that telemetry calls are not blocking.
-state: dict[str, Union[Optional[str], Optional[ThreadPoolExecutor]]] = {
+state: dict[str, str | None | ThreadPoolExecutor | None] = {
     # Will be assigned ThreadPoolExecutor(max_workers=1)
     # in event() the first time it's required
     "executor": None,
@@ -200,7 +204,7 @@ state: dict[str, Union[Optional[str], Optional[ThreadPoolExecutor]]] = {
 
 def event(
     event_type: EventType,
-    event_details: Optional[dict[str, Any]] = None,
+    event_details: dict[str, Any] | None = None,
 ) -> Future:  # type: ignore
     """Submit create_event to ThreadPoolExecutor to avoid blocking."""
     if state["executor"] is None:
@@ -212,7 +216,7 @@ def event(
     return result
 
 
-def create_event(event_type: EventType, event_details: Optional[dict[str, Any]]) -> str:
+def create_event(event_type: EventType, event_details: dict[str, Any] | None) -> str:
     """Create telemetry event."""
     if state["source"] is None:
         state["source"] = _get_source_id()