flwr-nightly 1.17.0.dev20250320__py3-none-any.whl → 1.17.0.dev20250322__py3-none-any.whl

flwr/common/record/{parametersrecord.py → arrayrecord.py}

@@ -1,4 +1,4 @@
-# Copyright 2024 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""ParametersRecord and Array."""
+"""ArrayRecord and Array."""
 
 
 from __future__ import annotations
@@ -22,11 +22,13 @@ import sys
 from collections import OrderedDict
 from dataclasses import dataclass
 from io import BytesIO
+from logging import WARN
 from typing import TYPE_CHECKING, Any, cast, overload
 
 import numpy as np
 
 from ..constant import GC_THRESHOLD, SType
+from ..logger import log
 from ..typing import NDArray
 from .typeddict import TypedDict
 
@@ -42,9 +44,9 @@ def _raise_array_init_error() -> None:
     )
 
 
-def _raise_parameters_record_init_error() -> None:
+def _raise_array_record_init_error() -> None:
     raise TypeError(
-        f"Invalid arguments for {ParametersRecord.__qualname__}. Expected either "
+        f"Invalid arguments for {ArrayRecord.__qualname__}. Expected either "
         "a list of NumPy ndarrays, a PyTorch state_dict, or a dictionary of Arrays. "
         "The `keep_input` argument is keyword-only."
     )
@@ -274,13 +276,14 @@ def _check_value(value: Array) -> None:
         )
 
 
-class ParametersRecord(TypedDict[str, Array]):
-    r"""Parameters record.
+class ArrayRecord(TypedDict[str, Array]):
+    """Array record.
 
-    A typed dictionary (``str`` to :class:`Array`) that can store named parameters
-    as serialized tensors. Internally, this behaves similarly to an
-    ``OrderedDict[str, Array]``. A ``ParametersRecord`` can be viewed as an
-    equivalent to PyTorch's ``state_dict``, but it holds arrays in serialized form.
+    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]``.
+    An ``ArrayRecord`` can be viewed as an equivalent to PyTorch's ``state_dict``,
+    but it holds arrays in a serialized form.
 
     This object is one of the record types supported by :class:`RecordDict` and can
     therefore be stored in the ``content`` of a :class:`Message` or the ``state``
@@ -312,33 +315,33 @@ class ParametersRecord(TypedDict[str, Array]):
 
     Examples
     --------
-    Initializing an empty ParametersRecord:
+    Initializing an empty ArrayRecord:
 
-    >>> p_record = ParametersRecord()
+    >>> record = ArrayRecord()
 
     Initializing with a dictionary of :class:`Array`:
 
     >>> arr = Array("float32", [5, 5], "numpy.ndarray", b"serialized_data...")
-    >>> p_record = ParametersRecord({"weight": arr})
+    >>> record = ArrayRecord({"weight": arr})
 
     Initializing with a list of NumPy arrays:
 
     >>> import numpy as np
     >>> arr1 = np.random.randn(3, 3)
     >>> arr2 = np.random.randn(2, 2)
-    >>> p_record = ParametersRecord([arr1, arr2])
+    >>> record = ArrayRecord([arr1, arr2])
 
     Initializing with a PyTorch model state_dict:
 
     >>> import torch.nn as nn
     >>> model = nn.Linear(10, 5)
-    >>> p_record = ParametersRecord(model.state_dict())
+    >>> record = ArrayRecord(model.state_dict())
 
     Initializing with a TensorFlow model weights (a list of NumPy arrays):
 
     >>> import tensorflow as tf
     >>> model = tf.keras.Sequential([tf.keras.layers.Dense(5, input_shape=(10,))])
-    >>> p_record = ParametersRecord(model.get_weights())
+    >>> record = ArrayRecord(model.get_weights())
     """
 
     @overload
@@ -380,7 +383,7 @@ class ParametersRecord(TypedDict[str, Array]):
 
         # Init the argument
         if len(args) > 1:
-            _raise_parameters_record_init_error()
+            _raise_array_record_init_error()
         arg = args[0] if args else None
         init_method: str | None = None  # Track which init method is being used
 
@@ -393,10 +396,10 @@ class ParametersRecord(TypedDict[str, Array]):
             nonlocal arg, init_method
             # Raise an error if arg is already set
             if arg is not None:
-                _raise_parameters_record_init_error()
+                _raise_array_record_init_error()
             # Raise an error if a different initialization method is already set
             if init_method is not None:
-                _raise_parameters_record_init_error()
+                _raise_array_record_init_error()
             # Set init_method and arg
             if init_method is None:
                 init_method = method
@@ -454,7 +457,7 @@ class ParametersRecord(TypedDict[str, Array]):
                 self.__dict__.update(converted.__dict__)
                 return
 
-        _raise_parameters_record_init_error()
+        _raise_array_record_init_error()
 
     @classmethod
     def from_array_dict(
@@ -462,9 +465,9 @@ class ParametersRecord(TypedDict[str, Array]):
         array_dict: OrderedDict[str, Array],
         *,
         keep_input: bool = True,
-    ) -> ParametersRecord:
-        """Create ParametersRecord from a dictionary of :class:`Array`."""
-        record = ParametersRecord()
+    ) -> ArrayRecord:
+        """Create ArrayRecord from a dictionary of :class:`Array`."""
+        record = ArrayRecord()
         for k, v in array_dict.items():
             record[k] = Array(
                 dtype=v.dtype, shape=list(v.shape), stype=v.stype, data=v.data
@@ -479,9 +482,9 @@ class ParametersRecord(TypedDict[str, Array]):
         ndarrays: list[NDArray],
         *,
         keep_input: bool = True,
-    ) -> ParametersRecord:
-        """Create ParametersRecord from a list of NumPy ``ndarray``."""
-        record = ParametersRecord()
+    ) -> ArrayRecord:
+        """Create ArrayRecord from a list of NumPy ``ndarray``."""
+        record = ArrayRecord()
         total_serialized_bytes = 0
 
         for i in range(len(ndarrays)):  # pylint: disable=C0200
@@ -509,14 +512,14 @@ class ParametersRecord(TypedDict[str, Array]):
         state_dict: OrderedDict[str, torch.Tensor],
         *,
         keep_input: bool = True,
-    ) -> ParametersRecord:
-        """Create ParametersRecord from PyTorch ``state_dict``."""
+    ) -> ArrayRecord:
+        """Create ArrayRecord from PyTorch ``state_dict``."""
         if "torch" not in sys.modules:
             raise RuntimeError(
                 f"PyTorch is required to use {cls.from_torch_state_dict.__name__}"
             )
 
-        record = ParametersRecord()
+        record = ArrayRecord()
 
         for k in list(state_dict.keys()):
             v = state_dict[k] if keep_input else state_dict.pop(k)
@@ -525,7 +528,7 @@ class ParametersRecord(TypedDict[str, Array]):
         return record
 
     def to_numpy_ndarrays(self, *, keep_input: bool = True) -> list[NDArray]:
-        """Return the ParametersRecord as a list of NumPy ``ndarray``."""
+        """Return the ArrayRecord as a list of NumPy ``ndarray``."""
         if keep_input:
             return [v.numpy() for v in self.values()]
 
@@ -551,7 +554,7 @@ class ParametersRecord(TypedDict[str, Array]):
     def to_torch_state_dict(
         self, *, keep_input: bool = True
     ) -> OrderedDict[str, torch.Tensor]:
-        """Return the ParametersRecord as a PyTorch ``state_dict``."""
+        """Return the ArrayRecord as a PyTorch ``state_dict``."""
         if not (torch := sys.modules.get("torch")):
             raise RuntimeError(
                 f"PyTorch is required to use {self.to_torch_state_dict.__name__}"
@@ -581,3 +584,43 @@ class ParametersRecord(TypedDict[str, Array]):
             num_bytes += len(k)
 
         return num_bytes
+
+
+class ParametersRecord(ArrayRecord):
+    """Deprecated class ``ParametersRecord``, use ``ArrayRecord`` instead.
+
+    This class exists solely for backward compatibility with legacy
+    code that previously used ``ParametersRecord``. It has been renamed
+    to ``ArrayRecord``.
+
+    .. warning::
+        ``ParametersRecord`` is deprecated and will be removed in a future release.
+        Use ``ArrayRecord`` instead.
+
+    Examples
+    --------
+    Legacy (deprecated) usage::
+
+        from flwr.common import ParametersRecord
+
+        record = ParametersRecord()
+
+    Updated usage::
+
+        from flwr.common import ArrayRecord
+
+        record = ArrayRecord()
+    """
+
+    _warning_logged = False
+
+    def __init__(self, *args: Any, **kwargs: dict[str, Any]) -> None:
+        if not ParametersRecord._warning_logged:
+            ParametersRecord._warning_logged = True
+            log(
+                WARN,
+                "The `ParametersRecord` class has been renamed to `ArrayRecord`. "
+                "Support for `ParametersRecord` will be removed in a future release. "
+                "Please update your code accordingly.",
+            )
+        super().__init__(*args, **kwargs)

flwr/common/record/{configsrecord.py → configrecord.py}

@@ -1,4 +1,4 @@
-# Copyright 2024 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""ConfigsRecord."""
+"""ConfigRecord."""
 
 
+from logging import WARN
 from typing import Optional, get_args
 
-from flwr.common.typing import ConfigsRecordValues, ConfigsScalar
+from flwr.common.typing import ConfigRecordValues, ConfigScalar
 
+from ..logger import log
 from .typeddict import TypedDict
 
 
@@ -28,20 +30,20 @@ def _check_key(key: str) -> None:
         raise TypeError(f"Key must be of type `str` but `{type(key)}` was passed.")
 
 
-def _check_value(value: ConfigsRecordValues) -> None:
-    def is_valid(__v: ConfigsScalar) -> None:
+def _check_value(value: ConfigRecordValues) -> None:
+    def is_valid(__v: ConfigScalar) -> None:
         """Check if value is of expected type."""
-        if not isinstance(__v, get_args(ConfigsScalar)):
+        if not isinstance(__v, get_args(ConfigScalar)):
             raise TypeError(
                 "Not all values are of valid type."
-                f" Expected `{ConfigsRecordValues}` but `{type(__v)}` was passed."
+                f" Expected `{ConfigRecordValues}` but `{type(__v)}` was passed."
             )
 
     if isinstance(value, list):
         # If your lists are large (e.g. 1M+ elements) this will be slow
         # 1s to check 10M element list on a M2 Pro
         # In such settings, you'd be better of treating such config as
-        # an array and pass it to a ParametersRecord.
+        # an array and pass it to a ArrayRecord.
         # Empty lists are valid
         if len(value) > 0:
             is_valid(value[0])
@@ -51,24 +53,24 @@ def _check_value(value: ConfigsRecordValues) -> None:
             if not all(isinstance(v, value_type) for v in value):
                 raise TypeError(
                     "All values in a list must be of the same valid type. "
-                    f"One of {ConfigsScalar}."
+                    f"One of {ConfigScalar}."
                 )
     else:
         is_valid(value)
 
 
