flwr-nightly 1.12.0.dev20240906__py3-none-any.whl → 1.12.0.dev20240913__py3-none-any.whl

flwr/common/config.py

@@ -17,7 +17,7 @@
 import os
 import re
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union, cast, get_args
+from typing import Any, Optional, Union, cast, get_args
 
 import tomli
 
@@ -53,7 +53,7 @@ def get_project_dir(
     return Path(flwr_dir) / APP_DIR / publisher / project_name / fab_version
 
 
-def get_project_config(project_dir: Union[str, Path]) -> Dict[str, Any]:
+def get_project_config(project_dir: Union[str, Path]) -> dict[str, Any]:
     """Return pyproject.toml in the given project directory."""
     # Load pyproject.toml file
     toml_path = Path(project_dir) / FAB_CONFIG_FILE
@@ -137,13 +137,13 @@ def get_fused_config(run: Run, flwr_dir: Optional[Path]) -> UserConfig:
 
 
 def flatten_dict(
-    raw_dict: Optional[Dict[str, Any]], parent_key: str = ""
+    raw_dict: Optional[dict[str, Any]], parent_key: str = ""
 ) -> UserConfig:
     """Flatten dict by joining nested keys with a given separator."""
     if raw_dict is None:
         return {}
 
-    items: List[Tuple[str, UserConfigValue]] = []
+    items: list[tuple[str, UserConfigValue]] = []
     separator: str = "."
     for k, v in raw_dict.items():
         new_key = f"{parent_key}{separator}{k}" if parent_key else k
@@ -159,9 +159,9 @@ def flatten_dict(
     return dict(items)
 
 
-def unflatten_dict(flat_dict: Dict[str, Any]) -> Dict[str, Any]:
+def unflatten_dict(flat_dict: dict[str, Any]) -> dict[str, Any]:
     """Unflatten a dict with keys containing separators into a nested dict."""
-    unflattened_dict: Dict[str, Any] = {}
+    unflattened_dict: dict[str, Any] = {}
     separator: str = "."
 
     for key, value in flat_dict.items():
@@ -177,7 +177,7 @@ def unflatten_dict(flat_dict: Dict[str, Any]) -> Dict[str, Any]:
 
 
 def parse_config_args(
-    config: Optional[List[str]],
+    config: Optional[list[str]],
 ) -> UserConfig:
     """Parse separator separated list of key-value pairs separated by '='."""
     overrides: UserConfig = {}
@@ -209,7 +209,7 @@ def parse_config_args(
     return overrides
 
 
-def get_metadata_from_config(config: Dict[str, Any]) -> Tuple[str, str]:
+def get_metadata_from_config(config: dict[str, Any]) -> tuple[str, str]:
     """Extract `fab_version` and `fab_id` from a project config."""
     return (
         config["project"]["version"],

flwr/common/constant.py

@@ -37,7 +37,18 @@ TRANSPORT_TYPES = [
     TRANSPORT_TYPE_VCE,
 ]
 
-SUPEREXEC_DEFAULT_ADDRESS = "0.0.0.0:9093"
+# Addresses
+# SuperNode
+CLIENTAPPIO_API_DEFAULT_ADDRESS = "0.0.0.0:9094"
+# SuperExec
+EXEC_API_DEFAULT_ADDRESS = "0.0.0.0:9093"
+# SuperLink
+DRIVER_API_DEFAULT_ADDRESS = "0.0.0.0:9091"
+FLEET_API_GRPC_RERE_DEFAULT_ADDRESS = "0.0.0.0:9092"
+FLEET_API_GRPC_BIDI_DEFAULT_ADDRESS = (
+    "[::]:8080"  # IPv6 to keep start_server compatible
+)
+FLEET_API_REST_DEFAULT_ADDRESS = "0.0.0.0:9093"
 
 # Constants for ping
 PING_DEFAULT_INTERVAL = 30

flwr/common/differential_privacy.py

@@ -16,7 +16,7 @@
 
 
 from logging import WARNING
-from typing import Optional, Tuple
+from typing import Optional
 
 import numpy as np
 
@@ -125,7 +125,7 @@ def compute_adaptive_noise_params(
     noise_multiplier: float,
     num_sampled_clients: float,
     clipped_count_stddev: Optional[float],
-) -> Tuple[float, float]:
+) -> tuple[float, float]:
     """Compute noising parameters for the adaptive clipping.
 
     Paper: https://arxiv.org/abs/1905.03871

flwr/common/dp.py

@@ -15,8 +15,6 @@
 """Building block functions for DP algorithms."""
 
 
-from typing import Tuple
-
 import numpy as np
 
 from flwr.common.logger import warn_deprecated_feature
@@ -41,7 +39,7 @@ def add_gaussian_noise(update: NDArrays, std_dev: float) -> NDArrays:
     return update_noised
 
 
-def clip_by_l2(update: NDArrays, threshold: float) -> Tuple[NDArrays, bool]:
+def clip_by_l2(update: NDArrays, threshold: float) -> tuple[NDArrays, bool]:
     """Scales the update so thats its L2 norm is upper-bound to threshold."""
     warn_deprecated_feature("`clip_by_l2` method")
     update_norm = _get_update_norm(update)

flwr/common/exit_handlers.py

@@ -19,7 +19,7 @@ import sys
 from signal import SIGINT, SIGTERM, signal
 from threading import Thread
 from types import FrameType
-from typing import List, Optional
+from typing import Optional
 
 from grpc import Server
 
@@ -28,8 +28,8 @@ from flwr.common.telemetry import EventType, event
 
 def register_exit_handlers(
     event_type: EventType,
-    grpc_servers: Optional[List[Server]] = None,
-    bckg_threads: Optional[List[Thread]] = None,
+    grpc_servers: Optional[list[Server]] = None,
+    bckg_threads: Optional[list[Thread]] = None,
 ) -> None:
     """Register exit handlers for `SIGINT` and `SIGTERM` signals.
 

flwr/common/grpc.py

@@ -15,8 +15,9 @@
 """Utility functions for gRPC."""
 
 
+from collections.abc import Sequence
 from logging import DEBUG
-from typing import Optional, Sequence
+from typing import Optional
 
 import grpc
 

flwr/common/logger.py

@@ -18,7 +18,7 @@
 import logging
 from logging import WARN, LogRecord
 from logging.handlers import HTTPHandler
-from typing import TYPE_CHECKING, Any, Dict, Optional, TextIO, Tuple
+from typing import TYPE_CHECKING, Any, Optional, TextIO
 
 # Create logger
 LOGGER_NAME = "flwr"
@@ -119,12 +119,12 @@ class CustomHTTPHandler(HTTPHandler):
         url: str,
         method: str = "GET",
         secure: bool = False,
-        credentials: Optional[Tuple[str, str]] = None,
+        credentials: Optional[tuple[str, str]] = None,
     ) -> None:
         super().__init__(host, url, method, secure, credentials)
         self.identifier = identifier
 
-    def mapLogRecord(self, record: LogRecord) -> Dict[str, Any]:
+    def mapLogRecord(self, record: LogRecord) -> dict[str, Any]:
         """Filter for the properties to be send to the logserver."""
         record_dict = record.__dict__
         return {

flwr/common/object_ref.py

@@ -21,7 +21,7 @@ import sys
 from importlib.util import find_spec
 from logging import WARN
 from pathlib import Path
-from typing import Any, Optional, Tuple, Type, Union
+from typing import Any, Optional, Union
 
 from .logger import log
 
@@ -40,7 +40,7 @@ def validate(
     module_attribute_str: str,
     check_module: bool = True,
     project_dir: Optional[Union[str, Path]] = None,
-) -> Tuple[bool, Optional[str]]:
+) -> tuple[bool, Optional[str]]:
     """Validate object reference.
 
     Parameters
@@ -106,7 +106,7 @@ def validate(
 
 def load_app(  # pylint: disable= too-many-branches
     module_attribute_str: str,
-    error_type: Type[Exception],
+    error_type: type[Exception],
     project_dir: Optional[Union[str, Path]] = None,
 ) -> Any:
     """Return the object specified in a module attribute string.

flwr/common/record/configsrecord.py

@@ -15,7 +15,7 @@
 """ConfigsRecord."""
 
 
-from typing import Dict, List, Optional, get_args
+from typing import Optional, get_args
 
 from flwr.common.typing import ConfigsRecordValues, ConfigsScalar
 
@@ -109,7 +109,7 @@ class ConfigsRecord(TypedDict[str, ConfigsRecordValues]):
 
     def __init__(
         self,
-        configs_dict: Optional[Dict[str, ConfigsRecordValues]] = None,
+        configs_dict: Optional[dict[str, ConfigsRecordValues]] = None,
         keep_input: bool = True,
     ) -> None:
 
@@ -141,7 +141,7 @@ class ConfigsRecord(TypedDict[str, ConfigsRecordValues]):
         num_bytes = 0
 
         for k, v in self.items():
-            if isinstance(v, List):
+            if isinstance(v, list):
                 if isinstance(v[0], (bytes, str)):
                     # not all str are of equal length necessarily
                     # for both the footprint of each element is 1 Byte

flwr/common/record/metricsrecord.py

@@ -15,7 +15,7 @@
 """MetricsRecord."""
 
 
-from typing import Dict, List, Optional, get_args
+from typing import Optional, get_args
 
 from flwr.common.typing import MetricsRecordValues, MetricsScalar
 
@@ -115,7 +115,7 @@ class MetricsRecord(TypedDict[str, MetricsRecordValues]):
 
     def __init__(
         self,
-        metrics_dict: Optional[Dict[str, MetricsRecordValues]] = None,
+        metrics_dict: Optional[dict[str, MetricsRecordValues]] = None,
         keep_input: bool = True,
     ):
         super().__init__(_check_key, _check_value)
@@ -130,7 +130,7 @@ class MetricsRecord(TypedDict[str, MetricsRecordValues]):
         num_bytes = 0
 
         for k, v in self.items():
-            if isinstance(v, List):
+            if isinstance(v, list):
                 # both int and float normally take 4 bytes
                 # But MetricRecords are mapped to 64bit int/float
                 # during protobuffing

flwr/common/record/parametersrecord.py

@@ -14,9 +14,10 @@
 # ==============================================================================
 """ParametersRecord and Array."""
 
+from collections import OrderedDict
 from dataclasses import dataclass
 from io import BytesIO
-from typing import List, Optional, OrderedDict, cast
+from typing import Optional, cast
 
 import numpy as np
 
@@ -51,7 +52,7 @@ class Array:
     """
 
     dtype: str
-    shape: List[int]
+    shape: list[int]
     stype: str
     data: bytes
 

flwr/common/record/recordset.py

@@ -119,7 +119,7 @@ class RecordSet:
     Let's see an example.
 
     >>>  from flwr.common import RecordSet
-    >>>  from flwr.common import ConfigsRecords, MetricsRecords, ParametersRecord
+    >>>  from flwr.common import ConfigsRecord, MetricsRecord, ParametersRecord
     >>>
     >>>  # Let's begin with an empty record
     >>>  my_recordset = RecordSet()

flwr/common/record/typeddict.py

@@ -15,7 +15,8 @@
 """Typed dict base class for *Records."""
 
 
-from typing import Callable, Dict, Generic, Iterator, MutableMapping, TypeVar, cast
+from collections.abc import ItemsView, Iterator, KeysView, MutableMapping, ValuesView
+from typing import Callable, Generic, TypeVar, cast
 
 K = TypeVar("K")  # Key type
 V = TypeVar("V")  # Value type
@@ -38,38 +39,50 @@ class TypedDict(MutableMapping[K, V], Generic[K, V]):
         cast(Callable[[V], None], self.__dict__["_check_value_fn"])(value)
 
         # Set key-value pair
-        cast(Dict[K, V], self.__dict__["_data"])[key] = value
+        cast(dict[K, V], self.__dict__["_data"])[key] = value
 
     def __delitem__(self, key: K) -> None:
         """Remove the item with the specified key."""
-        del cast(Dict[K, V], self.__dict__["_data"])[key]
+        del cast(dict[K, V], self.__dict__["_data"])[key]
 
     def __getitem__(self, item: K) -> V:
         """Return the value for the specified key."""
-        return cast(Dict[K, V], self.__dict__["_data"])[item]
+        return cast(dict[K, V], self.__dict__["_data"])[item]
 
     def __iter__(self) -> Iterator[K]:
         """Yield an iterator over the keys of the dictionary."""
-        return iter(cast(Dict[K, V], self.__dict__["_data"]))
+        return iter(cast(dict[K, V], self.__dict__["_data"]))
 
     def __repr__(self) -> str:
         """Return a string representation of the dictionary."""
-        return cast(Dict[K, V], self.__dict__["_data"]).__repr__()
+        return cast(dict[K, V], self.__dict__["_data"]).__repr__()
 
     def __len__(self) -> int:
         """Return the number of items in the dictionary."""
-        return len(cast(Dict[K, V], self.__dict__["_data"]))
+        return len(cast(dict[K, V], self.__dict__["_data"]))
 
     def __contains__(self, key: object) -> bool:
         """Check if the dictionary contains the specified key."""
-        return key in cast(Dict[K, V], self.__dict__["_data"])
+        return key in cast(dict[K, V], self.__dict__["_data"])
 
     def __eq__(self, other: object) -> bool:
         """Compare this instance to another dictionary or TypedDict."""
-        data = cast(Dict[K, V], self.__dict__["_data"])
+        data = cast(dict[K, V], self.__dict__["_data"])
         if isinstance(other, TypedDict):
-            other_data = cast(Dict[K, V], other.__dict__["_data"])
+            other_data = cast(dict[K, V], other.__dict__["_data"])
             return data == other_data
         if isinstance(other, dict):
             return data == other
         return NotImplemented
+
+    def keys(self) -> KeysView[K]:
+        """D.keys() -> a set-like object providing a view on D's keys."""
+        return cast(dict[K, V], self.__dict__["_data"]).keys()
+
+    def values(self) -> ValuesView[V]:
+        """D.values() -> an object providing a view on D's values."""
+        return cast(dict[K, V], self.__dict__["_data"]).values()
+
+    def items(self) -> ItemsView[K, V]:
+        """D.items() -> a set-like object providing a view on D's items."""
+        return cast(dict[K, V], self.__dict__["_data"]).items()

flwr/common/recordset_compat.py

@@ -15,7 +15,9 @@
 """RecordSet utilities."""
 
 
-from typing import Dict, Mapping, OrderedDict, Tuple, Union, cast, get_args
+from collections import OrderedDict
+from collections.abc import Mapping
+from typing import Union, cast, get_args
 
 from . import Array, ConfigsRecord, MetricsRecord, ParametersRecord, RecordSet
 from .typing import (
@@ -115,7 +117,7 @@ def parameters_to_parametersrecord(
 
 def _check_mapping_from_recordscalartype_to_scalar(
     record_data: Mapping[str, Union[ConfigsRecordValues, MetricsRecordValues]]
-) -> Dict[str, Scalar]:
+) -> dict[str, Scalar]:
     """Check mapping `common.*RecordValues` into `common.Scalar` is possible."""
     for value in record_data.values():
         if not isinstance(value, get_args(Scalar)):
@@ -126,14 +128,14 @@ def _check_mapping_from_recordscalartype_to_scalar(
                 "supported by the `common.RecordSet` infrastructure. "
                 f"You used type: {type(value)}"
             )
-    return cast(Dict[str, Scalar], record_data)
+    return cast(dict[str, Scalar], record_data)
 
 
 def _recordset_to_fit_or_evaluate_ins_components(
     recordset: RecordSet,
     ins_str: str,
     keep_input: bool,
-) -> Tuple[Parameters, Dict[str, Scalar]]:
+) -> tuple[Parameters, dict[str, Scalar]]:
     """Derive Fit/Evaluate Ins from a RecordSet."""
     # get Array and construct Parameters
     parameters_record = recordset.parameters_records[f"{ins_str}.parameters"]
@@ -169,7 +171,7 @@ def _fit_or_evaluate_ins_to_recordset(
 def _embed_status_into_recordset(
     res_str: str, status: Status, recordset: RecordSet
 ) -> RecordSet:
-    status_dict: Dict[str, ConfigsRecordValues] = {
+    status_dict: dict[str, ConfigsRecordValues] = {
         "code": int(status.code.value),
         "message": status.message,
     }

flwr/common/retry_invoker.py

@@ -18,20 +18,9 @@
 import itertools
 import random
 import time
+from collections.abc import Generator, Iterable
 from dataclasses import dataclass
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Generator,
-    Iterable,
-    List,
-    Optional,
-    Tuple,
-    Type,
-    Union,
-    cast,
-)
+from typing import Any, Callable, Optional, Union, cast
 
 
 def exponential(
@@ -93,8 +82,8 @@ class RetryState:
     """State for callbacks in RetryInvoker."""
 
     target: Callable[..., Any]
-    args: Tuple[Any, ...]
-    kwargs: Dict[str, Any]
+    args: tuple[Any, ...]
+    kwargs: dict[str, Any]
     tries: int
     elapsed_time: float
     exception: Optional[Exception] = None
@@ -167,7 +156,7 @@ class RetryInvoker:
     def __init__(
         self,
         wait_gen_factory: Callable[[], Generator[float, None, None]],
-        recoverable_exceptions: Union[Type[Exception], Tuple[Type[Exception], ...]],
+        recoverable_exceptions: Union[type[Exception], tuple[type[Exception], ...]],
         max_tries: Optional[int],
         max_time: Optional[float],
         *,
@@ -244,7 +233,7 @@ class RetryInvoker:
         try_cnt = 0
         wait_generator = self.wait_gen_factory()
         start = time.monotonic()
-        ref_state: List[Optional[RetryState]] = [None]
+        ref_state: list[Optional[RetryState]] = [None]
 
         while True:
             try_cnt += 1

flwr/common/secure_aggregation/crypto/shamir.py

@@ -17,20 +17,20 @@
 
 import pickle
 from concurrent.futures import ThreadPoolExecutor
-from typing import List, Tuple, cast
+from typing import cast
 
 from Crypto.Protocol.SecretSharing import Shamir
 from Crypto.Util.Padding import pad, unpad
 
 
-def create_shares(secret: bytes, threshold: int, num: int) -> List[bytes]:
+def create_shares(secret: bytes, threshold: int, num: int) -> list[bytes]:
     """Return list of shares (bytes)."""
     secret_padded = pad(secret, 16)
     secret_padded_chunk = [
         (threshold, num, secret_padded[i : i + 16])
         for i in range(0, len(secret_padded), 16)
     ]
-    share_list: List[List[Tuple[int, bytes]]] = [[] for _ in range(num)]
+    share_list: list[list[tuple[int, bytes]]] = [[] for _ in range(num)]
 
     with ThreadPoolExecutor(max_workers=10) as executor:
         for chunk_shares in executor.map(
@@ -43,22 +43,22 @@ def create_shares(secret: bytes, threshold: int, num: int) -> List[bytes]:
     return [pickle.dumps(shares) for shares in share_list]
 
 
-def _shamir_split(threshold: int, num: int, chunk: bytes) -> List[Tuple[int, bytes]]:
+def _shamir_split(threshold: int, num: int, chunk: bytes) -> list[tuple[int, bytes]]:
     return Shamir.split(threshold, num, chunk, ssss=False)
 
 
 # Reconstructing secret with PyCryptodome
-def combine_shares(share_list: List[bytes]) -> bytes:
+def combine_shares(share_list: list[bytes]) -> bytes:
     """Reconstruct secret from shares."""
-    unpickled_share_list: List[List[Tuple[int, bytes]]] = [
-        cast(List[Tuple[int, bytes]], pickle.loads(share)) for share in share_list
+    unpickled_share_list: list[list[tuple[int, bytes]]] = [
+        cast(list[tuple[int, bytes]], pickle.loads(share)) for share in share_list
     ]
 
     chunk_num = len(unpickled_share_list[0])
     secret_padded = bytearray(0)
-    chunk_shares_list: List[List[Tuple[int, bytes]]] = []
+    chunk_shares_list: list[list[tuple[int, bytes]]] = []
     for i in range(chunk_num):
-        chunk_shares: List[Tuple[int, bytes]] = []
+        chunk_shares: list[tuple[int, bytes]] = []
         for share in unpickled_share_list:
             chunk_shares.append(share[i])
         chunk_shares_list.append(chunk_shares)
@@ -71,5 +71,5 @@ def combine_shares(share_list: List[bytes]) -> bytes:
     return bytes(secret)
 
 
-def _shamir_combine(shares: List[Tuple[int, bytes]]) -> bytes:
+def _shamir_combine(shares: list[tuple[int, bytes]]) -> bytes:
     return Shamir.combine(shares, ssss=False)

flwr/common/secure_aggregation/crypto/symmetric_encryption.py

@@ -16,7 +16,7 @@
 
 
 import base64
-from typing import Tuple, cast
+from typing import cast
 
 from cryptography.exceptions import InvalidSignature
 from cryptography.fernet import Fernet
@@ -26,7 +26,7 @@ from cryptography.hazmat.primitives.kdf.hkdf import HKDF
 
 
 def generate_key_pairs() -> (
-    Tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]
+    tuple[ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]
 ):
     """Generate private and public key pairs with Cryptography."""
     private_key = ec.generate_private_key(ec.SECP384R1())

flwr/common/secure_aggregation/ndarrays_arithmetic.py

@@ -15,51 +15,51 @@
 """Utility functions for performing operations on Numpy NDArrays."""
 
 
-from typing import Any, List, Tuple, Union
+from typing import Any, Union
 
 import numpy as np
 from numpy.typing import DTypeLike, NDArray
 
 
-def factor_combine(factor: int, parameters: List[NDArray[Any]]) -> List[NDArray[Any]]:
+def factor_combine(factor: int, parameters: list[NDArray[Any]]) -> list[NDArray[Any]]:
     """Combine factor with parameters."""
     return [np.array([factor])] + parameters
 
 
 def factor_extract(
-    parameters: List[NDArray[Any]],
-) -> Tuple[int, List[NDArray[Any]]]:
+    parameters: list[NDArray[Any]],
+) -> tuple[int, list[NDArray[Any]]]:
     """Extract factor from parameters."""
     return parameters[0][0], parameters[1:]
 
 
-def get_parameters_shape(parameters: List[NDArray[Any]]) -> List[Tuple[int, ...]]:
+def get_parameters_shape(parameters: list[NDArray[Any]]) -> list[tuple[int, ...]]:
     """Get dimensions of each NDArray in parameters."""
     return [arr.shape for arr in parameters]
 
 
 def get_zero_parameters(
-    dimensions_list: List[Tuple[int, ...]], dtype: DTypeLike = np.int64
-) -> List[NDArray[Any]]:
+    dimensions_list: list[tuple[int, ...]], dtype: DTypeLike = np.int64
+) -> list[NDArray[Any]]:
     """Generate zero parameters based on the dimensions list."""
     return [np.zeros(dimensions, dtype=dtype) for dimensions in dimensions_list]
 
 
 def parameters_addition(
-    parameters1: List[NDArray[Any]], parameters2: List[NDArray[Any]]
-) -> List[NDArray[Any]]:
+    parameters1: list[NDArray[Any]], parameters2: list[NDArray[Any]]
+) -> list[NDArray[Any]]:
     """Add two parameters."""
     return [parameters1[idx] + parameters2[idx] for idx in range(len(parameters1))]
 
 
 def parameters_subtraction(
-    parameters1: List[NDArray[Any]], parameters2: List[NDArray[Any]]
-) -> List[NDArray[Any]]:
+    parameters1: list[NDArray[Any]], parameters2: list[NDArray[Any]]
+) -> list[NDArray[Any]]:
     """Subtract parameters from the other parameters."""
     return [parameters1[idx] - parameters2[idx] for idx in range(len(parameters1))]
 
 
-def parameters_mod(parameters: List[NDArray[Any]], divisor: int) -> List[NDArray[Any]]:
+def parameters_mod(parameters: list[NDArray[Any]], divisor: int) -> list[NDArray[Any]]:
     """Take mod of parameters with an integer divisor."""
     if bin(divisor).count("1") == 1:
         msk = divisor - 1
@@ -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]
-) -> List[NDArray[Any]]:
+    parameters: list[NDArray[Any]], multiplier: Union[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]
-) -> List[NDArray[Any]]:
+    parameters: list[NDArray[Any]], divisor: Union[int, float]
+) -> list[NDArray[Any]]:
     """Divide weight by an integer/float divisor."""
     return [parameters[idx] / divisor for idx in range(len(parameters))]

flwr/common/secure_aggregation/quantization.py

@@ -15,7 +15,7 @@
 """Utility functions for model quantization."""
 
 
-from typing import List, cast
+from typing import cast
 
 import numpy as np
 
@@ -30,10 +30,10 @@ def _stochastic_round(arr: NDArrayFloat) -> NDArrayInt:
 
 
 def quantize(
-    parameters: List[NDArrayFloat], clipping_range: float, target_range: int
-) -> List[NDArrayInt]:
+    parameters: list[NDArrayFloat], clipping_range: float, target_range: int
+) -> list[NDArrayInt]:
     """Quantize float Numpy arrays to integer Numpy arrays."""
-    quantized_list: List[NDArrayInt] = []
+    quantized_list: list[NDArrayInt] = []
     quantizer = target_range / (2 * clipping_range)
     for arr in parameters:
         # Stochastic quantization
@@ -49,12 +49,12 @@ def quantize(
 
 # Dequantize parameters to range [-clipping_range, clipping_range]
 def dequantize(
-    quantized_parameters: List[NDArrayInt],
+    quantized_parameters: list[NDArrayInt],
     clipping_range: float,
     target_range: int,
-) -> List[NDArrayFloat]:
+) -> list[NDArrayFloat]:
     """Dequantize integer Numpy arrays to float Numpy arrays."""
-    reverse_quantized_list: List[NDArrayFloat] = []
+    reverse_quantized_list: list[NDArrayFloat] = []
     quantizer = (2 * clipping_range) / target_range
     shift = -clipping_range
     for arr in quantized_parameters: