flwr-nightly 1.8.0.dev20240309__py3-none-any.whl → 1.8.0.dev20240311__py3-none-any.whl

flwr/cli/flower_toml.py

@@ -14,12 +14,13 @@
 # ==============================================================================
 """Utility to validate the `flower.toml` file."""
 
-import importlib
 import os
 from typing import Any, Dict, List, Optional, Tuple
 
 import tomli
 
+from flwr.common.object_ref import validate
+
 
 def load_flower_toml(path: Optional[str] = None) -> Optional[Dict[str, Any]]:
     """Load flower.toml and return as dict."""
@@ -71,47 +72,6 @@ def validate_flower_toml_fields(
     return len(errors) == 0, errors, warnings
 
 
-def validate_object_reference(ref: str) -> Tuple[bool, Optional[str]]:
-    """Validate object reference.
-
-    Returns
-    -------
-    Tuple[bool, Optional[str]]
-        A boolean indicating whether an object reference is valid and
-        the reason why it might not be.
-    """
-    module_str, _, attributes_str = ref.partition(":")
-    if not module_str:
-        return (
-            False,
-            f"Missing module in {ref}",
-        )
-    if not attributes_str:
-        return (
-            False,
-            f"Missing attribute in {ref}",
-        )
-
-    # Load module
-    try:
-        module = importlib.import_module(module_str)
-    except ModuleNotFoundError:
-        return False, f"Unable to load module {module_str}"
-
-    # Recursively load attribute
-    attribute = module
-    try:
-        for attribute_str in attributes_str.split("."):
-            attribute = getattr(attribute, attribute_str)
-    except AttributeError:
-        return (
-            False,
-            f"Unable to load attribute {attributes_str} from module {module_str}",
-        )
-
-    return (True, None)
-
-
 def validate_flower_toml(config: Dict[str, Any]) -> Tuple[bool, List[str], List[str]]:
     """Validate flower.toml."""
     is_valid, errors, warnings = validate_flower_toml_fields(config)
@@ -120,16 +80,12 @@ def validate_flower_toml(config: Dict[str, Any]) -> Tuple[bool, List[str], List[
         return False, errors, warnings
 
     # Validate serverapp
-    is_valid, reason = validate_object_reference(
-        config["flower"]["components"]["serverapp"]
-    )
+    is_valid, reason = validate(config["flower"]["components"]["serverapp"])
     if not is_valid and isinstance(reason, str):
         return False, [reason], []
 
     # Validate clientapp
-    is_valid, reason = validate_object_reference(
-        config["flower"]["components"]["clientapp"]
-    )
+    is_valid, reason = validate(config["flower"]["components"]["clientapp"])
 
     if not is_valid and isinstance(reason, str):
         return False, [reason], []

flwr/cli/new/new.py

@@ -22,7 +22,7 @@ from typing import Dict, Optional
 import typer
 from typing_extensions import Annotated
 
-from ..utils import prompt_options
+from ..utils import prompt_options, prompt_text
 
 
 class MlFramework(str, Enum):
@@ -72,9 +72,9 @@ def render_and_create(file_path: str, template: str, context: Dict[str, str]) ->
 
 def new(
     project_name: Annotated[
-        str,
+        Optional[str],
         typer.Argument(metavar="project_name", help="The name of the project"),
-    ],
+    ] = None,
     framework: Annotated[
         Optional[MlFramework],
         typer.Option(case_sensitive=False, help="The ML framework to use"),
@@ -83,6 +83,9 @@ def new(
     """Create new Flower project."""
     print(f"Creating Flower project {project_name}...")
 
+    if project_name is None:
+        project_name = prompt_text("Please provide project name")
+
     if framework is not None:
         framework_str = str(framework.value)
     else:

flwr/cli/new/templates/app/code/task.pytorch.py.tpl

@@ -1,6 +1,5 @@
 """$project_name: A Flower / PyTorch app."""
 
-import warnings
 from collections import OrderedDict
 
 import torch
@@ -9,7 +8,6 @@ import torch.nn.functional as F
 from torch.utils.data import DataLoader
 from torchvision.datasets import CIFAR10
 from torchvision.transforms import Compose, Normalize, ToTensor
-from tqdm import tqdm
 
 
 DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
@@ -77,7 +75,7 @@ def test(net, testloader):
     criterion = torch.nn.CrossEntropyLoss()
     correct, loss = 0, 0.0
     with torch.no_grad():
-        for images, labels in tqdm(testloader):
+        for images, labels in testloader:
             outputs = net(images.to(DEVICE))
             labels = labels.to(DEVICE)
             loss += criterion(outputs, labels).item()

flwr/cli/new/templates/app/pyproject.toml.tpl

@@ -15,7 +15,7 @@ readme = "README.md"
 [tool.poetry.dependencies]
 python = "^3.9"
 # Mandatory dependencies
-flwr-nightly = { version = "1.8.0.dev20240308", extras = ["simulation"] }
+flwr-nightly = { version = "1.8.0.dev20240309", extras = ["simulation"] }
 flwr-datasets = { version = "^0.0.2", extras = ["vision"] }
 torch = "2.2.1"
 torchvision = "0.17.1"

flwr/cli/new/templates/app/requirements.pytorch.txt.tpl

@@ -1,4 +1,4 @@
-flwr>=1.8, <2.0
-flwr-datasets[vision]>=0.0.2, <1.0.0
+flwr-nightly[simulation]==1.8.0.dev20240309
+flwr-datasets[vision]==0.0.2
 torch==2.2.1
 torchvision==0.17.1

flwr/cli/utils.py

@@ -14,11 +14,24 @@
 # ==============================================================================
 """Flower command line interface utils."""
 
-from typing import List
+from typing import List, cast
 
 import typer
 
 
+def prompt_text(text: str) -> str:
+    """Ask user to enter text input."""
+    while True:
+        result = typer.prompt(
+            typer.style(f"\n💬 {text}", fg=typer.colors.MAGENTA, bold=True)
+        )
+        if len(result) > 0:
+            break
+        print(typer.style("❌ Invalid entry", fg=typer.colors.RED, bold=True))
+
+    return cast(str, result)
+
+
 def prompt_options(text: str, options: List[str]) -> str:
     """Ask user to select one of the given options and return the selected item."""
     # Turn options into a list with index as in " [ 0] quickstart-pytorch"

flwr/client/app.py

@@ -25,7 +25,7 @@ from typing import Callable, ContextManager, Optional, Tuple, Type, Union
 from grpc import RpcError
 
 from flwr.client.client import Client
-from flwr.client.client_app import ClientApp
+from flwr.client.client_app import ClientApp, LoadClientAppError
 from flwr.client.typing import ClientFn
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH, EventType, Message, event
 from flwr.common.address import parse_address
@@ -38,9 +38,9 @@ from flwr.common.constant import (
 )
 from flwr.common.exit_handlers import register_exit_handlers
 from flwr.common.logger import log, warn_deprecated_feature, warn_experimental_feature
+from flwr.common.object_ref import load_app, validate
 from flwr.common.retry_invoker import RetryInvoker, exponential
 
-from .client_app import load_client_app
 from .grpc_client.connection import grpc_connection
 from .grpc_rere_client.connection import grpc_request_response
 from .message_handler.message_handler import handle_control_message
@@ -97,8 +97,19 @@ def run_client_app() -> None:
     if client_app_dir is not None:
         sys.path.insert(0, client_app_dir)
 
+    app_ref: str = getattr(args, "client-app")
+    valid, error_msg = validate(app_ref)
+    if not valid and error_msg:
+        raise LoadClientAppError(error_msg) from None
+
     def _load() -> ClientApp:
-        client_app: ClientApp = load_client_app(getattr(args, "client-app"))
+        client_app = load_app(app_ref, LoadClientAppError)
+
+        if not isinstance(client_app, ClientApp):
+            raise LoadClientAppError(
+                f"Attribute {app_ref} is not of type {ClientApp}",
+            ) from None
+
         return client_app
 
     _start_client_internal(
@@ -445,7 +456,19 @@ def _start_client_internal(
                     time.sleep(3)  # Wait for 3s before asking again
                     continue
 
-                log(INFO, "Received message")
+                log(INFO, "")
+                log(
+                    INFO,
+                    "[RUN %s, ROUND %s]",
+                    message.metadata.run_id,
+                    message.metadata.group_id,
+                )
+                log(
+                    INFO,
+                    "Received: %s message %s",
+                    message.metadata.message_type,
+                    message.metadata.message_id,
+                )
 
                 # Handle control message
                 out_message, sleep_duration = handle_control_message(message)
@@ -473,7 +496,18 @@ def _start_client_internal(
 
                 # Send
                 send(out_message)
-                log(INFO, "Sent reply")
+                log(
+                    INFO,
+                    "[RUN %s, ROUND %s]",
+                    out_message.metadata.run_id,
+                    out_message.metadata.group_id,
+                )
+                log(
+                    INFO,
+                    "Sent: %s reply to message %s",
+                    out_message.metadata.message_type,
+                    message.metadata.message_id,
+                )
 
             # Unregister node
             if delete_node is not None:

flwr/client/client_app.py

@@ -15,8 +15,7 @@
 """Flower ClientApp."""
 
 
-import importlib
-from typing import Callable, List, Optional, cast
+from typing import Callable, List, Optional
 
 from flwr.client.message_handler.message_handler import (
     handle_legacy_message_from_msgtype,
@@ -194,51 +193,6 @@ class LoadClientAppError(Exception):
     """Error when trying to load `ClientApp`."""
 
 
-def load_client_app(module_attribute_str: str) -> ClientApp:
-    """Load the `ClientApp` object specified in a module attribute string.
-
-    The module/attribute string should have the form <module>:<attribute>. Valid
-    examples include `client:app` and `project.package.module:wrapper.app`. It
-    must refer to a module on the PYTHONPATH, the module needs to have the specified
-    attribute, and the attribute must be of type `ClientApp`.
-    """
-    module_str, _, attributes_str = module_attribute_str.partition(":")
-    if not module_str:
-        raise LoadClientAppError(
-            f"Missing module in {module_attribute_str}",
-        ) from None
-    if not attributes_str:
-        raise LoadClientAppError(
-            f"Missing attribute in {module_attribute_str}",
-        ) from None
-
-    # Load module
-    try:
-        module = importlib.import_module(module_str)
-    except ModuleNotFoundError:
-        raise LoadClientAppError(
-            f"Unable to load module {module_str}",
-        ) from None
-
-    # Recursively load attribute
-    attribute = module
-    try:
-        for attribute_str in attributes_str.split("."):
-            attribute = getattr(attribute, attribute_str)
-    except AttributeError:
-        raise LoadClientAppError(
-            f"Unable to load attribute {attributes_str} from module {module_str}",
-        ) from None
-
-    # Check type
-    if not isinstance(attribute, ClientApp):
-        raise LoadClientAppError(
-            f"Attribute {attributes_str} is not of type {ClientApp}",
-        ) from None
-
-    return cast(ClientApp, attribute)
-
-
 def _registration_error(fn_name: str) -> ValueError:
     return ValueError(
         f"""Use either `@app.{fn_name}()` or `client_fn`, but not both.

flwr/client/mod/__init__.py

@@ -17,7 +17,7 @@
 
 from .centraldp_mods import adaptiveclipping_mod, fixedclipping_mod
 from .localdp_mod import LocalDpMod
-from .secure_aggregation.secaggplus_mod import secaggplus_mod
+from .secure_aggregation import secagg_mod, secaggplus_mod
 from .utils import make_ffn
 
 __all__ = [
@@ -25,5 +25,6 @@ __all__ = [
     "fixedclipping_mod",
     "LocalDpMod",
     "make_ffn",
+    "secagg_mod",
     "secaggplus_mod",
 ]

flwr/client/mod/secure_aggregation/__init__.py

@@ -15,8 +15,10 @@
 """Secure Aggregation mods."""
 
 
+from .secagg_mod import secagg_mod
 from .secaggplus_mod import secaggplus_mod
 
 __all__ = [
+    "secagg_mod",
     "secaggplus_mod",
 ]

flwr/client/mod/secure_aggregation/secagg_mod.py

@@ -0,0 +1,30 @@
+# Copyright 2024 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.
+# ==============================================================================
+"""Modifier for the SecAgg protocol."""
+
+
+from flwr.client.typing import ClientAppCallable
+from flwr.common import Context, Message
+
+from .secaggplus_mod import secaggplus_mod
+
+
+def secagg_mod(
+    msg: Message,
+    ctxt: Context,
+    call_next: ClientAppCallable,
+) -> Message:
+    """Handle incoming message and return results, following the SecAgg protocol."""
+    return secaggplus_mod(msg, ctxt, call_next)