flwr-nightly 1.19.0.dev20250610__py3-none-any.whl → 1.19.0.dev20250612__py3-none-any.whl

flwr/client/grpc_rere_client/connection.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Contextmanager for a gRPC request-response channel to the Flower server."""
 
+
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 from copy import copy
@@ -30,7 +31,11 @@ from flwr.common import GRPC_MAX_MESSAGE_LENGTH
 from flwr.common.constant import HEARTBEAT_CALL_TIMEOUT, HEARTBEAT_DEFAULT_INTERVAL
 from flwr.common.grpc import create_channel, on_channel_state_change
 from flwr.common.heartbeat import HeartbeatSender
-from flwr.common.inflatable import get_all_nested_objects
+from flwr.common.inflatable import (
+    get_all_nested_objects,
+    get_object_tree,
+    no_object_id_recompute,
+)
 from flwr.common.inflatable_grpc_utils import (
     make_pull_object_fn_grpc,
     make_push_object_fn_grpc,
@@ -62,7 +67,9 @@ from flwr.proto.heartbeat_pb2 import (  # pylint: disable=E0611
     SendNodeHeartbeatRequest,
     SendNodeHeartbeatResponse,
 )
-from flwr.proto.message_pb2 import ObjectIDs  # pylint: disable=E0611
+from flwr.proto.message_pb2 import (  # pylint: disable=E0611
+    ConfirmMessageReceivedRequest,
+)
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=E0611
 
@@ -269,14 +276,23 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
 
         if message_proto:
             msg_id = message_proto.metadata.message_id
+            run_id = message_proto.metadata.run_id
             all_object_contents = pull_objects(
                 list(response.objects_to_pull[msg_id].object_ids) + [msg_id],
                 pull_object_fn=make_pull_object_fn_grpc(
                     pull_object_grpc=stub.PullObject,
                     node=node,
-                    run_id=message_proto.metadata.run_id,
+                    run_id=run_id,
                 ),
             )
+
+            # Confirm that the message has been received
+            stub.ConfirmMessageReceived(
+                ConfirmMessageReceivedRequest(
+                    node=node, run_id=run_id, message_object_id=msg_id
+                )
+            )
+
             in_message = cast(
                 Message, inflate_object_from_contents(msg_id, all_object_contents)
             )
@@ -311,33 +327,36 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
             log(ERROR, "Invalid out message")
             return
 
-        # Get all nested objects
-        all_objects = get_all_nested_objects(message)
-        all_object_ids = list(all_objects.keys())
-        msg_id = all_object_ids[-1]  # Last object is the message itself
-        descendant_ids = all_object_ids[:-1]  # All but the last object are descendants
-
-        # Serialize Message
-        message_proto = message_to_proto(message=remove_content_from_message(message))
-        request = PushMessagesRequest(
-            node=node,
-            messages_list=[message_proto],
-            msg_to_descendant_mapping={msg_id: ObjectIDs(object_ids=descendant_ids)},
-        )
-        response: PushMessagesResponse = stub.PushMessages(request=request)
-
-        if response.objects_to_push:
-            objs_to_push = set(response.objects_to_push[message.object_id].object_ids)
-            push_objects(
-                all_objects,
-                push_object_fn=make_push_object_fn_grpc(
-                    push_object_grpc=stub.PushObject,
-                    node=node,
-                    run_id=message.metadata.run_id,
-                ),
-                object_ids_to_push=objs_to_push,
+        with no_object_id_recompute():
+            # Get all nested objects
+            all_objects = get_all_nested_objects(message)
+            object_tree = get_object_tree(message)
+
+            # Serialize Message
+            message_proto = message_to_proto(
+                message=remove_content_from_message(message)
+            )
+            request = PushMessagesRequest(
+                node=node,
+                messages_list=[message_proto],
+                message_object_trees=[object_tree],
             )
-            log(DEBUG, "Pushed %s objects to servicer.", len(objs_to_push))
+            response: PushMessagesResponse = stub.PushMessages(request=request)
+
+            if response.objects_to_push:
+                objs_to_push = set(
+                    response.objects_to_push[message.object_id].object_ids
+                )
+                push_objects(
+                    all_objects,
+                    push_object_fn=make_push_object_fn_grpc(
+                        push_object_grpc=stub.PushObject,
+                        node=node,
+                        run_id=message.metadata.run_id,
+                    ),
+                    object_ids_to_push=objs_to_push,
+                )
+                log(DEBUG, "Pushed %s objects to servicer.", len(objs_to_push))
 
         # Cleanup
         metadata = None

flwr/client/grpc_rere_client/grpc_adapter.py

@@ -50,6 +50,8 @@ from flwr.proto.heartbeat_pb2 import (  # pylint: disable=E0611
     SendNodeHeartbeatResponse,
 )
 from flwr.proto.message_pb2 import (  # pylint: disable=E0611
+    ConfirmMessageReceivedRequest,
+    ConfirmMessageReceivedResponse,
     PullObjectRequest,
     PullObjectResponse,
     PushObjectRequest,
@@ -169,3 +171,9 @@ class GrpcAdapter:
     ) -> PullObjectResponse:
         """."""
         return self._send_and_receive(request, PullObjectResponse, **kwargs)
+
+    def ConfirmMessageReceived(  # pylint: disable=C0103
+        self, request: ConfirmMessageReceivedRequest, **kwargs: Any
+    ) -> ConfirmMessageReceivedResponse:
+        """."""
+        return self._send_and_receive(request, ConfirmMessageReceivedResponse, **kwargs)

flwr/client/rest_client/connection.py

@@ -14,12 +14,11 @@
 # ==============================================================================
 """Contextmanager for a REST request-response channel to the Flower server."""
 
-
 from collections.abc import Iterator
 from contextlib import contextmanager
 from copy import copy
-from logging import ERROR, INFO, WARN
-from typing import Callable, Optional, TypeVar, Union
+from logging import DEBUG, ERROR, INFO, WARN
+from typing import Callable, Optional, TypeVar, Union, cast
 
 from cryptography.hazmat.primitives.asymmetric import ec
 from google.protobuf.message import Message as GrpcMessage
@@ -31,10 +30,24 @@ from flwr.common import GRPC_MAX_MESSAGE_LENGTH
 from flwr.common.constant import HEARTBEAT_DEFAULT_INTERVAL
 from flwr.common.exit import ExitCode, flwr_exit
 from flwr.common.heartbeat import HeartbeatSender
+from flwr.common.inflatable import (
+    get_all_nested_objects,
+    get_object_tree,
+    no_object_id_recompute,
+)
+from flwr.common.inflatable_rest_utils import (
+    make_pull_object_fn_rest,
+    make_push_object_fn_rest,
+)
+from flwr.common.inflatable_utils import (
+    inflate_object_from_contents,
+    pull_objects,
+    push_objects,
+)
 from flwr.common.logger import log
-from flwr.common.message import Message
+from flwr.common.message import Message, remove_content_from_message
 from flwr.common.retry_invoker import RetryInvoker
-from flwr.common.serde import message_from_proto, message_to_proto, run_from_proto
+from flwr.common.serde import message_to_proto, run_from_proto
 from flwr.common.typing import Fab, Run
 from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
@@ -51,6 +64,14 @@ from flwr.proto.heartbeat_pb2 import (  # pylint: disable=E0611
     SendNodeHeartbeatRequest,
     SendNodeHeartbeatResponse,
 )
+from flwr.proto.message_pb2 import (  # pylint: disable=E0611
+    ConfirmMessageReceivedRequest,
+    ConfirmMessageReceivedResponse,
+    PullObjectRequest,
+    PullObjectResponse,
+    PushObjectRequest,
+    PushObjectResponse,
+)
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=E0611
 
@@ -64,9 +85,12 @@ PATH_CREATE_NODE: str = "api/v0/fleet/create-node"
 PATH_DELETE_NODE: str = "api/v0/fleet/delete-node"
 PATH_PULL_MESSAGES: str = "/api/v0/fleet/pull-messages"
 PATH_PUSH_MESSAGES: str = "/api/v0/fleet/push-messages"
+PATH_PULL_OBJECT: str = "/api/v0/fleet/pull-object"
+PATH_PUSH_OBJECT: str = "/api/v0/fleet/push-object"
 PATH_SEND_NODE_HEARTBEAT: str = "api/v0/fleet/send-node-heartbeat"
 PATH_GET_RUN: str = "/api/v0/fleet/get-run"
 PATH_GET_FAB: str = "/api/v0/fleet/get-fab"
+PATH_CONFIRM_MESSAGE_RECEIVED: str = "/api/v0/fleet/confirm-message-received"
 
 T = TypeVar("T", bound=GrpcMessage)
 
@@ -296,14 +320,58 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         ):
             message_proto = None
 
-        # Return the Message if available
-        nonlocal metadata
-        message = None
-        if message_proto is not None:
-            message = message_from_proto(message_proto)
-            metadata = copy(message.metadata)
+        # Construct the Message
+        in_message: Optional[Message] = None
+
+        if message_proto:
             log(INFO, "[Node] POST /%s: success", PATH_PULL_MESSAGES)
-        return message
+            msg_id = message_proto.metadata.message_id
+            run_id = message_proto.metadata.run_id
+
+            def fn(request: PullObjectRequest) -> PullObjectResponse:
+                res = _request(
+                    req=request, res_type=PullObjectResponse, api_path=PATH_PULL_OBJECT
+                )
+                if res is None:
+                    raise ValueError("PushObjectResponse is None.")
+                return res
+
+            try:
+                all_object_contents = pull_objects(
+                    list(res.objects_to_pull[msg_id].object_ids) + [msg_id],
+                    pull_object_fn=make_pull_object_fn_rest(
+                        pull_object_rest=fn,
+                        node=node,
+                        run_id=run_id,
+                    ),
+                )
+
+                # Confirm that the message has been received
+                _request(
+                    req=ConfirmMessageReceivedRequest(
+                        node=node, run_id=run_id, message_object_id=msg_id
+                    ),
+                    res_type=ConfirmMessageReceivedResponse,
+                    api_path=PATH_CONFIRM_MESSAGE_RECEIVED,
+                )
+            except ValueError as e:
+                log(
+                    ERROR,
+                    "Pulling objects failed. Potential irrecoverable error: %s",
+                    str(e),
+                )
+            in_message = cast(
+                Message, inflate_object_from_contents(msg_id, all_object_contents)
+            )
+            # The deflated message doesn't contain the message_id (its own object_id)
+            # Inject
+            in_message.metadata.__dict__["_message_id"] = msg_id
+
+        # Remember `metadata` of the in message
+        nonlocal metadata
+        metadata = copy(in_message.metadata) if in_message else None
+
+        return in_message
 
     def send(message: Message) -> None:
         """Send Message result back to server."""
@@ -318,29 +386,72 @@ def http_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
             log(ERROR, "No current message")
             return
 
+        # Set message_id
+        message.metadata.__dict__["_message_id"] = message.object_id
         # Validate out message
         if not validate_out_message(message, metadata):
             log(ERROR, "Invalid out message")
             return
-        metadata = None
 
-        # Serialize ProtoBuf to bytes
-        message_proto = message_to_proto(message=message)
+        with no_object_id_recompute():
+            # Get all nested objects
+            all_objects = get_all_nested_objects(message)
+            object_tree = get_object_tree(message)
 
-        # Serialize ProtoBuf to bytes
-        req = PushMessagesRequest(node=node, messages_list=[message_proto])
+            # Serialize Message
+            message_proto = message_to_proto(
+                message=remove_content_from_message(message)
+            )
+            req = PushMessagesRequest(
+                node=node,
+                messages_list=[message_proto],
+                message_object_trees=[object_tree],
+            )
 
-        # Send the request
-        res = _request(req, PushMessagesResponse, PATH_PUSH_MESSAGES)
-        if res is None:
-            return
+            # Send the request
+            res = _request(req, PushMessagesResponse, PATH_PUSH_MESSAGES)
+            if res:
+                log(
+                    INFO,
+                    "[Node] POST /%s: success, created result %s",
+                    PATH_PUSH_MESSAGES,
+                    res.results,  # pylint: disable=no-member
+                )
+
+            if res and res.objects_to_push:
+                objs_to_push = set(res.objects_to_push[message.object_id].object_ids)
+
+                def fn(request: PushObjectRequest) -> PushObjectResponse:
+                    res = _request(
+                        req=request,
+                        res_type=PushObjectResponse,
+                        api_path=PATH_PUSH_OBJECT,
+                    )
+                    if res is None:
+                        raise ValueError("PushObjectResponse is None.")
+                    return res
+
+                try:
+                    push_objects(
+                        all_objects,
+                        push_object_fn=make_push_object_fn_rest(
+                            push_object_rest=fn,
+                            node=node,
+                            run_id=message_proto.metadata.run_id,
+                        ),
+                        object_ids_to_push=objs_to_push,
+                    )
+                    log(DEBUG, "Pushed %s objects to servicer.", len(objs_to_push))
+                except ValueError as e:
+                    log(
+                        ERROR,
+                        "Pushing objects failed. Potential irrecoverable error: %s",
+                        str(e),
+                    )
+                    log(ERROR, str(e))
 
-        log(
-            INFO,
-            "[Node] POST /%s: success, created result %s",
-            PATH_PUSH_MESSAGES,
-            res.results,  # pylint: disable=no-member
-        )
+        # Cleanup
+        metadata = None
 
     def get_run(run_id: int) -> Run:
         # Construct the request

flwr/common/auth_plugin/auth_plugin.py

@@ -20,7 +20,7 @@ from collections.abc import Sequence
 from pathlib import Path
 from typing import Optional, Union
 
-from flwr.common.typing import UserInfo
+from flwr.common.typing import AccountInfo
 from flwr.proto.exec_pb2_grpc import ExecStub
 
 from ..typing import UserAuthCredentials, UserAuthLoginDetails
@@ -53,7 +53,7 @@ class ExecAuthPlugin(ABC):
     @abstractmethod
     def validate_tokens_in_metadata(
         self, metadata: Sequence[tuple[str, Union[str, bytes]]]
-    ) -> tuple[bool, Optional[UserInfo]]:
+    ) -> tuple[bool, Optional[AccountInfo]]:
         """Validate authentication tokens in the provided metadata."""
 
     @abstractmethod
@@ -63,7 +63,9 @@ class ExecAuthPlugin(ABC):
     @abstractmethod
     def refresh_tokens(
         self, metadata: Sequence[tuple[str, Union[str, bytes]]]
-    ) -> tuple[Optional[Sequence[tuple[str, Union[str, bytes]]]], Optional[UserInfo]]:
+    ) -> tuple[
+        Optional[Sequence[tuple[str, Union[str, bytes]]]], Optional[AccountInfo]
+    ]:
         """Refresh authentication tokens in the provided metadata."""
 
 
@@ -84,7 +86,7 @@ class ExecAuthzPlugin(ABC):  # pylint: disable=too-few-public-methods
         """Abstract constructor."""
 
     @abstractmethod
-    def verify_user_authorization(self, user_info: UserInfo) -> bool:
+    def verify_user_authorization(self, account_info: AccountInfo) -> bool:
         """Verify user authorization request."""
 
 

flwr/common/event_log_plugin/event_log_plugin.py

@@ -21,7 +21,7 @@ from typing import Optional, Union
 import grpc
 from google.protobuf.message import Message as GrpcMessage
 
-from flwr.common.typing import LogEntry, UserInfo
+from flwr.common.typing import AccountInfo, LogEntry
 
 
 class EventLogWriterPlugin(ABC):
@@ -36,7 +36,7 @@ class EventLogWriterPlugin(ABC):
         self,
         request: GrpcMessage,
         context: grpc.ServicerContext,
-        user_info: Optional[UserInfo],
+        account_info: Optional[AccountInfo],
         method_name: str,
     ) -> LogEntry:
         """Compose pre-event log entry from the provided request and context."""
@@ -46,7 +46,7 @@ class EventLogWriterPlugin(ABC):
         self,
         request: GrpcMessage,
         context: grpc.ServicerContext,
-        user_info: Optional[UserInfo],
+        account_info: Optional[AccountInfo],
         method_name: str,
         response: Optional[Union[GrpcMessage, BaseException]],
     ) -> LogEntry:

flwr/common/inflatable.py

@@ -18,8 +18,13 @@
 from __future__ import annotations
 
 import hashlib
+import threading
+from collections.abc import Iterator
+from contextlib import contextmanager
 from typing import TypeVar, cast
 
+from flwr.proto.message_pb2 import ObjectTree  # pylint: disable=E0611
+
 from .constant import HEAD_BODY_DIVIDER, HEAD_VALUE_DIVIDER
 
 
@@ -33,6 +38,33 @@ class UnexpectedObjectContentError(Exception):
         )
 
 
+_ctx = threading.local()
+
+
+def _is_recompute_enabled() -> bool:
+    """Check if recomputing object IDs is enabled."""
+    return getattr(_ctx, "recompute_object_id_enabled", True)
+
+
+def _get_computed_object_ids() -> set[str]:
+    """Get the set of computed object IDs."""
+    return getattr(_ctx, "computed_object_ids", set())
+
+
+@contextmanager
+def no_object_id_recompute() -> Iterator[None]:
+    """Context manager to disable recomputing object IDs."""
+    old_value = _is_recompute_enabled()
+    old_set = _get_computed_object_ids()
+    _ctx.recompute_object_id_enabled = False
+    _ctx.computed_object_ids = set()
+    try:
+        yield
+    finally:
+        _ctx.recompute_object_id_enabled = old_value
+        _ctx.computed_object_ids = old_set
+
+
 class InflatableObject:
     """Base class for inflatable objects."""
 
@@ -65,8 +97,23 @@ class InflatableObject:
     @property
     def object_id(self) -> str:
         """Get object_id."""
+        # If recomputing object ID is disabled and the object ID is already computed,
+        # return the cached object ID.
+        if (
+            not _is_recompute_enabled()
+            and (obj_id := self.__dict__.get("_object_id"))
+            in _get_computed_object_ids()
+        ):
+            return cast(str, obj_id)
+
         if self.is_dirty or "_object_id" not in self.__dict__:
-            self.__dict__["_object_id"] = get_object_id(self.deflate())
+            obj_id = get_object_id(self.deflate())
+            self.__dict__["_object_id"] = obj_id
+
+            # If recomputing object ID is disabled, add the object ID to the set of
+            # computed object IDs to avoid recomputing it within the context.
+            if not _is_recompute_enabled():
+                _get_computed_object_ids().add(obj_id)
         return cast(str, self.__dict__["_object_id"])
 
     @property
@@ -219,3 +266,25 @@ def get_all_nested_objects(obj: InflatableObject) -> dict[str, InflatableObject]
     ret[obj.object_id] = obj
 
     return ret
+
+
+def get_object_tree(obj: InflatableObject) -> ObjectTree:
+    """Get a tree representation of the InflatableObject."""
+    tree_children = []
+    if children := obj.children:
+        for child in children.values():
+            tree_children.append(get_object_tree(child))
+    return ObjectTree(object_id=obj.object_id, children=tree_children)
+
+
+def iterate_object_tree(
+    tree: ObjectTree,
+) -> Iterator[ObjectTree]:
+    """Iterate over the object tree and yield object IDs.
+
+    This function performs a post-order traversal of the tree, yielding the object ID of
+    each node after all its children have been yielded.
+    """
+    for child in tree.children:
+        yield from iterate_object_tree(child)
+    yield tree

flwr/common/inflatable_grpc_utils.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""InflatableObject utils."""
+"""InflatableObject gRPC utils."""
 
 
 from typing import Callable

