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

flwr/common/inflatable_utils.py

@@ -14,21 +14,23 @@
 # ==============================================================================
 """InflatableObject utilities."""
 
+
 import concurrent.futures
 import os
 import random
 import threading
 import time
-from collections.abc import Iterable, Iterator
-from typing import Callable, Optional, TypeVar
+from collections.abc import Callable, Iterable, Iterator
+from queue import Queue
+from typing import TypeVar
 
 from flwr.proto.message_pb2 import ObjectTree  # pylint: disable=E0611
 
 from .constant import (
+    FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PULLS,
+    FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PUSHES,
     HEAD_BODY_DIVIDER,
     HEAD_VALUE_DIVIDER,
-    MAX_CONCURRENT_PULLS,
-    MAX_CONCURRENT_PUSHES,
     PULL_BACKOFF_CAP,
     PULL_INITIAL_BACKOFF,
     PULL_MAX_TIME,
@@ -116,9 +118,9 @@ def push_objects(
     objects: dict[str, InflatableObject],
     push_object_fn: Callable[[str, bytes], None],
     *,
-    object_ids_to_push: Optional[set[str]] = None,
+    object_ids_to_push: set[str] | None = None,
     keep_objects: bool = False,
-    max_concurrent_pushes: int = MAX_CONCURRENT_PUSHES,
+    max_concurrent_pushes: int = FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PUSHES,
 ) -> None:
     """Push multiple objects to the servicer.
 
@@ -137,7 +139,7 @@ def push_objects(
         If `True`, the original objects will be kept in the `objects` dictionary
         after pushing. If `False`, they will be removed from the dictionary to avoid
         high memory usage.
-    max_concurrent_pushes : int (default: MAX_CONCURRENT_PUSHES)
+    max_concurrent_pushes : int (default: FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PUSHES)
         The maximum number of concurrent pushes to perform.
     """
     lock = threading.Lock()
@@ -168,7 +170,7 @@ def push_object_contents_from_iterable(
     object_contents: Iterable[tuple[str, bytes]],
     push_object_fn: Callable[[str, bytes], None],
     *,
-    max_concurrent_pushes: int = MAX_CONCURRENT_PUSHES,
+    max_concurrent_pushes: int = FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PUSHES,
 ) -> None:
     """Push multiple object contents to the servicer.
 
@@ -181,15 +183,24 @@ def push_object_contents_from_iterable(
         A function that takes an object ID and its content as bytes, and pushes
         it to the servicer. This function should raise `ObjectIdNotPreregisteredError`
         if the object ID is not pre-registered.
-    max_concurrent_pushes : int (default: MAX_CONCURRENT_PUSHES)
+    max_concurrent_pushes : int (default: FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PUSHES)
         The maximum number of concurrent pushes to perform.
     """
+    error_event = threading.Event()
+    err_queue: Queue[Exception] = Queue()
 
     def push(args: tuple[str, bytes]) -> None:
         """Push a single object."""
+        if error_event.is_set():
+            return
         obj_id, obj_content = args
         # Push the object using the provided function
-        push_object_fn(obj_id, obj_content)
+        try:
+            push_object_fn(obj_id, obj_content)
+        except Exception as err:  # pylint: disable=broad-except
+            # Unexpected error during pushing
+            error_event.set()
+            err_queue.put(err)
 
     # Push all object contents concurrently
     num_workers = get_num_workers(max_concurrent_pushes)
@@ -205,14 +216,18 @@ def push_object_contents_from_iterable(
     # Remove the executor from the list of tracked executors
     _untrack_executor(executor)
 
+    # If an error occurred during pushing, raise it
+    if not err_queue.empty():
+        raise err_queue.get()
+
 
 def pull_objects(  # pylint: disable=too-many-arguments,too-many-locals
     object_ids: list[str],
     pull_object_fn: Callable[[str], bytes],
     *,
-    max_concurrent_pulls: int = MAX_CONCURRENT_PULLS,
-    max_time: Optional[float] = PULL_MAX_TIME,
-    max_tries_per_object: Optional[int] = PULL_MAX_TRIES_PER_OBJECT,
+    max_concurrent_pulls: int = FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PULLS,
+    max_time: float | None = PULL_MAX_TIME,
+    max_tries_per_object: int | None = PULL_MAX_TRIES_PER_OBJECT,
     initial_backoff: float = PULL_INITIAL_BACKOFF,
     backoff_cap: float = PULL_BACKOFF_CAP,
 ) -> dict[str, bytes]:
@@ -227,7 +242,7 @@ def pull_objects(  # pylint: disable=too-many-arguments,too-many-locals
         The function should raise `ObjectUnavailableError` if the object is not yet
         available, or `ObjectIdNotPreregisteredError` if the object ID is not
         pre-registered.
-    max_concurrent_pulls : int (default: MAX_CONCURRENT_PULLS)
+    max_concurrent_pulls : int (default: FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PULLS)
         The maximum number of concurrent pulls to perform.
     max_time : Optional[float] (default: PULL_MAX_TIME)
         The maximum time to wait for all pulls to complete. If `None`, waits
@@ -254,13 +269,16 @@ def pull_objects(  # pylint: disable=too-many-arguments,too-many-locals
 
     results: dict[str, bytes] = {}
     results_lock = threading.Lock()
-    err_to_raise: Optional[Exception] = None
+    err_queue: Queue[Exception] = Queue()
     early_stop = threading.Event()
     start = time.monotonic()
 
+    def stop_on_error(err: Exception) -> None:
+        early_stop.set()
+        err_queue.put(err)
+
     def pull_with_retries(object_id: str) -> None:
         """Attempt to pull a single object with retry and backoff."""
-        nonlocal err_to_raise
         tries = 0
         delay = initial_backoff
 
@@ -278,10 +296,7 @@ def pull_objects(  # pylint: disable=too-many-arguments,too-many-locals
                     or time.monotonic() - start >= max_time
                 ):
                     # Stop all work if one object exhausts retries
-                    early_stop.set()
-                    with results_lock:
-                        if err_to_raise is None:
-                            err_to_raise = err
+                    stop_on_error(err)
                     return
 
                 # Apply exponential backoff with ±20% jitter
@@ -291,10 +306,12 @@ def pull_objects(  # pylint: disable=too-many-arguments,too-many-locals
 
             except ObjectIdNotPreregisteredError as err:
                 # Permanent failure: object ID is invalid
-                early_stop.set()
-                with results_lock:
-                    if err_to_raise is None:
-                        err_to_raise = err
+                stop_on_error(err)
+                return
+
+            except Exception as err:  # pylint: disable=broad-except
+                # Permanent failure: unexpected error
+                stop_on_error(err)
                 return
 
     # Submit all pull tasks concurrently
@@ -312,8 +329,8 @@ def pull_objects(  # pylint: disable=too-many-arguments,too-many-locals
     _untrack_executor(executor)
 
     # If an error occurred during pulling, raise it
-    if err_to_raise is not None:
-        raise err_to_raise
+    if not err_queue.empty():
+        raise err_queue.get()
 
     return results
 
@@ -323,7 +340,7 @@ def inflate_object_from_contents(
     object_contents: dict[str, bytes],
     *,
     keep_object_contents: bool = False,
-    objects: Optional[dict[str, InflatableObject]] = None,
+    objects: dict[str, InflatableObject] | None = None,
 ) -> InflatableObject:
     """Inflate an object from object contents.
 
@@ -442,9 +459,9 @@ def pull_and_inflate_object_from_tree(  # pylint: disable=R0913
     confirm_object_received_fn: Callable[[str], None],
     *,
     return_type: type[T] = InflatableObject,  # type: ignore
-    max_concurrent_pulls: int = MAX_CONCURRENT_PULLS,
-    max_time: Optional[float] = PULL_MAX_TIME,
-    max_tries_per_object: Optional[int] = PULL_MAX_TRIES_PER_OBJECT,
+    max_concurrent_pulls: int = FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PULLS,
+    max_time: float | None = PULL_MAX_TIME,
+    max_tries_per_object: int | None = PULL_MAX_TRIES_PER_OBJECT,
     initial_backoff: float = PULL_INITIAL_BACKOFF,
     backoff_cap: float = PULL_BACKOFF_CAP,
 ) -> T:
@@ -460,7 +477,7 @@ def pull_and_inflate_object_from_tree(  # pylint: disable=R0913
         A function to confirm that the object has been received.
     return_type : type[T] (default: InflatableObject)
         The type of the object to return. Must be a subclass of `InflatableObject`.
-    max_concurrent_pulls : int (default: MAX_CONCURRENT_PULLS)
+    max_concurrent_pulls : int (default: FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PULLS)
         The maximum number of concurrent pulls to perform.
     max_time : Optional[float] (default: PULL_MAX_TIME)
         The maximum time to wait for all pulls to complete. If `None`, waits

flwr/common/logger.py

@@ -26,7 +26,7 @@ from io import StringIO
 from logging import ERROR, WARN, LogRecord
 from logging.handlers import HTTPHandler
 from queue import Empty, Queue
-from typing import TYPE_CHECKING, Any, Optional, TextIO, Union
+from typing import TYPE_CHECKING, Any, TextIO
 
 import grpc
 import typer
@@ -68,7 +68,7 @@ class ConsoleHandler(StreamHandler):
         timestamps: bool = False,
         json: bool = False,
         colored: bool = True,
-        stream: Optional[TextIO] = None,
+        stream: TextIO | None = None,
     ) -> None:
         super().__init__(stream)
         self.timestamps = timestamps
@@ -103,9 +103,9 @@ class ConsoleHandler(StreamHandler):
 
 
 def update_console_handler(
-    level: Optional[Union[int, str]] = None,
-    timestamps: Optional[bool] = None,
-    colored: Optional[bool] = None,
+    level: int | str | None = None,
+    timestamps: bool | None = None,
+    colored: bool | None = None,
 ) -> None:
     """Update the logging handler."""
     for handler in logging.getLogger(LOGGER_NAME).handlers:
@@ -160,7 +160,7 @@ class CustomHTTPHandler(HTTPHandler):
         url: str,
         method: str = "GET",
         secure: bool = False,
-        credentials: Optional[tuple[str, str]] = None,
+        credentials: tuple[str, str] | None = None,
     ) -> None:
         super().__init__(host, url, method, secure, credentials)
         self.identifier = identifier
@@ -180,7 +180,7 @@ class CustomHTTPHandler(HTTPHandler):
 
 
 def configure(
-    identifier: str, filename: Optional[str] = None, host: Optional[str] = None
+    identifier: str, filename: str | None = None, host: str | None = None
 ) -> None:
     """Configure logging to file and/or remote log server."""
     # Create formatter
@@ -298,7 +298,7 @@ def set_logger_propagation(
     return child_logger
 
 
-def mirror_output_to_queue(log_queue: Queue[Optional[str]]) -> None:
+def mirror_output_to_queue(log_queue: Queue[str | None]) -> None:
     """Mirror stdout and stderr output to the provided queue."""
 
     def get_write_fn(stream: TextIO) -> Any:
@@ -335,7 +335,7 @@ def redirect_output(output_buffer: StringIO) -> None:
 
 
 def _log_uploader(
-    log_queue: Queue[Optional[str]], node_id: int, run_id: int, stub: ServerAppIoStub
+    log_queue: Queue[str | None], node_id: int, run_id: int, stub: ServerAppIoStub
 ) -> None:
     """Upload logs to the SuperLink."""
     exit_flag = False
@@ -378,10 +378,10 @@ def _log_uploader(
 
 
 def start_log_uploader(
-    log_queue: Queue[Optional[str]],
+    log_queue: Queue[str | None],
     node_id: int,
     run_id: int,
-    stub: Union[ServerAppIoStub, SimulationIoStub],
+    stub: ServerAppIoStub | SimulationIoStub,
 ) -> threading.Thread:
     """Start the log uploader thread and return it."""
     thread = threading.Thread(
@@ -392,7 +392,7 @@ def start_log_uploader(
 
 
 def stop_log_uploader(
-    log_queue: Queue[Optional[str]], log_uploader: threading.Thread
+    log_queue: Queue[str | None], log_uploader: threading.Thread
 ) -> None:
     """Stop the log uploader thread."""
     log_queue.put(None)
@@ -403,19 +403,19 @@ def _remove_emojis(text: str) -> str:
     """Remove emojis from the provided text."""
     emoji_pattern = re.compile(
         "["
-        "\U0001F600-\U0001F64F"  # Emoticons
-        "\U0001F300-\U0001F5FF"  # Symbols & Pictographs
-        "\U0001F680-\U0001F6FF"  # Transport & Map Symbols
-        "\U0001F1E0-\U0001F1FF"  # Flags
-        "\U00002702-\U000027B0"  # Dingbats
-        "\U000024C2-\U0001F251"
+        "\U0001f600-\U0001f64f"  # Emoticons
+        "\U0001f300-\U0001f5ff"  # Symbols & Pictographs
+        "\U0001f680-\U0001f6ff"  # Transport & Map Symbols
+        "\U0001f1e0-\U0001f1ff"  # Flags
+        "\U00002702-\U000027b0"  # Dingbats
+        "\U000024c2-\U0001f251"
         "]+",
         flags=re.UNICODE,
     )
     return emoji_pattern.sub(r"", text)
 
 
-def print_json_error(msg: str, e: Union[typer.Exit, Exception]) -> None:
+def print_json_error(msg: str, e: typer.Exit | Exception) -> None:
     """Print error message as JSON."""
     Console().print_json(
         _json.dumps(

flwr/common/message.py

@@ -105,7 +105,7 @@ class Message(InflatableObject):
     """
 
     @overload
-    def __init__(  # pylint: disable=too-many-arguments  # noqa: E704
+    def __init__(  # pylint: disable=too-many-arguments
         self,
         content: RecordDict,
         dst_node_id: int,
@@ -116,12 +116,12 @@ class Message(InflatableObject):
     ) -> None: ...
 
     @overload
-    def __init__(  # noqa: E704
+    def __init__(
         self, content: RecordDict, *, reply_to: Message, ttl: float | None = None
     ) -> None: ...
 
     @overload
-    def __init__(  # noqa: E704
+    def __init__(
         self, error: Error, *, reply_to: Message, ttl: float | None = None
     ) -> None: ...
 
@@ -511,7 +511,7 @@ def _check_arg_types(  # pylint: disable=too-many-arguments, R0917
         and (message_type is None or isinstance(message_type, str))
         and (content is None or isinstance(content, RecordDict))
         and (error is None or isinstance(error, Error))
-        and (ttl is None or isinstance(ttl, (int, float)))
+        and (ttl is None or isinstance(ttl, (int | float)))
         and (group_id is None or isinstance(group_id, str))
         and (reply_to is None or isinstance(reply_to, Message))
         and (metadata is None or isinstance(metadata, Metadata))

flwr/common/object_ref.py

@@ -21,7 +21,7 @@ import sys
 from importlib.util import find_spec
 from pathlib import Path
 from threading import Lock
-from typing import Any, Optional, Union
+from typing import Any
 
 OBJECT_REF_HELP_STR = """
 \n\nThe object reference string should have the form <module>:<attribute>. Valid
@@ -31,15 +31,15 @@ attribute.
 """
 
 
-_current_sys_path: Optional[str] = None
+_current_sys_path: str | None = None
 _import_lock = Lock()
 
 
 def validate(
     module_attribute_str: str,
     check_module: bool = True,
-    project_dir: Optional[Union[str, Path]] = None,
-) -> tuple[bool, Optional[str]]:
+    project_dir: str | Path | None = None,
+) -> tuple[bool, str | None]:
     """Validate object reference.
 
     Parameters
@@ -114,7 +114,7 @@ def validate(
 def load_app(  # pylint: disable= too-many-branches
     module_attribute_str: str,
     error_type: type[Exception],
-    project_dir: Optional[Union[str, Path]] = None,
+    project_dir: str | Path | None = None,
 ) -> Any:
     """Return the object specified in a module attribute string.
 
@@ -194,12 +194,12 @@ def _unload_modules(project_dir: Path) -> None:
     """Unload modules from the project directory."""
     dir_str = str(project_dir.absolute())
     for name, m in list(sys.modules.items()):
-        path: Optional[str] = getattr(m, "__file__", None)
+        path: str | None = getattr(m, "__file__", None)
         if path is not None and path.startswith(dir_str):
             del sys.modules[name]
 
 
-def _set_sys_path(directory: Optional[Union[str, Path]]) -> None:
+def _set_sys_path(directory: str | Path | None) -> None:
     """Set the system path."""
     if directory is None:
         directory = Path.cwd()

flwr/common/record/array.py

@@ -25,7 +25,7 @@ from typing import TYPE_CHECKING, Any, cast, overload
 
 import numpy as np
 
-from ..constant import MAX_ARRAY_CHUNK_SIZE, SType
+from ..constant import FLWR_PRIVATE_MAX_ARRAY_CHUNK_SIZE, SType
 from ..inflatable import (
     InflatableObject,
     add_header_to_object_body,
@@ -117,15 +117,15 @@ class Array(InflatableObject):
     data: bytes
 
     @overload
-    def __init__(  # noqa: E704
+    def __init__(
         self, dtype: str, shape: tuple[int, ...], stype: str, data: bytes
     ) -> None: ...
 
     @overload
-    def __init__(self, ndarray: NDArray) -> None: ...  # noqa: E704
+    def __init__(self, ndarray: NDArray) -> None: ...
 
     @overload
-    def __init__(self, torch_tensor: torch.Tensor) -> None: ...  # noqa: E704
+    def __init__(self, torch_tensor: torch.Tensor) -> None: ...
 
     def __init__(  # pylint: disable=too-many-arguments, too-many-locals
         self,
@@ -272,8 +272,8 @@ class Array(InflatableObject):
         chunks: list[tuple[str, InflatableObject]] = []
         # memoryview allows for zero-copy slicing
         data_view = memoryview(self.data)
-        for start in range(0, len(data_view), MAX_ARRAY_CHUNK_SIZE):
-            end = min(start + MAX_ARRAY_CHUNK_SIZE, len(data_view))
+        for start in range(0, len(data_view), FLWR_PRIVATE_MAX_ARRAY_CHUNK_SIZE):
+            end = min(start + FLWR_PRIVATE_MAX_ARRAY_CHUNK_SIZE, len(data_view))
             ac = ArrayChunk(data_view[start:end])
             chunks.append((ac.object_id, ac))
 

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,22 +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],
+        # `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: ...
@@ -151,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] | 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)
 
@@ -204,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
@@ -230,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
                 )
@@ -244,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:
@@ -291,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:
@@ -424,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