flwr 1.15.1__py3-none-any.whl → 1.16.0__py3-none-any.whl

flwr/common/record/recordset.py

@@ -17,82 +17,79 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import cast
+from logging import WARN
+from textwrap import indent
+from typing import TypeVar, Union, cast
 
+from ..logger import log
 from .configsrecord import ConfigsRecord
 from .metricsrecord import MetricsRecord
 from .parametersrecord import ParametersRecord
 from .typeddict import TypedDict
 
+RecordType = Union[ParametersRecord, MetricsRecord, ConfigsRecord]
 
-@dataclass
-class RecordSetData:
-    """Inner data container for the RecordSet class."""
+T = TypeVar("T")
 
-    parameters_records: TypedDict[str, ParametersRecord]
-    metrics_records: TypedDict[str, MetricsRecord]
-    configs_records: TypedDict[str, ConfigsRecord]
 
-    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:
-        self.parameters_records = TypedDict[str, ParametersRecord](
-            self._check_fn_str, self._check_fn_params
+def _check_key(key: str) -> None:
+    if not isinstance(key, str):
+        raise TypeError(
+            f"Expected `{str.__name__}`, but "
+            f"received `{type(key).__name__}` for the key."
         )
-        self.metrics_records = TypedDict[str, MetricsRecord](
-            self._check_fn_str, self._check_fn_metrics
-        )
-        self.configs_records = TypedDict[str, ConfigsRecord](
-            self._check_fn_str, self._check_fn_configs
+
+
+def _check_value(value: RecordType) -> None:
+    if not isinstance(value, (ParametersRecord, MetricsRecord, ConfigsRecord)):
+        raise TypeError(
+            f"Expected `{ParametersRecord.__name__}`, `{MetricsRecord.__name__}`, "
+            f"or `{ConfigsRecord.__name__}` but received "
+            f"`{type(value).__name__}` for the value."
         )
-        if parameters_records is not None:
-            self.parameters_records.update(parameters_records)
-        if metrics_records is not None:
-            self.metrics_records.update(metrics_records)
-        if configs_records is not None:
-            self.configs_records.update(configs_records)
-
-    def _check_fn_str(self, key: str) -> None:
-        if not isinstance(key, str):
-            raise TypeError(
-                f"Expected `{str.__name__}`, but "
-                f"received `{type(key).__name__}` for the key."
-            )
 
-    def _check_fn_params(self, record: ParametersRecord) -> None:
-        if not isinstance(record, ParametersRecord):
-            raise TypeError(
-                f"Expected `{ParametersRecord.__name__}`, but "
-                f"received `{type(record).__name__}` for the value."
-            )
 
-    def _check_fn_metrics(self, record: MetricsRecord) -> None:
-        if not isinstance(record, MetricsRecord):
-            raise TypeError(
-                f"Expected `{MetricsRecord.__name__}`, but "
-                f"received `{type(record).__name__}` for the value."
-            )
+class _SyncedDict(TypedDict[str, T]):
+    """A synchronized dictionary that mirrors changes to an underlying RecordSet.
+
+    This dictionary ensures that any modifications (set or delete operations)
+    are automatically reflected in the associated `RecordSet`. Only values of
+    the specified `allowed_type` are permitted.
+    """
 
-    def _check_fn_configs(self, record: ConfigsRecord) -> None:
-        if not isinstance(record, ConfigsRecord):
+    def __init__(self, ref_recordset: RecordSet, allowed_type: type[T]) -> None:
+        if not issubclass(
+            allowed_type, (ParametersRecord, MetricsRecord, ConfigsRecord)
+        ):
+            raise TypeError(f"{allowed_type} is not a valid type.")
+        super().__init__(_check_key, self.check_value)
+        self.recordset = ref_recordset
+        self.allowed_type = allowed_type
+
+    def __setitem__(self, key: str, value: T) -> None:
+        super().__setitem__(key, value)
+        self.recordset[key] = cast(RecordType, value)
+
+    def __delitem__(self, key: str) -> None:
+        super().__delitem__(key)
+        del self.recordset[key]
+
+    def check_value(self, value: T) -> None:
+        """Check if value is of expected type."""
+        if not isinstance(value, self.allowed_type):
             raise TypeError(
-                f"Expected `{ConfigsRecord.__name__}`, but "
-                f"received `{type(record).__name__}` for the value."
+                f"Expected `{self.allowed_type.__name__}`, but "
+                f"received `{type(value).__name__}` for the value."
             )
 
 
-class RecordSet:
+class RecordSet(TypedDict[str, RecordType]):
     """RecordSet stores groups of parameters, metrics and configs.
 
-    A :code:`RecordSet` is the unified mechanism by which parameters,
-    metrics and configs can be either stored as part of a
-    `flwr.common.Context <flwr.common.Context.html>`_ in your apps
-    or communicated as part of a
-    `flwr.common.Message <flwr.common.Message.html>`_ between your apps.
+    A :class:`RecordSet` is the unified mechanism by which parameters,
+    metrics and configs can be either stored as part of a :class:`Context`
+    in your apps or communicated as part of a :class:`Message` between
+    your apps.
 
     Parameters
     ----------
@@ -127,12 +124,12 @@ class RecordSet:
     >>>  # We can create a ConfigsRecord
     >>>  c_record = ConfigsRecord({"lr": 0.1, "batch-size": 128})
     >>>  # Adding it to the record_set would look like this
-    >>>  my_recordset.configs_records["my_config"] = c_record
+    >>>  my_recordset["my_config"] = c_record
     >>>
     >>>  # We can create a MetricsRecord following a similar process
     >>>  m_record = MetricsRecord({"accuracy": 0.93, "losses": [0.23, 0.1]})
     >>>  # Adding it to the record_set would look like this
-    >>>  my_recordset.metrics_records["my_metrics"] = m_record
+    >>>  my_recordset["my_metrics"] = m_record
 
     Adding a :code:`ParametersRecord` follows the same steps as above but first,
     the array needs to be serialized and represented as a :code:`flwr.common.Array`.
@@ -151,52 +148,62 @@ class RecordSet:
     >>>  p_record = ParametersRecord({"my_array": arr})
     >>>
     >>>  # Adding it to the record_set would look like this
-    >>>  my_recordset.parameters_records["my_parameters"] = p_record
+    >>>  my_recordset["my_parameters"] = p_record
 
     For additional examples on how to construct each of the records types shown
     above, please refer to the documentation for :code:`ConfigsRecord`,
     :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:
-        data = RecordSetData(
-            parameters_records=parameters_records,
-            metrics_records=metrics_records,
-            configs_records=configs_records,
-        )
-        self.__dict__["_data"] = data
+    def __init__(self, records: dict[str, RecordType] | None = None) -> None:
+        super().__init__(_check_key, _check_value)
+        if records is not None:
+            for key, record in records.items():
+                self[key] = record
 
     @property
     def parameters_records(self) -> TypedDict[str, ParametersRecord]:
-        """Dictionary holding ParametersRecord instances."""
-        data = cast(RecordSetData, self.__dict__["_data"])
-        return data.parameters_records
+        """Dictionary holding only ParametersRecord instances."""
+        synced_dict = _SyncedDict[ParametersRecord](self, ParametersRecord)
+        for key, record in self.items():
+            if isinstance(record, ParametersRecord):
+                synced_dict[key] = record
+        return synced_dict
 
     @property
     def metrics_records(self) -> TypedDict[str, MetricsRecord]:
-        """Dictionary holding MetricsRecord instances."""
-        data = cast(RecordSetData, self.__dict__["_data"])
-        return data.metrics_records
+        """Dictionary holding only MetricsRecord instances."""
+        synced_dict = _SyncedDict[MetricsRecord](self, MetricsRecord)
+        for key, record in self.items():
+            if isinstance(record, MetricsRecord):
+                synced_dict[key] = record
+        return synced_dict
 
     @property
     def configs_records(self) -> TypedDict[str, ConfigsRecord]:
-        """Dictionary holding ConfigsRecord instances."""
-        data = cast(RecordSetData, self.__dict__["_data"])
-        return data.configs_records
+        """Dictionary holding only ConfigsRecord instances."""
+        synced_dict = _SyncedDict[ConfigsRecord](self, ConfigsRecord)
+        for key, record in self.items():
+            if isinstance(record, ConfigsRecord):
+                synced_dict[key] = record
+        return synced_dict
 
     def __repr__(self) -> str:
         """Return a string representation of this instance."""
         flds = ("parameters_records", "metrics_records", "configs_records")
-        view = ", ".join([f"{fld}={getattr(self, fld)!r}" for fld in flds])
-        return f"{self.__class__.__qualname__}({view})"
-
-    def __eq__(self, other: object) -> bool:
-        """Compare two instances of the class."""
-        if not isinstance(other, self.__class__):
-            raise NotImplementedError
-        return self.__dict__ == other.__dict__
+        fld_views = [f"{fld}={dict(getattr(self, fld))!r}" for fld in flds]
+        view = indent(",\n".join(fld_views), "  ")
+        return f"{self.__class__.__qualname__}(\n{view}\n)"
+
+    def __setitem__(self, key: str, value: RecordType) -> None:
+        """Set the given key to the given value after type checking."""
+        original_value = self.get(key, None)
+        super().__setitem__(key, value)
+        if original_value is not None and not isinstance(value, type(original_value)):
+            log(
+                WARN,
+                "Key '%s' was overwritten: record of type `%s` replaced with type `%s`",
+                key,
+                type(original_value).__name__,
+                type(value).__name__,
+            )

flwr/common/secure_aggregation/quantization.py

@@ -25,7 +25,11 @@ from flwr.common.typing import NDArrayFloat, NDArrayInt
 def _stochastic_round(arr: NDArrayFloat) -> NDArrayInt:
     ret: NDArrayInt = np.ceil(arr).astype(np.int32)
     rand_arr = np.random.rand(*ret.shape)
-    ret[rand_arr < ret - arr] -= 1
+    if len(ret.shape) == 0:
+        if rand_arr < ret - arr:
+            ret -= 1
+    else:
+        ret[rand_arr < ret - arr] -= 1
     return ret
 
 

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/common/telemetry.py

@@ -181,16 +181,6 @@ class EventType(str, Enum):
     RUN_SUPERNODE_ENTER = auto()
     RUN_SUPERNODE_LEAVE = auto()
 
-    # --- DEPRECATED -------------------------------------------------------------------
-
-    # [DEPRECATED] CLI: `flower-server-app`
-    RUN_SERVER_APP_ENTER = auto()
-    RUN_SERVER_APP_LEAVE = auto()
-
-    # [DEPRECATED] CLI: `flower-client-app`
-    RUN_CLIENT_APP_ENTER = auto()
-    RUN_CLIENT_APP_LEAVE = auto()
-
 
 # Use the ThreadPoolExecutor with max_workers=1 to have a queue
 # and also ensure that telemetry calls are not blocking.

flwr/common/typing.py

@@ -286,3 +286,39 @@ class UserAuthCredentials:
 
     access_token: str
     refresh_token: str
+
+
+@dataclass
+class UserInfo:
+    """User information for event log."""
+
+    user_id: Optional[str]
+    user_name: Optional[str]
+
+
+@dataclass
+class Actor:
+    """Event log actor."""
+
+    actor_id: Optional[str]
+    description: Optional[str]
+    ip_address: str
+
+
+@dataclass
+class Event:
+    """Event log description."""
+
+    action: str
+    run_id: Optional[int]
+    fab_hash: Optional[str]
+
+
+@dataclass
+class LogEntry:
+    """Event log record."""
+
+    timestamp: str
+    actor: Actor
+    event: Event
+    status: str

flwr/server/app.py

@@ -90,7 +90,11 @@ BASE_DIR = get_flwr_dir() / "superlink" / "ffs"
 
 
 try:
-    from flwr.ee import add_ee_args_superlink, get_exec_auth_plugins
+    from flwr.ee import (
+        add_ee_args_superlink,
+        get_dashboard_server,
+        get_exec_auth_plugins,
+    )
 except ImportError:
 
     # pylint: disable-next=unused-argument
@@ -431,6 +435,17 @@ def run_superlink() -> None:
         scheduler_th.start()
         bckg_threads.append(scheduler_th)
 
+    # Add Dashboard server if available
+    if dashboard_address := getattr(args, "dashboard_address", None):
+        dashboard_address_str, _, _ = _format_address(dashboard_address)
+        dashboard_server = get_dashboard_server(
+            address=dashboard_address_str,
+            state_factory=state_factory,
+            certificates=None,
+        )
+
+        grpc_servers.append(dashboard_server)
+
     # Graceful shutdown
     register_exit_handlers(
         event_type=EventType.RUN_SUPERLINK_LEAVE,
@@ -710,7 +725,8 @@ def _add_args_common(parser: argparse.ArgumentParser) -> None:
         "--insecure",
         action="store_true",
         help="Run the server without HTTPS, regardless of whether certificate "
-        "paths are provided. By default, the server runs with HTTPS enabled. "
+        "paths are provided. Data transmitted between the gRPC client and server "
+        "is not encrypted. By default, the server runs with HTTPS enabled. "
         "Use this flag only if you understand the risks.",
     )
     parser.add_argument(

flwr/server/compat/app.py

@@ -79,10 +79,13 @@ def start_driver(  # pylint: disable=too-many-arguments, too-many-locals
     log(INFO, "")
 
     # Start the thread updating nodes
-    thread, f_stop = start_update_client_manager_thread(
+    thread, f_stop, c_done = start_update_client_manager_thread(
         driver, initialized_server.client_manager()
     )
 
+    # Wait until the node registration done
+    c_done.wait()
+
     # Start training
     hist = run_fl(
         server=initialized_server,

flwr/server/compat/app_utils.py

@@ -27,7 +27,7 @@ from ..driver import Driver
 def start_update_client_manager_thread(
     driver: Driver,
     client_manager: ClientManager,
-) -> tuple[threading.Thread, threading.Event]:
+) -> tuple[threading.Thread, threading.Event, threading.Event]:
     """Periodically update the nodes list in the client manager in a thread.
 
     This function starts a thread that periodically uses the associated driver to
@@ -51,26 +51,31 @@ def start_update_client_manager_thread(
         A thread that updates the ClientManager and handles the stop event.
     threading.Event
         An event that, when set, signals the thread to stop.
+    threading.Event
+        An event that, when set, signals the node registration done.
     """
     f_stop = threading.Event()
+    c_done = threading.Event()
     thread = threading.Thread(
         target=_update_client_manager,
         args=(
             driver,
             client_manager,
             f_stop,
+            c_done,
         ),
         daemon=True,
     )
     thread.start()
 
-    return thread, f_stop
+    return thread, f_stop, c_done
 
 
 def _update_client_manager(
     driver: Driver,
     client_manager: ClientManager,
     f_stop: threading.Event,
+    c_done: threading.Event,
 ) -> None:
     """Update the nodes list in the client manager."""
     # Loop until the driver is disconnected
@@ -102,6 +107,9 @@ def _update_client_manager(
             else:
                 raise RuntimeError("Could not register node.")
 
+        # Flag first pass for nodes registration is completed
+        c_done.set()
+
         # Sleep for 3 seconds
         if not f_stop.is_set():
             f_stop.wait(3)

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/driver.py

@@ -85,7 +85,7 @@ class Driver(ABC):
         """
 
     @abstractmethod
-    def get_node_ids(self) -> list[int]:
+    def get_node_ids(self) -> Iterable[int]:
         """Get node IDs."""
 
     @abstractmethod

flwr/server/driver/grpc_driver.py

@@ -183,7 +183,7 @@ class GrpcDriver(Driver):
         )
         return Message(metadata=metadata, content=content)
 
-    def get_node_ids(self) -> list[int]:
+    def get_node_ids(self) -> Iterable[int]:
         """Get node IDs."""
         # Call GrpcDriverStub method
         res: GetNodesResponse = self._stub.GetNodes(
@@ -212,6 +212,15 @@ class GrpcDriver(Driver):
                 messages_list=message_proto_list, run_id=cast(Run, self._run).run_id
             )
         )
+        if len([msg_id for msg_id in res.message_ids if msg_id]) != len(
+            list(message_proto_list)
+        ):
+            log(
+                WARNING,
+                "Not all messages could be pushed to the SuperLink. The returned "
+                "list has `None` for those messages (the order is preserved as passed "
+                "to `push_messages`). This could be due to a malformed message.",
+            )
         return list(res.message_ids)
 
     def pull_messages(self, message_ids: Iterable[str]) -> Iterable[Message]: