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

flwr/common/record/recorddict.py

@@ -22,12 +22,12 @@ from textwrap import indent
 from typing import TypeVar, Union, cast
 
 from ..logger import log
-from .configsrecord import ConfigsRecord
-from .metricsrecord import MetricsRecord
-from .parametersrecord import ParametersRecord
+from .arrayrecord import ArrayRecord
+from .configrecord import ConfigRecord
+from .metricrecord import MetricRecord
 from .typeddict import TypedDict
 
-RecordType = Union[ParametersRecord, MetricsRecord, ConfigsRecord]
+RecordType = Union[ArrayRecord, MetricRecord, ConfigRecord]
 
 T = TypeVar("T")
 
@@ -41,10 +41,10 @@ def _check_key(key: str) -> None:
 
 
 def _check_value(value: RecordType) -> None:
-    if not isinstance(value, (ParametersRecord, MetricsRecord, ConfigsRecord)):
+    if not isinstance(value, (ArrayRecord, MetricRecord, ConfigRecord)):
         raise TypeError(
-            f"Expected `{ParametersRecord.__name__}`, `{MetricsRecord.__name__}`, "
-            f"or `{ConfigsRecord.__name__}` but received "
+            f"Expected `{ArrayRecord.__name__}`, `{MetricRecord.__name__}`, "
+            f"or `{ConfigRecord.__name__}` but received "
             f"`{type(value).__name__}` for the value."
         )
 
