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

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(configs_records={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(configs_records={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(configs_records={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

flwr/simulation/ray_transport/ray_client_proxy.py

@@ -23,7 +23,7 @@ from flwr import common
 from flwr.client import ClientFnExt
 from flwr.client.client_app import ClientApp
 from flwr.client.run_info_store import DeprecatedRunInfoStore
-from flwr.common import DEFAULT_TTL, Message, Metadata, RecordSet
+from flwr.common import DEFAULT_TTL, Message, Metadata, RecordDict, now
 from flwr.common.constant import (
     NUM_PARTITIONS_KEY,
     PARTITION_ID_KEY,
@@ -31,15 +31,16 @@ from flwr.common.constant import (
     MessageTypeLegacy,
 )
 from flwr.common.logger import log
-from flwr.common.recordset_compat import (
-    evaluateins_to_recordset,
-    fitins_to_recordset,
-    getparametersins_to_recordset,
-    getpropertiesins_to_recordset,
-    recordset_to_evaluateres,
-    recordset_to_fitres,
-    recordset_to_getparametersres,
-    recordset_to_getpropertiesres,
+from flwr.common.message import make_message
+from flwr.common.recorddict_compat import (
+    evaluateins_to_recorddict,
+    fitins_to_recorddict,
+    getparametersins_to_recorddict,
+    getpropertiesins_to_recorddict,
+    recorddict_to_evaluateres,
+    recorddict_to_fitres,
+    recorddict_to_getparametersres,
+    recorddict_to_getpropertiesres,
 )
 from flwr.server.client_proxy import ClientProxy
 from flwr.simulation.ray_transport.ray_actor import VirtualClientEngineActorPool
@@ -109,23 +110,24 @@ class RayActorClientProxy(ClientProxy):
 
         return out_mssg
 
-    def _wrap_recordset_in_message(
+    def _wrap_recorddict_in_message(
         self,
-        recordset: RecordSet,
+        recorddict: RecordDict,
         message_type: str,
         timeout: Optional[float],
         group_id: Optional[int],
     ) -> Message:
-        """Wrap a RecordSet inside a Message."""
-        return Message(
-            content=recordset,
+        """Wrap a RecordDict inside a Message."""
+        return make_message(
+            content=recorddict,
             metadata=Metadata(
                 run_id=0,
                 message_id="",
                 group_id=str(group_id) if group_id is not None else "",
                 src_node_id=0,
                 dst_node_id=self.node_id,
-                reply_to_message="",
+                reply_to_message_id="",
+                created_at=now().timestamp(),
                 ttl=timeout if timeout else DEFAULT_TTL,
                 message_type=message_type,
             ),
@@ -138,9 +140,9 @@ class RayActorClientProxy(ClientProxy):
         group_id: Optional[int],
     ) -> common.GetPropertiesRes:
         """Return client's properties."""
-        recordset = getpropertiesins_to_recordset(ins)
-        message = self._wrap_recordset_in_message(
-            recordset,
+        recorddict = getpropertiesins_to_recorddict(ins)
+        message = self._wrap_recorddict_in_message(
+            recorddict,
             message_type=MessageTypeLegacy.GET_PROPERTIES,
             timeout=timeout,
             group_id=group_id,
@@ -148,7 +150,7 @@ class RayActorClientProxy(ClientProxy):
 
         message_out = self._submit_job(message, timeout)
 
-        return recordset_to_getpropertiesres(message_out.content)
+        return recorddict_to_getpropertiesres(message_out.content)
 
     def get_parameters(
         self,
@@ -157,9 +159,9 @@ class RayActorClientProxy(ClientProxy):
         group_id: Optional[int],
     ) -> common.GetParametersRes:
         """Return the current local model parameters."""
-        recordset = getparametersins_to_recordset(ins)
-        message = self._wrap_recordset_in_message(
-            recordset,
+        recorddict = getparametersins_to_recorddict(ins)
+        message = self._wrap_recorddict_in_message(
+            recorddict,
             message_type=MessageTypeLegacy.GET_PARAMETERS,
             timeout=timeout,
             group_id=group_id,
@@ -167,17 +169,17 @@ class RayActorClientProxy(ClientProxy):
 
         message_out = self._submit_job(message, timeout)
 
-        return recordset_to_getparametersres(message_out.content, keep_input=False)
+        return recorddict_to_getparametersres(message_out.content, keep_input=False)
 
     def fit(
         self, ins: common.FitIns, timeout: Optional[float], group_id: Optional[int]
     ) -> common.FitRes:
         """Train model parameters on the locally held dataset."""
-        recordset = fitins_to_recordset(
+        recorddict = fitins_to_recorddict(
             ins, keep_input=True
         )  # This must stay TRUE since ins are in-memory
-        message = self._wrap_recordset_in_message(
-            recordset,
+        message = self._wrap_recorddict_in_message(
+            recorddict,
             message_type=MessageType.TRAIN,
             timeout=timeout,
             group_id=group_id,
@@ -185,17 +187,17 @@ class RayActorClientProxy(ClientProxy):
 
         message_out = self._submit_job(message, timeout)
 
-        return recordset_to_fitres(message_out.content, keep_input=False)
+        return recorddict_to_fitres(message_out.content, keep_input=False)
 
     def evaluate(
         self, ins: common.EvaluateIns, timeout: Optional[float], group_id: Optional[int]
     ) -> common.EvaluateRes:
         """Evaluate model parameters on the locally held dataset."""
-        recordset = evaluateins_to_recordset(
+        recorddict = evaluateins_to_recorddict(
             ins, keep_input=True
         )  # This must stay TRUE since ins are in-memory
-        message = self._wrap_recordset_in_message(
-            recordset,
+        message = self._wrap_recorddict_in_message(
+            recorddict,
             message_type=MessageType.EVALUATE,
             timeout=timeout,
             group_id=group_id,
@@ -203,7 +205,7 @@ class RayActorClientProxy(ClientProxy):
 
         message_out = self._submit_job(message, timeout)
 
-        return recordset_to_evaluateres(message_out.content)
+        return recorddict_to_evaluateres(message_out.content)
 
     def reconnect(
         self,

flwr/simulation/run_simulation.py

@@ -30,7 +30,7 @@ from typing import Any, Optional
 from flwr.cli.config_utils import load_and_validate
 from flwr.cli.utils import get_sha256_hash
 from flwr.client import ClientApp
-from flwr.common import Context, EventType, RecordSet, event, log, now
+from flwr.common import Context, EventType, RecordDict, event, log, now
 from flwr.common.config import get_fused_config_from_dir, parse_config_args
 from flwr.common.constant import RUN_ID_NUM_BYTES, Status
 from flwr.common.logger import (
@@ -39,7 +39,7 @@ from flwr.common.logger import (
     warn_deprecated_feature_with_example,
 )
 from flwr.common.typing import Run, RunStatus, UserConfig
-from flwr.server.driver import Driver, InMemoryDriver
+from flwr.server.grid import Grid, InMemoryGrid
 from flwr.server.run_serverapp import run as _run
 from flwr.server.server_app import ServerApp
 from flwr.server.superlink.fleet import vce
@@ -168,7 +168,7 @@ def run_simulation(
         messages sent by the `ServerApp`.
 
     num_supernodes : int
-        Number of nodes that run a ClientApp. They can be sampled by a Driver in the
+        Number of nodes that run a ClientApp. They can be sampled by a Grid in the
         ServerApp and receive a Message describing what the ClientApp should perform.
 
     backend_name : str (default: ray)
@@ -180,7 +180,7 @@ def run_simulation(
         for values parsed to initialisation of backend, `client_resources`
         to define the resources for clients, and `actor` to define the actor
         parameters. Values supported in <value> are those included by
-        `flwr.common.typing.ConfigsRecordValues`.
+        `flwr.common.typing.ConfigRecordValues`.
 
     enable_tf_gpu_growth : bool (default: False)
         A boolean to indicate whether to enable GPU growth on the main thread. This is
@@ -225,7 +225,7 @@ def run_serverapp_th(
     server_app_attr: Optional[str],
     server_app: Optional[ServerApp],
     server_app_run_config: UserConfig,
-    driver: Driver,
+    grid: Grid,
     app_dir: str,
     f_stop: threading.Event,
     has_exception: threading.Event,
@@ -239,7 +239,7 @@ def run_serverapp_th(
         tf_gpu_growth: bool,
         stop_event: threading.Event,
         exception_event: threading.Event,
-        _driver: Driver,
+        _grid: Grid,
         _server_app_dir: str,
         _server_app_run_config: UserConfig,
         _server_app_attr: Optional[str],
@@ -260,13 +260,13 @@ def run_serverapp_th(
                 run_id=run_id,
                 node_id=0,
                 node_config={},
-                state=RecordSet(),
+                state=RecordDict(),
                 run_config=_server_app_run_config,
             )
 
             # Run ServerApp
             updated_context = _run(
-                driver=_driver,
+                grid=_grid,
                 context=context,
                 server_app_dir=_server_app_dir,
                 server_app_attr=_server_app_attr,
@@ -291,7 +291,7 @@ def run_serverapp_th(
             enable_tf_gpu_growth,
             f_stop,
             has_exception,
-            driver,
+            grid,
             app_dir,
             server_app_run_config,
             server_app_attr,
@@ -333,7 +333,7 @@ def _main_loop(
         run_id=run.run_id,
         node_id=0,
         node_config=UserConfig(),
-        state=RecordSet(),
+        state=RecordDict(),
         run_config=UserConfig(),
     )
     try:
@@ -347,9 +347,9 @@ def _main_loop(
         if server_app_run_config is None:
             server_app_run_config = {}
 
-        # Initialize Driver
-        driver = InMemoryDriver(state_factory=state_factory)
-        driver.set_run(run_id=run.run_id)
+        # Initialize Grid
+        grid = InMemoryGrid(state_factory=state_factory)
+        grid.set_run(run_id=run.run_id)
         output_context_queue: Queue[Context] = Queue()
 
         # Get and run ServerApp thread
@@ -357,7 +357,7 @@ def _main_loop(
             server_app_attr=server_app_attr,
             server_app=server_app,
             server_app_run_config=server_app_run_config,
-            driver=driver,
+            grid=grid,
             app_dir=app_dir,
             f_stop=f_stop,
             has_exception=server_app_thread_has_exception,
@@ -546,7 +546,7 @@ def _parse_args_run_simulation() -> argparse.ArgumentParser:
         default="{}",
         help='A JSON formatted stream, e.g \'{"<keyA>":<value>, "<keyB>":<value>}\' to '
         "configure a backend. Values supported in <value> are those included by "
-        "`flwr.common.typing.ConfigsRecordValues`. ",
+        "`flwr.common.typing.ConfigRecordValues`. ",
     )
     parser.add_argument(
         "--enable-tf-gpu-growth",

flwr/superexec/app.py

@@ -16,26 +16,12 @@
 
 
 import argparse
-import sys
-from logging import INFO
 
-from flwr.common import log
 from flwr.common.object_ref import load_app, validate
 
 from .executor import Executor
 
 
-def run_superexec() -> None:
-    """Run Flower SuperExec."""
-    log(INFO, "Starting Flower SuperExec")
-
-    sys.exit(
-        "Manually launching the SuperExec is deprecated. Since `flwr 1.13.0` "
-        "the executor service runs in the SuperLink. Launching it manually is not "
-        "recommended."
-    )
-
-
 def load_executor(
     args: argparse.Namespace,
 ) -> Executor:

flwr/superexec/deployment.py

@@ -23,7 +23,7 @@ from typing import Optional
 from typing_extensions import override
 
 from flwr.cli.config_utils import get_fab_metadata
-from flwr.common import ConfigsRecord, Context, RecordSet
+from flwr.common import ConfigRecord, Context, RecordDict
 from flwr.common.constant import (
     SERVERAPPIO_API_DEFAULT_CLIENT_ADDRESS,
     Status,
@@ -141,7 +141,7 @@ class DeploymentEngine(Executor):
         fab_id, fab_version = get_fab_metadata(fab.content)
 
         run_id = self.linkstate.create_run(
-            fab_id, fab_version, fab_hash, override_config, ConfigsRecord()
+            fab_id, fab_version, fab_hash, override_config, ConfigRecord()
         )
         return run_id
 
@@ -149,7 +149,7 @@ class DeploymentEngine(Executor):
         """Register a Context for a Run."""
         # Create an empty context for the Run
         context = Context(
-            run_id=run_id, node_id=0, node_config={}, state=RecordSet(), run_config={}
+            run_id=run_id, node_id=0, node_config={}, state=RecordDict(), run_config={}
         )
 
         # Register the context at the LinkState
@@ -160,7 +160,7 @@ class DeploymentEngine(Executor):
         self,
         fab_file: bytes,
         override_config: UserConfig,
-        federation_options: ConfigsRecord,
+        federation_options: ConfigRecord,
     ) -> Optional[int]:
         """Start run using the Flower Deployment Engine."""
         run_id = None