flwr-nightly 1.12.0.dev20241007__tar.gz → 1.12.0.dev20241009__tar.gz

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.12.0.dev20241007
+Version: 1.12.0.dev20241009
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.12.0.dev20241007"
+version = "1.12.0.dev20241009"
 description = "Flower: A Friendly Federated Learning Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/new.py

@@ -240,6 +240,8 @@ def new(
             MlFramework.HUGGINGFACE.value,
             MlFramework.MLX.value,
             MlFramework.TENSORFLOW.value,
+            MlFramework.SKLEARN.value,
+            MlFramework.NUMPY.value,
         ]
         if framework_str in frameworks_with_tasks:
             files[f"{import_name}/task.py"] = {

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/templates/app/code/client.jax.py.tpl

@@ -1,9 +1,9 @@
 """$project_name: A Flower / $framework_str app."""
 
 import jax
-from flwr.client import NumPyClient, ClientApp
-from flwr.common import Context
 
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
 from $import_name.task import (
     evaluation,
     get_params,
@@ -17,37 +17,31 @@ from $import_name.task import (
 
 # Define Flower Client and client_fn
 class FlowerClient(NumPyClient):
-    def __init__(self):
+    def __init__(self, input_dim):
         self.train_x, self.train_y, self.test_x, self.test_y = load_data()
         self.grad_fn = jax.grad(loss_fn)
-        model_shape = self.train_x.shape[1:]
-
-        self.params = load_model(model_shape)
-
-    def get_parameters(self, config):
-        return get_params(self.params)
-
-    def set_parameters(self, parameters):
-        set_params(self.params, parameters)
+        self.params = load_model((input_dim,))
 
     def fit(self, parameters, config):
-        self.set_parameters(parameters)
+        set_params(self.params, parameters)
         self.params, loss, num_examples = train(
             self.params, self.grad_fn, self.train_x, self.train_y
         )
-        parameters = self.get_parameters(config={})
-        return parameters, num_examples, {"loss": float(loss)}
+        return get_params(self.params), num_examples, {"loss": float(loss)}
 
     def evaluate(self, parameters, config):
-        self.set_parameters(parameters)
+        set_params(self.params, parameters)
         loss, num_examples = evaluation(
             self.params, self.grad_fn, self.test_x, self.test_y
         )
         return float(loss), num_examples, {"loss": float(loss)}
 
+
 def client_fn(context: Context):
+    input_dim = context.run_config["input-dim"]
+
     # Return Client instance
-    return FlowerClient().to_client()
+    return FlowerClient(input_dim).to_client()
 
 
 # Flower ClientApp

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/templates/app/code/client.mlx.py.tpl

@@ -3,17 +3,18 @@
 import mlx.core as mx
 import mlx.nn as nn
 import mlx.optimizers as optim
-from flwr.client import NumPyClient, ClientApp
-from flwr.common import Context
 
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
+from flwr.common.config import UserConfig
 from $import_name.task import (
+    MLP,
     batch_iterate,
     eval_fn,
     get_params,
     load_data,
     loss_fn,
     set_params,
-    MLP,
 )
 
 
@@ -22,37 +23,24 @@ class FlowerClient(NumPyClient):
     def __init__(
         self,
         data,
-        num_layers,
-        hidden_dim,
+        run_config: UserConfig,
         num_classes,
-        batch_size,
-        learning_rate,
-        num_epochs,
     ):
-        self.num_layers = num_layers
-        self.hidden_dim = hidden_dim
-        self.num_classes = num_classes
-        self.batch_size = batch_size
-        self.learning_rate = learning_rate
-        self.num_epochs = num_epochs
+        num_layers = run_config["num-layers"]
+        hidden_dim = run_config["hidden-dim"]
+        input_dim = run_config["input-dim"]
+        batch_size = run_config["batch-size"]
+        learning_rate = run_config["lr"]
+        self.num_epochs = run_config["local-epochs"]
 
         self.train_images, self.train_labels, self.test_images, self.test_labels = data
-        self.model = MLP(
-            num_layers, self.train_images.shape[-1], hidden_dim, num_classes
-        )
+        self.model = MLP(num_layers, input_dim, hidden_dim, num_classes)
         self.optimizer = optim.SGD(learning_rate=learning_rate)
         self.loss_and_grad_fn = nn.value_and_grad(self.model, loss_fn)
-        self.num_epochs = num_epochs
         self.batch_size = batch_size
 
-    def get_parameters(self, config):
-        return get_params(self.model)
-
-    def set_parameters(self, parameters):
-        set_params(self.model, parameters)
-
     def fit(self, parameters, config):
-        self.set_parameters(parameters)
+        set_params(self.model, parameters)
         for _ in range(self.num_epochs):
             for X, y in batch_iterate(
                 self.batch_size, self.train_images, self.train_labels
@@ -60,10 +48,10 @@ class FlowerClient(NumPyClient):
                 _, grads = self.loss_and_grad_fn(self.model, X, y)
                 self.optimizer.update(self.model, grads)
                 mx.eval(self.model.parameters(), self.optimizer.state)
-        return self.get_parameters(config={}), len(self.train_images), {}
+        return get_params(self.model), len(self.train_images), {}
 
     def evaluate(self, parameters, config):
-        self.set_parameters(parameters)
+        set_params(self.model, parameters)
         accuracy = eval_fn(self.model, self.test_images, self.test_labels)
         loss = loss_fn(self.model, self.test_images, self.test_labels)
         return loss.item(), len(self.test_images), {"accuracy": accuracy.item()}
@@ -73,18 +61,10 @@ def client_fn(context: Context):
     partition_id = context.node_config["partition-id"]
     num_partitions = context.node_config["num-partitions"]
     data = load_data(partition_id, num_partitions)
-
-    num_layers = context.run_config["num-layers"]
-    hidden_dim = context.run_config["hidden-dim"]
     num_classes = 10
-    batch_size = context.run_config["batch-size"]
-    learning_rate = context.run_config["lr"]
-    num_epochs = context.run_config["local-epochs"]
 
     # Return Client instance
-    return FlowerClient(
-        data, num_layers, hidden_dim, num_classes, batch_size, learning_rate, num_epochs
-    ).to_client()
+    return FlowerClient(data, context.run_config, num_classes).to_client()
 
 
 # Flower ClientApp

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/templates/app/code/client.numpy.py.tpl

@@ -1,16 +1,15 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.client import NumPyClient, ClientApp
+from flwr.client import ClientApp, NumPyClient
 from flwr.common import Context
-import numpy as np
+from $import_name.task import get_dummy_model
 
 
 class FlowerClient(NumPyClient):
-    def get_parameters(self, config):
-        return [np.ones((1, 1))]
 
     def fit(self, parameters, config):
-        return ([np.ones((1, 1))], 1, {})
+        model = get_dummy_model()
+        return [model], 1, {}
 
     def evaluate(self, parameters, config):
         return float(0.0), 1, {"accuracy": float(1.0)}

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/templates/app/code/client.pytorch.py.tpl

@@ -1,17 +1,10 @@
 """$project_name: A Flower / $framework_str app."""
 
 import torch
-from flwr.client import NumPyClient, ClientApp
-from flwr.common import Context
 
-from $import_name.task import (
-    Net,
-    load_data,
-    get_weights,
-    set_weights,
-    train,
-    test,
-)
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
+from $import_name.task import Net, get_weights, load_data, set_weights, test, train
 
 
 # Define Flower Client and client_fn
@@ -32,7 +25,11 @@ class FlowerClient(NumPyClient):
             self.local_epochs,
             self.device,
         )
-        return get_weights(self.net), len(self.trainloader.dataset), {"train_loss": train_loss}
+        return (
+            get_weights(self.net),
+            len(self.trainloader.dataset),
+            {"train_loss": train_loss},
+        )
 
     def evaluate(self, parameters, config):
         set_weights(self.net, parameters)

flwr_nightly-1.12.0.dev20241009/src/py/flwr/cli/new/templates/app/code/client.sklearn.py.tpl

@@ -0,0 +1,63 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import warnings
+
+from sklearn.metrics import log_loss
+
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
+from $import_name.task import (
+    get_model,
+    get_model_params,
+    load_data,
+    set_initial_params,
+    set_model_params,
+)
+
+
+class FlowerClient(NumPyClient):
+    def __init__(self, model, X_train, X_test, y_train, y_test):
+        self.model = model
+        self.X_train = X_train
+        self.X_test = X_test
+        self.y_train = y_train
+        self.y_test = y_test
+
+    def fit(self, parameters, config):
+        set_model_params(self.model, parameters)
+
+        # Ignore convergence failure due to low local epochs
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            self.model.fit(self.X_train, self.y_train)
+
+        return get_model_params(self.model), len(self.X_train), {}
+
+    def evaluate(self, parameters, config):
+        set_model_params(self.model, parameters)
+
+        loss = log_loss(self.y_test, self.model.predict_proba(self.X_test))
+        accuracy = self.model.score(self.X_test, self.y_test)
+
+        return loss, len(self.X_test), {"accuracy": accuracy}
+
+
+def client_fn(context: Context):
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+
+    X_train, X_test, y_train, y_test = load_data(partition_id, num_partitions)
+
+    # Create LogisticRegression Model
+    penalty = context.run_config["penalty"]
+    local_epochs = context.run_config["local-epochs"]
+    model = get_model(penalty, local_epochs)
+
+    # Setting initial parameters, akin to model.compile for keras models
+    set_initial_params(model)
+
+    return FlowerClient(model, X_train, X_test, y_train, y_test).to_client()
+
+
+# Flower ClientApp
+app = ClientApp(client_fn=client_fn)

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/templates/app/code/server.jax.py.tpl

@@ -1,16 +1,22 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.common import Context
-from flwr.server.strategy import FedAvg
+from flwr.common import Context, ndarrays_to_parameters
 from flwr.server import ServerApp, ServerAppComponents, ServerConfig
+from flwr.server.strategy import FedAvg
+from $import_name.task import get_params, load_model
 
 
 def server_fn(context: Context):
     # Read from config
     num_rounds = context.run_config["num-server-rounds"]
+    input_dim = context.run_config["input-dim"]
+
+    # Initialize global model
+    params = get_params(load_model((input_dim,)))
+    initial_parameters = ndarrays_to_parameters(params)
 
     # Define strategy
-    strategy = FedAvg()
+    strategy = FedAvg(initial_parameters=initial_parameters)
     config = ServerConfig(num_rounds=num_rounds)
 
     return ServerAppComponents(strategy=strategy, config=config)

flwr_nightly-1.12.0.dev20241009/src/py/flwr/cli/new/templates/app/code/server.mlx.py.tpl

@@ -0,0 +1,31 @@
+"""$project_name: A Flower / $framework_str app."""
+
+from flwr.common import Context, ndarrays_to_parameters
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
+from flwr.server.strategy import FedAvg
+from $import_name.task import MLP, get_params
+
+
+def server_fn(context: Context):
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+
+    num_classes = 10
+    num_layers = context.run_config["num-layers"]
+    input_dim = context.run_config["input-dim"]
+    hidden_dim = context.run_config["hidden-dim"]
+
+    # Initialize global model
+    model = MLP(num_layers, input_dim, hidden_dim, num_classes)
+    params = get_params(model)
+    initial_parameters = ndarrays_to_parameters(params)
+
+    # Define strategy
+    strategy = FedAvg(initial_parameters=initial_parameters)
+    config = ServerConfig(num_rounds=num_rounds)
+
+    return ServerAppComponents(strategy=strategy, config=config)
+
+
+# Create ServerApp
+app = ServerApp(server_fn=server_fn)

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/templates/app/code/server.numpy.py.tpl

@@ -1,16 +1,21 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.common import Context
+from flwr.common import Context, ndarrays_to_parameters
 from flwr.server import ServerApp, ServerAppComponents, ServerConfig
 from flwr.server.strategy import FedAvg
+from $import_name.task import get_dummy_model
 
 
 def server_fn(context: Context):
     # Read from config
     num_rounds = context.run_config["num-server-rounds"]
 
+    # Initial model
+    model = get_dummy_model()
+    dummy_parameters = ndarrays_to_parameters([model])
+
     # Define strategy
-    strategy = FedAvg()
+    strategy = FedAvg(initial_parameters=dummy_parameters)
     config = ServerConfig(num_rounds=num_rounds)
 
     return ServerAppComponents(strategy=strategy, config=config)

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/templates/app/code/server.sklearn.py.tpl

@@ -1,19 +1,31 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.common import Context
+from flwr.common import Context, ndarrays_to_parameters
 from flwr.server import ServerApp, ServerAppComponents, ServerConfig
 from flwr.server.strategy import FedAvg
+from $import_name.task import get_model, get_model_params, set_initial_params
 
 
 def server_fn(context: Context):
     # Read from config
     num_rounds = context.run_config["num-server-rounds"]
 
+    # Create LogisticRegression Model
+    penalty = context.run_config["penalty"]
+    local_epochs = context.run_config["local-epochs"]
+    model = get_model(penalty, local_epochs)
+
+    # Setting initial parameters, akin to model.compile for keras models
+    set_initial_params(model)
+
+    initial_parameters = ndarrays_to_parameters(get_model_params(model))
+
     # Define strategy
     strategy = FedAvg(
         fraction_fit=1.0,
         fraction_evaluate=1.0,
         min_available_clients=2,
+        initial_parameters=initial_parameters,
     )
     config = ServerConfig(num_rounds=num_rounds)
 

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/templates/app/code/task.jax.py.tpl

@@ -2,9 +2,9 @@
 
 import jax
 import jax.numpy as jnp
+import numpy as np
 from sklearn.datasets import make_regression
 from sklearn.model_selection import train_test_split
-import numpy as np
 
 key = jax.random.PRNGKey(0)
 
@@ -33,7 +33,7 @@ def train(params, grad_fn, X, y):
     num_examples = X.shape[0]
     for epochs in range(50):
         grads = grad_fn(params, X, y)
-        params = jax.tree_map(lambda p, g: p - 0.05 * g, params, grads)
+        params = jax.tree.map(lambda p, g: p - 0.05 * g, params, grads)
         loss = loss_fn(params, X, y)
     return params, loss, num_examples
 

flwr_nightly-1.12.0.dev20241009/src/py/flwr/cli/new/templates/app/code/task.numpy.py.tpl

@@ -0,0 +1,7 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import numpy as np
+
+
+def get_dummy_model():
+    return np.ones((1, 1))

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/templates/app/code/task.pytorch.py.tpl

@@ -5,10 +5,10 @@ from collections import OrderedDict
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from torch.utils.data import DataLoader
-from torchvision.transforms import Compose, Normalize, ToTensor
 from flwr_datasets import FederatedDataset
 from flwr_datasets.partitioner import IidPartitioner
+from torch.utils.data import DataLoader
+from torchvision.transforms import Compose, Normalize, ToTensor
 
 
 class Net(nn.Module):
@@ -67,7 +67,7 @@ def train(net, trainloader, epochs, device):
     """Train the model on the training set."""
     net.to(device)  # move model to GPU if available
     criterion = torch.nn.CrossEntropyLoss().to(device)
-    optimizer = torch.optim.SGD(net.parameters(), lr=0.1, momentum=0.9)
+    optimizer = torch.optim.Adam(net.parameters(), lr=0.01)
     net.train()
     running_loss = 0.0
     for _ in range(epochs):

flwr_nightly-1.12.0.dev20241009/src/py/flwr/cli/new/templates/app/code/task.sklearn.py.tpl

@@ -0,0 +1,67 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import numpy as np
+from flwr_datasets import FederatedDataset
+from flwr_datasets.partitioner import IidPartitioner
+from sklearn.linear_model import LogisticRegression
+
+fds = None  # Cache FederatedDataset
+
+
+def load_data(partition_id: int, num_partitions: int):
+    """Load partition MNIST data."""
+    # Only initialize `FederatedDataset` once
+    global fds
+    if fds is None:
+        partitioner = IidPartitioner(num_partitions=num_partitions)
+        fds = FederatedDataset(
+            dataset="mnist",
+            partitioners={"train": partitioner},
+        )
+
+    dataset = fds.load_partition(partition_id, "train").with_format("numpy")
+
+    X, y = dataset["image"].reshape((len(dataset), -1)), dataset["label"]
+
+    # Split the on edge data: 80% train, 20% test
+    X_train, X_test = X[: int(0.8 * len(X))], X[int(0.8 * len(X)) :]
+    y_train, y_test = y[: int(0.8 * len(y))], y[int(0.8 * len(y)) :]
+
+    return X_train, X_test, y_train, y_test
+
+
+def get_model(penalty: str, local_epochs: int):
+
+    return LogisticRegression(
+        penalty=penalty,
+        max_iter=local_epochs,
+        warm_start=True,
+    )
+
+
+def get_model_params(model):
+    if model.fit_intercept:
+        params = [
+            model.coef_,
+            model.intercept_,
+        ]
+    else:
+        params = [model.coef_]
+    return params
+
+
+def set_model_params(model, params):
+    model.coef_ = params[0]
+    if model.fit_intercept:
+        model.intercept_ = params[1]
+    return model
+
+
+def set_initial_params(model):
+    n_classes = 10  # MNIST has 10 classes
+    n_features = 784  # Number of features in dataset
+    model.classes_ = np.array([i for i in range(10)])
+
+    model.coef_ = np.zeros((n_classes, n_features))
+    if model.fit_intercept:
+        model.intercept_ = np.zeros((n_classes,))

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/templates/app/pyproject.jax.toml.tpl

@@ -9,8 +9,8 @@ description = ""
 license = "Apache-2.0"
 dependencies = [
     "flwr[simulation]>=1.10.0",
-    "jax==0.4.13",
-    "jaxlib==0.4.13",
+    "jax==0.4.30",
+    "jaxlib==0.4.30",
     "scikit-learn==1.3.2",
 ]
 
@@ -26,6 +26,7 @@ clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
 num-server-rounds = 3
+input-dim = 3
 
 [tool.flwr.federations]
 default = "local-simulation"

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/templates/app/pyproject.mlx.toml.tpl

@@ -28,6 +28,7 @@ clientapp = "$import_name.client_app:app"
 num-server-rounds = 3
 local-epochs = 1
 num-layers = 2
+input-dim = 784 # 28*28
 hidden-dim = 32
 batch-size = 256
 lr = 0.1

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/cli/new/templates/app/pyproject.sklearn.toml.tpl

@@ -25,6 +25,8 @@ clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
 num-server-rounds = 3
+penalty = "l2"
+local-epochs = 1
 
 [tool.flwr.federations]
 default = "local-simulation"

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/common/constant.py

@@ -63,7 +63,10 @@ NODE_ID_NUM_BYTES = 8
 
 # Constants for FAB
 APP_DIR = "apps"
+FAB_ALLOWED_EXTENSIONS = {".py", ".toml", ".md"}
 FAB_CONFIG_FILE = "pyproject.toml"
+FAB_DATE = (2024, 10, 1, 0, 0, 0)
+FAB_HASH_TRUNCATION = 8
 FLWR_HOME = "FLWR_HOME"
 
 # Constants entries in Node config for Simulation

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241009}/src/py/flwr/server/compat/driver_client_proxy.py

@@ -15,7 +15,6 @@
 """Flower ClientProxy implementation for Driver API."""
 
 
-import time
 from typing import Optional
 
 from flwr import common
@@ -25,8 +24,6 @@ from flwr.server.client_proxy import ClientProxy
 
 from ..driver.driver import Driver
 
-SLEEP_TIME = 1
-
 
 class DriverClientProxy(ClientProxy):
     """Flower client proxy which delegates work using the Driver API."""
@@ -122,29 +119,18 @@ class DriverClientProxy(ClientProxy):
             ttl=timeout,
         )
 
-        # Push message
-        message_ids = list(self.driver.push_messages(messages=[message]))
-        if len(message_ids) != 1:
-            raise ValueError("Unexpected number of message_ids")
-
-        message_id = message_ids[0]
-        if message_id == "":
-            raise ValueError(f"Failed to send message to node {self.node_id}")
-
-        if timeout:
-            start_time = time.time()
-
-        while True:
-            messages = list(self.driver.pull_messages(message_ids))
-            if len(messages) == 1:
-                msg: Message = messages[0]
-                if msg.has_error():
-                    raise ValueError(
-                        f"Message contains an Error (reason: {msg.error.reason}). "
-                        "It originated during client-side execution of a message."
-                    )
-                return msg.content
-
-            if timeout is not None and time.time() > start_time + timeout:
-                raise RuntimeError("Timeout reached")
-            time.sleep(SLEEP_TIME)
+        # Send message and wait for reply
+        messages = list(self.driver.send_and_receive(messages=[message]))
+
+        # A single reply is expected
+        if len(messages) != 1:
+            raise ValueError(f"Expected one Message but got: {len(messages)}")
+
+        # Only messages without errors can be handled beyond these point
+        msg: Message = messages[0]
+        if msg.has_error():
+            raise ValueError(
+                f"Message contains an Error (reason: {msg.error.reason}). "
+                "It originated during client-side execution of a message."
+            )
+        return msg.content