@@ -58,9 +58,7 @@ class _SyncedDict(TypedDict[str, T]):
     """
 
     def __init__(self, ref_recorddict: RecordDict, allowed_type: type[T]) -> None:
-        if not issubclass(
-            allowed_type, (ParametersRecord, MetricsRecord, ConfigsRecord)
-        ):
+        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
@@ -84,27 +82,19 @@ class _SyncedDict(TypedDict[str, T]):
 
 
 class RecordDict(TypedDict[str, RecordType]):
-    """RecordDict stores groups of parameters, metrics and configs.
+    """RecordDict stores groups of arrays, metrics and configs.
 
-    A :class:`RecordDict` is the unified mechanism by which parameters,
+    A :class:`RecordDict` is the unified mechanism by which arrays,
     metrics and configs can be either stored as part of a :class:`Context`
     in your apps or communicated as part of a :class:`Message` between
     your apps.
 
     Parameters
     ----------
-    parameters_records : Optional[Dict[str, ParametersRecord]]
-        A dictionary of :code:`ParametersRecords` that can be used to record
-        and communicate model parameters and high-dimensional arrays.
-    metrics_records : Optional[Dict[str, MetricsRecord]]
-        A dictionary of :code:`MetricsRecord` that can be used to record
-        and communicate scalar-valued metrics that are the result of performing
-        and action, for example, by a :code:`ClientApp`.
-    configs_records : Optional[Dict[str, ConfigsRecord]]
-        A dictionary of :code:`ConfigsRecord` that can be used to record
-        and communicate configuration values to an entity (e.g. to a
-        :code:`ClientApp`)
-        for it to adjust how an action is performed.
+    records : Optional[dict[str, RecordType]]
+        A dictionary mapping string keys to record instances, where each value
+        is either a :class:`ParametersRecord`, :class:`MetricsRecord`,
+        or :class:`ConfigsRecord`.
 
     Examples
     --------
@@ -116,43 +106,41 @@ class RecordDict(TypedDict[str, RecordType]):
     Let's see an example.
 
     >>>  from flwr.common import RecordDict
-    >>>  from flwr.common import ConfigsRecord, MetricsRecord, ParametersRecord
+    >>>  from flwr.common import ArrayRecord, ConfigRecord, MetricRecord
     >>>
     >>>  # Let's begin with an empty record
     >>>  my_records = RecordDict()
     >>>
-    >>>  # We can create a ConfigsRecord
-    >>>  c_record = ConfigsRecord({"lr": 0.1, "batch-size": 128})
-    >>>  # Adding it to the record_set would look like this
+    >>>  # We can create a ConfigRecord
+    >>>  c_record = ConfigRecord({"lr": 0.1, "batch-size": 128})
+    >>>  # Adding it to the RecordDict would look like this
     >>>  my_records["my_config"] = c_record
     >>>
-    >>>  # We can create a MetricsRecord following a similar process
-    >>>  m_record = MetricsRecord({"accuracy": 0.93, "losses": [0.23, 0.1]})
-    >>>  # Adding it to the record_set would look like this
+    >>>  # We can create a MetricRecord following a similar process
+    >>>  m_record = MetricRecord({"accuracy": 0.93, "losses": [0.23, 0.1]})
+    >>>  # Adding it to the RecordDict would look like this
     >>>  my_records["my_metrics"] = m_record
 
-    Adding a :code:`ParametersRecord` follows the same steps as above but first,
+    Adding an :code:`ArrayRecord` follows the same steps as above but first,
     the array needs to be serialized and represented as a :code:`flwr.common.Array`.
-    If the array is a :code:`NumPy` array, you can use the built-in utility function
-    `array_from_numpy <flwr.common.array_from_numpy.html>`_. It is often possible to
-    convert an array first to :code:`NumPy` and then use the aforementioned function.
+    For example:
 
-    >>>  from flwr.common import array_from_numpy
-    >>>  # Creating a ParametersRecord would look like this
+    >>>  from flwr.common import Array
+    >>>  # Creating an ArrayRecord would look like this
     >>>  arr_np = np.random.randn(3, 3)
     >>>
     >>>  # You can use the built-in tool to serialize the array
-    >>>  arr = array_from_numpy(arr_np)
+    >>>  arr = Array(arr_np)
     >>>
     >>>  # Finally, create the record
-    >>>  p_record = ParametersRecord({"my_array": arr})
+    >>>  arr_record = ArrayRecord({"my_array": arr})
     >>>
-    >>>  # Adding it to the record_set would look like this
-    >>>  my_records["my_parameters"] = p_record
+    >>>  # Adding it to the RecordDict would look like this
+    >>>  my_records["my_parameters"] = arr_record
 
     For additional examples on how to construct each of the records types shown
-    above, please refer to the documentation for :code:`ConfigsRecord`,
-    :code:`MetricsRecord` and :code:`ParametersRecord`.
+    above, please refer to the documentation for :code:`ConfigRecord`,
+    :code:`MetricRecord` and :code:`ArrayRecord`.
     """
 
     def __init__(self, records: dict[str, RecordType] | None = None) -> None:
@@ -162,35 +150,35 @@ class RecordDict(TypedDict[str, RecordType]):
                 self[key] = record
 
     @property
-    def parameters_records(self) -> TypedDict[str, ParametersRecord]:
-        """Dictionary holding only ParametersRecord instances."""
-        synced_dict = _SyncedDict[ParametersRecord](self, ParametersRecord)
+    def array_records(self) -> TypedDict[str, ArrayRecord]:
+        """Dictionary holding only ArrayRecord instances."""
+        synced_dict = _SyncedDict[ArrayRecord](self, ArrayRecord)
         for key, record in self.items():
-            if isinstance(record, ParametersRecord):
+            if isinstance(record, ArrayRecord):
                 synced_dict[key] = record
         return synced_dict
 
     @property
-    def metrics_records(self) -> TypedDict[str, MetricsRecord]:
-        """Dictionary holding only MetricsRecord instances."""
-        synced_dict = _SyncedDict[MetricsRecord](self, MetricsRecord)
+    def metric_records(self) -> TypedDict[str, MetricRecord]:
+        """Dictionary holding only MetricRecord instances."""
+        synced_dict = _SyncedDict[MetricRecord](self, MetricRecord)
         for key, record in self.items():
