flwr-nightly 1.23.0.dev20251029__tar.gz → 1.23.0.dev20251030__tar.gz

{flwr_nightly-1.23.0.dev20251029 → flwr_nightly-1.23.0.dev20251030}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.23.0.dev20251029
+Version: 1.23.0.dev20251030
 Summary: Flower: A Friendly Federated AI Framework
 License: Apache-2.0
 Keywords: Artificial Intelligence,Federated AI,Federated Analytics,Federated Evaluation,Federated Learning,Flower,Machine Learning

{flwr_nightly-1.23.0.dev20251029 → flwr_nightly-1.23.0.dev20251030}/py/flwr/common/constant.py

@@ -62,7 +62,9 @@ HEARTBEAT_DEFAULT_INTERVAL = 30
 HEARTBEAT_CALL_TIMEOUT = 5
 HEARTBEAT_BASE_MULTIPLIER = 0.8
 HEARTBEAT_RANDOM_RANGE = (-0.1, 0.1)
-HEARTBEAT_MAX_INTERVAL = 1e300
+HEARTBEAT_MIN_INTERVAL = 10
+HEARTBEAT_MAX_INTERVAL = 1800  # 30 minutes
+HEARTBEAT_INTERVAL_INF = 1e300  # Large value, disabling heartbeats
 HEARTBEAT_PATIENCE = 2
 RUN_FAILURE_DETAILS_NO_HEARTBEAT = "No heartbeat received from the run."
 

{flwr_nightly-1.23.0.dev20251029 → flwr_nightly-1.23.0.dev20251030}/py/flwr/server/superlink/fleet/grpc_rere/fleet_servicer.py

@@ -21,7 +21,10 @@ from logging import DEBUG, ERROR, INFO
 import grpc
 from google.protobuf.json_format import MessageToDict
 
-from flwr.common.constant import SUPERNODE_NOT_CREATED_FROM_CLI_MESSAGE
+from flwr.common.constant import (
+    PUBLIC_KEY_ALREADY_IN_USE_MESSAGE,
+    SUPERNODE_NOT_CREATED_FROM_CLI_MESSAGE,
+)
 from flwr.common.inflatable import UnexpectedObjectContentError
 from flwr.common.logger import log
 from flwr.common.typing import InvalidRunStatusException
@@ -151,46 +154,100 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
     def RegisterNode(
         self, request: RegisterNodeFleetRequest, context: grpc.ServicerContext
     ) -> RegisterNodeFleetResponse:
-        """Register a node (not implemented)."""
-        log(ERROR, "[Fleet.RegisterNode] RegisterNode is not implemented")
-        context.abort(
-            grpc.StatusCode.UNIMPLEMENTED,
-            "RegisterNode RPC is not yet implemented",
-        )
-        raise NotImplementedError
+        """Register a node."""
+        # Prevent registration when SuperNode authentication is enabled
+        if self.enable_supernode_auth:
+            log(ERROR, "SuperNode registration is disabled through Fleet API.")
+            context.abort(
+                grpc.StatusCode.FAILED_PRECONDITION,
+                "SuperNode authentication is enabled. "
+                "All SuperNodes must be registered via the CLI.",
+            )
+
+        try:
+            return message_handler.register_node(
+                request=request,
+                state=self.state_factory.state(),
+            )
+        except ValueError:
+            # Public key already in use
+            log(ERROR, PUBLIC_KEY_ALREADY_IN_USE_MESSAGE)
+            context.abort(
+                grpc.StatusCode.FAILED_PRECONDITION, PUBLIC_KEY_ALREADY_IN_USE_MESSAGE
+            )
+
+        raise RuntimeError  # Make mypy happy
 
     def ActivateNode(
         self, request: ActivateNodeRequest, context: grpc.ServicerContext
     ) -> ActivateNodeResponse:
-        """Activate a node (not implemented)."""
-        log(ERROR, "[Fleet.ActivateNode] ActivateNode is not implemented")
-        context.abort(
-            grpc.StatusCode.UNIMPLEMENTED,
-            "ActivateNode RPC is not yet implemented",
-        )
-        raise NotImplementedError
+        """Activate a node."""
+        try:
+            response = message_handler.activate_node(
+                request=request,
+                state=self.state_factory.state(),
+            )
+            log(INFO, "[Fleet.ActivateNode] Activated node_id=%s", response.node_id)
+            return response
+        except message_handler.InvalidHeartbeatIntervalError:
+            # Heartbeat interval is invalid
+            log(ERROR, "[Fleet.ActivateNode] Invalid heartbeat interval")
+            context.abort(
+                grpc.StatusCode.INVALID_ARGUMENT, "Invalid heartbeat interval"
+            )
+        except ValueError as e:
+            log(ERROR, "[Fleet.ActivateNode] Activation failed: %s", str(e))
+            context.abort(grpc.StatusCode.FAILED_PRECONDITION, str(e))
+
+        raise RuntimeError  # Make mypy happy
 
     def DeactivateNode(
         self, request: DeactivateNodeRequest, context: grpc.ServicerContext
     ) -> DeactivateNodeResponse:
-        """Deactivate a node (not implemented)."""
-        log(ERROR, "[Fleet.DeactivateNode] DeactivateNode is not implemented")
-        context.abort(
-            grpc.StatusCode.UNIMPLEMENTED,
-            "DeactivateNode RPC is not yet implemented",
-        )
-        raise NotImplementedError
+        """Deactivate a node."""
+        try:
+            response = message_handler.deactivate_node(
+                request=request,
+                state=self.state_factory.state(),
+            )
+            log(INFO, "[Fleet.DeactivateNode] Deactivated node_id=%s", request.node_id)
+            return response
+        except ValueError as e:
+            log(ERROR, "[Fleet.DeactivateNode] Deactivation failed: %s", str(e))
+            context.abort(grpc.StatusCode.FAILED_PRECONDITION, str(e))
+
+        raise RuntimeError  # Make mypy happy
 
     def UnregisterNode(
         self, request: UnregisterNodeFleetRequest, context: grpc.ServicerContext
     ) -> UnregisterNodeFleetResponse:
-        """Unregister a node (not implemented)."""
-        log(ERROR, "[Fleet.UnregisterNode] UnregisterNode is not implemented")
-        context.abort(
-            grpc.StatusCode.UNIMPLEMENTED,
-            "UnregisterNode RPC is not yet implemented",
-        )
-        raise NotImplementedError
+        """Unregister a node."""
+        # Prevent unregistration when SuperNode authentication is enabled
+        if self.enable_supernode_auth:
+            log(ERROR, "SuperNode unregistration is disabled through Fleet API.")
+            context.abort(
+                grpc.StatusCode.FAILED_PRECONDITION,
+                "SuperNode authentication is enabled. "
+                "All SuperNodes must be unregistered via the CLI.",
+            )
+
+        try:
+            response = message_handler.unregister_node(
+                request=request,
+                state=self.state_factory.state(),
+            )
+            log(
+                DEBUG, "[Fleet.UnregisterNode] Unregistered node_id=%s", request.node_id
+            )
+            return response
+        except ValueError as e:
+            log(
+                ERROR,
+                "[Fleet.UnregisterNode] Unregistration failed: %s",
+                str(e),
+            )
+            context.abort(grpc.StatusCode.FAILED_PRECONDITION, str(e))
+            raise RuntimeError from None  # Make mypy happy
 
     def DeleteNode(
         self, request: DeleteNodeRequest, context: grpc.ServicerContext
@@ -220,10 +277,18 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
     ) -> SendNodeHeartbeatResponse:
         """."""
         log(DEBUG, "[Fleet.SendNodeHeartbeat] Request: %s", MessageToDict(request))
