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

flwr/common/exit/exit_code.py

@@ -38,12 +38,14 @@ class ExitCode:
     SERVERAPP_STRATEGY_PRECONDITION_UNMET = 200
     SERVERAPP_EXCEPTION = 201
     SERVERAPP_STRATEGY_AGGREGATION_ERROR = 202
+    SERVERAPP_RUN_START_REJECTED = 203
 
     # SuperNode-specific exit codes (300-399)
     SUPERNODE_REST_ADDRESS_INVALID = 300
     # SUPERNODE_NODE_AUTH_KEYS_REQUIRED = 301 --- DELETED ---
     SUPERNODE_NODE_AUTH_KEY_INVALID = 302
     SUPERNODE_STARTED_WITHOUT_TLS_BUT_NODE_AUTH_ENABLED = 303
+    SUPERNODE_INVALID_TRUSTED_ENTITIES = 304
 
     # SuperExec-specific exit codes (400-499)
     SUPEREXEC_INVALID_PLUGIN_CONFIG = 400
@@ -56,6 +58,9 @@ class ExitCode:
     COMMON_MISSING_EXTRA_REST = 601
     COMMON_TLS_NOT_SUPPORTED = 602
 
+    # Simulation exit codes (700-799)
+    SIMULATION_EXCEPTION = 700
+
     def __new__(cls) -> ExitCode:
         """Prevent instantiation."""
         raise TypeError(f"{cls.__name__} cannot be instantiated.")
@@ -101,6 +106,11 @@ EXIT_CODE_HELP = {
         "The strategy encountered an error during aggregation. Please check the logs "
         "for more details."
     ),
+    ExitCode.SERVERAPP_RUN_START_REJECTED: (
+        "The SuperLink rejected the request to start the run. This may occur if the "
+        "run has been stopped, the run ID or FAB is invalid, or the run failed to "
+        "start within the allowed time."
+    ),
     # SuperNode-specific exit codes (300-399)
     ExitCode.SUPERNODE_REST_ADDRESS_INVALID: (
         "When using the REST API, please provide `https://` or "
@@ -115,6 +125,11 @@ EXIT_CODE_HELP = {
         "The private key for SuperNode authentication was provided, but TLS is not "
         "enabled. Node authentication can only be used when TLS is enabled."
     ),
+    ExitCode.SUPERNODE_INVALID_TRUSTED_ENTITIES: (
+        "Failed to read the trusted entities YAML file. "
+        "Please ensure that a valid file is provided using "
+        "the `--trusted-entities` option."
+    ),
     # SuperExec-specific exit codes (400-499)
     ExitCode.SUPEREXEC_INVALID_PLUGIN_CONFIG: (
         "The YAML configuration for the SuperExec plugin is invalid."
@@ -138,4 +153,8 @@ To use the REST API, install `flwr` with the `rest` extra:
     `pip install "flwr[rest]"`.
 """,
     ExitCode.COMMON_TLS_NOT_SUPPORTED: "Please use the '--insecure' flag.",
+    # Simulation exit codes (700-799)
+    ExitCode.SIMULATION_EXCEPTION: (
+        "An unhandled exception occurred when running the simulation."
+    ),
 }

flwr/common/exit/exit_handler.py

@@ -17,7 +17,7 @@
 
 import signal
 import threading
-from typing import Callable
+from collections.abc import Callable
 
 from .exit_code import ExitCode
 
@@ -58,5 +58,9 @@ def trigger_exit_handlers() -> None:
     """Trigger all registered exit handlers in LIFO order."""
     with _lock_handlers:
         for handler in reversed(registered_exit_handlers):
-            handler()
+            try:
+                handler()
+            except Exception:  # pylint: disable=broad-exception-caught
+                # Ignore exceptions in exit handlers
+                pass
         registered_exit_handlers.clear()

flwr/common/exit/signal_handler.py

@@ -16,9 +16,9 @@
 
 
 import signal
+from collections.abc import Callable
 from threading import Thread
 from types import FrameType
-from typing import Callable, Optional
 
 from grpc import Server
 
@@ -40,10 +40,10 @@ if hasattr(signal, "SIGQUIT"):
 
 def register_signal_handlers(
     event_type: EventType,
-    exit_message: Optional[str] = None,
-    grpc_servers: Optional[list[Server]] = None,
-    bckg_threads: Optional[list[Thread]] = None,
-    exit_handlers: Optional[list[Callable[[], None]]] = None,
+    exit_message: str | None = None,
+    grpc_servers: list[Server] | None = None,
+    bckg_threads: list[Thread] | None = None,
+    exit_handlers: list[Callable[[], None]] | None = None,
 ) -> None:
     """Register exit handlers for `SIGINT`, `SIGTERM` and `SIGQUIT` signals.
 

flwr/common/grpc.py

@@ -18,9 +18,9 @@
 import concurrent.futures
 import os
 import sys
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from logging import DEBUG, ERROR
-from typing import Any, Callable, Optional
+from typing import Any
 
 import grpc
 
@@ -46,9 +46,9 @@ if "GRPC_VERBOSITY" not in os.environ:
 def create_channel(
     server_address: str,
     insecure: bool,
-    root_certificates: Optional[bytes] = None,
+    root_certificates: bytes | None = None,
     max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
-    interceptors: Optional[Sequence[grpc.UnaryUnaryClientInterceptor]] = None,
+    interceptors: Sequence[grpc.UnaryUnaryClientInterceptor] | None = None,
 ) -> grpc.Channel:
     """Create a gRPC channel, either secure or insecure."""
     # Check for conflicting parameters
@@ -104,8 +104,8 @@ def generic_create_grpc_server(  # pylint: disable=too-many-arguments, R0914, R0
     max_concurrent_workers: int = 1000,
     max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
     keepalive_time_ms: int = 210000,
-    certificates: Optional[tuple[bytes, bytes, bytes]] = None,
-    interceptors: Optional[Sequence[grpc.ServerInterceptor]] = None,
+    certificates: tuple[bytes, bytes, bytes] | None = None,
+    interceptors: Sequence[grpc.ServerInterceptor] | None = None,
 ) -> grpc.Server:
     """Create a gRPC server with a single servicer.
 

flwr/common/inflatable_protobuf_utils.py

@@ -15,7 +15,7 @@
 """InflatableObject gRPC utils."""
 
 
-from typing import Callable
+from collections.abc import Callable
 
 from flwr.proto.message_pb2 import (  # pylint: disable=E0611
     ConfirmMessageReceivedRequest,

flwr/common/inflatable_utils.py

@@ -14,13 +14,15 @@
 # ==============================================================================
 """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
 
@@ -116,7 +118,7 @@ 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 = FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PUSHES,
 ) -> None:
@@ -184,12 +186,21 @@ def push_object_contents_from_iterable(
     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 = FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PULLS,
-    max_time: Optional[float] = PULL_MAX_TIME,
-    max_tries_per_object: Optional[int] = PULL_MAX_TRIES_PER_OBJECT,
+    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]:
@@ -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.
 
@@ -443,8 +460,8 @@ def pull_and_inflate_object_from_tree(  # pylint: disable=R0913
     *,
     return_type: type[T] = InflatableObject,  # type: ignore
     max_concurrent_pulls: int = FLWR_PRIVATE_MAX_CONCURRENT_OBJ_PULLS,
-    max_time: Optional[float] = PULL_MAX_TIME,
-    max_tries_per_object: Optional[int] = PULL_MAX_TRIES_PER_OBJECT,
+    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:

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

@@ -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,

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