-class ConfigsRecord(TypedDict[str, ConfigsRecordValues]):
+class ConfigRecord(TypedDict[str, ConfigRecordValues]):
     """Configs record.
 
-    A :code:`ConfigsRecord` is a Python dictionary designed to ensure that
-    each key-value pair adheres to specified data types. A :code:`ConfigsRecord`
+    A :code:`ConfigRecord` is a Python dictionary designed to ensure that
+    each key-value pair adheres to specified data types. A :code:`ConfigRecord`
     is one of the types of records that a
     `flwr.common.RecordDict <flwr.common.RecordDict.html#recorddict>`_ supports and
     can therefore be used to construct :code:`common.Message` objects.
 
     Parameters
     ----------
-    configs_dict : Optional[Dict[str, ConfigsRecordValues]]
+    config_dict : Optional[Dict[str, ConfigRecordValues]]
         A dictionary that stores basic types (i.e. `str`, `int`, `float`, `bytes` as
         defined in `ConfigsScalar`) and lists of such types (see
         `ConfigsScalarList`).
@@ -80,20 +82,20 @@ class ConfigsRecord(TypedDict[str, ConfigsRecordValues]):
 
     Examples
     --------
-    The usage of a :code:`ConfigsRecord` is envisioned for sending configuration values
+    The usage of a :code:`ConfigRecord` is envisioned for sending configuration values
     telling the target node how to perform a certain action (e.g. train/evaluate a model
     ). You can use standard Python built-in types such as :code:`float`, :code:`str`
     , :code:`bytes`. All types allowed are defined in
-    :code:`flwr.common.ConfigsRecordValues`. While lists are supported, we
-    encourage you to use a :code:`ParametersRecord` instead if these are of high
+    :code:`flwr.common.ConfigRecordValues`. While lists are supported, we
+    encourage you to use a :code:`ArrayRecord` instead if these are of high
     dimensionality.
 
-    Let's see some examples of how to construct a :code:`ConfigsRecord` from scratch:
+    Let's see some examples of how to construct a :code:`ConfigRecord` from scratch:
 
-    >>> from flwr.common import ConfigsRecord
+    >>> from flwr.common import ConfigRecord
     >>>
-    >>> # A `ConfigsRecord` is a specialized Python dictionary
-    >>> record = ConfigsRecord({"lr": 0.1, "batch-size": 128})
+    >>> # A `ConfigRecord` is a specialized Python dictionary
+    >>> record = ConfigRecord({"lr": 0.1, "batch-size": 128})
     >>> # You can add more content to an existing record
     >>> record["compute-average"] = True
     >>> # It also supports lists
@@ -104,21 +106,21 @@ class ConfigsRecord(TypedDict[str, ConfigsRecordValues]):
     Just like the other types of records in a :code:`flwr.common.RecordDict`, types are
     enforced. If you need to add a custom data structure or object, we recommend to
     serialise it into bytes and save it as such (bytes are allowed in a
-    :code:`ConfigsRecord`)
+    :code:`ConfigRecord`)
     """
 
     def __init__(
         self,
-        configs_dict: Optional[dict[str, ConfigsRecordValues]] = None,
+        config_dict: Optional[dict[str, ConfigRecordValues]] = None,
         keep_input: bool = True,
     ) -> None:
 
         super().__init__(_check_key, _check_value)
-        if configs_dict:
-            for k in list(configs_dict.keys()):
-                self[k] = configs_dict[k]
+        if config_dict:
+            for k in list(config_dict.keys()):
+                self[k] = config_dict[k]
                 if not keep_input:
-                    del configs_dict[k]
+                    del config_dict[k]
 
     def count_bytes(self) -> int:
         """Return number of Bytes stored in this object.
@@ -126,7 +128,7 @@ class ConfigsRecord(TypedDict[str, ConfigsRecordValues]):
         This function counts booleans as occupying 1 Byte.
         """
 
-        def get_var_bytes(value: ConfigsScalar) -> int:
+        def get_var_bytes(value: ConfigScalar) -> int:
             """Return Bytes of value passed."""
             var_bytes = 0
             if isinstance(value, bool):
@@ -161,3 +163,47 @@ class ConfigsRecord(TypedDict[str, ConfigsRecordValues]):
             num_bytes += len(k)
 
         return num_bytes
+
+
+class ConfigsRecord(ConfigRecord):
+    """Deprecated class ``ConfigsRecord``, use ``ConfigRecord`` instead.
+
+    This class exists solely for backward compatibility with legacy
+    code that previously used ``ConfigsRecord``. It has been renamed
+    to ``ConfigRecord``.
+
+    .. warning::
+        ``ConfigsRecord`` is deprecated and will be removed in a future release.
+        Use ``ConfigRecord`` instead.
+
+    Examples
+    --------
+    Legacy (deprecated) usage::
+
+        from flwr.common import ConfigsRecord
+
+        record = ConfigsRecord()
+
+    Updated usage::
+
+        from flwr.common import ConfigRecord
+
+        record = ConfigRecord()
+    """
+
+    _warning_logged = False
+
+    def __init__(
+        self,
+        config_dict: Optional[dict[str, ConfigRecordValues]] = None,
+        keep_input: bool = True,
+    ):
+        if not ConfigsRecord._warning_logged:
+            ConfigsRecord._warning_logged = True
+            log(
+                WARN,
+                "The `ConfigsRecord` class has been renamed to `ConfigRecord`. "
+                "Support for `ConfigsRecord` will be removed in a future release. "
+                "Please update your code accordingly.",
+            )
+        super().__init__(config_dict, keep_input)

