flwr 1.19.0__py3-none-any.whl → 1.21.0__py3-none-any.whl

flwr/cli/run/run.py

@@ -30,7 +30,7 @@ from flwr.cli.config_utils import (
     process_loaded_project_config,
     validate_federation_in_project_config,
 )
-from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
+from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE, RUN_CONFIG_HELP_MESSAGE
 from flwr.common.config import (
     flatten_dict,
     get_metadata_from_config,
@@ -41,8 +41,8 @@ from flwr.common.constant import CliOutputFormat
 from flwr.common.logger import print_json_error, redirect_output, restore_output
 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
+from flwr.proto.control_pb2 import StartRunRequest  # pylint: disable=E0611
+from flwr.proto.control_pb2_grpc import ControlStub
 
 from ..log import start_stream
 from ..utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
@@ -65,11 +65,7 @@ def run(
         typer.Option(
             "--run-config",
             "-c",
-            help="Override run configuration values in the format:\n\n"
-            "`--run-config 'key1=value1 key2=value2' --run-config 'key3=value3'`\n\n"
-            "Values can be of any type supported in TOML, such as bool, int, "
-            "float, or string. Ensure that the keys (`key1`, `key2`, `key3` "
-            "in this example) exist in `pyproject.toml` for proper overriding.",
+            help=RUN_CONFIG_HELP_MESSAGE,
         ),
     ] = None,
     federation_config_overrides: Annotated[
@@ -112,7 +108,7 @@ def run(
         )
 
         if "address" in federation_config:
-            _run_with_exec_api(
+            _run_with_control_api(
                 app,
                 federation,
                 federation_config,
@@ -121,7 +117,7 @@ def run(
                 output_format,
             )
         else:
-            _run_without_exec_api(
+            _run_without_control_api(
                 app, federation_config, run_config_overrides, federation
             )
     except (typer.Exit, Exception) as err:  # pylint: disable=broad-except
@@ -142,7 +138,7 @@ def run(
 
 
 # pylint: disable-next=R0913, R0914, R0917
-def _run_with_exec_api(
+def _run_with_control_api(
     app: Path,
     federation: str,
     federation_config: dict[str, Any],
@@ -150,53 +146,60 @@ def _run_with_exec_api(
     stream: bool,
     output_format: str,
 ) -> None:
-    auth_plugin = try_obtain_cli_auth_plugin(app, federation, federation_config)
-    channel = init_channel(app, federation_config, auth_plugin)
-    stub = ExecStub(channel)
+    channel = None
+    try:
+        auth_plugin = try_obtain_cli_auth_plugin(app, federation, federation_config)
+        channel = init_channel(app, federation_config, auth_plugin)
+        stub = ControlStub(channel)
 
-    fab_bytes, fab_hash, config = build_fab(app)
-    fab_id, fab_version = get_metadata_from_config(config)
+        fab_bytes, fab_hash, config = build_fab(app)
+        fab_id, fab_version = get_metadata_from_config(config)
 
-    fab = Fab(fab_hash, fab_bytes)
+        fab = Fab(fab_hash, fab_bytes)
 
-    # Construct a `ConfigRecord` out of a flattened `UserConfig`
-    fed_config = flatten_dict(federation_config.get("options", {}))
-    c_record = user_config_to_configrecord(fed_config)
+        # Construct a `ConfigRecord` out of a flattened `UserConfig`
+        fed_config = flatten_dict(federation_config.get("options", {}))
+        c_record = user_config_to_configrecord(fed_config)
 
-    req = StartRunRequest(
-        fab=fab_to_proto(fab),
-        override_config=user_config_to_proto(parse_config_args(config_overrides)),
-        federation_options=config_record_to_proto(c_record),
-    )
-    with flwr_cli_grpc_exc_handler():
-        res = stub.StartRun(req)
-
-    if res.HasField("run_id"):
-        typer.secho(f"🎊 Successfully started run {res.run_id}", fg=typer.colors.GREEN)
-    else:
-        typer.secho("❌ Failed to start run", fg=typer.colors.RED)
-        raise typer.Exit(code=1)
-
-    if output_format == CliOutputFormat.JSON:
-        run_output = json.dumps(
-            {
-                "success": res.HasField("run_id"),
-                "run-id": res.run_id if res.HasField("run_id") else None,
-                "fab-id": fab_id,
-                "fab-name": fab_id.rsplit("/", maxsplit=1)[-1],
-                "fab-version": fab_version,
-                "fab-hash": fab_hash[:8],
-                "fab-filename": get_fab_filename(config, fab_hash),
-            }
+        req = StartRunRequest(
+            fab=fab_to_proto(fab),
+            override_config=user_config_to_proto(parse_config_args(config_overrides)),
+            federation_options=config_record_to_proto(c_record),
         )
-        restore_output()
-        Console().print_json(run_output)
+        with flwr_cli_grpc_exc_handler():
+            res = stub.StartRun(req)
 
-    if stream:
-        start_stream(res.run_id, channel, CONN_REFRESH_PERIOD)
+        if res.HasField("run_id"):
+            typer.secho(
+                f"🎊 Successfully started run {res.run_id}", fg=typer.colors.GREEN
+            )
+        else:
+            typer.secho("❌ Failed to start run", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        if output_format == CliOutputFormat.JSON:
+            run_output = json.dumps(
+                {
+                    "success": res.HasField("run_id"),
+                    "run-id": res.run_id if res.HasField("run_id") else None,
+                    "fab-id": fab_id,
+                    "fab-name": fab_id.rsplit("/", maxsplit=1)[-1],
+                    "fab-version": fab_version,
+                    "fab-hash": fab_hash[:8],
+                    "fab-filename": get_fab_filename(config, fab_hash),
+                }
+            )
+            restore_output()
+            Console().print_json(run_output)
+
+        if stream:
+            start_stream(res.run_id, channel, CONN_REFRESH_PERIOD)
+    finally:
+        if channel:
+            channel.close()
 
 
-def _run_without_exec_api(
+def _run_without_control_api(
     app: Optional[Path],
     federation_config: dict[str, Any],
     config_overrides: Optional[list[str]],

flwr/cli/stop.py

@@ -32,8 +32,11 @@ from flwr.cli.config_utils import (
 from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
 from flwr.common.constant import FAB_CONFIG_FILE, CliOutputFormat
 from flwr.common.logger import print_json_error, redirect_output, restore_output
-from flwr.proto.exec_pb2 import StopRunRequest, StopRunResponse  # pylint: disable=E0611
-from flwr.proto.exec_pb2_grpc import ExecStub
+from flwr.proto.control_pb2 import (  # pylint: disable=E0611
+    StopRunRequest,
+    StopRunResponse,
+)
+from flwr.proto.control_pb2_grpc import ControlStub
 
 from .utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
 
@@ -88,7 +91,7 @@ def stop(  # pylint: disable=R0914
         try:
             auth_plugin = try_obtain_cli_auth_plugin(app, federation, federation_config)
             channel = init_channel(app, federation_config, auth_plugin)
-            stub = ExecStub(channel)  # pylint: disable=unused-variable # noqa: F841
+            stub = ControlStub(channel)  # pylint: disable=unused-variable # noqa: F841
 
             typer.secho(f"✋ Stopping run ID {run_id}...", fg=typer.colors.GREEN)
             _stop_run(stub=stub, run_id=run_id, output_format=output_format)
@@ -120,7 +123,7 @@ def stop(  # pylint: disable=R0914
         captured_output.close()
 
 
-def _stop_run(stub: ExecStub, run_id: int, output_format: str) -> None:
+def _stop_run(stub: ControlStub, run_id: int, output_format: str) -> None:
     """Stop a run."""
     with flwr_cli_grpc_exc_handler():
         response: StopRunResponse = stub.StopRun(request=StopRunRequest(run_id=run_id))

flwr/cli/utils.py

@@ -32,6 +32,7 @@ from flwr.common.constant import (
     AUTH_TYPE_JSON_KEY,
     CREDENTIALS_DIR,
     FLWR_DIR,
+    NO_USER_AUTH_MESSAGE,
     RUN_ID_NOT_FOUND_MESSAGE,
 )
 from flwr.common.grpc import (
@@ -259,7 +260,7 @@ def try_obtain_cli_auth_plugin(
 def init_channel(
     app: Path, federation_config: dict[str, Any], auth_plugin: Optional[CliAuthPlugin]
 ) -> grpc.Channel:
-    """Initialize gRPC channel to the Exec API."""
+    """Initialize gRPC channel to the Control API."""
     insecure, root_certificates_bytes = validate_certificate_in_federation_config(
         app, federation_config
     )
@@ -296,9 +297,9 @@ def init_channel(
 def flwr_cli_grpc_exc_handler() -> Iterator[None]:
     """Context manager to handle specific gRPC errors.
 
-    It catches grpc.RpcError exceptions with UNAUTHENTICATED, UNIMPLEMENTED, and
-    PERMISSION_DENIED statuses, informs the user, and exits the application. All other
-    exceptions will be allowed to escape.
+    It catches grpc.RpcError exceptions with UNAUTHENTICATED, UNIMPLEMENTED,
+    UNAVAILABLE, and PERMISSION_DENIED statuses, informs the user, and exits the
+    application. All other exceptions will be allowed to escape.
     """
     try:
         yield
@@ -312,25 +313,42 @@ def flwr_cli_grpc_exc_handler() -> Iterator[None]:
             )
             raise typer.Exit(code=1) from None
         if e.code() == grpc.StatusCode.UNIMPLEMENTED:
+            if e.details() == NO_USER_AUTH_MESSAGE:  # pylint: disable=E1101
+                typer.secho(
+                    "❌ User authentication is not enabled on this SuperLink.",
+                    fg=typer.colors.RED,
+                    bold=True,
+                )
+            else:
+                typer.secho(
+                    "❌ The SuperLink cannot process this request. Please verify that "
+                    "you set the address to its Control API endpoint correctly in your "
+                    "`pyproject.toml`, and ensure that the Flower versions used by "
+                    "the CLI and SuperLink are compatible.",
+                    fg=typer.colors.RED,
+                    bold=True,
+                )
+            raise typer.Exit(code=1) from None
+        if e.code() == grpc.StatusCode.PERMISSION_DENIED:
             typer.secho(
-                "❌ User authentication is not enabled on this SuperLink.",
+                "❌ Permission denied.",
                 fg=typer.colors.RED,
                 bold=True,
             )
+            # pylint: disable-next=E1101
+            typer.secho(e.details(), fg=typer.colors.RED, bold=True)
             raise typer.Exit(code=1) from None
-        if e.code() == grpc.StatusCode.PERMISSION_DENIED:
+        if e.code() == grpc.StatusCode.UNAVAILABLE:
             typer.secho(
-                "❌ Authorization failed. Please contact your administrator"
-                " to check your permissions.",
+                "Connection to the SuperLink is unavailable. Please check your network "
+                "connection and 'address' in the federation configuration.",
                 fg=typer.colors.RED,
                 bold=True,
             )
-            # pylint: disable=E1101
-            typer.secho(e.details(), fg=typer.colors.RED, bold=True)
             raise typer.Exit(code=1) from None
         if (
             e.code() == grpc.StatusCode.NOT_FOUND
-            and e.details() == RUN_ID_NOT_FOUND_MESSAGE
+            and e.details() == RUN_ID_NOT_FOUND_MESSAGE  # pylint: disable=E1101
         ):
             typer.secho(
                 "❌ Run ID not found.",

flwr/client/grpc_adapter_client/connection.py

@@ -29,6 +29,7 @@ from flwr.common.logger import log
 from flwr.common.message import Message
 from flwr.common.retry_invoker import RetryInvoker
 from flwr.common.typing import Fab, Run
+from flwr.proto.message_pb2 import ObjectTree  # pylint: disable=E0611
 
 
 @contextmanager
@@ -43,12 +44,15 @@ def grpc_adapter(  # pylint: disable=R0913,too-many-positional-arguments
     ] = None,
 ) -> Iterator[
     tuple[
-        Callable[[], Optional[Message]],
-        Callable[[Message], None],
+        Callable[[], Optional[tuple[Message, ObjectTree]]],
+        Callable[[Message, ObjectTree], set[str]],
         Callable[[], Optional[int]],
         Callable[[], None],
         Callable[[int], Run],
         Callable[[str, int], Fab],
+        Callable[[int, str], bytes],
+        Callable[[int, str, bytes], None],
+        Callable[[int, str], None],
     ]
 ]:
     """Primitives for request/response-based interaction with a server via GrpcAdapter.
@@ -77,12 +81,15 @@ def grpc_adapter(  # pylint: disable=R0913,too-many-positional-arguments
 
     Returns
     -------
-    receive : Callable
-    send : Callable
+    receive : Callable[[], Optional[tuple[Message, ObjectTree]]]
+    send : Callable[[Message, ObjectTree], set[str]]
     create_node : Optional[Callable]
     delete_node : Optional[Callable]
     get_run : Optional[Callable]
     get_fab : Optional[Callable]
+    pull_object : Callable[[str], bytes]
+    push_object : Callable[[str, bytes], None]
+    confirm_message_received : Callable[[str], None]
     """
     if authentication_keys is not None:
         log(ERROR, "Client authentication is not supported for this transport type.")

flwr/client/grpc_rere_client/connection.py

@@ -17,33 +17,21 @@
 
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
-from copy import copy
-from logging import DEBUG, ERROR
+from logging import ERROR
 from pathlib import Path
 from typing import Callable, Optional, Union, cast
 
 import grpc
 from cryptography.hazmat.primitives.asymmetric import ec
 
-from flwr.app.metadata import Metadata
-from flwr.client.message_handler.message_handler import validate_out_message
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
 from flwr.common.constant import HEARTBEAT_CALL_TIMEOUT, HEARTBEAT_DEFAULT_INTERVAL
 from flwr.common.grpc import create_channel, on_channel_state_change
 from flwr.common.heartbeat import HeartbeatSender
-from flwr.common.inflatable import (
-    get_all_nested_objects,
-    get_object_tree,
-    no_object_id_recompute,
-)
-from flwr.common.inflatable_grpc_utils import (
-    make_pull_object_fn_grpc,
-    make_push_object_fn_grpc,
-)
-from flwr.common.inflatable_utils import (
-    inflate_object_from_contents,
-    pull_objects,
-    push_objects,
+from flwr.common.inflatable_protobuf_utils import (
+    make_confirm_message_received_fn_protobuf,
+    make_pull_object_fn_protobuf,
+    make_push_object_fn_protobuf,
 )
 from flwr.common.logger import log
 from flwr.common.message import Message, remove_content_from_message
@@ -51,8 +39,8 @@ from flwr.common.retry_invoker import RetryInvoker, _wrap_stub
 from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
     generate_key_pairs,
 )
-from flwr.common.serde import message_to_proto, run_from_proto
-from flwr.common.typing import Fab, Run, RunNotRunningException
+from flwr.common.serde import message_from_proto, message_to_proto, run_from_proto
+from flwr.common.typing import Fab, Run
 from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     CreateNodeRequest,
@@ -67,9 +55,7 @@ from flwr.proto.heartbeat_pb2 import (  # pylint: disable=E0611
     SendNodeHeartbeatRequest,
     SendNodeHeartbeatResponse,
 )
-from flwr.proto.message_pb2 import (  # pylint: disable=E0611
-    ConfirmMessageReceivedRequest,
-)
+from flwr.proto.message_pb2 import ObjectTree  # pylint: disable=E0611
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=E0611
 
@@ -90,12 +76,15 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     adapter_cls: Optional[Union[type[FleetStub], type[GrpcAdapter]]] = None,
 ) -> Iterator[
     tuple[
-        Callable[[], Optional[Message]],
-        Callable[[Message], None],
+        Callable[[], Optional[tuple[Message, ObjectTree]]],
+        Callable[[Message, ObjectTree], set[str]],
         Callable[[], Optional[int]],
         Callable[[], None],
         Callable[[int], Run],
         Callable[[str, int], Fab],
+        Callable[[int, str], bytes],
+        Callable[[int, str, bytes], None],
+        Callable[[int, str], None],
     ]
 ]:
     """Primitives for request/response-based interaction with a server.
@@ -138,6 +127,9 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     create_node : Optional[Callable]
     delete_node : Optional[Callable]
     get_run : Optional[Callable]
+    pull_object : Callable[[str], bytes]
+    push_object : Callable[[str, bytes], None]
+    confirm_message_received : Callable[[str], None]
     """
     if isinstance(root_certificates, str):
         root_certificates = Path(root_certificates).read_bytes()
@@ -163,20 +155,8 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     if adapter_cls is None:
         adapter_cls = FleetStub
     stub = adapter_cls(channel)
-    metadata: Optional[Metadata] = None
     node: Optional[Node] = None
 
-    def _should_giveup_fn(e: Exception) -> bool:
-        if e.code() == grpc.StatusCode.PERMISSION_DENIED:  # type: ignore
-            raise RunNotRunningException
-        if e.code() == grpc.StatusCode.UNAVAILABLE:  # type: ignore
-            return False
-        return True
-
-    # Restrict retries to cases where the status code is UNAVAILABLE
-    # If the status code is PERMISSION_DENIED, additionally raise RunNotRunningException
-    retry_invoker.should_giveup = _should_giveup_fn
-
     # Wrap stub
     _wrap_stub(stub, retry_invoker)
     ###########################################################################
@@ -249,117 +229,52 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         # Cleanup
         node = None
 
-    def receive() -> Optional[Message]:
-        """Receive next message from server."""
+    def receive() -> Optional[tuple[Message, ObjectTree]]:
+        """Pull a message with its ObjectTree from SuperLink."""
         # Get Node
         if node is None:
             log(ERROR, "Node instance missing")
             return None
 
-        # Request instructions (message) from server
+        # Try to pull a message with its object tree from SuperLink
         request = PullMessagesRequest(node=node)
         response: PullMessagesResponse = stub.PullMessages(request=request)
 
-        # Get the current Messages
-        message_proto = (
-            None if len(response.messages_list) == 0 else response.messages_list[0]
-        )
+        # If no messages are available, return None
+        if len(response.messages_list) == 0:
+            return None
 
-        # Discard the current message if not valid
-        if message_proto is not None and not (
-            message_proto.metadata.dst_node_id == node.node_id
-        ):
-            message_proto = None
+        # Get the current Message and its object tree
+        message_proto = response.messages_list[0]
+        object_tree = response.message_object_trees[0]
 
         # Construct the Message
-        in_message: Optional[Message] = None
-
-        if message_proto:
-            msg_id = message_proto.metadata.message_id
-            run_id = message_proto.metadata.run_id
-            all_object_contents = pull_objects(
-                list(response.objects_to_pull[msg_id].object_ids) + [msg_id],
-                pull_object_fn=make_pull_object_fn_grpc(
-                    pull_object_grpc=stub.PullObject,
-                    node=node,
-                    run_id=run_id,
-                ),
-            )
+        in_message = message_from_proto(message_proto)
 
-            # Confirm that the message has been received
-            stub.ConfirmMessageReceived(
-                ConfirmMessageReceivedRequest(
-                    node=node, run_id=run_id, message_object_id=msg_id
-                )
-            )
-
-            in_message = cast(
-                Message, inflate_object_from_contents(msg_id, all_object_contents)
-            )
-            # The deflated message doesn't contain the message_id (its own object_id)
-            # Inject
-            in_message.metadata.__dict__["_message_id"] = msg_id
-
-        # Remember `metadata` of the in message
-        nonlocal metadata
-        metadata = copy(in_message.metadata) if in_message else None
-
-        # Return the message if available
-        return in_message
+        # Return the Message and its object tree
+        return in_message, object_tree
 
-    def send(message: Message) -> None:
-        """Send message reply to server."""
+    def send(message: Message, object_tree: ObjectTree) -> set[str]:
+        """Send the message with its ObjectTree to SuperLink."""
         # Get Node
         if node is None:
             log(ERROR, "Node instance missing")
-            return
-
-        # Get the metadata of the incoming message
-        nonlocal metadata
-        if metadata is None:
-            log(ERROR, "No current message")
-            return
+            return set()
 
-        # Set message_id
-        message.metadata.__dict__["_message_id"] = message.object_id
-        # Validate out message
-        if not validate_out_message(message, metadata):
-            log(ERROR, "Invalid out message")
-            return
+        # Remove the content from the message if it has
+        if message.has_content():
+            message = remove_content_from_message(message)
 
-        with no_object_id_recompute():
-            # Get all nested objects
-            all_objects = get_all_nested_objects(message)
-            object_tree = get_object_tree(message)
-
-            # Serialize Message
-            message_proto = message_to_proto(
-                message=remove_content_from_message(message)
-            )
-            request = PushMessagesRequest(
-                node=node,
-                messages_list=[message_proto],
-                message_object_trees=[object_tree],
-            )
-            response: PushMessagesResponse = stub.PushMessages(request=request)
-
-            if response.objects_to_push:
-                objs_to_push = set(
-                    response.objects_to_push[message.object_id].object_ids
-                )
-                push_objects(
-                    all_objects,
-                    push_object_fn=make_push_object_fn_grpc(
-                        push_object_grpc=stub.PushObject,
-                        node=node,
-                        run_id=message.metadata.run_id,
-                    ),
-                    object_ids_to_push=objs_to_push,
-                )
-                log(DEBUG, "Pushed %s objects to servicer.", len(objs_to_push))
+        # Send the message with its ObjectTree to SuperLink
+        request = PushMessagesRequest(
+            node=node,
+            messages_list=[message_to_proto(message)],
+            message_object_trees=[object_tree],
+        )
+        response: PushMessagesResponse = stub.PushMessages(request=request)
 
-        # Cleanup
-        metadata = None
+        # Get and return the object IDs to push
+        return set(response.objects_to_push)
 
     def get_run(run_id: int) -> Run:
         # Call FleetAPI
@@ -376,9 +291,58 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
 
         return Fab(get_fab_response.fab.hash_str, get_fab_response.fab.content)
 
+    def pull_object(run_id: int, object_id: str) -> bytes:
+        """Pull the object from the SuperLink."""
+        # Check Node
+        if node is None:
+            raise RuntimeError("Node instance missing")
+
+        fn = make_pull_object_fn_protobuf(
+            pull_object_protobuf=stub.PullObject,
+            node=node,
+            run_id=run_id,
+        )
+        return fn(object_id)
+
+    def push_object(run_id: int, object_id: str, contents: bytes) -> None:
+        """Push the object to the SuperLink."""
+        # Check Node
+        if node is None:
+            raise RuntimeError("Node instance missing")
+
+        fn = make_push_object_fn_protobuf(
+            push_object_protobuf=stub.PushObject,
+            node=node,
+            run_id=run_id,
+        )
+        fn(object_id, contents)
+
+    def confirm_message_received(run_id: int, object_id: str) -> None:
+        """Confirm that the message has been received."""
+        # Check Node
+        if node is None:
+            raise RuntimeError("Node instance missing")
+
+        fn = make_confirm_message_received_fn_protobuf(
+            confirm_message_received_protobuf=stub.ConfirmMessageReceived,
+            node=node,
+            run_id=run_id,
+        )
+        fn(object_id)
+
     try:
         # Yield methods
-        yield (receive, send, create_node, delete_node, get_run, get_fab)
+        yield (
+            receive,
+            send,
+            create_node,
+            delete_node,
+            get_run,
+            get_fab,
+            pull_object,
+            push_object,
+            confirm_message_received,
+        )
     except Exception as exc:  # pylint: disable=broad-except
         log(ERROR, exc)
     # Cleanup