-            if isinstance(record, MetricsRecord):
+            if isinstance(record, MetricRecord):
                 synced_dict[key] = record
         return synced_dict
 
     @property
-    def configs_records(self) -> TypedDict[str, ConfigsRecord]:
-        """Dictionary holding only ConfigsRecord instances."""
-        synced_dict = _SyncedDict[ConfigsRecord](self, ConfigsRecord)
+    def config_records(self) -> TypedDict[str, ConfigRecord]:
+        """Dictionary holding only ConfigRecord instances."""
+        synced_dict = _SyncedDict[ConfigRecord](self, ConfigRecord)
         for key, record in self.items():
-            if isinstance(record, ConfigsRecord):
+            if isinstance(record, ConfigRecord):
                 synced_dict[key] = record
         return synced_dict
 
     def __repr__(self) -> str:
         """Return a string representation of this instance."""
-        flds = ("parameters_records", "metrics_records", "configs_records")
+        flds = ("array_records", "metric_records", "config_records")
         fld_views = [f"{fld}={dict(getattr(self, fld))!r}" for fld in flds]
         view = indent(",\n".join(fld_views), "  ")
         return f"{self.__class__.__qualname__}(\n{view}\n)"
@@ -236,6 +224,9 @@ class RecordSet(RecordDict):
     """
 
     _warning_logged = False
+    _warning_logged_params = False
+    _warning_logged_metrics = False
+    _warning_logged_configs = False
 
     def __init__(self, records: dict[str, RecordType] | None = None) -> None:
         if not RecordSet._warning_logged:
@@ -247,3 +238,51 @@ class RecordSet(RecordDict):
                 "Please update your code accordingly.",
             )
         super().__init__(records)
+
+    @property
+    def parameters_records(self) -> TypedDict[str, ArrayRecord]:
+        """Deprecated property.
+
+        Use ``array_records`` instead.
+        """
+        if not RecordSet._warning_logged_params:
+            RecordSet._warning_logged_params = True
+            log(
+                WARN,
+                "`RecordSet.parameters_records` has been deprecated "
+                "and will be removed in a future release. Please use "
+                "`RecordDict.array_records` instead.",
+            )
+        return self.array_records
+
+    @property
+    def metrics_records(self) -> TypedDict[str, MetricRecord]:
+        """Deprecated property.
+
+        Use ``metric_records`` instead.
+        """
+        if not RecordSet._warning_logged_metrics:
+            RecordSet._warning_logged_metrics = True
+            log(
+                WARN,
+                "`RecordSet.metrics_records` has been deprecated "
+                "and will be removed in a future release. Please use "
+                "`RecordDict.metric_records` instead.",
+            )
+        return self.metric_records
+
+    @property
+    def configs_records(self) -> TypedDict[str, ConfigRecord]:
+        """Deprecated property.
+
+        Use ``config_records`` instead.
+        """
+        if not RecordSet._warning_logged_configs:
+            RecordSet._warning_logged_configs = True
+            log(
+                WARN,
+                "`RecordSet.configs_records` has been deprecated "
+                "and will be removed in a future release. Please use "
+                "`RecordDict.config_records` instead.",
+            )
+        return self.config_records

flwr/common/recorddict_compat.py

@@ -19,10 +19,10 @@ from collections import OrderedDict
 from collections.abc import Mapping
 from typing import Union, cast, get_args
 
-from . import Array, ConfigsRecord, MetricsRecord, ParametersRecord, RecordDict
+from . import Array, ArrayRecord, ConfigRecord, MetricRecord, RecordDict
 from .typing import (
     Code,
-    ConfigsRecordValues,
+    ConfigRecordValues,
     EvaluateIns,
     EvaluateRes,
     FitIns,
@@ -31,7 +31,7 @@ from .typing import (
     GetParametersRes,
     GetPropertiesIns,
     GetPropertiesRes,
-    MetricsRecordValues,
+    MetricRecordValues,
     Parameters,
     Scalar,
     Status,
@@ -40,21 +40,19 @@ from .typing import (
 EMPTY_TENSOR_KEY = "_empty"
 
 
-def parametersrecord_to_parameters(
-    record: ParametersRecord, keep_input: bool
-) -> Parameters:
+def arrayrecord_to_parameters(record: ArrayRecord, keep_input: bool) -> Parameters:
     """Convert ParameterRecord to legacy Parameters.
 
     Warnings
     --------
