flwr-nightly 1.23.0.dev20251029__py3-none-any.whl → 1.23.0.dev20251030__py3-none-any.whl

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/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/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/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/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/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/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.dist-info → flwr_nightly-1.23.0.dev20251030.dist-info}/METADATA

@@ -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.dist-info → flwr_nightly-1.23.0.dev20251030.dist-info}/RECORD

@@ -126,7 +126,7 @@ flwr/common/__init__.py,sha256=5GCLVk399Az_rTJHNticRlL0Sl_oPw_j5_LuFKfX7-M,4171
 flwr/common/address.py,sha256=9JucdTwlc-jpeJkRKeUboZoacUtErwSVtnDR9kAtLqE,4119
 flwr/common/args.py,sha256=Nq2u4yePbkSY0CWFamn0hZY6Rms8G1xYDeDGIcLIITE,5849
 flwr/common/config.py,sha256=glcZDjco-amw1YfQcYTFJ4S1pt9APoexT-mf1QscuHs,13960
-flwr/common/constant.py,sha256=EjVoFZZgkxREzd312A2K4LlNk8H27rU4hWGW-CZ9qCI,10145
+flwr/common/constant.py,sha256=du408_dylfRx6H-YXzpc_2BvpI1bnFUcz0RiQryM_n8,10254
 flwr/common/context.py,sha256=Be8obQR_OvEDy1OmshuUKxGRQ7Qx89mf5F4xlhkR10s,2407
 flwr/common/date.py,sha256=1ZT2cRSpC2DJqprOVTLXYCR_O2_OZR0zXO_brJ3LqWc,1554
 flwr/common/differential_privacy.py,sha256=FdlpdpPl_H_2HJa8CQM1iCUGBBQ5Dc8CzxmHERM-EoE,6148
@@ -305,22 +305,22 @@ flwr/server/superlink/fleet/grpc_bidi/grpc_bridge.py,sha256=KouR9PUcrPmMtoLooF4O
 flwr/server/superlink/fleet/grpc_bidi/grpc_client_proxy.py,sha256=iSf0mbBAlig7G6subQwBSVjcUCgSihONKdZ1RmQPTOk,4887
 flwr/server/superlink/fleet/grpc_bidi/grpc_server.py,sha256=OsS-6GgCIzMMZDVu5Y-OKjynHVUrpdc_5OrtuB-IbU0,5174
 flwr/server/superlink/fleet/grpc_rere/__init__.py,sha256=ahDJJ1e-lDxBpeBMgPk7YZt2wB38_QltcpOC0gLbpFs,758
-flwr/server/superlink/fleet/grpc_rere/fleet_servicer.py,sha256=0HwtOgCuQ1x8YCZXMFN6a2Y7agR4TR5e6rruBuxqqrI,13620
+flwr/server/superlink/fleet/grpc_rere/fleet_servicer.py,sha256=j81X6yVdhWZpdAOKEr3DQpCrd4ETnmdniQ12IMThymU,16226
 flwr/server/superlink/fleet/grpc_rere/node_auth_server_interceptor.py,sha256=UWeFQNBW2pGBRVN36HodHcv7bKTgMmdToh96Lhqip1M,5411
 flwr/server/superlink/fleet/message_handler/__init__.py,sha256=fHsRV0KvJ8HtgSA4_YBsEzuhJLjO8p6xx4aCY2oE1p4,731
-flwr/server/superlink/fleet/message_handler/message_handler.py,sha256=GYveEXgKRlyrKRUr2H6kjWPx_g4-fnATrMdJD2G4Gaw,8762
+flwr/server/superlink/fleet/message_handler/message_handler.py,sha256=_ZTKTloYgC3axwJYnKUZ9v6Va6psH_PEux-UPVtArzg,11021
 flwr/server/superlink/fleet/rest_rere/__init__.py,sha256=Lzc93nA7tDqoy-zRUaPG316oqFiZX1HUCL5ELaXY_xw,735
-flwr/server/superlink/fleet/rest_rere/rest_api.py,sha256=HzLx_3sY2_EXBLzLA_ZvKgZrgFDzIh0wesDfLrqyxvU,9875
+flwr/server/superlink/fleet/rest_rere/rest_api.py,sha256=Xcm_o41j0iHCBraLglZc2dY47FSiY8egmcznWUsrLYY,10383
 flwr/server/superlink/fleet/vce/__init__.py,sha256=XOKbAWOzlCqEOQ3M2cBYkH7HKA7PxlbCJMunt-ty-DY,784
 flwr/server/superlink/fleet/vce/backend/__init__.py,sha256=PPH89Yqd1XKm-sRJN6R0WQlKT_b4v54Kzl2yzHAFzM8,1437
 flwr/server/superlink/fleet/vce/backend/backend.py,sha256=cSrHZ5SjCCvy4vI0pgsyjtx3cDMuMQve8KcKkK-dWWo,2196
 flwr/server/superlink/fleet/vce/backend/raybackend.py,sha256=cBZYTmfiAsb1HmVUmOQXYLU-UJmJTFWkj1wW4RYRDuc,7218
-flwr/server/superlink/fleet/vce/vce_api.py,sha256=sgsAx7dgIADA-Ae71s5dwoPY0bw3-qA7RukJgnh8pgc,13389
+flwr/server/superlink/fleet/vce/vce_api.py,sha256=7dJdxRjXttXfZSflZHd-TwX9278ZzrdJxmmWbRiEH_I,13389
 flwr/server/superlink/linkstate/__init__.py,sha256=OtsgvDTnZLU3k0sUbkHbqoVwW6ql2FDmb6uT6DbNkZo,1064
-flwr/server/superlink/linkstate/in_memory_linkstate.py,sha256=STJs4CNgdRknGFvreCdumBSDfUxqW8X0hpCun1wcROM,31829
+flwr/server/superlink/linkstate/in_memory_linkstate.py,sha256=l3n1HJfIOYYSAuSeD-HHDjnL490HxH5NTSj962OSDAk,31829
 flwr/server/superlink/linkstate/linkstate.py,sha256=DabTgFFissJhT_MCPiluz5eFrS3c412q8FnRqQrAidY,15945
 flwr/server/superlink/linkstate/linkstate_factory.py,sha256=KVBpc8UxVrJCQ7IkOjVZVWb-kqWx08AGVi7qXzZS190,2126
-flwr/server/superlink/linkstate/sqlite_linkstate.py,sha256=5KJnrqDz1bNphLhJI9iZz2_mrbl1_DsTOSbwfncsE1E,47528
+flwr/server/superlink/linkstate/sqlite_linkstate.py,sha256=Herm-aUM9Wmpg9IV7c25UdXGmPqL8sWdVOOCrWxha_k,47528
 flwr/server/superlink/linkstate/utils.py,sha256=ZtyqSo4HzGrHXW3Wn_4irYMpIiq4onNI2XCIVOOJmJM,13971
 flwr/server/superlink/serverappio/__init__.py,sha256=Fy4zJuoccZe5mZSEIpOmQvU6YeXFBa1M4eZuXXmJcn8,717
 flwr/server/superlink/serverappio/serverappio_grpc.py,sha256=-I7kBbr4w4ZVYwBZoAIle-xHKthFnZrsVfxa6WR8uxA,2310
@@ -433,7 +433,7 @@ flwr/supernode/servicer/__init__.py,sha256=lucTzre5WPK7G1YLCfaqg3rbFWdNSb7ZTt-ca
 flwr/supernode/servicer/clientappio/__init__.py,sha256=7Oy62Y_oijqF7Dxi6tpcUQyOpLc_QpIRZ83NvwmB0Yg,813
 flwr/supernode/servicer/clientappio/clientappio_servicer.py,sha256=ZvKosLV7GN1_fOF-tOmhqFQysYQywCysRc-m23DVIWA,10265
 flwr/supernode/start_client_internal.py,sha256=wKqh9-_rQYi7JFKpYBLRiUeq9YJUSyUd9b-SnVnuvwI,21567
-flwr_nightly-1.23.0.dev20251029.dist-info/METADATA,sha256=IbVE7qYkOpvhbjaQ8hYXUx3el8wwZN8UQKbeTKeKrjE,14559
-flwr_nightly-1.23.0.dev20251029.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-flwr_nightly-1.23.0.dev20251029.dist-info/entry_points.txt,sha256=hxHD2ixb_vJFDOlZV-zB4Ao32_BQlL34ftsDh1GXv14,420
-flwr_nightly-1.23.0.dev20251029.dist-info/RECORD,,
+flwr_nightly-1.23.0.dev20251030.dist-info/METADATA,sha256=yDbmaIH946MJMvXaMPddPZREsfS76qhbPVOMP8JA2b4,14559
+flwr_nightly-1.23.0.dev20251030.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+flwr_nightly-1.23.0.dev20251030.dist-info/entry_points.txt,sha256=hxHD2ixb_vJFDOlZV-zB4Ao32_BQlL34ftsDh1GXv14,420
+flwr_nightly-1.23.0.dev20251030.dist-info/RECORD,,