flwr-nightly 1.7.0.dev20240116__py3-none-any.whl → 1.7.0.dev20240118__py3-none-any.whl

flwr/client/app.py

@@ -35,7 +35,7 @@ from flwr.common.constant import (
     TRANSPORT_TYPES,
 )
 from flwr.common.logger import log, warn_experimental_feature
-from flwr.proto.task_pb2 import TaskIns, TaskRes
+from flwr.proto.task_pb2 import TaskIns, TaskRes  # pylint: disable=E0611
 
 from .flower import load_flower_callable
 from .grpc_client.connection import grpc_connection
@@ -138,10 +138,12 @@ def _check_actionable_client(
     client: Optional[Client], client_fn: Optional[ClientFn]
 ) -> None:
     if client_fn is None and client is None:
-        raise Exception("Both `client_fn` and `client` are `None`, but one is required")
+        raise ValueError(
+            "Both `client_fn` and `client` are `None`, but one is required"
+        )
 
     if client_fn is not None and client is not None:
-        raise Exception(
+        raise ValueError(
             "Both `client_fn` and `client` are provided, but only one is allowed"
         )
 
@@ -150,6 +152,7 @@ def _check_actionable_client(
 # pylint: disable=too-many-branches
 # pylint: disable=too-many-locals
 # pylint: disable=too-many-statements
+# pylint: disable=too-many-arguments
 def start_client(
     *,
     server_address: str,
@@ -299,7 +302,7 @@ def _start_client_internal(
                 cid: str,  # pylint: disable=unused-argument
             ) -> Client:
                 if client is None:  # Added this to keep mypy happy
-                    raise Exception(
+                    raise ValueError(
                         "Both `client_fn` and `client` are `None`, but one is required"
                     )
                 return client  # Always return the same instance

flwr/client/dpfedavg_numpy_client.py

@@ -117,16 +117,16 @@ class DPFedAvgNumPyClient(NumPyClient):
         update = [np.subtract(x, y) for (x, y) in zip(updated_params, original_params)]
 
         if "dpfedavg_clip_norm" not in config:
-            raise Exception("Clipping threshold not supplied by the server.")
+            raise KeyError("Clipping threshold not supplied by the server.")
         if not isinstance(config["dpfedavg_clip_norm"], float):
-            raise Exception("Clipping threshold should be a floating point value.")
+            raise TypeError("Clipping threshold should be a floating point value.")
 
         # Clipping
         update, clipped = clip_by_l2(update, config["dpfedavg_clip_norm"])
 
         if "dpfedavg_noise_stddev" in config:
             if not isinstance(config["dpfedavg_noise_stddev"], float):
-                raise Exception(
+                raise TypeError(
                     "Scale of noise to be added should be a floating point value."
                 )
             # Noising
@@ -138,7 +138,7 @@ class DPFedAvgNumPyClient(NumPyClient):
         # Calculating value of norm indicator bit, required for adaptive clipping
         if "dpfedavg_adaptive_clip_enabled" in config:
             if not isinstance(config["dpfedavg_adaptive_clip_enabled"], bool):
-                raise Exception(
+                raise TypeError(
                     "dpfedavg_adaptive_clip_enabled should be a boolean-valued flag."
                 )
             metrics["dpfedavg_norm_bit"] = not clipped

flwr/client/grpc_client/connection.py

@@ -25,10 +25,13 @@ from typing import Callable, Iterator, Optional, Tuple, Union
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
 from flwr.common.grpc import create_channel
 from flwr.common.logger import log
-from flwr.proto.node_pb2 import Node
-from flwr.proto.task_pb2 import Task, TaskIns, TaskRes
-from flwr.proto.transport_pb2 import ClientMessage, ServerMessage
-from flwr.proto.transport_pb2_grpc import FlowerServiceStub
+from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
+from flwr.proto.task_pb2 import Task, TaskIns, TaskRes  # pylint: disable=E0611
+from flwr.proto.transport_pb2 import (  # pylint: disable=E0611
+    ClientMessage,
+    ServerMessage,
+)
+from flwr.proto.transport_pb2_grpc import FlowerServiceStub  # pylint: disable=E0611
 
 # The following flags can be uncommented for debugging. Other possible values:
 # https://github.com/grpc/grpc/blob/master/doc/environment_variables.md

flwr/client/grpc_rere_client/connection.py

@@ -29,15 +29,15 @@ from flwr.client.message_handler.task_handler import (
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
 from flwr.common.grpc import create_channel
 from flwr.common.logger import log, warn_experimental_feature
-from flwr.proto.fleet_pb2 import (
+from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     CreateNodeRequest,
     DeleteNodeRequest,
     PullTaskInsRequest,
     PushTaskResRequest,
 )
-from flwr.proto.fleet_pb2_grpc import FleetStub
-from flwr.proto.node_pb2 import Node
-from flwr.proto.task_pb2 import TaskIns, TaskRes
+from flwr.proto.fleet_pb2_grpc import FleetStub  # pylint: disable=E0611
+from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
+from flwr.proto.task_pb2 import TaskIns, TaskRes  # pylint: disable=E0611
 
 KEY_NODE = "node"
 KEY_TASK_INS = "current_task_ins"

flwr/client/message_handler/message_handler.py

@@ -32,8 +32,17 @@ from flwr.client.run_state import RunState
 from flwr.client.secure_aggregation import SecureAggregationHandler
 from flwr.client.typing import ClientFn
 from flwr.common import serde
-from flwr.proto.task_pb2 import SecureAggregation, Task, TaskIns, TaskRes
-from flwr.proto.transport_pb2 import ClientMessage, Reason, ServerMessage
+from flwr.proto.task_pb2 import (  # pylint: disable=E0611
+    SecureAggregation,
+    Task,
+    TaskIns,
+    TaskRes,
+)
+from flwr.proto.transport_pb2 import (  # pylint: disable=E0611
+    ClientMessage,
+    Reason,
+    ServerMessage,
+)
 
 
 class UnexpectedServerMessage(Exception):

flwr/client/message_handler/task_handler.py

@@ -17,10 +17,13 @@
 
 from typing import Optional
 
-from flwr.proto.fleet_pb2 import PullTaskInsResponse
-from flwr.proto.node_pb2 import Node
-from flwr.proto.task_pb2 import Task, TaskIns, TaskRes
-from flwr.proto.transport_pb2 import ClientMessage, ServerMessage
+from flwr.proto.fleet_pb2 import PullTaskInsResponse  # pylint: disable=E0611
+from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
+from flwr.proto.task_pb2 import Task, TaskIns, TaskRes  # pylint: disable=E0611
+from flwr.proto.transport_pb2 import (  # pylint: disable=E0611
+    ClientMessage,
+    ServerMessage,
+)
 
 
 def validate_task_ins(task_ins: TaskIns, discard_reconnect_ins: bool) -> bool:
@@ -80,8 +83,7 @@ def validate_task_res(task_res: TaskRes) -> bool:
     initialized_fields_in_task = {field.name for field, _ in task_res.task.ListFields()}
 
     # Check if certain fields are already initialized
-    # pylint: disable-next=too-many-boolean-expressions
-    if (
+    if (  # pylint: disable-next=too-many-boolean-expressions
         "task_id" in initialized_fields_in_task_res
         or "group_id" in initialized_fields_in_task_res
         or "run_id" in initialized_fields_in_task_res

flwr/client/node_state_tests.py

@@ -17,7 +17,7 @@
 
 from flwr.client.node_state import NodeState
 from flwr.client.run_state import RunState
-from flwr.proto.task_pb2 import TaskIns
+from flwr.proto.task_pb2 import TaskIns  # pylint: disable=E0611
 
 
 def _run_dummy_task(state: RunState) -> RunState:

flwr/client/numpy_client.py

@@ -242,7 +242,7 @@ def _fit(self: Client, ins: FitIns) -> FitRes:
         and isinstance(results[1], int)
         and isinstance(results[2], dict)
     ):
-        raise Exception(EXCEPTION_MESSAGE_WRONG_RETURN_TYPE_FIT)
+        raise TypeError(EXCEPTION_MESSAGE_WRONG_RETURN_TYPE_FIT)
 
     # Return FitRes
     parameters_prime, num_examples, metrics = results
@@ -266,7 +266,7 @@ def _evaluate(self: Client, ins: EvaluateIns) -> EvaluateRes:
         and isinstance(results[1], int)
         and isinstance(results[2], dict)
     ):
-        raise Exception(EXCEPTION_MESSAGE_WRONG_RETURN_TYPE_EVALUATE)
+        raise TypeError(EXCEPTION_MESSAGE_WRONG_RETURN_TYPE_EVALUATE)
 
     # Return EvaluateRes
     loss, num_examples, metrics = results

flwr/client/rest_client/connection.py

@@ -29,7 +29,7 @@ from flwr.client.message_handler.task_handler import (
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
 from flwr.common.constant import MISSING_EXTRA_REST
 from flwr.common.logger import log
-from flwr.proto.fleet_pb2 import (
+from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     CreateNodeRequest,
     CreateNodeResponse,
     DeleteNodeRequest,
@@ -38,8 +38,8 @@ from flwr.proto.fleet_pb2 import (
     PushTaskResRequest,
     PushTaskResResponse,
 )
-from flwr.proto.node_pb2 import Node
-from flwr.proto.task_pb2 import TaskIns, TaskRes
+from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
+from flwr.proto.task_pb2 import TaskIns, TaskRes  # pylint: disable=E0611
 
 try:
     import requests
@@ -143,6 +143,7 @@ def http_request_response(
             },
             data=create_node_req_bytes,
             verify=verify,
+            timeout=None,
         )
 
         # Check status code and headers
@@ -185,6 +186,7 @@ def http_request_response(
             },
             data=delete_node_req_req_bytes,
             verify=verify,
+            timeout=None,
         )
 
         # Check status code and headers
@@ -225,6 +227,7 @@ def http_request_response(
             },
             data=pull_task_ins_req_bytes,
             verify=verify,
+            timeout=None,
         )
 
         # Check status code and headers
@@ -303,6 +306,7 @@ def http_request_response(
             },
             data=push_task_res_request_bytes,
             verify=verify,
+            timeout=None,
         )
 
         state[KEY_TASK_INS] = None

flwr/client/secure_aggregation/secaggplus_handler.py

@@ -333,7 +333,7 @@ def _share_keys(
 
     # Check if the size is larger than threshold
     if len(state.public_keys_dict) < state.threshold:
-        raise Exception("Available neighbours number smaller than threshold")
+        raise ValueError("Available neighbours number smaller than threshold")
 
     # Check if all public keys are unique
     pk_list: List[bytes] = []
@@ -341,14 +341,14 @@ def _share_keys(
         pk_list.append(pk1)
         pk_list.append(pk2)
     if len(set(pk_list)) != len(pk_list):
-        raise Exception("Some public keys are identical")
+        raise ValueError("Some public keys are identical")
 
     # Check if public keys of this client are correct in the dictionary
     if (
         state.public_keys_dict[state.sid][0] != state.pk1
         or state.public_keys_dict[state.sid][1] != state.pk2
     ):
-        raise Exception(
+        raise ValueError(
             "Own public keys are displayed in dict incorrectly, should not happen!"
         )
 
@@ -393,7 +393,7 @@ def _collect_masked_input(
     ciphertexts = cast(List[bytes], named_values[KEY_CIPHERTEXT_LIST])
     srcs = cast(List[int], named_values[KEY_SOURCE_LIST])
     if len(ciphertexts) + 1 < state.threshold:
-        raise Exception("Not enough available neighbour clients.")
+        raise ValueError("Not enough available neighbour clients.")
 
     # Decrypt ciphertexts, verify their sources, and store shares.
     for src, ciphertext in zip(srcs, ciphertexts):
@@ -409,7 +409,7 @@ def _collect_masked_input(
                 f"from {actual_src} instead of {src}."
             )
         if dst != state.sid:
-            ValueError(
+            raise ValueError(
                 f"Client {state.sid}: received an encrypted message"
                 f"for Client {dst} from Client {src}."
             )
@@ -476,7 +476,7 @@ def _unmask(state: SecAggPlusState, named_values: Dict[str, Value]) -> Dict[str,
     # Send private mask seed share for every avaliable client (including itclient)
     # Send first private key share for building pairwise mask for every dropped client
     if len(active_sids) < state.threshold:
-        raise Exception("Available neighbours number smaller than threshold")
+        raise ValueError("Available neighbours number smaller than threshold")
 
     sids, shares = [], []
     sids += active_sids

flwr/client/typing.py

@@ -18,7 +18,7 @@ from dataclasses import dataclass
 from typing import Callable
 
 from flwr.client.run_state import RunState
-from flwr.proto.task_pb2 import TaskIns, TaskRes
+from flwr.proto.task_pb2 import TaskIns, TaskRes  # pylint: disable=E0611
 
 from .client import Client as Client
 

flwr/common/configsrecord.py

@@ -0,0 +1,98 @@
+# Copyright 2024 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.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""ConfigsRecord."""
+
+
+from dataclasses import dataclass, field
+from typing import Dict, Optional, get_args
+
+from .typing import ConfigsRecordValues, ConfigsScalar
+
+
+@dataclass
+class ConfigsRecord:
+    """Configs record."""
+
+    keep_input: bool
+    data: Dict[str, ConfigsRecordValues] = field(default_factory=dict)
+
+    def __init__(
+        self,
+        configs_dict: Optional[Dict[str, ConfigsRecordValues]] = None,
+        keep_input: bool = True,
+    ):
+        """Construct a ConfigsRecord object.
+
+        Parameters
+        ----------
+        configs_dict : Optional[Dict[str, ConfigsRecordValues]]
+            A dictionary that stores basic types (i.e. `str`, `int`, `float`, `bytes` as
+            defined in `ConfigsScalar`) and lists of such types (see
+            `ConfigsScalarList`).
+        keep_input : bool (default: True)
+            A boolean indicating whether config passed should be deleted from the input
+            dictionary immediately after adding them to the record. When set
+            to True, the data is duplicated in memory. If memory is a concern, set
+            it to False.
+        """
+        self.keep_input = keep_input
+        self.data = {}
+        if configs_dict:
+            self.set_configs(configs_dict)
+
+    def set_configs(self, configs_dict: Dict[str, ConfigsRecordValues]) -> None:
+        """Add configs to the record.
+
+        Parameters
+        ----------
+        configs_dict : Dict[str, ConfigsRecordValues]
+            A dictionary that stores basic types (i.e. `str`,`int`, `float`, `bytes` as
+            defined in `ConfigsRecordValues`) and list of such types (see
+            `ConfigsScalarList`).
+        """
+        if any(not isinstance(k, str) for k in configs_dict.keys()):
+            raise TypeError(f"Not all keys are of valid type. Expected {str}")
+
+        def is_valid(value: ConfigsScalar) -> None:
+            """Check if value is of expected type."""
+            if not isinstance(value, get_args(ConfigsScalar)):
+                raise TypeError(
+                    "Not all values are of valid type."
+                    f" Expected {ConfigsRecordValues} but you passed {type(value)}."
+                )
+
+        # Check types of values
+        # Split between those values that are list and those that aren't
+        # then process in the same way
+        for value in configs_dict.values():
+            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.
+                for list_value in value:
+                    is_valid(list_value)
+            else:
+                is_valid(value)
+
+        # Add configs to record
+        if self.keep_input:
+            # Copy
+            self.data = configs_dict.copy()
+        else:
+            # Add entries to dataclass without duplicating memory
+            for key in list(configs_dict.keys()):
+                self.data[key] = configs_dict[key]
+                del configs_dict[key]

flwr/common/logger.py

@@ -111,3 +111,17 @@ def warn_experimental_feature(name: str) -> None:
         """,
         name,
     )
+
+
+def warn_deprecated_feature(name: str) -> None:
+    """Warn the user when they use a deprecated feature."""
+    log(
+        WARN,
+        """
+        DEPRECATED FEATURE: %s
+
+        This is a deprecated feature. It will be removed
+        entirely in future versions of Flower.
+        """,
+        name,
+    )

flwr/common/metricsrecord.py

@@ -0,0 +1,96 @@
+# Copyright 2024 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.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""MetricsRecord."""
+
+
+from dataclasses import dataclass, field
+from typing import Dict, Optional, get_args
+
+from .typing import MetricsRecordValues, MetricsScalar
+
+
+@dataclass
+class MetricsRecord:
+    """Metrics record."""
+
+    keep_input: bool
+    data: Dict[str, MetricsRecordValues] = field(default_factory=dict)
+
+    def __init__(
+        self,
+        metrics_dict: Optional[Dict[str, MetricsRecordValues]] = None,
+        keep_input: bool = True,
+    ):
+        """Construct a MetricsRecord object.
+
+        Parameters
+        ----------
+        metrics_dict : Optional[Dict[str, MetricsRecordValues]]
+            A dictionary that stores basic types (i.e. `int`, `float` as defined
+            in `MetricsScalar`) and list of such types (see `MetricsScalarList`).
+        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
+            to True, the data is duplicated in memory. If memory is a concern, set
+            it to False.
+        """
+        self.keep_input = keep_input
+        self.data = {}
+        if metrics_dict:
+            self.set_metrics(metrics_dict)
+
+    def set_metrics(self, metrics_dict: Dict[str, MetricsRecordValues]) -> None:
+        """Add metrics to the record.
+
+        Parameters
+        ----------
+        metrics_dict : Dict[str, MetricsRecordValues]
+            A dictionary that stores basic types (i.e. `int`, `float` as defined
+            in `MetricsScalar`) and list of such types (see `MetricsScalarList`).
+        """
+        if any(not isinstance(k, str) for k in metrics_dict.keys()):
+            raise TypeError(f"Not all keys are of valid type. Expected {str}.")
+
+        def is_valid(value: MetricsScalar) -> None:
+            """Check if value is of expected type."""
+            if not isinstance(value, get_args(MetricsScalar)):
+                raise TypeError(
+                    "Not all values are of valid type."
+                    f" Expected {MetricsRecordValues} but you passed {type(value)}."
+                )
+
+        # Check types of values
+        # Split between those values that are list and those that aren't
+        # then process in the same way
+        for value in metrics_dict.values():
+            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.
+                for list_value in value:
+                    is_valid(list_value)
+            else:
+                is_valid(value)
+
+        # Add metrics to record
+        if self.keep_input:
+            # Copy
+            self.data = metrics_dict.copy()
+        else:
+            # Add entries to dataclass without duplicating memory
+            for key in list(metrics_dict.keys()):
+                self.data[key] = metrics_dict[key]
+                del metrics_dict[key]

flwr/common/parametersrecord.py

@@ -0,0 +1,110 @@
+# Copyright 2024 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.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""ParametersRecord and Array."""
+
+
+from dataclasses import dataclass, field
+from typing import List, Optional, OrderedDict
+
+
+@dataclass
+class Array:
+    """Array type.
+
+    A dataclass containing serialized data from an array-like or tensor-like object
+    along with some metadata about it.
+
+    Parameters
+    ----------
+    dtype : str
+        A string representing the data type of the serialised object (e.g. `np.float32`)
+
+    shape : List[int]
+        A list representing the shape of the unserialized array-like object. This is
+        used to deserialize the data (depending on the serialization method) or simply
+        as a metadata field.
+
+    stype : str
+        A string indicating the type of serialisation mechanism used to generate the
+        bytes in `data` from an array-like or tensor-like object.
+
+    data: bytes
+        A buffer of bytes containing the data.
+    """
+
+    dtype: str
+    shape: List[int]
+    stype: str
+    data: bytes
+
+
+@dataclass
+class ParametersRecord:
+    """Parameters record.
+
+    A dataclass storing named Arrays in order. This means that it holds entries as an
+    OrderedDict[str, Array]. ParametersRecord objects can be viewed as an equivalent to
+    PyTorch's state_dict, but holding serialised tensors instead.
+    """
+
+    keep_input: bool
+    data: OrderedDict[str, Array] = field(default_factory=OrderedDict[str, Array])
+
+    def __init__(
+        self,
+        array_dict: Optional[OrderedDict[str, Array]] = None,
+        keep_input: bool = False,
+    ) -> None:
+        """Construct a ParametersRecord object.
+
+        Parameters
+        ----------
+        array_dict : Optional[OrderedDict[str, Array]]
+            A dictionary that stores serialized array-like or tensor-like objects.
+        keep_input : bool (default: False)
+            A boolean indicating whether parameters should be deleted from the input
+            dictionary immediately after adding them to the record. If False, the
+            dictionary passed to `set_parameters()` will be empty once exiting from that
+            function. This is the desired behaviour when working with very large
+            models/tensors/arrays. However, if you plan to continue working with your
+            parameters after adding it to the record, set this flag to True. When set
+            to True, the data is duplicated in memory.
+        """
+        self.keep_input = keep_input
+        self.data = OrderedDict()
+        if array_dict:
+            self.set_parameters(array_dict)
+
+    def set_parameters(self, array_dict: OrderedDict[str, Array]) -> None:
+        """Add parameters to record.
+
+        Parameters
+        ----------
+        array_dict : OrderedDict[str, Array]
+            A dictionary that stores serialized array-like or tensor-like objects.
+        """
+        if any(not isinstance(k, str) for k in array_dict.keys()):
+            raise TypeError(f"Not all keys are of valid type. Expected {str}")
+        if any(not isinstance(v, Array) for v in array_dict.values()):
+            raise TypeError(f"Not all values are of valid type. Expected {Array}")
+
+        if self.keep_input:
+            # Copy
+            self.data = OrderedDict(array_dict)
+        else:
+            # Add entries to dataclass without duplicating memory
+            for key in list(array_dict.keys()):
+                self.data[key] = array_dict[key]
+                del array_dict[key]

flwr/common/recordset.py

@@ -14,32 +14,22 @@
 # ==============================================================================
 """RecordSet."""
 
-from dataclasses import dataclass
-from typing import Dict
-
-
-@dataclass
-class ParametersRecord:
-    """Parameters record."""
-
-
-@dataclass
-class MetricsRecord:
-    """Metrics record."""
 
+from dataclasses import dataclass, field
+from typing import Dict
 
-@dataclass
-class ConfigsRecord:
-    """Configs record."""
+from .configsrecord import ConfigsRecord
+from .metricsrecord import MetricsRecord
+from .parametersrecord import ParametersRecord
 
 
 @dataclass
 class RecordSet:
     """Definition of RecordSet."""
 
-    parameters: Dict[str, ParametersRecord] = {}
-    metrics: Dict[str, MetricsRecord] = {}
-    configs: Dict[str, ConfigsRecord] = {}
+    parameters: Dict[str, ParametersRecord] = field(default_factory=dict)
+    metrics: Dict[str, MetricsRecord] = field(default_factory=dict)
+    configs: Dict[str, ConfigsRecord] = field(default_factory=dict)
 
     def set_parameters(self, name: str, record: ParametersRecord) -> None:
         """Add a ParametersRecord."""