-    Because `Arrays` in `ParametersRecord` encode more information of the
+    Because `Array`s in `ArrayRecord` encode more information of the
     array-like or tensor-like data (e.g their datatype, shape) than `Parameters` it
     might not be possible to reconstruct such data structures from `Parameters` objects
     alone. Additional information or metadata must be provided from elsewhere.
 
     Parameters
     ----------
-    record : ParametersRecord
+    record : ArrayRecord
         The record to be conveted into Parameters.
     keep_input : bool
         A boolean indicating whether entries in the record should be deleted from the
@@ -82,19 +80,17 @@ def parametersrecord_to_parameters(
     return parameters
 
 
-def parameters_to_parametersrecord(
-    parameters: Parameters, keep_input: bool
-) -> ParametersRecord:
-    """Convert legacy Parameters into a single ParametersRecord.
+def parameters_to_arrayrecord(parameters: Parameters, keep_input: bool) -> ArrayRecord:
+    """Convert legacy Parameters into a single ArrayRecord.
 
     Because there is no concept of names in the legacy Parameters, arbitrary keys will
-    be used when constructing the ParametersRecord. Similarly, the shape and data type
+    be used when constructing the ArrayRecord. Similarly, the shape and data type
     won't be recorded in the Array objects.
 
     Parameters
     ----------
     parameters : Parameters
-        Parameters object to be represented as a ParametersRecord.
+        Parameters object to be represented as a ArrayRecord.
     keep_input : bool
         A boolean indicating whether parameters should be deleted from the input
         Parameters object (i.e. a list of serialized NumPy arrays) immediately after
@@ -102,8 +98,8 @@ def parameters_to_parametersrecord(
 
     Returns
     -------
-    ParametersRecord
-        The ParametersRecord containing the provided parameters.
+    ArrayRecord
+        The ArrayRecord containing the provided parameters.
     """
     tensor_type = parameters.tensor_type
 
@@ -122,19 +118,19 @@ def parameters_to_parametersrecord(
         ordered_dict[EMPTY_TENSOR_KEY] = Array(
             data=b"", dtype="", stype=tensor_type, shape=[]
         )
-    return ParametersRecord(ordered_dict, keep_input=keep_input)
+    return ArrayRecord(ordered_dict, keep_input=keep_input)
 
 
 def _check_mapping_from_recordscalartype_to_scalar(
-    record_data: Mapping[str, Union[ConfigsRecordValues, MetricsRecordValues]]
+    record_data: Mapping[str, Union[ConfigRecordValues, MetricRecordValues]]
 ) -> 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)):
             raise TypeError(
                 "There is not a 1:1 mapping between `common.Scalar` types and those "
-                "supported in `common.ConfigsRecordValues` or "
-                "`common.ConfigsRecordValues`. Consider casting your values to a type "
+                "supported in `common.ConfigRecordValues` or "
+                "`common.ConfigRecordValues`. Consider casting your values to a type "
                 "supported by the `common.RecordDict` infrastructure. "
                 f"You used type: {type(value)}"
             )
@@ -148,14 +144,12 @@ def _recorddict_to_fit_or_evaluate_ins_components(
 ) -> tuple[Parameters, dict[str, Scalar]]:
     """Derive Fit/Evaluate Ins from a RecordDict."""
     # get Array and construct Parameters
-    parameters_record = recorddict.parameters_records[f"{ins_str}.parameters"]
+    array_record = recorddict.array_records[f"{ins_str}.parameters"]
 
-    parameters = parametersrecord_to_parameters(
-        parameters_record, keep_input=keep_input
-    )
+    parameters = arrayrecord_to_parameters(array_record, keep_input=keep_input)
 
     # get config dict
-    config_record = recorddict.configs_records[f"{ins_str}.config"]
+    config_record = recorddict.config_records[f"{ins_str}.config"]
     # pylint: disable-next=protected-access
     config_dict = _check_mapping_from_recordscalartype_to_scalar(config_record)
 
@@ -168,10 +162,10 @@ def _fit_or_evaluate_ins_to_recorddict(
     recorddict = RecordDict()
 
     ins_str = "fitins" if isinstance(ins, FitIns) else "evaluateins"
-    parametersrecord = parameters_to_parametersrecord(ins.parameters, keep_input)
-    recorddict.parameters_records[f"{ins_str}.parameters"] = parametersrecord
+    arr_record = parameters_to_arrayrecord(ins.parameters, keep_input)
+    recorddict.array_records[f"{ins_str}.parameters"] = arr_record
 
-    recorddict.configs_records[f"{ins_str}.config"] = ConfigsRecord(
+    recorddict.config_records[f"{ins_str}.config"] = ConfigRecord(
         ins.config  # type: ignore
     )
 
@@ -181,18 +175,18 @@ def _fit_or_evaluate_ins_to_recorddict(
 def _embed_status_into_recorddict(
     res_str: str, status: Status, recorddict: RecordDict
 ) -> RecordDict:
-    status_dict: dict[str, ConfigsRecordValues] = {
+    status_dict: dict[str, ConfigRecordValues] = {
         "code": int(status.code.value),
         "message": status.message,
     }
-    # we add it to a `ConfigsRecord`` because the `status.message`` is a string
-    # and `str` values aren't supported in `MetricsRecords`
-    recorddict.configs_records[f"{res_str}.status"] = ConfigsRecord(status_dict)
+    # we add it to a `ConfigRecord` because the `status.message` is a string
+    # and `str` values aren't supported in `MetricRecords`
+    recorddict.config_records[f"{res_str}.status"] = ConfigRecord(status_dict)
     return recorddict
 
 
 def _extract_status_from_recorddict(res_str: str, recorddict: RecordDict) -> Status:
-    status = recorddict.configs_records[f"{res_str}.status"]
+    status = recorddict.config_records[f"{res_str}.status"]
     code = cast(int, status["code"])
     return Status(code=Code(code), message=str(status["message"]))
 
@@ -216,16 +210,16 @@ def fitins_to_recorddict(fitins: FitIns, keep_input: bool) -> RecordDict:
 def recorddict_to_fitres(recorddict: RecordDict, keep_input: bool) -> FitRes:
     """Derive FitRes from a RecordDict object."""
     ins_str = "fitres"
-    parameters = parametersrecord_to_parameters(
-        recorddict.parameters_records[f"{ins_str}.parameters"], keep_input=keep_input
+    parameters = arrayrecord_to_parameters(
+        recorddict.array_records[f"{ins_str}.parameters"], keep_input=keep_input
     )
 
     num_examples = cast(
-        int, recorddict.metrics_records[f"{ins_str}.num_examples"]["num_examples"]
+        int, recorddict.metric_records[f"{ins_str}.num_examples"]["num_examples"]
     )
-    configs_record = recorddict.configs_records[f"{ins_str}.metrics"]
+    config_record = recorddict.config_records[f"{ins_str}.metrics"]
     # pylint: disable-next=protected-access
-    metrics = _check_mapping_from_recordscalartype_to_scalar(configs_record)
+    metrics = _check_mapping_from_recordscalartype_to_scalar(config_record)
     status = _extract_status_from_recorddict(ins_str, recorddict)
 
     return FitRes(
@@ -239,17 +233,15 @@ def fitres_to_recorddict(fitres: FitRes, keep_input: bool) -> RecordDict:
 
     res_str = "fitres"
 
-    recorddict.configs_records[f"{res_str}.metrics"] = ConfigsRecord(
+    recorddict.config_records[f"{res_str}.metrics"] = ConfigRecord(
         fitres.metrics  # type: ignore
     )
-    recorddict.metrics_records[f"{res_str}.num_examples"] = MetricsRecord(
+    recorddict.metric_records[f"{res_str}.num_examples"] = MetricRecord(
         {"num_examples": fitres.num_examples},
     )
-    recorddict.parameters_records[f"{res_str}.parameters"] = (
-        parameters_to_parametersrecord(
-            fitres.parameters,
-            keep_input,
-        )
+    recorddict.array_records[f"{res_str}.parameters"] = parameters_to_arrayrecord(
+        fitres.parameters,
+        keep_input,
     )
 
     # status
@@ -278,15 +270,15 @@ def recorddict_to_evaluateres(recorddict: RecordDict) -> EvaluateRes:
     """Derive EvaluateRes from a RecordDict object."""
     ins_str = "evaluateres"
 
-    loss = cast(int, recorddict.metrics_records[f"{ins_str}.loss"]["loss"])
+    loss = cast(int, recorddict.metric_records[f"{ins_str}.loss"]["loss"])
 
     num_examples = cast(
-        int, recorddict.metrics_records[f"{ins_str}.num_examples"]["num_examples"]
+        int, recorddict.metric_records[f"{ins_str}.num_examples"]["num_examples"]
     )
-    configs_record = recorddict.configs_records[f"{ins_str}.metrics"]
+    config_record = recorddict.config_records[f"{ins_str}.metrics"]
 
     # pylint: disable-next=protected-access
-    metrics = _check_mapping_from_recordscalartype_to_scalar(configs_record)
+    metrics = _check_mapping_from_recordscalartype_to_scalar(config_record)
     status = _extract_status_from_recorddict(ins_str, recorddict)
 
     return EvaluateRes(
@@ -300,17 +292,17 @@ def evaluateres_to_recorddict(evaluateres: EvaluateRes) -> RecordDict:
 
     res_str = "evaluateres"
     # loss
-    recorddict.metrics_records[f"{res_str}.loss"] = MetricsRecord(
+    recorddict.metric_records[f"{res_str}.loss"] = MetricRecord(
         {"loss": evaluateres.loss},
     )
 
     # num_examples
-    recorddict.metrics_records[f"{res_str}.num_examples"] = MetricsRecord(
+    recorddict.metric_records[f"{res_str}.num_examples"] = MetricRecord(
         {"num_examples": evaluateres.num_examples},
     )
 
     # metrics
-    recorddict.configs_records[f"{res_str}.metrics"] = ConfigsRecord(
+    recorddict.config_records[f"{res_str}.metrics"] = ConfigRecord(
         evaluateres.metrics,  # type: ignore
     )
 
@@ -324,7 +316,7 @@ def evaluateres_to_recorddict(evaluateres: EvaluateRes) -> RecordDict:
 
 def recorddict_to_getparametersins(recorddict: RecordDict) -> GetParametersIns:
     """Derive GetParametersIns from a RecordDict object."""
-    config_record = recorddict.configs_records["getparametersins.config"]
+    config_record = recorddict.config_records["getparametersins.config"]
     # pylint: disable-next=protected-access
     config_dict = _check_mapping_from_recordscalartype_to_scalar(config_record)
 
@@ -335,7 +327,7 @@ def getparametersins_to_recorddict(getparameters_ins: GetParametersIns) -> Recor
     """Construct a RecordDict from a GetParametersIns object."""
     recorddict = RecordDict()
 
-    recorddict.configs_records["getparametersins.config"] = ConfigsRecord(
+    recorddict.config_records["getparametersins.config"] = ConfigRecord(
         getparameters_ins.config,  # type: ignore
     )
     return recorddict
@@ -347,10 +339,10 @@ def getparametersres_to_recorddict(
     """Construct a RecordDict from a GetParametersRes object."""
     recorddict = RecordDict()
     res_str = "getparametersres"
-    parameters_record = parameters_to_parametersrecord(
+    array_record = parameters_to_arrayrecord(
         getparametersres.parameters, keep_input=keep_input
     )
-    recorddict.parameters_records[f"{res_str}.parameters"] = parameters_record
+    recorddict.array_records[f"{res_str}.parameters"] = array_record
 
     # status
     recorddict = _embed_status_into_recorddict(
@@ -365,8 +357,8 @@ def recorddict_to_getparametersres(
 ) -> GetParametersRes:
     """Derive GetParametersRes from a RecordDict object."""
     res_str = "getparametersres"
-    parameters = parametersrecord_to_parameters(
-        recorddict.parameters_records[f"{res_str}.parameters"], keep_input=keep_input
+    parameters = arrayrecord_to_parameters(
+        recorddict.array_records[f"{res_str}.parameters"], keep_input=keep_input
     )
 
     status = _extract_status_from_recorddict(res_str, recorddict)
@@ -375,7 +367,7 @@ def recorddict_to_getparametersres(
 
 def recorddict_to_getpropertiesins(recorddict: RecordDict) -> GetPropertiesIns:
     """Derive GetPropertiesIns from a RecordDict object."""
-    config_record = recorddict.configs_records["getpropertiesins.config"]
+    config_record = recorddict.config_records["getpropertiesins.config"]
     # pylint: disable-next=protected-access
     config_dict = _check_mapping_from_recordscalartype_to_scalar(config_record)
 
@@ -385,7 +377,7 @@ def recorddict_to_getpropertiesins(recorddict: RecordDict) -> GetPropertiesIns:
 def getpropertiesins_to_recorddict(getpropertiesins: GetPropertiesIns) -> RecordDict:
     """Construct a RecordDict from a GetPropertiesRes object."""
     recorddict = RecordDict()
-    recorddict.configs_records["getpropertiesins.config"] = ConfigsRecord(
+    recorddict.config_records["getpropertiesins.config"] = ConfigRecord(
         getpropertiesins.config,  # type: ignore
     )
     return recorddict
@@ -394,7 +386,7 @@ def getpropertiesins_to_recorddict(getpropertiesins: GetPropertiesIns) -> Record
 def recorddict_to_getpropertiesres(recorddict: RecordDict) -> GetPropertiesRes:
     """Derive GetPropertiesRes from a RecordDict object."""
     res_str = "getpropertiesres"
-    config_record = recorddict.configs_records[f"{res_str}.properties"]
+    config_record = recorddict.config_records[f"{res_str}.properties"]
     # pylint: disable-next=protected-access
     properties = _check_mapping_from_recordscalartype_to_scalar(config_record)
 
@@ -407,7 +399,7 @@ def getpropertiesres_to_recorddict(getpropertiesres: GetPropertiesRes) -> Record
     """Construct a RecordDict from a GetPropertiesRes object."""
     recorddict = RecordDict()
     res_str = "getpropertiesres"
-    recorddict.configs_records[f"{res_str}.properties"] = ConfigsRecord(
+    recorddict.config_records[f"{res_str}.properties"] = ConfigRecord(
         getpropertiesres.properties,  # type: ignore
     )
     # status

flwr/common/secure_aggregation/secaggplus_constants.py

@@ -42,7 +42,7 @@ class Stage:
 
 
 class Key:
-    """Keys for the configs in the ConfigsRecord."""
+    """Keys for the configs in the ConfigRecord."""
 
     STAGE = "stage"
     SAMPLE_NUMBER = "sample_num"