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

flwr/server/superlink/fleet/rest_rere/rest_api.py

@@ -17,22 +17,26 @@
 
 from __future__ import annotations
 
-from collections.abc import Awaitable
-from typing import Callable, TypeVar, cast
+from collections.abc import Awaitable, Callable
+from typing import TypeVar, cast
 
 from google.protobuf.message import Message as GrpcMessage
 
 from flwr.common.exit import ExitCode, flwr_exit
 from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
-    CreateNodeRequest,
-    CreateNodeResponse,
-    DeleteNodeRequest,
-    DeleteNodeResponse,
+    ActivateNodeRequest,
+    ActivateNodeResponse,
+    DeactivateNodeRequest,
+    DeactivateNodeResponse,
     PullMessagesRequest,
     PullMessagesResponse,
     PushMessagesRequest,
     PushMessagesResponse,
+    RegisterNodeFleetRequest,
+    RegisterNodeFleetResponse,
+    UnregisterNodeFleetRequest,
+    UnregisterNodeFleetResponse,
 )
 from flwr.proto.heartbeat_pb2 import (  # pylint: disable=E0611
     SendNodeHeartbeatRequest,
@@ -69,6 +73,8 @@ GrpcResponse = TypeVar("GrpcResponse", bound=GrpcMessage)
 GrpcAsyncFunction = Callable[[GrpcRequest], Awaitable[GrpcResponse]]
 RestEndPoint = Callable[[Request], Awaitable[Response]]
 
+routes = []
+
 
 def rest_request_response(
     grpc_request_type: type[GrpcRequest],
@@ -76,6 +82,7 @@ def rest_request_response(
     """Convert an async gRPC-based function into a RESTful HTTP endpoint."""
 
     def decorator(func: GrpcAsyncFunction[GrpcRequest, GrpcResponse]) -> RestEndPoint:
+
         async def wrapper(request: Request) -> Response:
             _check_headers(request.headers)
 
@@ -91,33 +98,64 @@ def rest_request_response(
                 headers={"Content-Type": "application/protobuf"},
             )
 
+        # Register route
+        path = f"/api/v0/fleet/{func.__name__.replace('_', '-')}"
+        routes.append(Route(path, wrapper, methods=["POST"]))
         return wrapper
 
     return decorator
 
 
-@rest_request_response(CreateNodeRequest)
-async def create_node(request: CreateNodeRequest) -> CreateNodeResponse:
-    """Create Node."""
+@rest_request_response(RegisterNodeFleetRequest)
+async def register_node(
+    request: RegisterNodeFleetRequest,
+) -> RegisterNodeFleetResponse:
+    """Register a node (Fleet API only)."""
+    # Get state from app
+    state: LinkState = cast(LinkStateFactory, app.state.STATE_FACTORY).state()
+
+    # Handle message
+    return message_handler.register_node(request=request, state=state)
+
+
+@rest_request_response(ActivateNodeRequest)
+async def activate_node(
+    request: ActivateNodeRequest,
+) -> ActivateNodeResponse:
+    """Activate a node."""
     # Get state from app
     state: LinkState = cast(LinkStateFactory, app.state.STATE_FACTORY).state()
 
     # Handle message
-    return message_handler.create_node(request=request, state=state)
+    return message_handler.activate_node(request=request, state=state)
 
 
-@rest_request_response(DeleteNodeRequest)
-async def delete_node(request: DeleteNodeRequest) -> DeleteNodeResponse:
-    """Delete Node Id."""
+@rest_request_response(DeactivateNodeRequest)
+async def deactivate_node(
+    request: DeactivateNodeRequest,
+) -> DeactivateNodeResponse:
+    """Deactivate a node."""
     # Get state from app
     state: LinkState = cast(LinkStateFactory, app.state.STATE_FACTORY).state()
 
     # Handle message
-    return message_handler.delete_node(request=request, state=state)
+    return message_handler.deactivate_node(request=request, state=state)
+
+
+@rest_request_response(UnregisterNodeFleetRequest)
+async def unregister_node(
+    request: UnregisterNodeFleetRequest,
+) -> UnregisterNodeFleetResponse:
+    """Unregister a node (Fleet API only)."""
+    # Get state from app
+    state: LinkState = cast(LinkStateFactory, app.state.STATE_FACTORY).state()
+
+    # Handle message
+    return message_handler.unregister_node(request=request, state=state)
 
 
 @rest_request_response(PullMessagesRequest)
-async def pull_message(request: PullMessagesRequest) -> PullMessagesResponse:
+async def pull_messages(request: PullMessagesRequest) -> PullMessagesResponse:
     """Pull PullMessages."""
     # Get state from app
     state: LinkState = cast(LinkStateFactory, app.state.STATE_FACTORY).state()
@@ -128,7 +166,7 @@ async def pull_message(request: PullMessagesRequest) -> PullMessagesResponse:
 
 
 @rest_request_response(PushMessagesRequest)
-async def push_message(request: PushMessagesRequest) -> PushMessagesResponse:
+async def push_messages(request: PushMessagesRequest) -> PushMessagesResponse:
     """Pull PushMessages."""
     # Get state from app
     state: LinkState = cast(LinkStateFactory, app.state.STATE_FACTORY).state()
@@ -212,23 +250,6 @@ async def confirm_message_received(
     )
 
 
-routes = [
-    Route("/api/v0/fleet/create-node", create_node, methods=["POST"]),
-    Route("/api/v0/fleet/delete-node", delete_node, methods=["POST"]),
-    Route("/api/v0/fleet/pull-messages", pull_message, methods=["POST"]),
-    Route("/api/v0/fleet/push-messages", push_message, methods=["POST"]),
-    Route("/api/v0/fleet/pull-object", pull_object, methods=["POST"]),
-    Route("/api/v0/fleet/push-object", push_object, methods=["POST"]),
-    Route("/api/v0/fleet/send-node-heartbeat", send_node_heartbeat, methods=["POST"]),
-    Route("/api/v0/fleet/get-run", get_run, methods=["POST"]),
-    Route("/api/v0/fleet/get-fab", get_fab, methods=["POST"]),
-    Route(
-        "/api/v0/fleet/confirm-message-received",
-        confirm_message_received,
-        methods=["POST"],
-    ),
-]
-
 app: Starlette = Starlette(
     debug=False,
     routes=routes,

flwr/server/superlink/fleet/vce/backend/backend.py

@@ -16,9 +16,9 @@
 
 
 from abc import ABC, abstractmethod
-from typing import Callable
+from collections.abc import Callable
 
-from flwr.client.client_app import ClientApp
+from flwr.clientapp.client_app import ClientApp
 from flwr.common.context import Context
 from flwr.common.message import Message
 from flwr.common.typing import ConfigRecordValues

flwr/server/superlink/fleet/vce/backend/raybackend.py

@@ -16,12 +16,12 @@
 
 
 import sys
+from collections.abc import Callable
 from logging import DEBUG, ERROR
-from typing import Callable, Optional, Union
 
 import ray
 
-from flwr.client.client_app import ClientApp
+from flwr.clientapp.client_app import ClientApp
 from flwr.common.constant import PARTITION_ID_KEY
 from flwr.common.context import Context
 from flwr.common.logger import log
@@ -32,8 +32,8 @@ from flwr.simulation.ray_transport.utils import enable_tf_gpu_growth
 
 from .backend import Backend, BackendConfig
 
-ClientResourcesDict = dict[str, Union[int, float]]
-ActorArgsDict = dict[str, Union[int, float, Callable[[], None]]]
+ClientResourcesDict = dict[str, int | float]
+ActorArgsDict = dict[str, int | float | Callable[[], None]]
 
 
 class RayBackend(Backend):
@@ -57,9 +57,9 @@ class RayBackend(Backend):
 
         # Valide actor resources
         self.actor_kwargs = self._validate_actor_arguments(config=backend_config)
-        self.pool: Optional[BasicActorPool] = None
+        self.pool: BasicActorPool | None = None
 
-        self.app_fn: Optional[Callable[[], ClientApp]] = None
+        self.app_fn: Callable[[], ClientApp] | None = None
 
     def _validate_client_resources(self, config: BackendConfig) -> ClientResourcesDict:
         client_resources_config = config.get(self.client_resources_key)

flwr/server/superlink/fleet/vce/vce_api.py

@@ -16,23 +16,26 @@
 
 
 import json
+import secrets
 import threading
 import time
 import traceback
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
 from logging import DEBUG, ERROR, INFO, WARN
 from pathlib import Path
 from queue import Empty, Queue
-from typing import Callable, Optional
 from uuid import uuid4
 
 from flwr.app.error import Error
-from flwr.client.client_app import ClientApp, ClientAppException, LoadClientAppError
-from flwr.client.clientapp.utils import get_load_client_app_fn
 from flwr.client.run_info_store import DeprecatedRunInfoStore
+from flwr.clientapp.client_app import ClientApp, ClientAppException, LoadClientAppError
+from flwr.clientapp.utils import get_load_client_app_fn
 from flwr.common import Message
 from flwr.common.constant import (
-    HEARTBEAT_MAX_INTERVAL,
+    HEARTBEAT_INTERVAL_INF,
+    NOOP_ACCOUNT_NAME,
+    NOOP_FLWR_AID,
     NUM_PARTITIONS_KEY,
     PARTITION_ID_KEY,
     ErrorCode,
@@ -40,6 +43,9 @@ from flwr.common.constant import (
 from flwr.common.logger import log
 from flwr.common.typing import Run
 from flwr.server.superlink.linkstate import LinkState, LinkStateFactory
+from flwr.supercore.constant import FLWR_IN_MEMORY_DB_NAME
+from flwr.supercore.object_store import ObjectStoreFactory
+from flwr.superlink.federation import NoOpFederationManager
 
 from .backend import Backend, error_messages_backends, supported_backends
 
@@ -53,7 +59,18 @@ def _register_nodes(
     nodes_mapping: NodeToPartitionMapping = {}
     state = state_factory.state()
     for i in range(num_nodes):
-        node_id = state.create_node(heartbeat_interval=HEARTBEAT_MAX_INTERVAL)
+        node_id = state.create_node(
+            # No node authentication in simulation;
+            # use NOOP_FLWR_AID as owner_aid and
+            # use random bytes as public key
+            NOOP_FLWR_AID,
+            NOOP_ACCOUNT_NAME,
+            secrets.token_bytes(32),
+            heartbeat_interval=HEARTBEAT_INTERVAL_INF,
+        )
+        state.acknowledge_node_heartbeat(
+            node_id=node_id, heartbeat_interval=HEARTBEAT_INTERVAL_INF
+        )
         nodes_mapping[node_id] = i
     log(DEBUG, "Registered %i nodes", len(nodes_mapping))
     return nodes_mapping
@@ -62,7 +79,7 @@ def _register_nodes(
 def _register_node_info_stores(
     nodes_mapping: NodeToPartitionMapping,
     run: Run,
-    app_dir: Optional[str] = None,
+    app_dir: str | None = None,
 ) -> dict[int, DeprecatedRunInfoStore]:
     """Create DeprecatedRunInfoStore objects and register the context for the run."""
     node_info_store: dict[int, DeprecatedRunInfoStore] = {}
@@ -257,12 +274,12 @@ def start_vce(
     is_app: bool,
     f_stop: threading.Event,
     run: Run,
-    flwr_dir: Optional[str] = None,
-    client_app: Optional[ClientApp] = None,
-    client_app_attr: Optional[str] = None,
-    num_supernodes: Optional[int] = None,
-    state_factory: Optional[LinkStateFactory] = None,
-    existing_nodes_mapping: Optional[NodeToPartitionMapping] = None,
+    flwr_dir: str | None = None,
+    client_app: ClientApp | None = None,
+    client_app_attr: str | None = None,
+    num_supernodes: int | None = None,
+    state_factory: LinkStateFactory | None = None,
+    existing_nodes_mapping: NodeToPartitionMapping | None = None,
 ) -> None:
     """Start Fleet API with the Simulation Engine."""
     nodes_mapping = {}
@@ -300,7 +317,9 @@ def start_vce(
     if not state_factory:
         log(INFO, "A StateFactory was not supplied to the SimulationEngine.")
         # Create an empty in-memory state factory
-        state_factory = LinkStateFactory(":flwr-in-memory-state:")
+        state_factory = LinkStateFactory(
+            FLWR_IN_MEMORY_DB_NAME, NoOpFederationManager(), ObjectStoreFactory()
+        )
         log(INFO, "Created new %s.", state_factory.__class__.__name__)
 
     if num_supernodes: