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

flwr/client/app.py

@@ -495,8 +495,9 @@ def start_client_internal(
                     context = run_info_store.retrieve_context(run_id=run_id)
                     # Create an error reply message that will never be used to prevent
                     # the used-before-assignment linting error
-                    reply_message = message.create_error_reply(
-                        error=Error(code=ErrorCode.UNKNOWN, reason="Unknown")
+                    reply_message = Message(
+                        Error(code=ErrorCode.UNKNOWN, reason="Unknown"),
+                        reply_to=message,
                     )
 
                     # Handle app loading and task message
@@ -593,8 +594,9 @@ def start_client_internal(
                         log(ERROR, "%s raised an exception", exc_entity, exc_info=ex)
 
                         # Create error message
-                        reply_message = message.create_error_reply(
-                            error=Error(code=e_code, reason=reason)
+                        reply_message = Message(
+                            Error(code=e_code, reason=reason),
+                            reply_to=message,
                         )
                     else:
                         # No exception, update node state

flwr/client/clientapp/app.py

@@ -152,8 +152,8 @@ def run_clientapp(  # pylint: disable=R0914
                 log(ERROR, "%s raised an exception", exc_entity, exc_info=ex)
 
                 # Create error message
-                reply_message = message.create_error_reply(
-                    error=Error(code=e_code, reason=reason)
+                reply_message = Message(
+                    Error(code=e_code, reason=reason), reply_to=message
                 )
 
             # Push Message and Context to SuperNode

flwr/client/grpc_client/connection.py

@@ -31,13 +31,15 @@ from flwr.common import (
     ConfigsRecord,
     Message,
     Metadata,
-    RecordSet,
+    RecordDict,
+    now,
 )
-from flwr.common import recordset_compat as compat
+from flwr.common import recorddict_compat as compat
 from flwr.common import serde
 from flwr.common.constant import MessageType, MessageTypeLegacy
 from flwr.common.grpc import create_channel, on_channel_state_change
 from flwr.common.logger import log
+from flwr.common.message import make_message
 from flwr.common.retry_invoker import RetryInvoker
 from flwr.common.typing import Fab, Run
 from flwr.proto.transport_pb2 import (  # pylint: disable=E0611
@@ -139,32 +141,32 @@ def grpc_connection(  # pylint: disable=R0913,R0915,too-many-positional-argument
         # Receive ServerMessage proto
         proto = next(server_message_iterator)
 
-        # ServerMessage proto --> *Ins --> RecordSet
+        # ServerMessage proto --> *Ins --> RecordDict
         field = proto.WhichOneof("msg")
         message_type = ""
         if field == "get_properties_ins":
-            recordset = compat.getpropertiesins_to_recordset(
+            recorddict = compat.getpropertiesins_to_recorddict(
                 serde.get_properties_ins_from_proto(proto.get_properties_ins)
             )
             message_type = MessageTypeLegacy.GET_PROPERTIES
         elif field == "get_parameters_ins":
-            recordset = compat.getparametersins_to_recordset(
+            recorddict = compat.getparametersins_to_recorddict(
                 serde.get_parameters_ins_from_proto(proto.get_parameters_ins)
             )
             message_type = MessageTypeLegacy.GET_PARAMETERS
         elif field == "fit_ins":
-            recordset = compat.fitins_to_recordset(
+            recorddict = compat.fitins_to_recorddict(
                 serde.fit_ins_from_proto(proto.fit_ins), False
             )
             message_type = MessageType.TRAIN
         elif field == "evaluate_ins":
-            recordset = compat.evaluateins_to_recordset(
+            recorddict = compat.evaluateins_to_recorddict(
                 serde.evaluate_ins_from_proto(proto.evaluate_ins), False
             )
             message_type = MessageType.EVALUATE
         elif field == "reconnect_ins":
-            recordset = RecordSet()
-            recordset.configs_records["config"] = ConfigsRecord(
+            recorddict = RecordDict()
+            recorddict.configs_records["config"] = ConfigsRecord(
                 {"seconds": proto.reconnect_ins.seconds}
             )
             message_type = "reconnect"
@@ -175,45 +177,46 @@ def grpc_connection(  # pylint: disable=R0913,R0915,too-many-positional-argument
             )
 
         # Construct Message
-        return Message(
+        return make_message(
             metadata=Metadata(
                 run_id=0,
                 message_id=str(uuid.uuid4()),
                 src_node_id=0,
                 dst_node_id=0,
-                reply_to_message="",
+                reply_to_message_id="",
                 group_id="",
+                created_at=now().timestamp(),
                 ttl=DEFAULT_TTL,
                 message_type=message_type,
             ),
-            content=recordset,
+            content=recorddict,
         )
 
     def send(message: Message) -> None:
-        # Retrieve RecordSet and message_type
-        recordset = message.content
+        # Retrieve RecordDict and message_type
+        recorddict = message.content
         message_type = message.metadata.message_type
 
-        # RecordSet --> *Res --> *Res proto -> ClientMessage proto
+        # RecordDict --> *Res --> *Res proto -> ClientMessage proto
         if message_type == MessageTypeLegacy.GET_PROPERTIES:
-            getpropres = compat.recordset_to_getpropertiesres(recordset)
+            getpropres = compat.recorddict_to_getpropertiesres(recorddict)
             msg_proto = ClientMessage(
                 get_properties_res=serde.get_properties_res_to_proto(getpropres)
             )
         elif message_type == MessageTypeLegacy.GET_PARAMETERS:
-            getparamres = compat.recordset_to_getparametersres(recordset, False)
+            getparamres = compat.recorddict_to_getparametersres(recorddict, False)
             msg_proto = ClientMessage(
                 get_parameters_res=serde.get_parameters_res_to_proto(getparamres)
             )
         elif message_type == MessageType.TRAIN:
-            fitres = compat.recordset_to_fitres(recordset, False)
+            fitres = compat.recorddict_to_fitres(recorddict, False)
             msg_proto = ClientMessage(fit_res=serde.fit_res_to_proto(fitres))
         elif message_type == MessageType.EVALUATE:
-            evalres = compat.recordset_to_evaluateres(recordset)
+            evalres = compat.recorddict_to_evaluateres(recorddict)
             msg_proto = ClientMessage(evaluate_res=serde.evaluate_res_to_proto(evalres))
         elif message_type == "reconnect":
             reason = cast(
-                Reason.ValueType, recordset.configs_records["config"]["reason"]
+                Reason.ValueType, recorddict.configs_records["config"]["reason"]
             )
             msg_proto = ClientMessage(
                 disconnect_res=ClientMessage.DisconnectRes(reason=reason)

flwr/client/message_handler/message_handler.py

@@ -26,17 +26,17 @@ from flwr.client.client import (
 )
 from flwr.client.numpy_client import NumPyClient
 from flwr.client.typing import ClientFnExt
-from flwr.common import ConfigsRecord, Context, Message, Metadata, RecordSet, log
+from flwr.common import ConfigsRecord, Context, Message, Metadata, RecordDict, log
 from flwr.common.constant import MessageType, MessageTypeLegacy
-from flwr.common.recordset_compat import (
-    evaluateres_to_recordset,
-    fitres_to_recordset,
-    getparametersres_to_recordset,
-    getpropertiesres_to_recordset,
-    recordset_to_evaluateins,
-    recordset_to_fitins,
-    recordset_to_getparametersins,
-    recordset_to_getpropertiesins,
+from flwr.common.recorddict_compat import (
+    evaluateres_to_recorddict,
+    fitres_to_recorddict,
+    getparametersres_to_recorddict,
+    getpropertiesres_to_recorddict,
+    recorddict_to_evaluateins,
+    recorddict_to_fitins,
+    recorddict_to_getparametersins,
+    recorddict_to_getpropertiesins,
 )
 from flwr.proto.transport_pb2 import (  # pylint: disable=E0611
     ClientMessage,
@@ -70,18 +70,18 @@ def handle_control_message(message: Message) -> tuple[Optional[Message], int]:
         Number of seconds that the client should disconnect from the server.
     """
     if message.metadata.message_type == "reconnect":
-        # Retrieve ReconnectIns from recordset
-        recordset = message.content
-        seconds = cast(int, recordset.configs_records["config"]["seconds"])
+        # Retrieve ReconnectIns from RecordDict
+        recorddict = message.content
+        seconds = cast(int, recorddict.configs_records["config"]["seconds"])
         # Construct ReconnectIns and call _reconnect
         disconnect_msg, sleep_duration = _reconnect(
             ServerMessage.ReconnectIns(seconds=seconds)
         )
-        # Store DisconnectRes in recordset
+        # Store DisconnectRes in RecordDict
         reason = cast(int, disconnect_msg.disconnect_res.reason)
-        recordset = RecordSet()
-        recordset.configs_records["config"] = ConfigsRecord({"reason": reason})
-        out_message = message.create_reply(recordset)
+        recorddict = RecordDict()
+        recorddict.configs_records["config"] = ConfigsRecord({"reason": reason})
+        out_message = Message(recorddict, reply_to=message)
         # Return Message and sleep duration
         return out_message, sleep_duration
 
@@ -111,37 +111,37 @@ def handle_legacy_message_from_msgtype(
     if message_type == MessageTypeLegacy.GET_PROPERTIES:
         get_properties_res = maybe_call_get_properties(
             client=client,
-            get_properties_ins=recordset_to_getpropertiesins(message.content),
+            get_properties_ins=recorddict_to_getpropertiesins(message.content),
         )
-        out_recordset = getpropertiesres_to_recordset(get_properties_res)
+        out_recorddict = getpropertiesres_to_recorddict(get_properties_res)
     # Handle GetParametersIns
     elif message_type == MessageTypeLegacy.GET_PARAMETERS:
         get_parameters_res = maybe_call_get_parameters(
             client=client,
-            get_parameters_ins=recordset_to_getparametersins(message.content),
+            get_parameters_ins=recorddict_to_getparametersins(message.content),
         )
-        out_recordset = getparametersres_to_recordset(
+        out_recorddict = getparametersres_to_recorddict(
             get_parameters_res, keep_input=False
         )
     # Handle FitIns
     elif message_type == MessageType.TRAIN:
         fit_res = maybe_call_fit(
             client=client,
-            fit_ins=recordset_to_fitins(message.content, keep_input=True),
+            fit_ins=recorddict_to_fitins(message.content, keep_input=True),
         )
-        out_recordset = fitres_to_recordset(fit_res, keep_input=False)
+        out_recorddict = fitres_to_recorddict(fit_res, keep_input=False)
     # Handle EvaluateIns
     elif message_type == MessageType.EVALUATE:
         evaluate_res = maybe_call_evaluate(
             client=client,
-            evaluate_ins=recordset_to_evaluateins(message.content, keep_input=True),
+            evaluate_ins=recorddict_to_evaluateins(message.content, keep_input=True),
         )
-        out_recordset = evaluateres_to_recordset(evaluate_res)
+        out_recorddict = evaluateres_to_recorddict(evaluate_res)
     else:
         raise ValueError(f"Invalid message type: {message_type}")
 
     # Return Message
-    return message.create_reply(out_recordset)
+    return Message(out_recorddict, reply_to=message)
 
 
 def _reconnect(
@@ -167,7 +167,7 @@ def validate_out_message(out_message: Message, in_message_metadata: Metadata) ->
         and out_meta.message_id == ""  # This will be generated by the server
         and out_meta.src_node_id == in_meta.dst_node_id
         and out_meta.dst_node_id == in_meta.src_node_id
-        and out_meta.reply_to_message == in_meta.message_id
+        and out_meta.reply_to_message_id == in_meta.message_id
         and out_meta.group_id == in_meta.group_id
         and out_meta.message_type == in_meta.message_type
         and out_meta.created_at > in_meta.created_at

flwr/client/mod/centraldp_mods.py

@@ -19,7 +19,7 @@ from logging import INFO
 
 from flwr.client.typing import ClientAppCallable
 from flwr.common import ndarrays_to_parameters, parameters_to_ndarrays
-from flwr.common import recordset_compat as compat
+from flwr.common import recorddict_compat as compat
 from flwr.common.constant import MessageType
 from flwr.common.context import Context
 from flwr.common.differential_privacy import (
@@ -53,7 +53,7 @@ def fixedclipping_mod(
     """
     if msg.metadata.message_type != MessageType.TRAIN:
         return call_next(msg, ctxt)
-    fit_ins = compat.recordset_to_fitins(msg.content, keep_input=True)
+    fit_ins = compat.recorddict_to_fitins(msg.content, keep_input=True)
     if KEY_CLIPPING_NORM not in fit_ins.config:
         raise KeyError(
             f"The {KEY_CLIPPING_NORM} value is not supplied by the "
@@ -71,7 +71,7 @@ def fixedclipping_mod(
     if out_msg.has_error():
         return out_msg
 
-    fit_res = compat.recordset_to_fitres(out_msg.content, keep_input=True)
+    fit_res = compat.recorddict_to_fitres(out_msg.content, keep_input=True)
 
     client_to_server_params = parameters_to_ndarrays(fit_res.parameters)
 
@@ -87,7 +87,7 @@ def fixedclipping_mod(
     )
 
     fit_res.parameters = ndarrays_to_parameters(client_to_server_params)
-    out_msg.content = compat.fitres_to_recordset(fit_res, keep_input=True)
+    out_msg.content = compat.fitres_to_recorddict(fit_res, keep_input=True)
     return out_msg
 
 
@@ -116,7 +116,7 @@ def adaptiveclipping_mod(
     if msg.metadata.message_type != MessageType.TRAIN:
         return call_next(msg, ctxt)
 
-    fit_ins = compat.recordset_to_fitins(msg.content, keep_input=True)
+    fit_ins = compat.recorddict_to_fitins(msg.content, keep_input=True)
 
     if KEY_CLIPPING_NORM not in fit_ins.config:
         raise KeyError(
@@ -136,7 +136,7 @@ def adaptiveclipping_mod(
     if out_msg.has_error():
         return out_msg
 
-    fit_res = compat.recordset_to_fitres(out_msg.content, keep_input=True)
+    fit_res = compat.recorddict_to_fitres(out_msg.content, keep_input=True)
 
     client_to_server_params = parameters_to_ndarrays(fit_res.parameters)
 
@@ -155,5 +155,5 @@ def adaptiveclipping_mod(
     fit_res.parameters = ndarrays_to_parameters(client_to_server_params)
 
     fit_res.metrics[KEY_NORM_BIT] = norm_bit
-    out_msg.content = compat.fitres_to_recordset(fit_res, keep_input=True)
+    out_msg.content = compat.fitres_to_recorddict(fit_res, keep_input=True)
     return out_msg

flwr/client/mod/localdp_mod.py

@@ -21,7 +21,7 @@ import numpy as np
 
 from flwr.client.typing import ClientAppCallable
 from flwr.common import ndarrays_to_parameters, parameters_to_ndarrays
-from flwr.common import recordset_compat as compat
+from flwr.common import recorddict_compat as compat
 from flwr.common.constant import MessageType
 from flwr.common.context import Context
 from flwr.common.differential_privacy import (
@@ -107,7 +107,7 @@ class LocalDpMod:
         if msg.metadata.message_type != MessageType.TRAIN:
             return call_next(msg, ctxt)
 
-        fit_ins = compat.recordset_to_fitins(msg.content, keep_input=True)
+        fit_ins = compat.recorddict_to_fitins(msg.content, keep_input=True)
         server_to_client_params = parameters_to_ndarrays(fit_ins.parameters)
 
         # Call inner app
@@ -117,7 +117,7 @@ class LocalDpMod:
         if out_msg.has_error():
             return out_msg
 
-        fit_res = compat.recordset_to_fitres(out_msg.content, keep_input=True)
+        fit_res = compat.recorddict_to_fitres(out_msg.content, keep_input=True)
 
         client_to_server_params = parameters_to_ndarrays(fit_res.parameters)
 
@@ -149,5 +149,5 @@ class LocalDpMod:
             noise_value_sd,
         )
 
-        out_msg.content = compat.fitres_to_recordset(fit_res, keep_input=True)
+        out_msg.content = compat.fitres_to_recorddict(fit_res, keep_input=True)
         return out_msg

flwr/client/mod/secure_aggregation/secaggplus_mod.py

@@ -26,11 +26,11 @@ from flwr.common import (
     Context,
     Message,
     Parameters,
-    RecordSet,
+    RecordDict,
     ndarray_to_bytes,
     parameters_to_ndarrays,
 )
-from flwr.common import recordset_compat as compat
+from flwr.common import recorddict_compat as compat
 from flwr.common.constant import MessageType
 from flwr.common.logger import log
 from flwr.common.secure_aggregation.crypto.shamir import create_shares
@@ -162,7 +162,7 @@ def secaggplus_mod(
     check_configs(state.current_stage, configs)
 
     # Execute
-    out_content = RecordSet()
+    out_content = RecordDict()
     if state.current_stage == Stage.SETUP:
         state.nid = msg.metadata.dst_node_id
         res = _setup(state, configs)
@@ -171,7 +171,7 @@ def secaggplus_mod(
     elif state.current_stage == Stage.COLLECT_MASKED_VECTORS:
         out_msg = call_next(msg, ctxt)
         out_content = out_msg.content
-        fitres = compat.recordset_to_fitres(out_content, keep_input=True)
+        fitres = compat.recorddict_to_fitres(out_content, keep_input=True)
         res = _collect_masked_vectors(
             state, configs, fitres.num_examples, fitres.parameters
         )
@@ -187,7 +187,7 @@ def secaggplus_mod(
 
     # Return message
     out_content.configs_records[RECORD_KEY_CONFIGS] = ConfigsRecord(res, False)
-    return msg.create_reply(out_content)
+    return Message(out_content, reply_to=msg)
 
 
 def check_stage(current_stage: str, configs: ConfigsRecord) -> None:

flwr/client/run_info_store.py

@@ -19,7 +19,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
 
-from flwr.common import Context, RecordSet
+from flwr.common import Context, RecordDict
 from flwr.common.config import (
     get_fused_config,
     get_fused_config_from_dir,
@@ -86,7 +86,7 @@ class DeprecatedRunInfoStore:
                     run_id=run_id,
                     node_id=self.node_id,
                     node_config=self.node_config,
-                    state=RecordSet(),
+                    state=RecordDict(),
                     run_config=initial_run_config.copy(),
                 ),
             )

flwr/common/__init__.py

@@ -34,6 +34,7 @@ from .record import Array as Array
 from .record import ConfigsRecord as ConfigsRecord
 from .record import MetricsRecord as MetricsRecord
 from .record import ParametersRecord as ParametersRecord
+from .record import RecordDict as RecordDict
 from .record import RecordSet as RecordSet
 from .record import array_from_numpy as array_from_numpy
 from .telemetry import EventType as EventType
@@ -98,6 +99,7 @@ __all__ = [
     "ParametersRecord",
     "Properties",
     "ReconnectIns",
+    "RecordDict",
     "RecordSet",
     "Scalar",
     "ServerMessage",

flwr/common/context.py

@@ -17,7 +17,7 @@
 
 from dataclasses import dataclass
 
-from .record import RecordSet
+from .record import RecordDict
 from .typing import UserConfig
 
 
@@ -34,7 +34,7 @@ class Context:
     node_config : UserConfig
         A config (key/value mapping) unique to the node and independent of the
         `run_config`. This config persists across all runs this node participates in.
-    state : RecordSet
+    state : RecordDict
         Holds records added by the entity in a given `run_id` and that will stay local.
         This means that the data it holds will never leave the system it's running from.
         This can be used as an intermediate storage or scratchpad when
@@ -50,7 +50,7 @@ class Context:
     run_id: int
     node_id: int
     node_config: UserConfig
-    state: RecordSet
+    state: RecordDict
     run_config: UserConfig
 
     def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
@@ -58,7 +58,7 @@ class Context:
         run_id: int,
         node_id: int,
         node_config: UserConfig,
-        state: RecordSet,
+        state: RecordDict,
         run_config: UserConfig,
     ) -> None:
         self.run_id = run_id