flwr 1.20.0__py3-none-any.whl → 1.22.0__py3-none-any.whl

flwr/__init__.py

@@ -17,12 +17,15 @@
 
 from flwr.common.version import package_version as _package_version
 
-from . import client, common, server, simulation
+from . import app, client, clientapp, common, server, serverapp, simulation
 
 __all__ = [
+    "app",
     "client",
+    "clientapp",
     "common",
     "server",
+    "serverapp",
     "simulation",
 ]
 

flwr/app/__init__.py

@@ -13,3 +13,31 @@
 # limitations under the License.
 # ==============================================================================
 """Public Flower App APIs."""
+
+
+from flwr.common.constant import MessageType
+from flwr.common.context import Context
+from flwr.common.message import Message
+from flwr.common.record import (
+    Array,
+    ArrayRecord,
+    ConfigRecord,
+    MetricRecord,
+    RecordDict,
+)
+
+from .error import Error
+from .metadata import Metadata
+
+__all__ = [
+    "Array",
+    "ArrayRecord",
+    "ConfigRecord",
+    "Context",
+    "Error",
+    "Message",
+    "MessageType",
+    "Metadata",
+    "MetricRecord",
+    "RecordDict",
+]

flwr/app/exception.py

@@ -0,0 +1,31 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Flower application exceptions."""
+
+
+class AppExitException(BaseException):
+    """Base exception for all application-level errors in ServerApp and ClientApp.
+
+    When raised, the process will exit and report a telemetry event with the associated
+    exit code. This is not intended to be caught by user code.
+    """
+
+    # Default exit code — subclasses must override
+    exit_code = -1
+
+    def __init_subclass__(cls) -> None:
+        """Ensure subclasses override the exit_code attribute."""
+        if cls.exit_code == -1:
+            raise ValueError("Subclasses must override the exit_code attribute.")

flwr/cli/app.py

@@ -25,6 +25,7 @@ from .log import log
 from .login import login
 from .ls import ls
 from .new import new
+from .pull import pull
 from .run import run
 from .stop import stop
 
@@ -46,6 +47,7 @@ app.command()(log)
 app.command()(ls)
 app.command()(stop)
 app.command()(login)
+app.command()(pull)
 
 typer_click_object = get_command(app)
 

flwr/cli/auth_plugin/oidc_cli_plugin.py

@@ -31,11 +31,11 @@ from flwr.common.constant import (
     AuthType,
 )
 from flwr.common.typing import UserAuthCredentials, UserAuthLoginDetails
-from flwr.proto.exec_pb2 import (  # pylint: disable=E0611
+from flwr.proto.control_pb2 import (  # pylint: disable=E0611
     GetAuthTokensRequest,
     GetAuthTokensResponse,
 )
-from flwr.proto.exec_pb2_grpc import ExecStub
+from flwr.proto.control_pb2_grpc import ControlStub
 
 
 class OidcCliPlugin(CliAuthPlugin):
@@ -49,7 +49,7 @@ class OidcCliPlugin(CliAuthPlugin):
     @staticmethod
     def login(
         login_details: UserAuthLoginDetails,
-        exec_stub: ExecStub,
+        control_stub: ControlStub,
     ) -> UserAuthCredentials:
         """Authenticate the user and retrieve authentication credentials."""
         typer.secho(
@@ -61,7 +61,7 @@ class OidcCliPlugin(CliAuthPlugin):
         time.sleep(login_details.interval)
 
         while (time.time() - start_time) < login_details.expires_in:
-            res: GetAuthTokensResponse = exec_stub.GetAuthTokens(
+            res: GetAuthTokensResponse = control_stub.GetAuthTokens(
                 GetAuthTokensRequest(device_code=login_details.device_code)
             )
 

flwr/cli/cli_user_auth_interceptor.py

@@ -20,7 +20,7 @@ from typing import Any, Callable, Union
 import grpc
 
 from flwr.common.auth_plugin import CliAuthPlugin
-from flwr.proto.exec_pb2 import (  # pylint: disable=E0611
+from flwr.proto.control_pb2 import (  # pylint: disable=E0611
     StartRunRequest,
     StreamLogsRequest,
 )

flwr/cli/config_utils.py

@@ -143,7 +143,7 @@ def validate_federation_in_project_config(
     if federation is None:
         typer.secho(
             "❌ No federation name was provided and the project's `pyproject.toml` "
-            "doesn't declare a default federation (with an Exec API address or an "
+            "doesn't declare a default federation (with an Control API address or an "
             "`options.num-supernodes` value).",
             fg=typer.colors.RED,
             bold=True,
@@ -230,8 +230,8 @@ def exit_if_no_address(federation_config: dict[str, Any], cmd: str) -> None:
     """Exit if the provided federation_config has no "address" key."""
     if "address" not in federation_config:
         typer.secho(
-            f"❌ `flwr {cmd}` currently works with a SuperLink. Ensure that the correct"
-            "SuperLink (Exec API) address is provided in `pyproject.toml`.",
+            f"❌ `flwr {cmd}` currently works with a SuperLink. Ensure that the "
+            "correct SuperLink (Control API) address is provided in `pyproject.toml`.",
             fg=typer.colors.RED,
             bold=True,
         )

flwr/cli/constant.py

@@ -15,13 +15,30 @@
 """Constants for CLI commands."""
 
 
+# General help message for config overrides
+CONFIG_HELP_MESSAGE = (
+    "Override {0} values using one of the following formats:\n\n"
+    "--{1} '<k1>=<v1> <k2>=<v2>' | --{1} '<k1>=<v1>' --{1} '<k2>=<v2>'{2}\n\n"
+    "When providing key-value pairs, values can be of any type supported by TOML "
+    "(e.g., bool, int, float, string). The specified keys (<k1> and <k2> in the "
+    "example) must exist in the {0} under the `{3}` section of `pyproject.toml` to be "
+    "overridden.{4}"
+)
+
+# The help message for `--run-config` option
+RUN_CONFIG_HELP_MESSAGE = CONFIG_HELP_MESSAGE.format(
+    "run configuration",
+    "run-config",
+    " | --run-config <path/to/your/toml>",
+    "[tool.flwr.app.config]",
+    " Alternatively, provide a TOML file containing overrides.",
+)
+
 # The help message for `--federation-config` option
-FEDERATION_CONFIG_HELP_MESSAGE = (
-    "Override federation configuration values in the format:\n\n"
-    "`--federation-config 'key1=value1 key2=value2' --federation-config "
-    "'key3=value3'`\n\nValues 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 the federation configuration under the "
-    "`[tool.flwr.federations.<YOUR_FEDERATION>]` table of the `pyproject.toml` "
-    "for proper overriding."
+FEDERATION_CONFIG_HELP_MESSAGE = CONFIG_HELP_MESSAGE.format(
+    "federation configuration",
+    "federation-config",
+    "",
+    "[tool.flwr.federations.<YOUR-FEDERATION>]",
+    "",
 )

flwr/cli/log.py

@@ -32,8 +32,8 @@ from flwr.cli.config_utils import (
 from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
 from flwr.common.constant import CONN_RECONNECT_INTERVAL, CONN_REFRESH_PERIOD
 from flwr.common.logger import log as logger
-from flwr.proto.exec_pb2 import StreamLogsRequest  # pylint: disable=E0611
-from flwr.proto.exec_pb2_grpc import ExecStub
+from flwr.proto.control_pb2 import StreamLogsRequest  # pylint: disable=E0611
+from flwr.proto.control_pb2_grpc import ControlStub
 
 from .utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
 
@@ -46,7 +46,7 @@ def start_stream(
     run_id: int, channel: grpc.Channel, refresh_period: int = CONN_REFRESH_PERIOD
 ) -> None:
     """Start log streaming for a given run ID."""
-    stub = ExecStub(channel)
+    stub = ControlStub(channel)
     after_timestamp = 0.0
     try:
         logger(INFO, "Starting logstream for run_id `%s`", run_id)
@@ -69,7 +69,7 @@ def start_stream(
 
 
 def stream_logs(
-    run_id: int, stub: ExecStub, duration: int, after_timestamp: float
+    run_id: int, stub: ControlStub, duration: int, after_timestamp: float
 ) -> float:
     """Stream logs from the beginning of a run with connection refresh.
 
@@ -77,8 +77,8 @@ def stream_logs(
     ----------
     run_id : int
         The identifier of the run.
-    stub : ExecStub
-        The gRPC stub to interact with the Exec service.
+    stub : ControlStub
+        The gRPC stub to interact with the Control service.
     duration : int
         The timeout duration for each stream connection in seconds.
     after_timestamp : float
@@ -112,7 +112,7 @@ def stream_logs(
 
 def print_logs(run_id: int, channel: grpc.Channel, timeout: int) -> None:
     """Print logs from the beginning of a run."""
-    stub = ExecStub(channel)
+    stub = ControlStub(channel)
     req = StreamLogsRequest(run_id=run_id, after_timestamp=0.0)
 
     try:
@@ -173,13 +173,13 @@ def log(
     exit_if_no_address(federation_config, "log")
 
     try:
-        _log_with_exec_api(app, federation, federation_config, run_id, stream)
+        _log_with_control_api(app, federation, federation_config, run_id, stream)
     except Exception as err:  # pylint: disable=broad-except
         typer.secho(str(err), fg=typer.colors.RED, bold=True)
         raise typer.Exit(code=1) from None
 
 
-def _log_with_exec_api(
+def _log_with_control_api(
     app: Path,
     federation: str,
     federation_config: dict[str, Any],

flwr/cli/login/login.py

@@ -29,11 +29,11 @@ from flwr.cli.config_utils import (
 )
 from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
 from flwr.common.typing import UserAuthLoginDetails
-from flwr.proto.exec_pb2 import (  # pylint: disable=E0611
+from flwr.proto.control_pb2 import (  # pylint: disable=E0611
     GetLoginDetailsRequest,
     GetLoginDetailsResponse,
 )
-from flwr.proto.exec_pb2_grpc import ExecStub
+from flwr.proto.control_pb2_grpc import ControlStub
 
 from ..utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
 
@@ -89,7 +89,7 @@ def login(  # pylint: disable=R0914
         raise typer.Exit(code=1)
 
     channel = init_channel(app, federation_config, None)
-    stub = ExecStub(channel)
+    stub = ControlStub(channel)
 
     login_request = GetLoginDetailsRequest()
     with flwr_cli_grpc_exc_handler():

flwr/cli/ls.py

@@ -38,11 +38,11 @@ from flwr.common.date import format_timedelta, isoformat8601_utc
 from flwr.common.logger import print_json_error, redirect_output, restore_output
 from flwr.common.serde import run_from_proto
 from flwr.common.typing import Run
-from flwr.proto.exec_pb2 import (  # pylint: disable=E0611
+from flwr.proto.control_pb2 import (  # pylint: disable=E0611
     ListRunsRequest,
     ListRunsResponse,
 )
-from flwr.proto.exec_pb2_grpc import ExecStub
+from flwr.proto.control_pb2_grpc import ControlStub
 
 from .utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
 
@@ -125,7 +125,7 @@ def ls(  # pylint: disable=too-many-locals, too-many-branches, R0913, R0917
                 )
             auth_plugin = try_obtain_cli_auth_plugin(app, federation, federation_config)
             channel = init_channel(app, federation_config, auth_plugin)
-            stub = ExecStub(channel)
+            stub = ControlStub(channel)
 
             # Display information about a specific run ID
             if run_id is not None:
@@ -293,7 +293,7 @@ def _to_json(run_list: list[_RunListType]) -> str:
     return json.dumps({"success": True, "runs": runs_list})
 
 
-def _list_runs(stub: ExecStub) -> list[_RunListType]:
+def _list_runs(stub: ControlStub) -> list[_RunListType]:
     """List all runs."""
     with flwr_cli_grpc_exc_handler():
         res: ListRunsResponse = stub.ListRuns(ListRunsRequest())
@@ -302,7 +302,7 @@ def _list_runs(stub: ExecStub) -> list[_RunListType]:
     return _format_runs(run_dict, res.now)
 
 
-def _display_one_run(stub: ExecStub, run_id: int) -> list[_RunListType]:
+def _display_one_run(stub: ControlStub, run_id: int) -> list[_RunListType]:
     """Display information about a specific run."""
     with flwr_cli_grpc_exc_handler():
         res: ListRunsResponse = stub.ListRuns(ListRunsRequest(run_id=run_id))

flwr/cli/new/new.py

@@ -41,8 +41,10 @@ class MlFramework(str, Enum):
     JAX = "JAX"
     MLX = "MLX"
     NUMPY = "NumPy"
+    XGBOOST = "XGBoost"
     FLOWERTUNE = "FlowerTune"
     BASELINE = "Flower Baseline"
+    PYTORCH_LEGACY_API = "PyTorch (Legacy API, deprecated)"
 
 
 class LlmChallengeName(str, Enum):
@@ -154,6 +156,9 @@ def new(
     if framework_str == MlFramework.BASELINE:
         framework_str = "baseline"
 
+    if framework_str == MlFramework.PYTORCH_LEGACY_API:
+        framework_str = "pytorch_legacy_api"
+
     print(
         typer.style(
             f"\n🔨 Creating Flower App {app_name}...",
@@ -197,7 +202,7 @@ def new(
         }
 
         # Challenge specific context
-        fraction_fit = "0.2" if llm_challenge_str == "code" else "0.1"
+        fraction_train = "0.2" if llm_challenge_str == "code" else "0.1"
         if llm_challenge_str == "generalnlp":
             challenge_name = "General NLP"
             num_clients = "20"
@@ -216,7 +221,7 @@ def new(
             dataset_name = "flwrlabs/code-alpaca-20k"
 
         context["llm_challenge_str"] = llm_challenge_str
-        context["fraction_fit"] = fraction_fit
+        context["fraction_train"] = fraction_train
         context["challenge_name"] = challenge_name
         context["num_clients"] = num_clients
         context["dataset_name"] = dataset_name
@@ -243,12 +248,20 @@ def new(
             MlFramework.TENSORFLOW.value,
             MlFramework.SKLEARN.value,
             MlFramework.NUMPY.value,
+            MlFramework.XGBOOST.value,
+            "pytorch_legacy_api",
         ]
         if framework_str in frameworks_with_tasks:
             files[f"{import_name}/task.py"] = {
                 "template": f"app/code/task.{template_name}.py.tpl"
             }
 
+        if framework_str == "pytorch_legacy_api":
+            # Use custom __init__ that better captures name of framework
+            files[f"{import_name}/__init__.py"] = {
+                "template": f"app/code/__init__.{framework_str}.py.tpl"
+            }
+
         if framework_str == "baseline":
             # Include additional files for baseline template
             for file_name in ["model", "dataset", "strategy", "utils", "__init__"]:

flwr/cli/new/templates/app/README.flowertune.md.tpl

@@ -26,7 +26,7 @@ pip install -e .
 ## Experimental setup
 
 The dataset is divided into $num_clients partitions in an IID fashion, a partition is assigned to each ClientApp.
-We randomly sample a fraction ($fraction_fit) of the total nodes to participate in each round, for a total of `200` rounds.
+We randomly sample a fraction ($fraction_train) of the total nodes to participate in each round, for a total of `200` rounds.
 All settings are defined in `pyproject.toml`.
 
 > [!IMPORTANT]

flwr/cli/new/templates/app/code/__init__.pytorch_legacy_api.py.tpl

@@ -0,0 +1 @@
+"""$project_name: A Flower / PyTorch app."""

flwr/cli/new/templates/app/code/client.baseline.py.tpl

@@ -1,58 +1,75 @@
 """$project_name: A Flower Baseline."""
 
 import torch
-from flwr.client import ClientApp, NumPyClient
-from flwr.common import Context
+from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
 
 from $import_name.dataset import load_data
-from $import_name.model import Net, get_weights, set_weights, test, train
-
-
-class FlowerClient(NumPyClient):
-    """A class defining the client."""
-
-    def __init__(self, net, trainloader, valloader, local_epochs):
-        self.net = net
-        self.trainloader = trainloader
-        self.valloader = valloader
-        self.local_epochs = local_epochs
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-        self.net.to(self.device)
-
-    def fit(self, parameters, config):
-        """Traim model using this client's data."""
-        set_weights(self.net, parameters)
-        train_loss = train(
-            self.net,
-            self.trainloader,
-            self.local_epochs,
-            self.device,
-        )
-        return (
-            get_weights(self.net),
-            len(self.trainloader.dataset),
-            {"train_loss": train_loss},
-        )
-
-    def evaluate(self, parameters, config):
-        """Evaluate model using this client's data."""
-        set_weights(self.net, parameters)
-        loss, accuracy = test(self.net, self.valloader, self.device)
-        return loss, len(self.valloader.dataset), {"accuracy": accuracy}
-
-
-def client_fn(context: Context):
-    """Construct a Client that will be run in a ClientApp."""
-    # Load model and data
-    net = Net()
+from $import_name.model import Net
+from $import_name.model import test as test_fn
+from $import_name.model import train as train_fn
+
+# Flower ClientApp
+app = ClientApp()
+
+
+@app.train()
+def train(msg: Message, context: Context):
+    """Train the model on local data."""
+
+    # Load the model and initialize it with the received weights
+    model = Net()
+    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+    # Load the data
     partition_id = int(context.node_config["partition-id"])
     num_partitions = int(context.node_config["num-partitions"])
-    trainloader, valloader = load_data(partition_id, num_partitions)
+    trainloader, _ = load_data(partition_id, num_partitions)
     local_epochs = context.run_config["local-epochs"]
 
-    # Return Client instance
-    return FlowerClient(net, trainloader, valloader, local_epochs).to_client()
+    # Call the training function
+    train_loss = train_fn(
+        model,
+        trainloader,
+        local_epochs,
+        device,
+    )
 
+    # Construct and return reply Message
+    model_record = ArrayRecord(model.state_dict())
+    metrics = {
+        "train_loss": train_loss,
+        "num-examples": len(trainloader.dataset),
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"arrays": model_record, "metrics": metric_record})
+    return Message(content=content, reply_to=msg)
 
-# Flower ClientApp
-app = ClientApp(client_fn)
+
+@app.evaluate()
+def evaluate(msg: Message, context: Context):
+    """Evaluate the model on local data."""
+
+    # Load the model and initialize it with the received weights
+    model = Net()
+    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+    # Load the data
+    partition_id = int(context.node_config["partition-id"])
+    num_partitions = int(context.node_config["num-partitions"])
+    _, valloader = load_data(partition_id, num_partitions)
+
+    # Call the evaluation function
+    eval_loss, eval_acc = test_fn(model, valloader, device)
+
+    # Construct and return reply Message
+    metrics = {
+        "eval_loss": eval_loss,
+        "eval_acc": eval_acc,
+        "num-examples": len(valloader.dataset),
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"metrics": metric_record})
+    return Message(content=content, reply_to=msg)

flwr/cli/new/templates/app/code/client.huggingface.py.tpl

@@ -1,41 +1,67 @@
 """$project_name: A Flower / $framework_str app."""
 
 import torch
-from flwr.client import ClientApp, NumPyClient
-from flwr.common import Context
+from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
 from transformers import AutoModelForSequenceClassification
 
-from $import_name.task import get_weights, load_data, set_weights, test, train
+from $import_name.task import load_data
+from $import_name.task import test as test_fn
+from $import_name.task import train as train_fn
 
+# Flower ClientApp
+app = ClientApp()
+
+
+@app.train()
+def train(msg: Message, context: Context):
+    """Train the model on local data."""
+
+    # Get this client's dataset partition
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    model_name = context.run_config["model-name"]
+    trainloader, _ = load_data(partition_id, num_partitions, model_name)
+
+    # Load model
+    num_labels = context.run_config["num-labels"]
+    net = AutoModelForSequenceClassification.from_pretrained(
+        model_name, num_labels=num_labels
+    )
 
-# Flower client
-class FlowerClient(NumPyClient):
-    def __init__(self, net, trainloader, testloader, local_epochs):
-        self.net = net
-        self.trainloader = trainloader
-        self.testloader = testloader
-        self.local_epochs = local_epochs
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-        self.net.to(self.device)
+    # Initialize it with the received weights
+    net.load_state_dict(msg.content["arrays"].to_torch_state_dict())
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    net.to(device)
 
-    def fit(self, parameters, config):
-        set_weights(self.net, parameters)
-        train(self.net, self.trainloader, epochs=self.local_epochs, device=self.device)
-        return get_weights(self.net), len(self.trainloader), {}
+    # Train the model on local data
+    train_loss = train_fn(
+        net,
+        trainloader,
+        context.run_config["local-steps"],
+        device,
+    )
 
-    def evaluate(self, parameters, config):
-        set_weights(self.net, parameters)
-        loss, accuracy = test(self.net, self.testloader, self.device)
-        return float(loss), len(self.testloader), {"accuracy": accuracy}
+    # Construct and return reply Message
+    model_record = ArrayRecord(net.state_dict())
+    metrics = {
+        "train_loss": train_loss,
+        "num-examples": len(trainloader.dataset),
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"arrays": model_record, "metrics": metric_record})
+    return Message(content=content, reply_to=msg)
 
 
-def client_fn(context: Context):
+@app.evaluate()
+def evaluate(msg: Message, context: Context):
+    """Evaluate the model on local data."""
 
     # Get this client's dataset partition
     partition_id = context.node_config["partition-id"]
     num_partitions = context.node_config["num-partitions"]
     model_name = context.run_config["model-name"]
-    trainloader, valloader = load_data(partition_id, num_partitions, model_name)
+    _, valloader = load_data(partition_id, num_partitions, model_name)
 
     # Load model
     num_labels = context.run_config["num-labels"]
@@ -43,13 +69,25 @@ def client_fn(context: Context):
         model_name, num_labels=num_labels
     )
 
-    local_epochs = context.run_config["local-epochs"]
-
-    # Return Client instance
-    return FlowerClient(net, trainloader, valloader, local_epochs).to_client()
+    # Initialize it with the received weights
+    net.load_state_dict(msg.content["arrays"].to_torch_state_dict())
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    net.to(device)
 
+    # Evaluate the model on local data
+    val_loss, val_accuracy = test_fn(
+        net,
+        valloader,
+        device,
+    )
 
-# Flower ClientApp
-app = ClientApp(
-    client_fn,
-)
+    # Construct and return reply Message
+    model_record = ArrayRecord(net.state_dict())
+    metrics = {
+        "val_loss": val_loss,
+        "val_accuracy": val_accuracy,
+        "num-examples": len(valloader.dataset),
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"arrays": model_record, "metrics": metric_record})
+    return Message(content=content, reply_to=msg)