flwr/common/record/conversion_utils.py

@@ -17,7 +17,7 @@
 
 from ..logger import warn_deprecated_feature
 from ..typing import NDArray
-from .parametersrecord import Array
+from .arrayrecord import Array
 
 WARN_DEPRECATED_MESSAGE = (
     "`array_from_numpy` is deprecated. Instead, use the `Array(ndarray)` class "

flwr/common/record/{metricsrecord.py → metricrecord.py}

@@ -1,4 +1,4 @@
-# Copyright 2024 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""MetricsRecord."""
+"""MetricRecord."""
 
 
+from logging import WARN
 from typing import Optional, get_args
 
-from flwr.common.typing import MetricsRecordValues, MetricsScalar
+from flwr.common.typing import MetricRecordValues, MetricScalar
 
+from ..logger import log
 from .typeddict import TypedDict
 
 
@@ -28,20 +30,20 @@ def _check_key(key: str) -> None:
         raise TypeError(f"Key must be of type `str` but `{type(key)}` was passed.")
 
 
-def _check_value(value: MetricsRecordValues) -> None:
-    def is_valid(__v: MetricsScalar) -> None:
+def _check_value(value: MetricRecordValues) -> None:
+    def is_valid(__v: MetricScalar) -> None:
         """Check if value is of expected type."""
-        if not isinstance(__v, get_args(MetricsScalar)) or isinstance(__v, bool):
+        if not isinstance(__v, get_args(MetricScalar)) or isinstance(__v, bool):
             raise TypeError(
                 "Not all values are of valid type."
-                f" Expected `{MetricsRecordValues}` but `{type(__v)}` was passed."
+                f" Expected `{MetricRecordValues}` but `{type(__v)}` was passed."
             )
 
     if isinstance(value, list):
         # If your lists are large (e.g. 1M+ elements) this will be slow
         # 1s to check 10M element list on a M2 Pro
         # In such settings, you'd be better of treating such metric as
-        # an array and pass it to a ParametersRecord.
+        # an array and pass it to an ArrayRecord.
         # Empty lists are valid
         if len(value) > 0:
             is_valid(value[0])
@@ -51,26 +53,26 @@ def _check_value(value: MetricsRecordValues) -> None:
             if not all(isinstance(v, value_type) for v in value):
                 raise TypeError(
                     "All values in a list must be of the same valid type. "
-                    f"One of {MetricsScalar}."
+                    f"One of {MetricScalar}."
                 )
     else:
         is_valid(value)
 
 
-class MetricsRecord(TypedDict[str, MetricsRecordValues]):
+class MetricRecord(TypedDict[str, MetricRecordValues]):
     """Metrics recod.
 
-    A :code:`MetricsRecord` is a Python dictionary designed to ensure that
-    each key-value pair adheres to specified data types. A :code:`MetricsRecord`
+    A :code:`MetricRecord` is a Python dictionary designed to ensure that
+    each key-value pair adheres to specified data types. A :code:`MetricRecord`
     is one of the types of records that a
     `flwr.common.RecordDict <flwr.common.RecordDict.html#recorddict>`_ supports and
     can therefore be used to construct :code:`common.Message` objects.
 
     Parameters
     ----------
-    metrics_dict : Optional[Dict[str, MetricsRecordValues]]
+    metric_dict : Optional[Dict[str, MetricRecordValues]]
         A dictionary that stores basic types (i.e. `int`, `float` as defined
-        in `MetricsScalar`) and list of such types (see `MetricsScalarList`).
+        in `MetricScalar`) and list of such types (see `MetricScalarList`).
     keep_input : bool (default: True)
         A boolean indicating whether metrics should be deleted from the input
         dictionary immediately after adding them to the record. When set
@@ -79,7 +81,7 @@ class MetricsRecord(TypedDict[str, MetricsRecordValues]):
 
     Examples
     --------
-    The usage of a :code:`MetricsRecord` is envisioned for communicating results
+    The usage of a :code:`MetricRecord` is envisioned for communicating results
     obtained when a node performs an action. A few typical examples include:
     communicating the training accuracy after a model is trained locally by a
     :code:`ClientApp`, reporting the validation loss obtained at a :code:`ClientApp`,
@@ -87,43 +89,43 @@ class MetricsRecord(TypedDict[str, MetricsRecordValues]):
     Common to these examples is that the output can be typically represented by
     a single scalar (:code:`int`, :code:`float`) or list of scalars.
 
-    Let's see some examples of how to construct a :code:`MetricsRecord` from scratch:
+    Let's see some examples of how to construct a :code:`MetricRecord` from scratch:
 
-    >>> from flwr.common import MetricsRecord
+    >>> from flwr.common import MetricRecord
     >>>
-    >>> # A `MetricsRecord` is a specialized Python dictionary
-    >>> record = MetricsRecord({"accuracy": 0.94})
+    >>> # A `MetricRecord` is a specialized Python dictionary
+    >>> record = MetricRecord({"accuracy": 0.94})
     >>> # You can add more content to an existing record
     >>> record["loss"] = 0.01
     >>> # It also supports lists
     >>> record["loss-historic"] = [0.9, 0.5, 0.01]
 
     Since types are enforced, the types of the objects inserted are checked. For a
-    :code:`MetricsRecord`, value types allowed are those in defined in
-    :code:`flwr.common.MetricsRecordValues`. Similarly, only :code:`str` keys are
+    :code:`MetricRecord`, value types allowed are those in defined in
+    :code:`flwr.common.MetricRecordValues`. Similarly, only :code:`str` keys are
     allowed.
 
-    >>> from flwr.common import MetricsRecord
+    >>> from flwr.common import MetricRecord
     >>>
-    >>> record = MetricsRecord() # an empty record
+    >>> record = MetricRecord() # an empty record
     >>> # Add unsupported value
     >>> record["something-unsupported"] = {'a': 123} # Will throw a `TypeError`
 
-    If you need a more versatily type of record try :code:`ConfigsRecord` or
-    :code:`ParametersRecord`.
+    If you need a more versatily type of record try :code:`ConfigRecord` or
+    :code:`ArrayRecord`.
     """
 
     def __init__(
         self,
-        metrics_dict: Optional[dict[str, MetricsRecordValues]] = None,
+        metric_dict: Optional[dict[str, MetricRecordValues]] = None,
         keep_input: bool = True,
-    ):
+    ) -> None:
         super().__init__(_check_key, _check_value)
