flwr-nightly 1.16.0.dev20250306__py3-none-any.whl → 1.16.0.dev20250308__py3-none-any.whl

flwr/client/message_handler/message_handler.py

@@ -82,7 +82,7 @@ def handle_control_message(message: Message) -> tuple[Optional[Message], int]:
         recordset = RecordSet()
         recordset.configs_records["config"] = ConfigsRecord({"reason": reason})
         out_message = message.create_reply(recordset)
-        # Return TaskRes and sleep duration
+        # Return Message and sleep duration
         return out_message, sleep_duration
 
     # Any other message

flwr/client/rest_client/connection.py

@@ -66,9 +66,7 @@ except ModuleNotFoundError:
 
 PATH_CREATE_NODE: str = "api/v0/fleet/create-node"
 PATH_DELETE_NODE: str = "api/v0/fleet/delete-node"
-PATH_PULL_TASK_INS: str = "api/v0/fleet/pull-task-ins"
 PATH_PULL_MESSAGES: str = "/api/v0/fleet/pull-messages"
-PATH_PUSH_TASK_RES: str = "api/v0/fleet/push-task-res"
 PATH_PUSH_MESSAGES: str = "/api/v0/fleet/push-messages"
 PATH_PING: str = "api/v0/fleet/ping"
 PATH_GET_RUN: str = "/api/v0/fleet/get-run"
@@ -280,7 +278,7 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         node = None
 
     def receive() -> Optional[Message]:
-        """Receive next task from server."""
+        """Receive next Message from server."""
         # Get Node
         if node is None:
             log(ERROR, "Node instance missing")
@@ -309,11 +307,11 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         if message_proto is not None:
             message = message_from_proto(message_proto)
             metadata = copy(message.metadata)
-            log(INFO, "[Node] POST /%s: success", PATH_PULL_TASK_INS)
+            log(INFO, "[Node] POST /%s: success", PATH_PULL_MESSAGES)
         return message
 
     def send(message: Message) -> None:
-        """Send task result back to server."""
+        """Send Message result back to server."""
         # Get Node
         if node is None:
             log(ERROR, "Node instance missing")
@@ -345,7 +343,7 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         log(
             INFO,
             "[Node] POST /%s: success, created result %s",
-            PATH_PUSH_TASK_RES,
+            PATH_PUSH_MESSAGES,
             res.results,  # pylint: disable=no-member
         )
 

flwr/common/message.py

@@ -25,7 +25,7 @@ from .constant import MESSAGE_TTL_TOLERANCE
 from .logger import log
 from .record import RecordSet
 
-DEFAULT_TTL = 3600
+DEFAULT_TTL = 43200  # This is 12 hours
 
 
 class Metadata:  # pylint: disable=too-many-instance-attributes
@@ -321,7 +321,7 @@ class Message:
             )
             message.metadata.ttl = ttl
 
-        self._limit_task_res_ttl(message)
+        self._limit_message_res_ttl(message)
 
         return message
 
@@ -364,7 +364,7 @@ class Message:
             )
             message.metadata.ttl = ttl
 
-        self._limit_task_res_ttl(message)
+        self._limit_message_res_ttl(message)
 
         return message
 
@@ -379,14 +379,14 @@ class Message:
         )
         return f"{self.__class__.__qualname__}({view})"
 
-    def _limit_task_res_ttl(self, message: Message) -> None:
-        """Limit the TaskRes TTL to not exceed the expiration time of the TaskIns it
-        replies to.
+    def _limit_message_res_ttl(self, message: Message) -> None:
+        """Limit the TTL of the provided Message to not exceed the expiration time of
+        this Message it replies to.
 
         Parameters
         ----------
         message : Message
-            The message to which the TaskRes is replying.
+            The reply Message to limit the TTL for.
         """
         # Calculate the maximum allowed TTL
         max_allowed_ttl = (

flwr/common/record/recordset.py

@@ -155,19 +155,11 @@ class RecordSet(TypedDict[str, RecordType]):
     :code:`MetricsRecord` and :code:`ParametersRecord`.
     """
 
-    def __init__(
-        self,
-        parameters_records: dict[str, ParametersRecord] | None = None,
-        metrics_records: dict[str, MetricsRecord] | None = None,
-        configs_records: dict[str, ConfigsRecord] | None = None,
-    ) -> None:
+    def __init__(self, records: dict[str, RecordType] | None = None) -> None:
         super().__init__(_check_key, _check_value)
-        for key, p_record in (parameters_records or {}).items():
-            self[key] = p_record
-        for key, m_record in (metrics_records or {}).items():
-            self[key] = m_record
-        for key, c_record in (configs_records or {}).items():
-            self[key] = c_record
+        if records is not None:
+            for key, record in records.items():
+                self[key] = record
 
     @property
     def parameters_records(self) -> TypedDict[str, ParametersRecord]:

flwr/common/serde.py

@@ -21,8 +21,6 @@ from typing import Any, TypeVar, cast
 
 from google.protobuf.message import Message as GrpcMessage
 
-from flwr.common.constant import SUPERLINK_NODE_ID
-
 # pylint: disable=E0611
 from flwr.proto.clientappio_pb2 import ClientAppOutputCode, ClientAppOutputStatus
 from flwr.proto.error_pb2 import Error as ProtoError
@@ -30,7 +28,6 @@ from flwr.proto.fab_pb2 import Fab as ProtoFab
 from flwr.proto.message_pb2 import Context as ProtoContext
 from flwr.proto.message_pb2 import Message as ProtoMessage
 from flwr.proto.message_pb2 import Metadata as ProtoMetadata
-from flwr.proto.node_pb2 import Node
 from flwr.proto.recordset_pb2 import Array as ProtoArray
 from flwr.proto.recordset_pb2 import BoolList, BytesList
 from flwr.proto.recordset_pb2 import ConfigsRecord as ProtoConfigsRecord
@@ -43,7 +40,6 @@ from flwr.proto.recordset_pb2 import RecordSet as ProtoRecordSet
 from flwr.proto.recordset_pb2 import SintList, StringList, UintList
 from flwr.proto.run_pb2 import Run as ProtoRun
 from flwr.proto.run_pb2 import RunStatus as ProtoRunStatus