flwr/common/inflatable_rest_utils.py

@@ -0,0 +1,99 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""InflatableObject REST utils."""
+
+
+from typing import Callable
+
+from flwr.proto.message_pb2 import (  # pylint: disable=E0611
+    PullObjectRequest,
+    PullObjectResponse,
+    PushObjectRequest,
+    PushObjectResponse,
+)
+from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
+
+from .inflatable_utils import ObjectIdNotPreregisteredError, ObjectUnavailableError
+
+
+def make_pull_object_fn_rest(
+    pull_object_rest: Callable[[PullObjectRequest], PullObjectResponse],
+    node: Node,
+    run_id: int,
+) -> Callable[[str], bytes]:
+    """Create a pull object function that uses REST to pull objects.
+
+    Parameters
+    ----------
+    pull_object_rest : Callable[[PullObjectRequest], PullObjectResponse]
+        A function that makes a POST request against the `/push-object` REST endpoint
+    node : Node
+        The node making the request.
+    run_id : int
+        The run ID for the current operation.
+
+    Returns
+    -------
+    Callable[[str], bytes]
+        A function that takes an object ID and returns the object content as bytes.
+        The function raises `ObjectIdNotPreregisteredError` if the object ID is not
+        pre-registered, or `ObjectUnavailableError` if the object is not yet available.
+    """
+
+    def pull_object_fn(object_id: str) -> bytes:
+        request = PullObjectRequest(node=node, run_id=run_id, object_id=object_id)
+        response: PullObjectResponse = pull_object_rest(request)
+        if not response.object_found:
+            raise ObjectIdNotPreregisteredError(object_id)
+        if not response.object_available:
+            raise ObjectUnavailableError(object_id)
+        return response.object_content
+
+    return pull_object_fn
+
+
+def make_push_object_fn_rest(
+    push_object_rest: Callable[[PushObjectRequest], PushObjectResponse],
+    node: Node,
+    run_id: int,
+) -> Callable[[str, bytes], None]:
+    """Create a push object function that uses REST to push objects.
+
+    Parameters
+    ----------
+    push_object_rest : Callable[[PushObjectRequest], PushObjectResponse]
+        A function that makes a POST request against the `/pull-object` REST endpoint
+    node : Node
+        The node making the request.
+    run_id : int
+        The run ID for the current operation.
+
+    Returns
+    -------
+    Callable[[str, bytes], None]
+        A function that takes an object ID and its content as bytes, and pushes it
+        to the servicer. The function raises `ObjectIdNotPreregisteredError` if
+        the object ID is not pre-registered.
+    """
+
+    def push_object_fn(object_id: str, object_content: bytes) -> None:
+        request = PushObjectRequest(
+            node=node, run_id=run_id, object_id=object_id, object_content=object_content
+        )
+        response: PushObjectResponse = push_object_rest(request)
+        if not response.stored:
+            raise ObjectIdNotPreregisteredError(object_id)
+
+    return push_object_fn

flwr/common/serde.py

@@ -630,6 +630,7 @@ def run_to_proto(run: typing.Run) -> ProtoRun:
         running_at=run.running_at,
         finished_at=run.finished_at,
         status=run_status_to_proto(run.status),
+        flwr_aid=run.flwr_aid,
     )
     return proto
 
@@ -647,6 +648,7 @@ def run_from_proto(run_proto: ProtoRun) -> typing.Run:
         running_at=run_proto.running_at,
         finished_at=run_proto.finished_at,
         status=run_status_from_proto(run_proto.status),
+        flwr_aid=run_proto.flwr_aid,
     )
     return run
 

flwr/common/typing.py

@@ -230,6 +230,7 @@ class Run:  # pylint: disable=too-many-instance-attributes
     running_at: str
     finished_at: str
     status: RunStatus
+    flwr_aid: str
 
     @classmethod
     def create_empty(cls, run_id: int) -> "Run":
@@ -245,6 +246,7 @@ class Run:  # pylint: disable=too-many-instance-attributes
             running_at="",
             finished_at="",
             status=RunStatus(status="", sub_status="", details=""),
+            flwr_aid="",
         )
 
 
@@ -289,11 +291,11 @@ class UserAuthCredentials:
 
 
 @dataclass
-class UserInfo:
+class AccountInfo:
     """User information for event log."""
 
-    user_id: Optional[str]
-    user_name: Optional[str]
+    flwr_aid: Optional[str]
+    account_name: Optional[str]
 
 
 @dataclass