flwr 1.23.0__py3-none-any.whl → 1.24.0__py3-none-any.whl

flwr/common/record/arrayrecord.py

@@ -63,7 +63,7 @@ class ArrayRecord(TypedDict[str, Array], InflatableObject):
 
     A typed dictionary (``str`` to :class:`Array`) that can store named arrays,
     including model parameters, gradients, embeddings or non-parameter arrays.
-    Internally, this behaves similarly to an ``OrderedDict[str, Array]``.
+    Internally, this behaves similarly to an ``dict[str, Array]``.
     An ``ArrayRecord`` can be viewed as an equivalent to PyTorch's ``state_dict``,
     but it holds arrays in a serialized form.
 
@@ -80,13 +80,13 @@ class ArrayRecord(TypedDict[str, Array], InflatableObject):
 
     Parameters
     ----------
-    array_dict : Optional[OrderedDict[str, Array]] (default: None)
+    array_dict : Optional[dict[str, Array]] (default: None)
         An existing dictionary containing named :class:`Array` instances. If
         provided, these entries will be used directly to populate the record.
     numpy_ndarrays : Optional[list[NDArray]] (default: None)
         A list of NumPy arrays. Each array will be automatically converted
         into an :class:`Array` and stored in this record with generated keys.
-    torch_state_dict : Optional[OrderedDict[str, torch.Tensor]] (default: None)
+    torch_state_dict : Optional[dict[str, torch.Tensor]] (default: None)
         A PyTorch ``state_dict`` (``str`` keys to ``torch.Tensor`` values). Each
         tensor will be converted into an :class:`Array` and stored in this record.
     keep_input : bool (default: True)
