flwr 1.16.0__py3-none-any.whl → 1.17.0__py3-none-any.whl

flwr/server/workflow/default_workflows.py

@@ -20,15 +20,16 @@ import timeit
 from logging import INFO, WARN
 from typing import Optional, Union, cast
 
-import flwr.common.recordset_compat as compat
+import flwr.common.recorddict_compat as compat
 from flwr.common import (
+    ArrayRecord,
     Code,
-    ConfigsRecord,
+    ConfigRecord,
     Context,
     EvaluateRes,
     FitRes,
     GetParametersIns,
-    ParametersRecord,
+    Message,
     log,
 )
 from flwr.common.constant import MessageType, MessageTypeLegacy
@@ -36,7 +37,7 @@ from flwr.common.constant import MessageType, MessageTypeLegacy
 from ..client_proxy import ClientProxy
 from ..compat.app_utils import start_update_client_manager_thread
 from ..compat.legacy_context import LegacyContext
-from ..driver import Driver
+from ..grid import Grid
 from ..typing import Workflow
 from .constant import MAIN_CONFIGS_RECORD, MAIN_PARAMS_RECORD, Key
 
@@ -56,7 +57,7 @@ class DefaultWorkflow:
         self.fit_workflow: Workflow = fit_workflow
         self.evaluate_workflow: Workflow = evaluate_workflow
 
-    def __call__(self, driver: Driver, context: Context) -> None:
+    def __call__(self, grid: Grid, context: Context) -> None:
         """Execute the workflow."""
         if not isinstance(context, LegacyContext):
             raise TypeError(
@@ -65,7 +66,7 @@ class DefaultWorkflow:
 
         # Start the thread updating nodes
         thread, f_stop, c_done = start_update_client_manager_thread(
-            driver, context.client_manager
+            grid, context.client_manager
         )
 
         # Wait until the node registration done
@@ -73,13 +74,13 @@ class DefaultWorkflow:
 
         # Initialize parameters
         log(INFO, "[INIT]")
-        default_init_params_workflow(driver, context)
+        default_init_params_workflow(grid, context)
 
         # Run federated learning for num_rounds
         start_time = timeit.default_timer()
-        cfg = ConfigsRecord()
+        cfg = ConfigRecord()
         cfg[Key.START_TIME] = start_time
-        context.state.configs_records[MAIN_CONFIGS_RECORD] = cfg
+        context.state.config_records[MAIN_CONFIGS_RECORD] = cfg
 
         for current_round in range(1, context.config.num_rounds + 1):
             log(INFO, "")
@@ -87,13 +88,13 @@ class DefaultWorkflow:
             cfg[Key.CURRENT_ROUND] = current_round
 
             # Fit round
-            self.fit_workflow(driver, context)
+            self.fit_workflow(grid, context)
 
             # Centralized evaluation
-            default_centralized_evaluation_workflow(driver, context)
+            default_centralized_evaluation_workflow(grid, context)
 
             # Evaluate round
-            self.evaluate_workflow(driver, context)
+            self.evaluate_workflow(grid, context)
 
         # Bookkeeping and log results
         end_time = timeit.default_timer()
@@ -119,7 +120,7 @@ class DefaultWorkflow:
         thread.join()
 
 
-def default_init_params_workflow(driver: Driver, context: Context) -> None:
+def default_init_params_workflow(grid: Grid, context: Context) -> None:
     """Execute the default workflow for parameters initialization."""
     if not isinstance(context, LegacyContext):
         raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
@@ -129,21 +130,19 @@ def default_init_params_workflow(driver: Driver, context: Context) -> None:
     )
     if parameters is not None:
         log(INFO, "Using initial global parameters provided by strategy")
-        paramsrecord = compat.parameters_to_parametersrecord(
-            parameters, keep_input=True
-        )
+        arr_record = compat.parameters_to_arrayrecord(parameters, keep_input=True)
     else:
         # Get initial parameters from one of the clients
         log(INFO, "Requesting initial parameters from one random client")
         random_client = context.client_manager.sample(1)[0]
         # Send GetParametersIns and get the response
