flwr-nightly 1.11.0.dev20240823__tar.gz → 1.11.0.dev20240824__tar.gz

{flwr_nightly-1.11.0.dev20240823 → flwr_nightly-1.11.0.dev20240824}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.11.0.dev20240823
+Version: 1.11.0.dev20240824
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -196,7 +196,7 @@ Other [examples](https://github.com/adap/flower/tree/main/examples):
 - [Vertical FL](https://github.com/adap/flower/tree/main/examples/vertical-fl)
 - [Federated Finetuning of OpenAI's Whisper](https://github.com/adap/flower/tree/main/examples/whisper-federated-finetuning)
 - [Federated Finetuning of Large Language Model](https://github.com/adap/flower/tree/main/examples/llm-flowertune)
-- [Federated Finetuning of a Vision Transformer](https://github.com/adap/flower/tree/main/examples/vit-finetune)
+- [Federated Finetuning of a Vision Transformer](https://github.com/adap/flower/tree/main/examples/flowertune-vit)
 - [Advanced Flower with TensorFlow/Keras](https://github.com/adap/flower/tree/main/examples/advanced-tensorflow)
 - [Advanced Flower with PyTorch](https://github.com/adap/flower/tree/main/examples/advanced-pytorch)
 - Single-Machine Simulation of Federated Learning Systems ([PyTorch](https://github.com/adap/flower/tree/main/examples/simulation-pytorch)) ([Tensorflow](https://github.com/adap/flower/tree/main/examples/simulation-tensorflow))

{flwr_nightly-1.11.0.dev20240823 → flwr_nightly-1.11.0.dev20240824}/README.md

@@ -144,7 +144,7 @@ Other [examples](https://github.com/adap/flower/tree/main/examples):
 - [Vertical FL](https://github.com/adap/flower/tree/main/examples/vertical-fl)
 - [Federated Finetuning of OpenAI's Whisper](https://github.com/adap/flower/tree/main/examples/whisper-federated-finetuning)
 - [Federated Finetuning of Large Language Model](https://github.com/adap/flower/tree/main/examples/llm-flowertune)
-- [Federated Finetuning of a Vision Transformer](https://github.com/adap/flower/tree/main/examples/vit-finetune)
+- [Federated Finetuning of a Vision Transformer](https://github.com/adap/flower/tree/main/examples/flowertune-vit)
 - [Advanced Flower with TensorFlow/Keras](https://github.com/adap/flower/tree/main/examples/advanced-tensorflow)
 - [Advanced Flower with PyTorch](https://github.com/adap/flower/tree/main/examples/advanced-pytorch)
 - Single-Machine Simulation of Federated Learning Systems ([PyTorch](https://github.com/adap/flower/tree/main/examples/simulation-pytorch)) ([Tensorflow](https://github.com/adap/flower/tree/main/examples/simulation-tensorflow))

{flwr_nightly-1.11.0.dev20240823 → flwr_nightly-1.11.0.dev20240824}/pyproject.toml

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

{flwr_nightly-1.11.0.dev20240823 → flwr_nightly-1.11.0.dev20240824}/src/py/flwr/server/app.py

@@ -278,24 +278,24 @@ def run_superlink() -> None:
         fleet_thread.start()
         bckg_threads.append(fleet_thread)
     elif args.fleet_api_type == TRANSPORT_TYPE_GRPC_RERE:
-        maybe_keys = _try_setup_client_authentication(args, certificates)
+        maybe_keys = _try_setup_node_authentication(args, certificates)
         interceptors: Optional[Sequence[grpc.ServerInterceptor]] = None
         if maybe_keys is not None:
             (
-                client_public_keys,
+                node_public_keys,
                 server_private_key,
                 server_public_key,
             ) = maybe_keys
             state = state_factory.state()
-            state.store_client_public_keys(client_public_keys)
+            state.store_node_public_keys(node_public_keys)
             state.store_server_private_public_key(
                 private_key_to_bytes(server_private_key),
                 public_key_to_bytes(server_public_key),
             )
             log(
                 INFO,
-                "Client authentication enabled with %d known public keys",
-                len(client_public_keys),
+                "Node authentication enabled with %d known public keys",
+                len(node_public_keys),
             )
             interceptors = [AuthenticateServerInterceptor(state)]
 
@@ -344,7 +344,7 @@ def _format_address(address: str) -> Tuple[str, str, int]:
     return (f"[{host}]:{port}" if is_v6 else f"{host}:{port}", host, port)
 
 
-def _try_setup_client_authentication(
+def _try_setup_node_authentication(
     args: argparse.Namespace,
     certificates: Optional[Tuple[bytes, bytes, bytes]],
 ) -> Optional[Tuple[Set[bytes], ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]]:
@@ -373,16 +373,16 @@ def _try_setup_client_authentication(
             "`--ssl-keyfile`, and `—-ssl-ca-certfile` and try again."
         )
 
-    client_keys_file_path = Path(args.auth_list_public_keys)
-    if not client_keys_file_path.exists():
+    node_keys_file_path = Path(args.auth_list_public_keys)
+    if not node_keys_file_path.exists():
         sys.exit(
             "The provided path to the known public keys CSV file does not exist: "
-            f"{client_keys_file_path}. "
+            f"{node_keys_file_path}. "
             "Please provide the CSV file path containing known public keys "
             "to '--auth-list-public-keys'."
         )
 
-    client_public_keys: Set[bytes] = set()
+    node_public_keys: Set[bytes] = set()
 
     try:
         ssh_private_key = load_ssh_private_key(
@@ -413,13 +413,13 @@ def _try_setup_client_authentication(
             "path points to a valid public key file and try again."
         )
 
-    with open(client_keys_file_path, newline="", encoding="utf-8") as csvfile:
+    with open(node_keys_file_path, newline="", encoding="utf-8") as csvfile:
         reader = csv.reader(csvfile)
         for row in reader:
             for element in row:
                 public_key = load_ssh_public_key(element.encode())
                 if isinstance(public_key, ec.EllipticCurvePublicKey):
-                    client_public_keys.add(public_key_to_bytes(public_key))
+                    node_public_keys.add(public_key_to_bytes(public_key))
                 else:
                     sys.exit(
                         "Error: Unable to parse the public keys in the CSV "
@@ -427,7 +427,7 @@ def _try_setup_client_authentication(
                         "known SSH public keys files and try again."
                     )
         return (
-            client_public_keys,
+            node_public_keys,
             ssh_private_key,
             ssh_public_key,
         )

{flwr_nightly-1.11.0.dev20240823 → flwr_nightly-1.11.0.dev20240824}/src/py/flwr/server/run_serverapp.py

@@ -97,6 +97,21 @@ def run_server_app() -> None:
 
     args = _parse_args_run_server_app().parse_args()
 
+    # Check if the server app reference is passed.
+    # Since Flower 1.11, passing a reference is not allowed.
+    app_path: Optional[str] = args.app
+    # If the provided app_path doesn't exist, and contains a ":",
+    # it is likely to be a server app reference instead of a path.
+    if app_path is not None and not Path(app_path).exists() and ":" in app_path:
+        sys.exit(
+            "It appears you've passed a reference like `server:app`.\n\n"
+            "Note that since version `1.11.0`, `flower-server-app` no longer supports "
+            "passing a reference to a `ServerApp` attribute. Instead, you need to pass "
+            "the path to Flower app via the argument `--app`. This is the path to a "
+            "directory containing a `pyproject.toml`. You can create a valid Flower "
+            "app by executing `flwr new` and following the prompt."
+        )
+
     if args.server != ADDRESS_DRIVER_API:
         warn = "Passing flag --server is deprecated. Use --superlink instead."
         warn_deprecated_feature(warn)
@@ -151,7 +166,6 @@ def run_server_app() -> None:
             cert_path,
         )
 
-    app_path: Optional[str] = args.app
     if not (app_path is None) ^ (args.run_id is None):
         raise sys.exit(
             "Please provide either a Flower App path or a Run ID, but not both. "

{flwr_nightly-1.11.0.dev20240823 → flwr_nightly-1.11.0.dev20240824}/src/py/flwr/server/superlink/fleet/grpc_rere/fleet_servicer.py

@@ -51,19 +51,22 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         self, request: CreateNodeRequest, context: grpc.ServicerContext
     ) -> CreateNodeResponse:
         """."""
-        log(INFO, "FleetServicer.CreateNode")
+        log(INFO, "[Fleet.CreateNode] Request ping_interval=%s", request.ping_interval)
+        log(DEBUG, "[Fleet.CreateNode] Request: %s", request)
         response = message_handler.create_node(
             request=request,
             state=self.state_factory.state(),
         )
-        log(INFO, "FleetServicer: Created node_id=%s", response.node.node_id)
+        log(INFO, "[Fleet.CreateNode] Created node_id=%s", response.node.node_id)
+        log(DEBUG, "[Fleet.CreateNode] Response: %s", response)
         return response
 
     def DeleteNode(
         self, request: DeleteNodeRequest, context: grpc.ServicerContext
     ) -> DeleteNodeResponse:
         """."""
-        log(INFO, "FleetServicer.DeleteNode")
+        log(INFO, "[Fleet.DeleteNode] Delete node_id=%s", request.node.node_id)
+        log(DEBUG, "[Fleet.DeleteNode] Request: %s", request)
         return message_handler.delete_node(
             request=request,
             state=self.state_factory.state(),
@@ -71,7 +74,7 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
 
     def Ping(self, request: PingRequest, context: grpc.ServicerContext) -> PingResponse:
         """."""
-        log(DEBUG, "FleetServicer.Ping")
+        log(DEBUG, "[Fleet.Ping] Request: %s", request)
         return message_handler.ping(
             request=request,
             state=self.state_factory.state(),
@@ -81,7 +84,8 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         self, request: PullTaskInsRequest, context: grpc.ServicerContext
     ) -> PullTaskInsResponse:
         """Pull TaskIns."""
-        log(INFO, "FleetServicer.PullTaskIns")
+        log(INFO, "[Fleet.PullTaskIns] node_id=%s", request.node.node_id)
+        log(DEBUG, "[Fleet.PullTaskIns] Request: %s", request)
         return message_handler.pull_task_ins(
             request=request,
             state=self.state_factory.state(),
@@ -91,7 +95,14 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         self, request: PushTaskResRequest, context: grpc.ServicerContext
     ) -> PushTaskResResponse:
         """Push TaskRes."""
-        log(INFO, "FleetServicer.PushTaskRes")
+        if request.task_res_list:
+            log(
+                INFO,
+                "[Fleet.PushTaskRes] Push results from node_id=%s",
+                request.task_res_list[0].task.producer.node_id,
+            )
+        else:
+            log(INFO, "[Fleet.PushTaskRes] No task results to push")
         return message_handler.push_task_res(
             request=request,
             state=self.state_factory.state(),
@@ -101,7 +112,7 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         self, request: GetRunRequest, context: grpc.ServicerContext
     ) -> GetRunResponse:
         """Get run information."""
-        log(INFO, "FleetServicer.GetRun")
+        log(INFO, "[Fleet.GetRun] Requesting `Run` for run_id=%s", request.run_id)
         return message_handler.get_run(
             request=request,
             state=self.state_factory.state(),
@@ -111,7 +122,7 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         self, request: GetFabRequest, context: grpc.ServicerContext
     ) -> GetFabResponse:
         """Get FAB."""
-        log(DEBUG, "DriverServicer.GetFab")
+        log(INFO, "[Fleet.GetFab] Requesting FAB for fab_hash=%s", request.hash_str)
         return message_handler.get_fab(
             request=request,
             ffs=self.ffs_factory.ffs(),

{flwr_nightly-1.11.0.dev20240823 → flwr_nightly-1.11.0.dev20240824}/src/py/flwr/server/superlink/fleet/grpc_rere/server_interceptor.py

@@ -78,13 +78,13 @@ def _get_value_from_tuples(
 
 
 class AuthenticateServerInterceptor(grpc.ServerInterceptor):  # type: ignore
-    """Server interceptor for client authentication."""
+    """Server interceptor for node authentication."""
 
     def __init__(self, state: State):
         self.state = state
 
-        self.client_public_keys = state.get_client_public_keys()
-        if len(self.client_public_keys) == 0:
+        self.node_public_keys = state.get_node_public_keys()
+        if len(self.node_public_keys) == 0:
             log(WARNING, "Authentication enabled, but no known public keys configured")
 
         private_key = self.state.get_server_private_key()
@@ -103,9 +103,9 @@ class AuthenticateServerInterceptor(grpc.ServerInterceptor):  # type: ignore
     ) -> grpc.RpcMethodHandler:
         """Flower server interceptor authentication logic.
 
-        Intercept all unary calls from clients and authenticate clients by validating
-        auth metadata sent by the client. Continue RPC call if client is authenticated,
-        else, terminate RPC call by setting context to abort.
+        Intercept all unary calls from nodes and authenticate nodes by validating auth
+        metadata sent by the node. Continue RPC call if node is authenticated, else,
+        terminate RPC call by setting context to abort.
         """
         # One of the method handlers in
         # `flwr.server.superlink.fleet.grpc_rere.fleet_server.FleetServicer`
@@ -119,17 +119,17 @@ class AuthenticateServerInterceptor(grpc.ServerInterceptor):  # type: ignore
             request: Request,
             context: grpc.ServicerContext,
         ) -> Response:
-            client_public_key_bytes = base64.urlsafe_b64decode(
+            node_public_key_bytes = base64.urlsafe_b64decode(
                 _get_value_from_tuples(
                     _PUBLIC_KEY_HEADER, context.invocation_metadata()
                 )
             )
-            if client_public_key_bytes not in self.client_public_keys:
+            if node_public_key_bytes not in self.node_public_keys:
                 context.abort(grpc.StatusCode.UNAUTHENTICATED, "Access denied")
 
             if isinstance(request, CreateNodeRequest):
                 response = self._create_authenticated_node(
-                    client_public_key_bytes, request, context
+                    node_public_key_bytes, request, context
                 )
                 log(
                     INFO,
@@ -144,13 +144,13 @@ class AuthenticateServerInterceptor(grpc.ServerInterceptor):  # type: ignore
                     _AUTH_TOKEN_HEADER, context.invocation_metadata()
                 )
             )
-            public_key = bytes_to_public_key(client_public_key_bytes)
+            public_key = bytes_to_public_key(node_public_key_bytes)
 
             if not self._verify_hmac(public_key, request, hmac_value):
                 context.abort(grpc.StatusCode.UNAUTHENTICATED, "Access denied")
 
             # Verify node_id
-            node_id = self.state.get_node_id(client_public_key_bytes)
+            node_id = self.state.get_node_id(node_public_key_bytes)
 
             if not self._verify_node_id(node_id, request):
                 context.abort(grpc.StatusCode.UNAUTHENTICATED, "Access denied")

{flwr_nightly-1.11.0.dev20240823 → flwr_nightly-1.11.0.dev20240824}/src/py/flwr/server/superlink/state/in_memory_state.py

@@ -45,7 +45,7 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
         self.task_ins_store: Dict[UUID, TaskIns] = {}
         self.task_res_store: Dict[UUID, TaskRes] = {}
 
-        self.client_public_keys: Set[bytes] = set()
+        self.node_public_keys: Set[bytes] = set()
         self.server_public_key: Optional[bytes] = None
         self.server_private_key: Optional[bytes] = None
 
@@ -237,7 +237,7 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
             return node_id
 
     def delete_node(self, node_id: int, public_key: Optional[bytes] = None) -> None:
-        """Delete a client node."""
+        """Delete a node."""
         with self.lock:
             if node_id not in self.node_ids:
                 raise ValueError(f"Node {node_id} not found")
@@ -254,7 +254,7 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
             del self.node_ids[node_id]
 
     def get_nodes(self, run_id: int) -> Set[int]:
-        """Return all available client nodes.
+        """Return all available nodes.
 
         Constraints
         -----------
@@ -271,9 +271,9 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
                 if online_until > current_time
             }
 
-    def get_node_id(self, client_public_key: bytes) -> Optional[int]:
-        """Retrieve stored `node_id` filtered by `client_public_keys`."""
-        return self.public_key_to_node_id.get(client_public_key)
+    def get_node_id(self, node_public_key: bytes) -> Optional[int]:
+        """Retrieve stored `node_id` filtered by `node_public_keys`."""
+        return self.public_key_to_node_id.get(node_public_key)
 
     def create_run(
         self,
@@ -318,19 +318,19 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
         """Retrieve `server_public_key` in urlsafe bytes."""
         return self.server_public_key
 
-    def store_client_public_keys(self, public_keys: Set[bytes]) -> None:
-        """Store a set of `client_public_keys` in state."""
+    def store_node_public_keys(self, public_keys: Set[bytes]) -> None:
+        """Store a set of `node_public_keys` in state."""
         with self.lock:
-            self.client_public_keys = public_keys
+            self.node_public_keys = public_keys
 
-    def store_client_public_key(self, public_key: bytes) -> None:
-        """Store a `client_public_key` in state."""
+    def store_node_public_key(self, public_key: bytes) -> None:
+        """Store a `node_public_key` in state."""
         with self.lock:
-            self.client_public_keys.add(public_key)
+            self.node_public_keys.add(public_key)
 
-    def get_client_public_keys(self) -> Set[bytes]:
-        """Retrieve all currently stored `client_public_keys` as a set."""
-        return self.client_public_keys
+    def get_node_public_keys(self) -> Set[bytes]:
+        """Retrieve all currently stored `node_public_keys` as a set."""
+        return self.node_public_keys
 
     def get_run(self, run_id: int) -> Optional[Run]:
         """Retrieve information about the run with the specified `run_id`."""

{flwr_nightly-1.11.0.dev20240823 → flwr_nightly-1.11.0.dev20240824}/src/py/flwr/server/superlink/state/sqlite_state.py

@@ -569,7 +569,7 @@ class SqliteState(State):  # pylint: disable=R0904
         return node_id
 
     def delete_node(self, node_id: int, public_key: Optional[bytes] = None) -> None:
-        """Delete a client node."""
+        """Delete a node."""
         query = "DELETE FROM node WHERE node_id = ?"
         params = (node_id,)
 
@@ -607,10 +607,10 @@ class SqliteState(State):  # pylint: disable=R0904
         result: Set[int] = {row["node_id"] for row in rows}
         return result
 
-    def get_node_id(self, client_public_key: bytes) -> Optional[int]:
-        """Retrieve stored `node_id` filtered by `client_public_keys`."""
+    def get_node_id(self, node_public_key: bytes) -> Optional[int]:
+        """Retrieve stored `node_id` filtered by `node_public_keys`."""
         query = "SELECT node_id FROM node WHERE public_key = :public_key;"
-        row = self.query(query, {"public_key": client_public_key})
+        row = self.query(query, {"public_key": node_public_key})
         if len(row) > 0:
             node_id: int = row[0]["node_id"]
             return node_id
@@ -684,19 +684,19 @@ class SqliteState(State):  # pylint: disable=R0904
             public_key = None
         return public_key
 
-    def store_client_public_keys(self, public_keys: Set[bytes]) -> None:
-        """Store a set of `client_public_keys` in state."""
+    def store_node_public_keys(self, public_keys: Set[bytes]) -> None:
+        """Store a set of `node_public_keys` in state."""
         query = "INSERT INTO public_key (public_key) VALUES (?)"
         data = [(key,) for key in public_keys]
         self.query(query, data)
 
-    def store_client_public_key(self, public_key: bytes) -> None:
-        """Store a `client_public_key` in state."""
+    def store_node_public_key(self, public_key: bytes) -> None:
+        """Store a `node_public_key` in state."""
         query = "INSERT INTO public_key (public_key) VALUES (:public_key)"
         self.query(query, {"public_key": public_key})
 
-    def get_client_public_keys(self) -> Set[bytes]:
-        """Retrieve all currently stored `client_public_keys` as a set."""
+    def get_node_public_keys(self) -> Set[bytes]:
+        """Retrieve all currently stored `node_public_keys` as a set."""
         query = "SELECT public_key FROM public_key"
         rows = self.query(query)
         result: Set[bytes] = {row["public_key"] for row in rows}

{flwr_nightly-1.11.0.dev20240823 → flwr_nightly-1.11.0.dev20240824}/src/py/flwr/server/superlink/state/state.py

@@ -153,8 +153,8 @@ class State(abc.ABC):  # pylint: disable=R0904
         """
 
     @abc.abstractmethod
-    def get_node_id(self, client_public_key: bytes) -> Optional[int]:
-        """Retrieve stored `node_id` filtered by `client_public_keys`."""
+    def get_node_id(self, node_public_key: bytes) -> Optional[int]:
+        """Retrieve stored `node_id` filtered by `node_public_keys`."""
 
     @abc.abstractmethod
     def create_run(
@@ -199,16 +199,16 @@ class State(abc.ABC):  # pylint: disable=R0904
         """Retrieve `server_public_key` in urlsafe bytes."""
 
     @abc.abstractmethod
-    def store_client_public_keys(self, public_keys: Set[bytes]) -> None:
-        """Store a set of `client_public_keys` in state."""
+    def store_node_public_keys(self, public_keys: Set[bytes]) -> None:
+        """Store a set of `node_public_keys` in state."""
 
     @abc.abstractmethod
-    def store_client_public_key(self, public_key: bytes) -> None:
-        """Store a `client_public_key` in state."""
+    def store_node_public_key(self, public_key: bytes) -> None:
+        """Store a `node_public_key` in state."""
 
     @abc.abstractmethod
-    def get_client_public_keys(self) -> Set[bytes]:
-        """Retrieve all currently stored `client_public_keys` as a set."""
+    def get_node_public_keys(self) -> Set[bytes]:
+        """Retrieve all currently stored `node_public_keys` as a set."""
 
     @abc.abstractmethod
     def acknowledge_ping(self, node_id: int, ping_interval: float) -> bool: