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

flwr/cli/run/run.py

@@ -35,15 +35,11 @@ from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
 from flwr.common.config import (
     flatten_dict,
     parse_config_args,
-    user_config_to_configsrecord,
+    user_config_to_configrecord,
 )
 from flwr.common.constant import CliOutputFormat
 from flwr.common.logger import print_json_error, redirect_output, restore_output
-from flwr.common.serde import (
-    configs_record_to_proto,
-    fab_to_proto,
-    user_config_to_proto,
-)
+from flwr.common.serde import config_record_to_proto, fab_to_proto, user_config_to_proto
 from flwr.common.typing import Fab
 from flwr.proto.exec_pb2 import StartRunRequest  # pylint: disable=E0611
 from flwr.proto.exec_pb2_grpc import ExecStub
@@ -171,14 +167,14 @@ def _run_with_exec_api(
 
     fab = Fab(fab_hash, content)
 
-    # Construct a `ConfigsRecord` out of a flattened `UserConfig`
+    # Construct a `ConfigRecord` out of a flattened `UserConfig`
     fed_conf = flatten_dict(federation_config.get("options", {}))
-    c_record = user_config_to_configsrecord(fed_conf)
+    c_record = user_config_to_configrecord(fed_conf)
 
     req = StartRunRequest(
         fab=fab_to_proto(fab),
         override_config=user_config_to_proto(parse_config_args(config_overrides)),
-        federation_options=configs_record_to_proto(c_record),
+        federation_options=config_record_to_proto(c_record),
     )
     with unauthenticated_exc_handler():
         res = stub.StartRun(req)

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/client_app.py

@@ -189,7 +189,7 @@ class ClientApp:
         >>> def train(message: Message, context: Context) -> Message:
         >>>     print("Executing default train function")
         >>>     # Create and return an echo reply message
-        >>>     return message.create_reply(content=message.content)
+        >>>     return Message(message.content, reply_to=message)
 
         Registering a train function with a custom action name:
 
@@ -200,7 +200,7 @@ class ClientApp:
         >>> @app.train("custom_action")
         >>> def custom_action(message: Message, context: Context) -> Message:
         >>>     print("Executing train function for custom action")
-        >>>     return message.create_reply(content=message.content)
+        >>>     return Message(message.content, reply_to=message)
 
         Registering a train function with a function-specific Flower Mod:
 
@@ -213,7 +213,7 @@ class ClientApp:
         >>> def train(message: Message, context: Context) -> Message:
         >>>     print("Executing train function with message size mod")
         >>>     # Create and return an echo reply message
-        >>>     return message.create_reply(content=message.content)
+        >>>     return Message(message.content, reply_to=message)
         """
         return _get_decorator(self, MessageType.TRAIN, action, mods)
 
@@ -244,7 +244,7 @@ class ClientApp:
         >>> def evaluate(message: Message, context: Context) -> Message:
         >>>     print("Executing default evaluate function")
         >>>     # Create and return an echo reply message
-        >>>     return message.create_reply(content=message.content)
+        >>>     return Message(message.content, reply_to=message)
 
         Registering an evaluate function with a custom action name:
 
@@ -255,7 +255,7 @@ class ClientApp:
         >>> @app.evaluate("custom_action")
         >>> def custom_action(message: Message, context: Context) -> Message:
         >>>     print("Executing evaluate function for custom action")
-        >>>     return message.create_reply(content=message.content)
+        >>>     return Message(message.content, reply_to=message)
 
         Registering an evaluate function with a function-specific Flower Mod:
 
@@ -268,7 +268,7 @@ class ClientApp:
         >>> def evaluate(message: Message, context: Context) -> Message:
         >>>     print("Executing evaluate function with message size mod")
         >>>     # Create and return an echo reply message
-        >>>     return message.create_reply(content=message.content)
+        >>>     return Message(message.content, reply_to=message)
         """
         return _get_decorator(self, MessageType.EVALUATE, action, mods)
 
@@ -299,7 +299,7 @@ class ClientApp:
         >>> def query(message: Message, context: Context) -> Message:
         >>>     print("Executing default query function")
         >>>     # Create and return an echo reply message
-        >>>     return message.create_reply(content=message.content)
+        >>>     return Message(message.content, reply_to=message)
 
         Registering a query function with a custom action name:
 
@@ -310,7 +310,7 @@ class ClientApp:
         >>> @app.query("custom_action")
         >>> def custom_action(message: Message, context: Context) -> Message:
         >>>     print("Executing query function for custom action")
-        >>>     return message.create_reply(content=message.content)
+        >>>     return Message(message.content, reply_to=message)
 
         Registering a query function with a function-specific Flower Mod:
 
@@ -323,7 +323,7 @@ class ClientApp:
         >>> def query(message: Message, context: Context) -> Message:
         >>>     print("Executing query function with message size mod")
         >>>     # Create and return an echo reply message
-        >>>     return message.create_reply(content=message.content)
+        >>>     return Message(message.content, reply_to=message)
         """
         return _get_decorator(self, MessageType.QUERY, action, mods)
 
@@ -454,8 +454,6 @@ def _registration_error(fn_name: str) -> ValueError:
         >>> def {fn_name}(message: Message, context: Context) -> Message:
         >>>    print("ClientApp {fn_name} running")
         >>>    # Create and return an echo reply message
-        >>>    return message.create_reply(
-        >>>        content=message.content()
-        >>>    )
+        >>>    return Message(message.content, reply_to=message)
         """,
     )

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