@@ -127,31 +127,23 @@ class ArrayRecord(TypedDict[str, Array], InflatableObject):
     """
 
     @overload
-    def __init__(self) -> None: ...  # noqa: E704
+    def __init__(self) -> None: ...
 
     @overload
-    def __init__(  # noqa: E704
-        self, array_dict: OrderedDict[str, Array], *, keep_input: bool = True
+    def __init__(
+        self, array_dict: dict[str, Array], *, keep_input: bool = True
     ) -> None: ...
 
     @overload
-    def __init__(  # noqa: E704
+    def __init__(
         self, numpy_ndarrays: list[NDArray], *, keep_input: bool = True
     ) -> None: ...
 
     @overload
-    def __init__(  # noqa: E704
+    def __init__(
         self,
-        torch_state_dict: OrderedDict[str, torch.Tensor],
-        *,
-        keep_input: bool = True,
-    ) -> None: ...
-
-    # This is also required for PyTorch state dict because they are not strongly typed
-    @overload
-    def __init__(  # noqa: E704
-        self,
-        torch_state_dict: dict[str, Any],
+        # `Any` is required for PyTorch state dict because they are not strongly typed
+        torch_state_dict: dict[str, torch.Tensor] | dict[str, Any],
         *,
         keep_input: bool = True,
     ) -> None: ...
@@ -160,15 +152,15 @@ class ArrayRecord(TypedDict[str, Array], InflatableObject):
         self,
         *args: Any,
         numpy_ndarrays: list[NDArray] | None = None,
-        torch_state_dict: OrderedDict[str, torch.Tensor] | dict[str, Any] | None = None,
-        array_dict: OrderedDict[str, Array] | None = None,
+        torch_state_dict: dict[str, torch.Tensor] | dict[str, Any] | None = None,
+        array_dict: dict[str, Array] | None = None,
         keep_input: bool = True,
     ) -> None:
         super().__init__(_check_key, _check_value)
 
         # Determine the initialization method and validates input arguments.
         # Support the following initialization formats:
-        # 1. cls(array_dict: OrderedDict[str, Array], keep_input: bool)
+        # 1. cls(array_dict: dict[str, Array], keep_input: bool)
         # 2. cls(numpy_ndarrays: list[NDArray], keep_input: bool)
         # 3. cls(torch_state_dict: dict[str, torch.Tensor], keep_input: bool)
 
@@ -213,7 +205,7 @@ class ArrayRecord(TypedDict[str, Array], InflatableObject):
                 and all(isinstance(k, str) for k in arg.keys())
                 and all(isinstance(v, Array) for v in arg.values())
             ):
-                array_dict = cast(OrderedDict[str, Array], arg)
+                array_dict = cast(dict[str, Array], arg)
                 converted = self.from_array_dict(array_dict, keep_input=keep_input)
                 self.__dict__.update(converted.__dict__)
                 return
@@ -239,9 +231,7 @@ class ArrayRecord(TypedDict[str, Array], InflatableObject):
                 and all(isinstance(k, str) for k in arg.keys())
                 and all(isinstance(v, torch.Tensor) for v in arg.values())
             ):
-                torch_state_dict = cast(
-                    OrderedDict[str, torch.Tensor], arg  # type: ignore
-                )
+                torch_state_dict = cast(dict[str, torch.Tensor], arg)  # type: ignore
                 converted = self.from_torch_state_dict(
                     torch_state_dict, keep_input=keep_input
                 )
@@ -253,7 +243,7 @@ class ArrayRecord(TypedDict[str, Array], InflatableObject):
     @classmethod
     def from_array_dict(
         cls,
-        array_dict: OrderedDict[str, Array],
+        array_dict: dict[str, Array],
         *,
         keep_input: bool = True,
     ) -> ArrayRecord:
@@ -300,7 +290,7 @@ class ArrayRecord(TypedDict[str, Array], InflatableObject):
     @classmethod
     def from_torch_state_dict(
         cls,
-        state_dict: OrderedDict[str, torch.Tensor],
+        state_dict: dict[str, torch.Tensor],
         *,
         keep_input: bool = True,
     ) -> ArrayRecord:
@@ -433,9 +423,7 @@ class ArrayRecord(TypedDict[str, Array], InflatableObject):
 
         # Instantiate new ArrayRecord
         return ArrayRecord(
-            OrderedDict(
-                {name: children[object_id] for name, object_id in array_refs.items()}
-            )
+            {name: children[object_id] for name, object_id in array_refs.items()}
         )
 
     @property

flwr/common/record/configrecord.py

@@ -142,11 +142,11 @@ class ConfigRecord(TypedDict[str, ConfigRecordValues], InflatableObject):
             var_bytes = 0
             if isinstance(value, bool):
                 var_bytes = 1
-            elif isinstance(value, (int, float)):
+            elif isinstance(value, (int | float)):
                 var_bytes = (
                     8  # the profobufing represents int/floats in ConfigRecords as 64bit
                 )
-            if isinstance(value, (str, bytes)):
+            if isinstance(value, (str | bytes)):
                 var_bytes = len(value)
             if var_bytes == 0:
                 raise ValueError(
@@ -159,7 +159,7 @@ class ConfigRecord(TypedDict[str, ConfigRecordValues], InflatableObject):
 
         for k, v in self.items():
             if isinstance(v, list):
-                if isinstance(v[0], (bytes, str)):
+                if isinstance(v[0], (bytes | str)):
                     # not all str are of equal length necessarily
                     # for both the footprint of each element is 1 Byte
                     num_bytes += int(sum(len(s) for s in v))  # type: ignore

flwr/common/record/recorddict.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 import json
 from logging import WARN
 from textwrap import indent
-from typing import TypeVar, Union, cast
+from typing import TypeVar, cast
 
 from ..inflatable import InflatableObject, add_header_to_object_body, get_object_body
 from ..logger import log
@@ -29,7 +29,7 @@ from .configrecord import ConfigRecord
 from .metricrecord import MetricRecord
 from .typeddict import TypedDict
 
-RecordType = Union[ArrayRecord, MetricRecord, ConfigRecord]
+RecordType = ArrayRecord | MetricRecord | ConfigRecord
 
 
 class _WarningTracker:
@@ -59,7 +59,7 @@ def _check_key(key: str) -> None:
 
 
 def _check_value(value: RecordType) -> None:
-    if not isinstance(value, (ArrayRecord, MetricRecord, ConfigRecord)):
+    if not isinstance(value, (ArrayRecord | MetricRecord | ConfigRecord)):
         raise TypeError(
             f"Expected `{ArrayRecord.__name__}`, `{MetricRecord.__name__}`, "
             f"or `{ConfigRecord.__name__}` but received "
@@ -76,7 +76,7 @@ class _SyncedDict(TypedDict[str, T]):
     """
 
     def __init__(self, ref_recorddict: RecordDict, allowed_type: type[T]) -> None:
-        if not issubclass(allowed_type, (ArrayRecord, MetricRecord, ConfigRecord)):
+        if not issubclass(allowed_type, (ArrayRecord | MetricRecord | ConfigRecord)):
             raise TypeError(f"{allowed_type} is not a valid type.")
         super().__init__(_check_key, self.check_value)
         self.recorddict = ref_recorddict
@@ -341,7 +341,7 @@ class RecordDict(TypedDict[str, RecordType], InflatableObject):
 
         # Ensure children are one of the *Record objects exepecte in a RecordDict
         if not all(
-            isinstance(ch, (ArrayRecord, ConfigRecord, MetricRecord))
+            isinstance(ch, (ArrayRecord | ConfigRecord | MetricRecord))
             for ch in children.values()
         ):
             raise ValueError(

flwr/common/record/typeddict.py

@@ -15,8 +15,15 @@
 """Typed dict base class for *Records."""
 
 
-from collections.abc import ItemsView, Iterator, KeysView, MutableMapping, ValuesView
-from typing import Callable, Generic, TypeVar, cast
+from collections.abc import (
+    Callable,
+    ItemsView,
+    Iterator,
+    KeysView,
+    MutableMapping,
+    ValuesView,
+)
+from typing import Generic, TypeVar, cast
 
 from typing_extensions import Self
 

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/ndarrays_arithmetic.py

@@ -15,7 +15,7 @@
 """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
@@ -68,14 +68,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,7 +15,6 @@
 """ProtoBuf serialization and deserialization."""
 
 
-from collections import OrderedDict
 from typing import Any, cast
 
 # pylint: disable=E0611
@@ -410,9 +409,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,
     )
 
@@ -632,6 +631,7 @@ 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,
     )
     return proto
 
@@ -650,6 +650,7 @@ 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,
     )
     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,7 +25,7 @@ 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
@@ -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()

flwr/common/typing.py

@@ -15,13 +15,16 @@
 """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.proto.node_pb2 import NodeInfo  # pylint: disable=E0611
+
 NDArray = npt.NDArray[Any]
 NDArrayInt = npt.NDArray[np.int_]
 NDArrayFloat = npt.NDArray[np.float64]
@@ -31,29 +34,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,7 +64,7 @@ Config = dict[str, Scalar]
 Properties = dict[str, Scalar]
 
 # Value type for user configs
-UserConfigValue = Union[bool, float, int, str]
+UserConfigValue = bool | float | int | str
 UserConfig = dict[str, UserConfigValue]
 
 
@@ -177,7 +180,7 @@ class GetPropertiesRes:
 class ReconnectIns:
     """ReconnectIns message from server to client."""
 
-    seconds: Optional[int]
+    seconds: int | None
 
 
 @dataclass
@@ -191,20 +194,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 +234,7 @@ class Run:  # pylint: disable=too-many-instance-attributes
     finished_at: str
     status: RunStatus
     flwr_aid: str
+    federation: str
 
     @classmethod
     def create_empty(cls, run_id: int) -> "Run":
@@ -247,6 +251,7 @@ class Run:  # pylint: disable=too-many-instance-attributes
             finished_at="",
             status=RunStatus(status="", sub_status="", details=""),
             flwr_aid="",
+            federation="",
         )
 
 
@@ -295,16 +300,16 @@ class AccountAuthCredentials:
 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
 
 
@@ -313,8 +318,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
@@ -325,3 +330,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]