-        content = compat.getparametersins_to_recordset(GetParametersIns({}))
-        messages = driver.send_and_receive(
+        content = compat.getparametersins_to_recorddict(GetParametersIns({}))
+        messages = grid.send_and_receive(
             [
-                driver.create_message(
+                Message(
                     content=content,
-                    message_type=MessageTypeLegacy.GET_PARAMETERS,
                     dst_node_id=random_client.node_id,
+                    message_type=MessageTypeLegacy.GET_PARAMETERS,
                     group_id="0",
                 )
             ]
@@ -152,26 +151,26 @@ def default_init_params_workflow(driver: Driver, context: Context) -> None:
 
         if (
             msg.has_content()
-            and compat._extract_status_from_recordset(  # pylint: disable=W0212
+            and compat._extract_status_from_recorddict(  # pylint: disable=W0212
                 "getparametersres", msg.content
             ).code
             == Code.OK
         ):
             log(INFO, "Received initial parameters from one random client")
-            paramsrecord = next(iter(msg.content.parameters_records.values()))
+            arr_record = next(iter(msg.content.array_records.values()))
         else:
             log(
                 WARN,
                 "Failed to receive initial parameters from the client."
                 " Empty initial parameters will be used.",
             )
-            paramsrecord = ParametersRecord()
+            arr_record = ArrayRecord()
 
-    context.state.parameters_records[MAIN_PARAMS_RECORD] = paramsrecord
+    context.state.array_records[MAIN_PARAMS_RECORD] = arr_record
 
     # Evaluate initial parameters
     log(INFO, "Starting evaluation of initial global parameters")
-    parameters = compat.parametersrecord_to_parameters(paramsrecord, keep_input=True)
+    parameters = compat.arrayrecord_to_parameters(arr_record, keep_input=True)
     res = context.strategy.evaluate(0, parameters=parameters)
     if res is not None:
         log(
@@ -186,19 +185,19 @@ def default_init_params_workflow(driver: Driver, context: Context) -> None:
         log(INFO, "Evaluation returned no results (`None`)")
 
 
-def default_centralized_evaluation_workflow(_: Driver, context: Context) -> None:
+def default_centralized_evaluation_workflow(_: Grid, context: Context) -> None:
     """Execute the default workflow for centralized evaluation."""
     if not isinstance(context, LegacyContext):
         raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
 
     # Retrieve current_round and start_time from the context
-    cfg = context.state.configs_records[MAIN_CONFIGS_RECORD]
+    cfg = context.state.config_records[MAIN_CONFIGS_RECORD]
     current_round = cast(int, cfg[Key.CURRENT_ROUND])
     start_time = cast(float, cfg[Key.START_TIME])
 
     # Centralized evaluation
-    parameters = compat.parametersrecord_to_parameters(
-        record=context.state.parameters_records[MAIN_PARAMS_RECORD],
+    parameters = compat.arrayrecord_to_parameters(
+        record=context.state.array_records[MAIN_PARAMS_RECORD],
         keep_input=True,
     )
     res_cen = context.strategy.evaluate(current_round, parameters=parameters)
@@ -218,20 +217,16 @@ def default_centralized_evaluation_workflow(_: Driver, context: Context) -> None
         )
 
 
-def default_fit_workflow(  # pylint: disable=R0914
-    driver: Driver, context: Context
-) -> None:
+def default_fit_workflow(grid: Grid, context: Context) -> None:  # pylint: disable=R0914
     """Execute the default workflow for a single fit round."""
     if not isinstance(context, LegacyContext):
         raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
 
     # Get current_round and parameters
-    cfg = context.state.configs_records[MAIN_CONFIGS_RECORD]
+    cfg = context.state.config_records[MAIN_CONFIGS_RECORD]
     current_round = cast(int, cfg[Key.CURRENT_ROUND])
-    parametersrecord = context.state.parameters_records[MAIN_PARAMS_RECORD]
-    parameters = compat.parametersrecord_to_parameters(
-        parametersrecord, keep_input=True
-    )
+    arr_record = context.state.array_records[MAIN_PARAMS_RECORD]
+    parameters = compat.arrayrecord_to_parameters(arr_record, keep_input=True)
 
     # Get clients and their respective instructions from strategy
     client_instructions = context.strategy.configure_fit(
@@ -255,10 +250,10 @@ def default_fit_workflow(  # pylint: disable=R0914
 
     # Build out messages
     out_messages = [
-        driver.create_message(
-            content=compat.fitins_to_recordset(fitins, True),
-            message_type=MessageType.TRAIN,
+        Message(
+            content=compat.fitins_to_recorddict(fitins, True),
             dst_node_id=proxy.node_id,
+            message_type=MessageType.TRAIN,
             group_id=str(current_round),
         )
         for proxy, fitins in client_instructions
@@ -266,7 +261,7 @@ def default_fit_workflow(  # pylint: disable=R0914
 
     # Send instructions to clients and
     # collect `fit` results from all clients participating in this round
-    messages = list(driver.send_and_receive(out_messages))
+    messages = list(grid.send_and_receive(out_messages))
     del out_messages
     num_failures = len([msg for msg in messages if msg.has_error()])
 
@@ -284,7 +279,7 @@ def default_fit_workflow(  # pylint: disable=R0914
     for msg in messages:
         if msg.has_content():
             proxy = node_id_to_proxy[msg.metadata.src_node_id]
-            fitres = compat.recordset_to_fitres(msg.content, False)
+            fitres = compat.recorddict_to_fitres(msg.content, False)
             if fitres.status.code == Code.OK:
                 results.append((proxy, fitres))
             else:
@@ -297,28 +292,24 @@ def default_fit_workflow(  # pylint: disable=R0914
 
     # Update the parameters and write history
     if parameters_aggregated:
-        paramsrecord = compat.parameters_to_parametersrecord(
-            parameters_aggregated, True
-        )
-        context.state.parameters_records[MAIN_PARAMS_RECORD] = paramsrecord
+        arr_record = compat.parameters_to_arrayrecord(parameters_aggregated, True)
+        context.state.array_records[MAIN_PARAMS_RECORD] = arr_record
         context.history.add_metrics_distributed_fit(
             server_round=current_round, metrics=metrics_aggregated
         )
 
 
 # pylint: disable-next=R0914
-def default_evaluate_workflow(driver: Driver, context: Context) -> None:
+def default_evaluate_workflow(grid: Grid, context: Context) -> None:
     """Execute the default workflow for a single evaluate round."""
     if not isinstance(context, LegacyContext):
         raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
 
     # Get current_round and parameters
-    cfg = context.state.configs_records[MAIN_CONFIGS_RECORD]
+    cfg = context.state.config_records[MAIN_CONFIGS_RECORD]
     current_round = cast(int, cfg[Key.CURRENT_ROUND])
-    parametersrecord = context.state.parameters_records[MAIN_PARAMS_RECORD]
-    parameters = compat.parametersrecord_to_parameters(
-        parametersrecord, keep_input=True
-    )
+    arr_record = context.state.array_records[MAIN_PARAMS_RECORD]
+    parameters = compat.arrayrecord_to_parameters(arr_record, keep_input=True)
 
     # Get clients and their respective instructions from strategy
     client_instructions = context.strategy.configure_evaluate(
@@ -341,10 +332,10 @@ def default_evaluate_workflow(driver: Driver, context: Context) -> None:
 
     # Build out messages
     out_messages = [
-        driver.create_message(
-            content=compat.evaluateins_to_recordset(evalins, True),
-            message_type=MessageType.EVALUATE,
+        Message(
+            content=compat.evaluateins_to_recorddict(evalins, True),
             dst_node_id=proxy.node_id,
+            message_type=MessageType.EVALUATE,
             group_id=str(current_round),
         )
         for proxy, evalins in client_instructions
@@ -352,7 +343,7 @@ def default_evaluate_workflow(driver: Driver, context: Context) -> None:
 
     # Send instructions to clients and
     # collect `evaluate` results from all clients participating in this round
-    messages = list(driver.send_and_receive(out_messages))
+    messages = list(grid.send_and_receive(out_messages))
     del out_messages
     num_failures = len([msg for msg in messages if msg.has_error()])
 
@@ -370,7 +361,7 @@ def default_evaluate_workflow(driver: Driver, context: Context) -> None:
     for msg in messages:
         if msg.has_content():
             proxy = node_id_to_proxy[msg.metadata.src_node_id]
-            evalres = compat.recordset_to_evaluateres(msg.content)
+            evalres = compat.recorddict_to_evaluateres(msg.content)
             if evalres.status.code == Code.OK:
                 results.append((proxy, evalres))
             else:

flwr/server/workflow/secure_aggregation/secaggplus_workflow.py

@@ -20,15 +20,15 @@ from dataclasses import dataclass, field
 from logging import DEBUG, ERROR, INFO, WARN
 from typing import Optional, Union, cast
 
-import flwr.common.recordset_compat as compat
+import flwr.common.recorddict_compat as compat
 from flwr.common import (
-    ConfigsRecord,
+    ConfigRecord,
     Context,
     FitRes,
     Message,
     MessageType,
     NDArrays,
-    RecordSet,
+    RecordDict,
     bytes_to_ndarray,
     log,
     ndarrays_to_parameters,
@@ -55,7 +55,7 @@ from flwr.common.secure_aggregation.secaggplus_constants import (
 from flwr.common.secure_aggregation.secaggplus_utils import pseudo_rand_gen
 from flwr.server.client_proxy import ClientProxy
 from flwr.server.compat.legacy_context import LegacyContext
-from flwr.server.driver import Driver
+from flwr.server.grid import Grid
 
 from ..constant import MAIN_CONFIGS_RECORD, MAIN_PARAMS_RECORD
 from ..constant import Key as WorkflowKey
@@ -66,7 +66,7 @@ class WorkflowState:  # pylint: disable=R0902
     """The state of the SecAgg+ protocol."""
 
     nid_to_proxies: dict[int, ClientProxy] = field(default_factory=dict)
-    nid_to_fitins: dict[int, RecordSet] = field(default_factory=dict)
+    nid_to_fitins: dict[int, RecordDict] = field(default_factory=dict)
     sampled_node_ids: set[int] = field(default_factory=set)
     active_node_ids: set[int] = field(default_factory=set)
     num_shares: int = 0
@@ -186,7 +186,7 @@ class SecAggPlusWorkflow:
 
         self._check_init_params()
 
-    def __call__(self, driver: Driver, context: Context) -> None:
+    def __call__(self, grid: Grid, context: Context) -> None:
         """Run the SecAgg+ protocol."""
         if not isinstance(context, LegacyContext):
             raise TypeError(
@@ -202,7 +202,7 @@ class SecAggPlusWorkflow:
         )
         log(INFO, "Secure aggregation commencing.")
         for step in steps:
-            if not step(driver, context, state):
+            if not step(grid, context, state):
                 log(INFO, "Secure aggregation halted.")
                 return
         log(INFO, "Secure aggregation completed.")
@@ -279,14 +279,14 @@ class SecAggPlusWorkflow:
         return True
 
     def setup_stage(  # pylint: disable=R0912, R0914, R0915
-        self, driver: Driver, context: LegacyContext, state: WorkflowState
+        self, grid: Grid, context: LegacyContext, state: WorkflowState
     ) -> bool:
         """Execute the 'setup' stage."""
         # Obtain fit instructions
-        cfg = context.state.configs_records[MAIN_CONFIGS_RECORD]
+        cfg = context.state.config_records[MAIN_CONFIGS_RECORD]
         current_round = cast(int, cfg[WorkflowKey.CURRENT_ROUND])
-        parameters = compat.parametersrecord_to_parameters(
-            context.state.parameters_records[MAIN_PARAMS_RECORD],
+        parameters = compat.arrayrecord_to_parameters(
+            context.state.array_records[MAIN_PARAMS_RECORD],
             keep_input=True,
         )
         proxy_fitins_lst = context.strategy.configure_fit(
@@ -303,7 +303,7 @@ class SecAggPlusWorkflow:
         )
 
         state.nid_to_fitins = {
-            proxy.node_id: compat.fitins_to_recordset(fitins, True)
+            proxy.node_id: compat.fitins_to_recorddict(fitins, True)
             for proxy, fitins in proxy_fitins_lst
         }
         state.nid_to_proxies = {proxy.node_id: proxy for proxy, _ in proxy_fitins_lst}
@@ -366,14 +366,14 @@ class SecAggPlusWorkflow:
         state.sampled_node_ids = state.active_node_ids
 
         # Send setup configuration to clients
-        cfgs_record = ConfigsRecord(sa_params_dict)  # type: ignore
-        content = RecordSet({RECORD_KEY_CONFIGS: cfgs_record})
+        cfg_record = ConfigRecord(sa_params_dict)  # type: ignore
+        content = RecordDict({RECORD_KEY_CONFIGS: cfg_record})
 
         def make(nid: int) -> Message:
-            return driver.create_message(
+            return Message(
                 content=content,
-                message_type=MessageType.TRAIN,
                 dst_node_id=nid,
+                message_type=MessageType.TRAIN,
                 group_id=str(cfg[WorkflowKey.CURRENT_ROUND]),
             )
 
@@ -382,7 +382,7 @@ class SecAggPlusWorkflow:
             "[Stage 0] Sending configurations to %s clients.",
             len(state.active_node_ids),
         )
-        msgs = driver.send_and_receive(
+        msgs = grid.send_and_receive(
             [make(node_id) for node_id in state.active_node_ids], timeout=self.timeout
         )
         state.active_node_ids = {
@@ -398,7 +398,7 @@ class SecAggPlusWorkflow:
             if msg.has_error():
                 state.failures.append(Exception(msg.error))
                 continue
-            key_dict = msg.content.configs_records[RECORD_KEY_CONFIGS]
+            key_dict = msg.content.config_records[RECORD_KEY_CONFIGS]
             node_id = msg.metadata.src_node_id
             pk1, pk2 = key_dict[Key.PUBLIC_KEY_1], key_dict[Key.PUBLIC_KEY_2]
             state.nid_to_publickeys[node_id] = [cast(bytes, pk1), cast(bytes, pk2)]
@@ -406,22 +406,22 @@ class SecAggPlusWorkflow:
         return self._check_threshold(state)
 
     def share_keys_stage(  # pylint: disable=R0914
-        self, driver: Driver, context: LegacyContext, state: WorkflowState
+        self, grid: Grid, context: LegacyContext, state: WorkflowState
     ) -> bool:
         """Execute the 'share keys' stage."""
-        cfg = context.state.configs_records[MAIN_CONFIGS_RECORD]
+        cfg = context.state.config_records[MAIN_CONFIGS_RECORD]
 
         def make(nid: int) -> Message:
             neighbours = state.nid_to_neighbours[nid] & state.active_node_ids
-            cfgs_record = ConfigsRecord(
+            cfg_record = ConfigRecord(
                 {str(nid): state.nid_to_publickeys[nid] for nid in neighbours}
             )
-            cfgs_record[Key.STAGE] = Stage.SHARE_KEYS
-            content = RecordSet({RECORD_KEY_CONFIGS: cfgs_record})
-            return driver.create_message(
+            cfg_record[Key.STAGE] = Stage.SHARE_KEYS
+            content = RecordDict({RECORD_KEY_CONFIGS: cfg_record})
+            return Message(
                 content=content,
-                message_type=MessageType.TRAIN,
                 dst_node_id=nid,
+                message_type=MessageType.TRAIN,
                 group_id=str(cfg[WorkflowKey.CURRENT_ROUND]),
             )
 
@@ -431,7 +431,7 @@ class SecAggPlusWorkflow:
             "[Stage 1] Forwarding public keys to %s clients.",
             len(state.active_node_ids),
         )
-        msgs = driver.send_and_receive(
+        msgs = grid.send_and_receive(
             [make(node_id) for node_id in state.active_node_ids], timeout=self.timeout
         )
         state.active_node_ids = {
@@ -458,7 +458,7 @@ class SecAggPlusWorkflow:
                 state.failures.append(Exception(msg.error))
                 continue
             node_id = msg.metadata.src_node_id
-            res_dict = msg.content.configs_records[RECORD_KEY_CONFIGS]
+            res_dict = msg.content.config_records[RECORD_KEY_CONFIGS]
             dst_lst = cast(list[int], res_dict[Key.DESTINATION_LIST])
             ctxt_lst = cast(list[bytes], res_dict[Key.CIPHERTEXT_LIST])
             srcs += [node_id] * len(dst_lst)
@@ -476,25 +476,25 @@ class SecAggPlusWorkflow:
         return self._check_threshold(state)
 
     def collect_masked_vectors_stage(
-        self, driver: Driver, context: LegacyContext, state: WorkflowState
+        self, grid: Grid, context: LegacyContext, state: WorkflowState
     ) -> bool:
         """Execute the 'collect masked vectors' stage."""
-        cfg = context.state.configs_records[MAIN_CONFIGS_RECORD]
+        cfg = context.state.config_records[MAIN_CONFIGS_RECORD]
 
         # Send secret key shares to clients (plus FitIns) and collect masked vectors
         def make(nid: int) -> Message:
-            cfgs_dict = {
+            cfg_dict = {
                 Key.STAGE: Stage.COLLECT_MASKED_VECTORS,
                 Key.CIPHERTEXT_LIST: state.forward_ciphertexts[nid],
                 Key.SOURCE_LIST: state.forward_srcs[nid],
             }
-            cfgs_record = ConfigsRecord(cfgs_dict)  # type: ignore
+            cfg_record = ConfigRecord(cfg_dict)  # type: ignore
             content = state.nid_to_fitins[nid]
-            content.configs_records[RECORD_KEY_CONFIGS] = cfgs_record
-            return driver.create_message(
+            content.config_records[RECORD_KEY_CONFIGS] = cfg_record
+            return Message(
                 content=content,
-                message_type=MessageType.TRAIN,
                 dst_node_id=nid,
+                message_type=MessageType.TRAIN,
                 group_id=str(cfg[WorkflowKey.CURRENT_ROUND]),
             )
 
@@ -503,7 +503,7 @@ class SecAggPlusWorkflow:
             "[Stage 2] Forwarding encrypted key shares to %s clients.",
             len(state.active_node_ids),
         )
-        msgs = driver.send_and_receive(
+        msgs = grid.send_and_receive(
             [make(node_id) for node_id in state.active_node_ids], timeout=self.timeout
         )
         state.active_node_ids = {
@@ -524,7 +524,7 @@ class SecAggPlusWorkflow:
             if msg.has_error():
                 state.failures.append(Exception(msg.error))
                 continue
-            res_dict = msg.content.configs_records[RECORD_KEY_CONFIGS]
+            res_dict = msg.content.config_records[RECORD_KEY_CONFIGS]
             bytes_list = cast(list[bytes], res_dict[Key.MASKED_PARAMETERS])
             client_masked_vec = [bytes_to_ndarray(b) for b in bytes_list]
             if masked_vector is None:
@@ -540,17 +540,17 @@ class SecAggPlusWorkflow:
             if msg.has_error():
                 state.failures.append(Exception(msg.error))
                 continue
-            fitres = compat.recordset_to_fitres(msg.content, True)
+            fitres = compat.recorddict_to_fitres(msg.content, True)
             proxy = state.nid_to_proxies[msg.metadata.src_node_id]
             state.legacy_results.append((proxy, fitres))
 
         return self._check_threshold(state)
 
     def unmask_stage(  # pylint: disable=R0912, R0914, R0915
-        self, driver: Driver, context: LegacyContext, state: WorkflowState
+        self, grid: Grid, context: LegacyContext, state: WorkflowState
     ) -> bool:
         """Execute the 'unmask' stage."""
-        cfg = context.state.configs_records[MAIN_CONFIGS_RECORD]
+        cfg = context.state.config_records[MAIN_CONFIGS_RECORD]
         current_round = cast(int, cfg[WorkflowKey.CURRENT_ROUND])
 
         # Construct active node IDs and dead node IDs
@@ -560,17 +560,17 @@ class SecAggPlusWorkflow:
         # Send secure IDs of active and dead clients and collect key shares from clients
         def make(nid: int) -> Message:
             neighbours = state.nid_to_neighbours[nid]
-            cfgs_dict = {
+            cfg_dict = {
                 Key.STAGE: Stage.UNMASK,
                 Key.ACTIVE_NODE_ID_LIST: list(neighbours & active_nids),
                 Key.DEAD_NODE_ID_LIST: list(neighbours & dead_nids),
             }
-            cfgs_record = ConfigsRecord(cfgs_dict)  # type: ignore
-            content = RecordSet({RECORD_KEY_CONFIGS: cfgs_record})
-            return driver.create_message(
+            cfg_record = ConfigRecord(cfg_dict)  # type: ignore
+            content = RecordDict({RECORD_KEY_CONFIGS: cfg_record})
+            return Message(
                 content=content,
-                message_type=MessageType.TRAIN,
                 dst_node_id=nid,
+                message_type=MessageType.TRAIN,
                 group_id=str(current_round),
             )
 
@@ -579,7 +579,7 @@ class SecAggPlusWorkflow:
             "[Stage 3] Requesting key shares from %s clients to remove masks.",
             len(state.active_node_ids),
         )
-        msgs = driver.send_and_receive(
+        msgs = grid.send_and_receive(
             [make(node_id) for node_id in state.active_node_ids], timeout=self.timeout
         )
         state.active_node_ids = {
@@ -599,7 +599,7 @@ class SecAggPlusWorkflow:
             if msg.has_error():
                 state.failures.append(Exception(msg.error))
                 continue
-            res_dict = msg.content.configs_records[RECORD_KEY_CONFIGS]
+            res_dict = msg.content.config_records[RECORD_KEY_CONFIGS]
             nids = cast(list[int], res_dict[Key.NODE_ID_LIST])
             shares = cast(list[bytes], res_dict[Key.SHARE_LIST])
             for owner_nid, share in zip(nids, shares):
@@ -676,10 +676,8 @@ class SecAggPlusWorkflow:
 
         # Update the parameters and write history
         if parameters_aggregated:
-            paramsrecord = compat.parameters_to_parametersrecord(
-                parameters_aggregated, True
-            )
-            context.state.parameters_records[MAIN_PARAMS_RECORD] = paramsrecord
+            arr_record = compat.parameters_to_arrayrecord(parameters_aggregated, True)
+            context.state.array_records[MAIN_PARAMS_RECORD] = arr_record
             context.history.add_metrics_distributed_fit(
                 server_round=current_round, metrics=metrics_aggregated
             )

flwr/simulation/app.py

@@ -47,7 +47,7 @@ from flwr.common.logger import (
     stop_log_uploader,
 )
 from flwr.common.serde import (
-    configs_record_from_proto,
+    config_record_from_proto,
     context_from_proto,
     context_to_proto,
     fab_from_proto,
@@ -184,7 +184,7 @@ def run_simulation_process(  # pylint: disable=R0914, disable=W0212, disable=R09
             fed_opt_res: GetFederationOptionsResponse = conn._stub.GetFederationOptions(
                 GetFederationOptionsRequest(run_id=run.run_id)
             )
-            federation_options = configs_record_from_proto(
+            federation_options = config_record_from_proto(
                 fed_opt_res.federation_options
             )
 

flwr/simulation/ray_transport/ray_actor.py

@@ -105,8 +105,10 @@ def pool_size_from_resources(client_resources: dict[str, Union[int, float]]) ->
         if not node_resources:
             continue
 
-        num_cpus = node_resources["CPU"]
-        num_gpus = node_resources.get("GPU", 0)  # There might not be GPU
+        # Fallback to zero when resource quantity is not configured on the ray node
+        # e.g.: node without GPU; head node set up not to run tasks (zero resources)
+        num_cpus = node_resources.get("CPU", 0)
+        num_gpus = node_resources.get("GPU", 0)
         num_actors = int(num_cpus / client_resources["num_cpus"])
 
         # If a GPU is present and client resources do require one