@@ -28,16 +28,18 @@ from cryptography.hazmat.primitives.asymmetric import ec
 from flwr.common import (
     DEFAULT_TTL,
     GRPC_MAX_MESSAGE_LENGTH,
-    ConfigsRecord,
+    ConfigRecord,
     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.config_records["config"] = ConfigRecord(
                 {"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.config_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 ConfigRecord, 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.config_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.config_records["config"] = ConfigRecord({"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/__init__.py

@@ -16,7 +16,7 @@
 
 
 from .centraldp_mods import adaptiveclipping_mod, fixedclipping_mod
-from .comms_mods import message_size_mod, parameters_size_mod
+from .comms_mods import arrays_size_mod, message_size_mod
 from .localdp_mod import LocalDpMod
 from .secure_aggregation import secagg_mod, secaggplus_mod
 from .utils import make_ffn
@@ -24,10 +24,10 @@ from .utils import make_ffn
 __all__ = [
     "LocalDpMod",
     "adaptiveclipping_mod",
+    "arrays_size_mod",
     "fixedclipping_mod",
     "make_ffn",
     "message_size_mod",
-    "parameters_size_mod",
     "secagg_mod",
     "secaggplus_mod",
 ]

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/comms_mods.py

@@ -34,47 +34,41 @@ def message_size_mod(
     """
     message_size_in_bytes = 0
 
-    for p_record in msg.content.parameters_records.values():
-        message_size_in_bytes += p_record.count_bytes()
-
-    for c_record in msg.content.configs_records.values():
-        message_size_in_bytes += c_record.count_bytes()
-
-    for m_record in msg.content.metrics_records.values():
-        message_size_in_bytes += m_record.count_bytes()
+    for record in msg.content.values():
+        message_size_in_bytes += record.count_bytes()
 
     log(INFO, "Message size: %i bytes", message_size_in_bytes)
 
     return call_next(msg, ctxt)
 
 
-def parameters_size_mod(
+def arrays_size_mod(
     msg: Message, ctxt: Context, call_next: ClientAppCallable
 ) -> Message:
-    """Parameters size mod.
+    """Arrays size mod.
 
-    This mod logs the number of parameters transmitted in the message as well as their
-    size in bytes.
+    This mod logs the number of array elements transmitted in ``ArrayRecord``s of
+    the message as well as their sizes in bytes.
     """
     model_size_stats = {}
-    parameters_size_in_bytes = 0
-    for record_name, p_record in msg.content.parameters_records.items():
-        p_record_bytes = p_record.count_bytes()
-        parameters_size_in_bytes += p_record_bytes
-        parameter_count = 0
-        for array in p_record.values():
-            parameter_count += (
+    arrays_size_in_bytes = 0
+    for record_name, arr_record in msg.content.array_records.items():
+        arr_record_bytes = arr_record.count_bytes()
+        arrays_size_in_bytes += arr_record_bytes
+        element_count = 0
+        for array in arr_record.values():
+            element_count += (
                 int(np.prod(array.shape)) if array.shape else array.numpy().size
             )
 
         model_size_stats[f"{record_name}"] = {
-            "parameters": parameter_count,
-            "bytes": p_record_bytes,
+            "elements": element_count,
+            "bytes": arr_record_bytes,
         }
 
     if model_size_stats:
         log(INFO, model_size_stats)
 
-    log(INFO, "Total parameters transmitted: %i bytes", parameters_size_in_bytes)
+    log(INFO, "Total array elements transmitted: %i bytes", arrays_size_in_bytes)
 
     return call_next(msg, ctxt)

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