-from flwr.proto.task_pb2 import Task, TaskIns, TaskRes
 from flwr.proto.transport_pb2 import (
     ClientMessage,
     Code,
@@ -583,128 +579,14 @@ def recordset_to_proto(recordset: RecordSet) -> ProtoRecordSet:
 
 def recordset_from_proto(recordset_proto: ProtoRecordSet) -> RecordSet:
     """Deserialize RecordSet from ProtoBuf."""
-    return RecordSet(
-        parameters_records={
-            k: parameters_record_from_proto(v)
-            for k, v in recordset_proto.parameters.items()
-        },
-        metrics_records={
-            k: metrics_record_from_proto(v) for k, v in recordset_proto.metrics.items()
-        },
-        configs_records={
-            k: configs_record_from_proto(v) for k, v in recordset_proto.configs.items()
-        },
-    )
-
-
-# === Message ===
-
-
-def message_to_taskins(message: Message) -> TaskIns:
-    """Create a TaskIns from the Message."""
-    md = message.metadata
-    return TaskIns(
-        group_id=md.group_id,
-        run_id=md.run_id,
-        task=Task(
-            producer=Node(node_id=SUPERLINK_NODE_ID),  # Assume driver node
-            consumer=Node(node_id=md.dst_node_id),
-            created_at=md.created_at,
-            ttl=md.ttl,
-            ancestry=[md.reply_to_message] if md.reply_to_message != "" else [],
-            task_type=md.message_type,
-            recordset=(
-                recordset_to_proto(message.content) if message.has_content() else None
-            ),
-            error=error_to_proto(message.error) if message.has_error() else None,
-        ),
-    )
-
-
-def message_from_taskins(taskins: TaskIns) -> Message:
-    """Create a Message from the TaskIns."""
-    # Retrieve the Metadata
-    metadata = Metadata(
-        run_id=taskins.run_id,
-        message_id=taskins.task_id,
-        src_node_id=taskins.task.producer.node_id,
-        dst_node_id=taskins.task.consumer.node_id,
-        reply_to_message=taskins.task.ancestry[0] if taskins.task.ancestry else "",
-        group_id=taskins.group_id,
-        ttl=taskins.task.ttl,
-        message_type=taskins.task.task_type,
-    )
-
-    # Construct Message
-    message = Message(
-        metadata=metadata,
-        content=(
-            recordset_from_proto(taskins.task.recordset)
-            if taskins.task.HasField("recordset")
-            else None
-        ),
-        error=(
-            error_from_proto(taskins.task.error)
-            if taskins.task.HasField("error")
-            else None
-        ),
-    )
-    message.metadata.created_at = taskins.task.created_at
-    return message
-
-
-def message_to_taskres(message: Message) -> TaskRes:
-    """Create a TaskRes from the Message."""
-    md = message.metadata
-    return TaskRes(
-        task_id="",  # This will be generated by the server
-        group_id=md.group_id,
-        run_id=md.run_id,
-        task=Task(
-            producer=Node(node_id=md.src_node_id),
-            consumer=Node(node_id=SUPERLINK_NODE_ID),  # Assume driver node
-            created_at=md.created_at,
-            ttl=md.ttl,
-            ancestry=[md.reply_to_message] if md.reply_to_message != "" else [],
-            task_type=md.message_type,
-            recordset=(
-                recordset_to_proto(message.content) if message.has_content() else None
-            ),
-            error=error_to_proto(message.error) if message.has_error() else None,
-        ),
-    )
-
-
-def message_from_taskres(taskres: TaskRes) -> Message:
-    """Create a Message from the TaskIns."""
-    # Retrieve the MetaData
-    metadata = Metadata(
-        run_id=taskres.run_id,
-        message_id=taskres.task_id,
-        src_node_id=taskres.task.producer.node_id,
-        dst_node_id=taskres.task.consumer.node_id,
-        reply_to_message=taskres.task.ancestry[0] if taskres.task.ancestry else "",
-        group_id=taskres.group_id,
-        ttl=taskres.task.ttl,
-        message_type=taskres.task.task_type,
-    )
-
-    # Construct the Message
-    message = Message(
-        metadata=metadata,
-        content=(
-            recordset_from_proto(taskres.task.recordset)
-            if taskres.task.HasField("recordset")
-            else None
-        ),
-        error=(
-            error_from_proto(taskres.task.error)
-            if taskres.task.HasField("error")
-            else None
-        ),
-    )
-    message.metadata.created_at = taskres.task.created_at
-    return message
+    ret = RecordSet()
+    for k, p_record_proto in recordset_proto.parameters.items():
+        ret[k] = parameters_record_from_proto(p_record_proto)
+    for k, m_record_proto in recordset_proto.metrics.items():
+        ret[k] = metrics_record_from_proto(m_record_proto)
+    for k, c_record_proto in recordset_proto.configs.items():
+        ret[k] = configs_record_from_proto(c_record_proto)
+    return ret
 
 
 # === FAB ===

flwr/server/compat/driver_client_proxy.py

@@ -104,7 +104,7 @@ class DriverClientProxy(ClientProxy):
     def _send_receive_recordset(
         self,
         recordset: RecordSet,
-        task_type: str,
+        message_type: str,
         timeout: Optional[float],
         group_id: Optional[int],
     ) -> RecordSet:
@@ -112,7 +112,7 @@ class DriverClientProxy(ClientProxy):
         # Create message
         message = self.driver.create_message(
             content=recordset,
-            message_type=task_type,
+            message_type=message_type,
             dst_node_id=self.node_id,
             group_id=str(group_id) if group_id else "",
             ttl=timeout,

flwr/server/driver/inmemory_driver.py

@@ -23,7 +23,6 @@ from uuid import UUID
 
 from flwr.common import DEFAULT_TTL, Message, Metadata, RecordSet
 from flwr.common.constant import SUPERLINK_NODE_ID
-from flwr.common.serde import message_from_taskres, message_to_taskins
 from flwr.common.typing import Run
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from flwr.server.superlink.linkstate import LinkStateFactory
@@ -60,6 +59,7 @@ class InMemoryDriver(Driver):
             and message.metadata.message_id == ""
             and message.metadata.reply_to_message == ""
             and message.metadata.ttl > 0
+            and message.metadata.delivered_at == ""
         ):
             raise ValueError(f"Invalid message: {message}")
 
@@ -119,18 +119,16 @@ class InMemoryDriver(Driver):
         This method takes an iterable of messages and sends each message
         to the node specified in `dst_node_id`.
         """
-        task_ids: list[str] = []
+        msg_ids: list[str] = []
         for msg in messages:
             # Check message
             self._check_message(msg)
-            # Convert Message to TaskIns
-            taskins = message_to_taskins(msg)
             # Store in state
-            task_id = self.state.store_task_ins(taskins)
-            if task_id:
-                task_ids.append(str(task_id))
+            msg_id = self.state.store_message_ins(msg)
+            if msg_id:
+                msg_ids.append(str(msg_id))
 
-        return task_ids
+        return msg_ids
 
     def pull_messages(self, message_ids: Iterable[str]) -> Iterable[Message]:
         """Pull messages based on message IDs.
@@ -139,17 +137,16 @@ class InMemoryDriver(Driver):
         set of given message IDs.
         """
         msg_ids = {UUID(msg_id) for msg_id in message_ids}
-        # Pull TaskRes
-        task_res_list = self.state.get_task_res(task_ids=msg_ids)
-        # Delete tasks in state
-        # Delete the TaskIns/TaskRes pairs if TaskRes is found
-        task_ins_ids_to_delete = {
-            UUID(task_res.task.ancestry[0]) for task_res in task_res_list
+        # Pull Messages
+        message_res_list = self.state.get_message_res(message_ids=msg_ids)
+        # Get IDs of Messages these replies are for
+        message_ins_ids_to_delete = {
+            UUID(msg_res.metadata.reply_to_message) for msg_res in message_res_list
         }
-        self.state.delete_tasks(task_ins_ids=task_ins_ids_to_delete)
-        # Convert TaskRes to Message
-        msgs = [message_from_taskres(taskres) for taskres in task_res_list]
-        return msgs
+        # Delete
+        self.state.delete_messages(message_ins_ids=message_ins_ids_to_delete)
+
+        return message_res_list
 
     def send_and_receive(
         self,

flwr/server/superlink/driver/serverappio_servicer.py

@@ -22,7 +22,7 @@ from uuid import UUID
 
 import grpc
 
-from flwr.common import ConfigsRecord
+from flwr.common import ConfigsRecord, Message
 from flwr.common.constant import Status
 from flwr.common.logger import log
 from flwr.common.serde import (
@@ -31,9 +31,7 @@ from flwr.common.serde import (
     fab_from_proto,
     fab_to_proto,
     message_from_proto,
-    message_from_taskres,
     message_to_proto,
-    message_to_taskins,
     run_status_from_proto,
     run_status_to_proto,
     run_to_proto,
@@ -69,12 +67,11 @@ from flwr.proto.serverappio_pb2 import (  # pylint: disable=E0611
     PushServerAppOutputsRequest,
     PushServerAppOutputsResponse,
 )
-from flwr.proto.task_pb2 import TaskRes  # pylint: disable=E0611
 from flwr.server.superlink.ffs.ffs import Ffs
 from flwr.server.superlink.ffs.ffs_factory import FfsFactory
 from flwr.server.superlink.linkstate import LinkState, LinkStateFactory
 from flwr.server.superlink.utils import abort_if
-from flwr.server.utils.validator import validate_task_ins_or_res
+from flwr.server.utils.validator import validate_message
 
 
 class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
@@ -161,20 +158,19 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
         while request.messages_list:
             message_proto = request.messages_list.pop(0)
             message = message_from_proto(message_proto=message_proto)
-            task_ins = message_to_taskins(message=message)
-            validation_errors = validate_task_ins_or_res(task_ins)
+            validation_errors = validate_message(message, is_reply_message=False)
             _raise_if(
                 validation_error=bool(validation_errors),
                 request_name="PushMessages",
                 detail=", ".join(validation_errors),
             )
             _raise_if(
-                validation_error=request.run_id != task_ins.run_id,
+                validation_error=request.run_id != message.metadata.run_id,
                 request_name="PushMessages",
-                detail="`task_ins` has mismatched `run_id`",
+                detail="`Message.metadata` has mismatched `run_id`",
             )
             # Store
-            message_id: Optional[UUID] = state.store_task_ins(task_ins=task_ins)
+            message_id: Optional[UUID] = state.store_message_ins(message=message)
             message_ids.append(message_id)
 
         return PushInsMessagesResponse(
@@ -200,32 +196,31 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
             context,
         )
 
-        # Convert each task_id str to UUID
+        # Convert each message_id str to UUID
         message_ids: set[UUID] = {
             UUID(message_id) for message_id in request.message_ids
         }
 
         # Read from state
-        task_res_list: list[TaskRes] = state.get_task_res(task_ids=message_ids)
+        messages_res: list[Message] = state.get_message_res(message_ids=message_ids)
 
-        # Delete the TaskIns/TaskRes pairs if TaskRes is found
-        task_ins_ids_to_delete = {
-            UUID(task_res.task.ancestry[0]) for task_res in task_res_list
+        # Delete the instruction Messages and their replies if found
+        message_ins_ids_to_delete = {
+            UUID(msg_res.metadata.reply_to_message) for msg_res in messages_res
         }
 
-        state.delete_tasks(task_ins_ids=task_ins_ids_to_delete)
+        state.delete_messages(message_ins_ids=message_ins_ids_to_delete)
 
-        # Convert to Messages
+        # Convert Messages to proto
         messages_list = []
-        while task_res_list:
-            task_res = task_res_list.pop(0)
+        while messages_res:
+            msg = messages_res.pop(0)
             _raise_if(
-                validation_error=request.run_id != task_res.run_id,
+                validation_error=request.run_id != msg.metadata.run_id,
                 request_name="PullMessages",
-                detail="`task_res` has mismatched `run_id`",
+                detail="`message.metadata` has mismatched `run_id`",
             )
-            message = message_from_taskres(taskres=task_res)
-            messages_list.append(message_to_proto(message))
+            messages_list.append(message_to_proto(msg))
 
         return PullResMessagesResponse(messages_list=messages_list)
 

flwr/server/superlink/fleet/grpc_rere/fleet_servicer.py

@@ -103,11 +103,11 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         if request.messages_list:
             log(
                 INFO,
-                "[Fleet.PushMessages] Push results from node_id=%s",
+                "[Fleet.PushMessages] Push replies from node_id=%s",
                 request.messages_list[0].metadata.src_node_id,
             )
         else:
-            log(INFO, "[Fleet.PushMessages] No task results to push")
+            log(INFO, "[Fleet.PushMessages] No replies to push")
 
         try:
             res = message_handler.push_messages(

flwr/server/superlink/fleet/message_handler/message_handler.py

@@ -18,13 +18,12 @@
 from typing import Optional
 from uuid import UUID
 
+from flwr.common import Message
 from flwr.common.constant import Status
 from flwr.common.serde import (
     fab_to_proto,
     message_from_proto,
-    message_from_taskins,
     message_to_proto,
-    message_to_taskres,
     user_config_to_proto,
 )
 from flwr.common.typing import Fab, InvalidRunStatusException
@@ -48,7 +47,6 @@ from flwr.proto.run_pb2 import (  # pylint: disable=E0611
     GetRunResponse,
     Run,
 )
-from flwr.proto.task_pb2 import TaskIns  # pylint: disable=E0611
 from flwr.server.superlink.ffs.ffs import Ffs
 from flwr.server.superlink.linkstate import LinkState
 from flwr.server.superlink.utils import check_abort
@@ -92,13 +90,12 @@ def pull_messages(
     node = request.node  # pylint: disable=no-member
     node_id: int = node.node_id
 
-    # Retrieve TaskIns from State
-    task_ins_list: list[TaskIns] = state.get_task_ins(node_id=node_id, limit=1)
+    # Retrieve Message from State
+    message_list: list[Message] = state.get_message_ins(node_id=node_id, limit=1)
 
     # Convert to Messages
     msg_proto = []
-    for task_ins in task_ins_list:
-        msg = message_from_taskins(task_ins)
+    for msg in message_list:
         msg_proto.append(message_to_proto(msg))
 
     return PullMessagesResponse(messages_list=msg_proto)
@@ -108,21 +105,20 @@ def push_messages(
     request: PushMessagesRequest, state: LinkState
 ) -> PushMessagesResponse:
     """Push Messages handler."""
-    # Convert Message to TaskRes
+    # Convert Message from proto
     msg = message_from_proto(message_proto=request.messages_list[0])
-    task_res = message_to_taskres(msg)
 
     # Abort if the run is not running
     abort_msg = check_abort(
-        task_res.run_id,
+        msg.metadata.run_id,
         [Status.PENDING, Status.STARTING, Status.FINISHED],
         state,
     )
     if abort_msg:
         raise InvalidRunStatusException(abort_msg)
 
-    # Store TaskRes in State
-    message_id: Optional[UUID] = state.store_task_res(task_res=task_res)
+    # Store Message in State
+    message_id: Optional[UUID] = state.store_message_res(message=msg)
 
     # Build response
     response = PushMessagesResponse(

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

@@ -45,7 +45,7 @@ class Backend(ABC):
     def num_workers(self) -> int:
         """Return number of workers in the backend.
 
-        This is the number of TaskIns that can be processed concurrently.
+        This is the number of Messages that can be processed concurrently.
         """
         return 0