-        return message_handler.send_node_heartbeat(
-            request=request,
-            state=self.state_factory.state(),
-        )
+        try:
+            return message_handler.send_node_heartbeat(
+                request=request,
+                state=self.state_factory.state(),
+            )
+        except message_handler.InvalidHeartbeatIntervalError:
+            # Heartbeat interval is invalid
+            log(ERROR, "[Fleet.SendNodeHeartbeat] Invalid heartbeat interval")
+            context.abort(
+                grpc.StatusCode.INVALID_ARGUMENT, "Invalid heartbeat interval"
+            )
+        raise RuntimeError  # Make mypy happy
 
     def PullMessages(
         self, request: PullMessagesRequest, context: grpc.ServicerContext

{flwr_nightly-1.23.0.dev20251029 → flwr_nightly-1.23.0.dev20251030}/py/flwr/server/superlink/fleet/message_handler/message_handler.py

@@ -18,7 +18,12 @@ from logging import ERROR
 from typing import Optional
 
 from flwr.common import Message, log
-from flwr.common.constant import NOOP_FLWR_AID, Status
+from flwr.common.constant import (
+    HEARTBEAT_MAX_INTERVAL,
+    HEARTBEAT_MIN_INTERVAL,
+    NOOP_FLWR_AID,
+    Status,
+)
 from flwr.common.inflatable import UnexpectedObjectContentError
 from flwr.common.serde import (
     fab_to_proto,
@@ -29,8 +34,12 @@ from flwr.common.serde import (
 from flwr.common.typing import Fab, InvalidRunStatusException
 from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
+    ActivateNodeRequest,
+    ActivateNodeResponse,
     CreateNodeRequest,
     CreateNodeResponse,
+    DeactivateNodeRequest,
+    DeactivateNodeResponse,
     DeleteNodeRequest,
     DeleteNodeResponse,
     PullMessagesRequest,
@@ -38,6 +47,10 @@ from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     PushMessagesRequest,
     PushMessagesResponse,
     Reconnect,
+    RegisterNodeFleetRequest,
+    RegisterNodeFleetResponse,
+    UnregisterNodeFleetRequest,
+    UnregisterNodeFleetResponse,
 )
 from flwr.proto.heartbeat_pb2 import (  # pylint: disable=E0611
     SendNodeHeartbeatRequest,
@@ -64,6 +77,10 @@ from flwr.supercore.object_store import NoObjectInStoreError, ObjectStore
 from flwr.supercore.object_store.utils import store_mapping_and_register_objects
 
 
+class InvalidHeartbeatIntervalError(Exception):
+    """Invalid heartbeat interval exception."""
+
+
 def create_node(
     request: CreateNodeRequest,  # pylint: disable=unused-argument
     state: LinkState,
@@ -87,11 +104,56 @@ def delete_node(request: DeleteNodeRequest, state: LinkState) -> DeleteNodeRespo
     return DeleteNodeResponse()
 
 
+def register_node(
+    request: RegisterNodeFleetRequest,
+    state: LinkState,
+) -> RegisterNodeFleetResponse:
+    """Register a node (Fleet API only)."""
+    state.create_node(NOOP_FLWR_AID, request.public_key, 0)
+    return RegisterNodeFleetResponse()
+
+
+def activate_node(
+    request: ActivateNodeRequest,
+    state: LinkState,
+) -> ActivateNodeResponse:
+    """Activate a node."""
+    node_id = state.get_node_id_by_public_key(request.public_key)
+    if node_id is None:
+        raise ValueError("No SuperNode found with the given public key.")
+    _validate_heartbeat_interval(request.heartbeat_interval)
+    if not state.activate_node(node_id, request.heartbeat_interval):
+        raise ValueError(f"SuperNode with node ID {node_id} could not be activated.")
+    return ActivateNodeResponse(node_id=node_id)
+
+
+def deactivate_node(
+    request: DeactivateNodeRequest,
+    state: LinkState,
+) -> DeactivateNodeResponse:
+    """Deactivate a node."""
+    if not state.deactivate_node(request.node_id):
+        raise ValueError(
+            f"SuperNode with node ID {request.node_id} could not be deactivated."
+        )
+    return DeactivateNodeResponse()
+
+
+def unregister_node(
+    request: UnregisterNodeFleetRequest,
+    state: LinkState,
+) -> UnregisterNodeFleetResponse:
+    """Unregister a node (Fleet API only)."""
+    state.delete_node(NOOP_FLWR_AID, request.node_id)
+    return UnregisterNodeFleetResponse()
+
+
 def send_node_heartbeat(
     request: SendNodeHeartbeatRequest,  # pylint: disable=unused-argument
     state: LinkState,  # pylint: disable=unused-argument
 ) -> SendNodeHeartbeatResponse:
     """."""
+    _validate_heartbeat_interval(request.heartbeat_interval)
     res = state.acknowledge_node_heartbeat(
         request.node.node_id, request.heartbeat_interval
     )
@@ -286,3 +348,12 @@ def confirm_message_received(
     store.delete(request.message_object_id)
 
     return ConfirmMessageReceivedResponse()
+
+
+def _validate_heartbeat_interval(interval: float) -> None:
+    """Raise if heartbeat interval is out of bounds."""
+    if not HEARTBEAT_MIN_INTERVAL <= interval <= HEARTBEAT_MAX_INTERVAL:
+        raise InvalidHeartbeatIntervalError(
+            f"Heartbeat interval {interval} is out of bounds "
+            f"[{HEARTBEAT_MIN_INTERVAL}, {HEARTBEAT_MAX_INTERVAL}]."
+        )

{flwr_nightly-1.23.0.dev20251029 → flwr_nightly-1.23.0.dev20251030}/py/flwr/server/superlink/fleet/rest_rere/rest_api.py

@@ -135,7 +135,11 @@ async def register_node(
     request: RegisterNodeFleetRequest,
 ) -> RegisterNodeFleetResponse:
     """Register a node (Fleet API only)."""
-    raise NotImplementedError("RegisterNode is not yet implemented.")
+    # 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)
@@ -143,7 +147,11 @@ async def activate_node(
     request: ActivateNodeRequest,
 ) -> ActivateNodeResponse:
     """Activate a node."""
-    raise NotImplementedError("ActivateNode is not yet implemented.")
+    # Get state from app
+    state: LinkState = cast(LinkStateFactory, app.state.STATE_FACTORY).state()
+
+    # Handle message
+    return message_handler.activate_node(request=request, state=state)
 
 
 @rest_request_response(DeactivateNodeRequest)
@@ -151,7 +159,11 @@ async def deactivate_node(
     request: DeactivateNodeRequest,
 ) -> DeactivateNodeResponse:
     """Deactivate a node."""
-    raise NotImplementedError("DeactivateNode is not yet implemented.")
+    # Get state from app
+    state: LinkState = cast(LinkStateFactory, app.state.STATE_FACTORY).state()
+
+    # Handle message
+    return message_handler.deactivate_node(request=request, state=state)
 
 
 @rest_request_response(UnregisterNodeFleetRequest)
@@ -159,7 +171,11 @@ async def unregister_node(
     request: UnregisterNodeFleetRequest,
 ) -> UnregisterNodeFleetResponse:
     """Unregister a node (Fleet API only)."""
-    raise NotImplementedError("UnregisterNode is not yet implemented.")
+    # 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)

{flwr_nightly-1.23.0.dev20251029 → flwr_nightly-1.23.0.dev20251030}/py/flwr/server/superlink/fleet/vce/vce_api.py

@@ -33,7 +33,7 @@ from flwr.clientapp.client_app import ClientApp, ClientAppException, LoadClientA
 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_FLWR_AID,
     NUM_PARTITIONS_KEY,
     PARTITION_ID_KEY,
@@ -62,10 +62,10 @@ def _register_nodes(
             # use random bytes as public key
             NOOP_FLWR_AID,
             secrets.token_bytes(32),
-            heartbeat_interval=HEARTBEAT_MAX_INTERVAL,
+            heartbeat_interval=HEARTBEAT_INTERVAL_INF,
         )
         state.acknowledge_node_heartbeat(
-            node_id=node_id, heartbeat_interval=HEARTBEAT_MAX_INTERVAL
+            node_id=node_id, heartbeat_interval=HEARTBEAT_INTERVAL_INF
         )
         nodes_mapping[node_id] = i
     log(DEBUG, "Registered %i nodes", len(nodes_mapping))

{flwr_nightly-1.23.0.dev20251029 → flwr_nightly-1.23.0.dev20251030}/py/flwr/server/superlink/linkstate/in_memory_linkstate.py

@@ -28,7 +28,7 @@ from typing import Optional
 from flwr.common import Context, Message, log, now
 from flwr.common.constant import (
     FLWR_APP_TOKEN_LENGTH,
-    HEARTBEAT_MAX_INTERVAL,
+    HEARTBEAT_INTERVAL_INF,
     HEARTBEAT_PATIENCE,
     MESSAGE_TTL_TOLERANCE,
     NODE_ID_NUM_BYTES,
@@ -641,7 +641,7 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
             current = now()
             run_record = self.run_ids[run_id]
             if new_status.status in (Status.STARTING, Status.RUNNING):
-                run_record.heartbeat_interval = HEARTBEAT_MAX_INTERVAL
+                run_record.heartbeat_interval = HEARTBEAT_INTERVAL_INF
                 run_record.active_until = (
                     current.timestamp() + run_record.heartbeat_interval
                 )

{flwr_nightly-1.23.0.dev20251029 → flwr_nightly-1.23.0.dev20251030}/py/flwr/server/superlink/linkstate/sqlite_linkstate.py

@@ -27,7 +27,7 @@ from typing import Any, Optional, Union, cast
 from flwr.common import Context, Message, Metadata, log, now
 from flwr.common.constant import (
     FLWR_APP_TOKEN_LENGTH,
-    HEARTBEAT_MAX_INTERVAL,
+    HEARTBEAT_INTERVAL_INF,
     HEARTBEAT_PATIENCE,
     MESSAGE_TTL_TOLERANCE,
     NODE_ID_NUM_BYTES,
@@ -982,7 +982,7 @@ class SqliteLinkState(LinkState, SqliteMixin):  # pylint: disable=R0904
         # when switching to starting or running
         current = now()
         if new_status.status in (Status.STARTING, Status.RUNNING):
-            heartbeat_interval = HEARTBEAT_MAX_INTERVAL
+            heartbeat_interval = HEARTBEAT_INTERVAL_INF
             active_until = current.timestamp() + heartbeat_interval
         else:
             heartbeat_interval = 0

{flwr_nightly-1.23.0.dev20251029 → flwr_nightly-1.23.0.dev20251030}/pyproject.toml

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