-        if metrics_dict:
-            for k in list(metrics_dict.keys()):
-                self[k] = metrics_dict[k]
+        if metric_dict:
+            for k in list(metric_dict.keys()):
+                self[k] = metric_dict[k]
                 if not keep_input:
-                    del metrics_dict[k]
+                    del metric_dict[k]
 
     def count_bytes(self) -> int:
         """Return number of Bytes stored in this object."""
@@ -140,3 +142,47 @@ class MetricsRecord(TypedDict[str, MetricsRecordValues]):
             # We also count the bytes footprint of the keys
             num_bytes += len(k)
         return num_bytes
+
+
+class MetricsRecord(MetricRecord):
+    """Deprecated class ``MetricsRecord``, use ``MetricRecord`` instead.
+
+    This class exists solely for backward compatibility with legacy
+    code that previously used ``MetricsRecord``. It has been renamed
+    to ``MetricRecord``.
+
+    .. warning::
+        ``MetricsRecord`` is deprecated and will be removed in a future release.
+        Use ``MetricRecord`` instead.
+
+    Examples
+    --------
+    Legacy (deprecated) usage::
+
+        from flwr.common import MetricsRecord
+
+        record = MetricsRecord()
+
+    Updated usage::
+
+        from flwr.common import MetricRecord
+
+        record = MetricRecord()
+    """
+
+    _warning_logged = False
+
+    def __init__(
+        self,
+        metric_dict: Optional[dict[str, MetricRecordValues]] = None,
+        keep_input: bool = True,
+    ):
+        if not MetricsRecord._warning_logged:
+            MetricsRecord._warning_logged = True
+            log(
+                WARN,
+                "The `MetricsRecord` class has been renamed to `MetricRecord`. "
+                "Support for `MetricsRecord` will be removed in a future release. "
+                "Please update your code accordingly.",
+            )
+        super().__init__(metric_dict, keep_input)