flwr-nightly 1.8.0.dev20240228__py3-none-any.whl → 1.8.0.dev20240229__py3-none-any.whl

flwr/client/mod/secure_aggregation/secaggplus_mod.py

@@ -52,31 +52,10 @@ from flwr.common.secure_aggregation.ndarrays_arithmetic import (
 )
 from flwr.common.secure_aggregation.quantization import quantize
 from flwr.common.secure_aggregation.secaggplus_constants import (
-    KEY_ACTIVE_SECURE_ID_LIST,
-    KEY_CIPHERTEXT_LIST,
-    KEY_CLIPPING_RANGE,
-    KEY_DEAD_SECURE_ID_LIST,
-    KEY_DESTINATION_LIST,
-    KEY_MASKED_PARAMETERS,
-    KEY_MOD_RANGE,
-    KEY_PUBLIC_KEY_1,
-    KEY_PUBLIC_KEY_2,
-    KEY_SAMPLE_NUMBER,
-    KEY_SECURE_ID,
-    KEY_SECURE_ID_LIST,
-    KEY_SHARE_LIST,
-    KEY_SHARE_NUMBER,
-    KEY_SOURCE_LIST,
-    KEY_STAGE,
-    KEY_TARGET_RANGE,
-    KEY_THRESHOLD,
     RECORD_KEY_CONFIGS,
     RECORD_KEY_STATE,
-    STAGE_COLLECT_MASKED_INPUT,
-    STAGE_SETUP,
-    STAGE_SHARE_KEYS,
-    STAGE_UNMASK,
-    STAGES,
+    Key,
+    Stage,
 )
 from flwr.common.secure_aggregation.secaggplus_utils import (
     pseudo_rand_gen,
@@ -91,7 +70,7 @@ from flwr.common.typing import ConfigsRecordValues, FitRes
 class SecAggPlusState:
     """State of the SecAgg+ protocol."""
 
-    current_stage: str = STAGE_UNMASK
+    current_stage: str = Stage.UNMASK
 
     sid: int = 0
     sample_num: int = 0
@@ -187,20 +166,20 @@ def secaggplus_mod(
     check_stage(state.current_stage, configs)
 
     # Update the current stage
-    state.current_stage = cast(str, configs.pop(KEY_STAGE))
+    state.current_stage = cast(str, configs.pop(Key.STAGE))
 
     # Check the validity of the configs based on the current stage
     check_configs(state.current_stage, configs)
 
     # Execute
-    if state.current_stage == STAGE_SETUP:
+    if state.current_stage == Stage.SETUP:
         res = _setup(state, configs)
-    elif state.current_stage == STAGE_SHARE_KEYS:
+    elif state.current_stage == Stage.SHARE_KEYS:
         res = _share_keys(state, configs)
-    elif state.current_stage == STAGE_COLLECT_MASKED_INPUT:
+    elif state.current_stage == Stage.COLLECT_MASKED_INPUT:
         fit = _get_fit_fn(msg, ctxt, call_next)
         res = _collect_masked_input(state, configs, fit)
-    elif state.current_stage == STAGE_UNMASK:
+    elif state.current_stage == Stage.UNMASK:
         res = _unmask(state, configs)
     else:
         raise ValueError(f"Unknown secagg stage: {state.current_stage}")
@@ -215,28 +194,29 @@ def secaggplus_mod(
 
 def check_stage(current_stage: str, configs: ConfigsRecord) -> None:
     """Check the validity of the next stage."""
-    # Check the existence of KEY_STAGE
-    if KEY_STAGE not in configs:
+    # Check the existence of Config.STAGE
+    if Key.STAGE not in configs:
         raise KeyError(
-            f"The required key '{KEY_STAGE}' is missing from the input `named_values`."
+            f"The required key '{Key.STAGE}' is missing from the input `named_values`."
         )
 
-    # Check the value type of the KEY_STAGE
-    next_stage = configs[KEY_STAGE]
+    # Check the value type of the Config.STAGE
+    next_stage = configs[Key.STAGE]
     if not isinstance(next_stage, str):
         raise TypeError(
-            f"The value for the key '{KEY_STAGE}' must be of type {str}, "
+            f"The value for the key '{Key.STAGE}' must be of type {str}, "
             f"but got {type(next_stage)} instead."
         )
 
     # Check the validity of the next stage
-    if next_stage == STAGE_SETUP:
-        if current_stage != STAGE_UNMASK:
+    if next_stage == Stage.SETUP:
+        if current_stage != Stage.UNMASK:
             log(WARNING, "Restart from the setup stage")
     # If stage is not "setup",
     # the stage from `named_values` should be the expected next stage
     else:
-        expected_next_stage = STAGES[(STAGES.index(current_stage) + 1) % len(STAGES)]
+        stages = Stage.all()
+        expected_next_stage = stages[(stages.index(current_stage) + 1) % len(stages)]
         if next_stage != expected_next_stage:
             raise ValueError(
                 "Abort secure aggregation: "
@@ -248,20 +228,20 @@ def check_stage(current_stage: str, configs: ConfigsRecord) -> None:
 def check_configs(stage: str, configs: ConfigsRecord) -> None:
     """Check the validity of the configs."""
     # Check `named_values` for the setup stage
-    if stage == STAGE_SETUP:
+    if stage == Stage.SETUP:
         key_type_pairs = [
-            (KEY_SAMPLE_NUMBER, int),
-            (KEY_SECURE_ID, int),
-            (KEY_SHARE_NUMBER, int),
-            (KEY_THRESHOLD, int),
-            (KEY_CLIPPING_RANGE, float),
-            (KEY_TARGET_RANGE, int),
-            (KEY_MOD_RANGE, int),
+            (Key.SAMPLE_NUMBER, int),
+            (Key.SECURE_ID, int),
+            (Key.SHARE_NUMBER, int),
+            (Key.THRESHOLD, int),
+            (Key.CLIPPING_RANGE, float),
+            (Key.TARGET_RANGE, int),
+            (Key.MOD_RANGE, int),
         ]
         for key, expected_type in key_type_pairs:
             if key not in configs:
                 raise KeyError(
-                    f"Stage {STAGE_SETUP}: the required key '{key}' is "
+                    f"Stage {Stage.SETUP}: the required key '{key}' is "
                     "missing from the input `named_values`."
                 )
             # Bool is a subclass of int in Python,
@@ -269,11 +249,11 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
             # pylint: disable-next=unidiomatic-typecheck
             if type(configs[key]) is not expected_type:
                 raise TypeError(
-                    f"Stage {STAGE_SETUP}: The value for the key '{key}' "
+                    f"Stage {Stage.SETUP}: The value for the key '{key}' "
                     f"must be of type {expected_type}, "
                     f"but got {type(configs[key])} instead."
                 )
-    elif stage == STAGE_SHARE_KEYS:
+    elif stage == Stage.SHARE_KEYS:
         for key, value in configs.items():
             if (
                 not isinstance(value, list)
@@ -282,18 +262,18 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
                 or not isinstance(value[1], bytes)
             ):
                 raise TypeError(
-                    f"Stage {STAGE_SHARE_KEYS}: "
+                    f"Stage {Stage.SHARE_KEYS}: "
                     f"the value for the key '{key}' must be a list of two bytes."
                 )
-    elif stage == STAGE_COLLECT_MASKED_INPUT:
+    elif stage == Stage.COLLECT_MASKED_INPUT:
         key_type_pairs = [
-            (KEY_CIPHERTEXT_LIST, bytes),
-            (KEY_SOURCE_LIST, int),
+            (Key.CIPHERTEXT_LIST, bytes),
+            (Key.SOURCE_LIST, int),
         ]
         for key, expected_type in key_type_pairs:
             if key not in configs:
                 raise KeyError(
-                    f"Stage {STAGE_COLLECT_MASKED_INPUT}: "
+                    f"Stage {Stage.COLLECT_MASKED_INPUT}: "
                     f"the required key '{key}' is "
                     "missing from the input `named_values`."
                 )
@@ -304,19 +284,19 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
                 if type(elm) is not expected_type
             ):
                 raise TypeError(
-                    f"Stage {STAGE_COLLECT_MASKED_INPUT}: "
+                    f"Stage {Stage.COLLECT_MASKED_INPUT}: "
                     f"the value for the key '{key}' "
                     f"must be of type List[{expected_type.__name__}]"
                 )
-    elif stage == STAGE_UNMASK:
+    elif stage == Stage.UNMASK:
         key_type_pairs = [
-            (KEY_ACTIVE_SECURE_ID_LIST, int),
-            (KEY_DEAD_SECURE_ID_LIST, int),
+            (Key.ACTIVE_SECURE_ID_LIST, int),
+            (Key.DEAD_SECURE_ID_LIST, int),
         ]
         for key, expected_type in key_type_pairs:
             if key not in configs:
                 raise KeyError(
-                    f"Stage {STAGE_UNMASK}: "
+                    f"Stage {Stage.UNMASK}: "
                     f"the required key '{key}' is "
                     "missing from the input `named_values`."
                 )
@@ -327,7 +307,7 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
                 if type(elm) is not expected_type
             ):
                 raise TypeError(
-                    f"Stage {STAGE_UNMASK}: "
+                    f"Stage {Stage.UNMASK}: "
                     f"the value for the key '{key}' "
                     f"must be of type List[{expected_type.__name__}]"
                 )
@@ -340,15 +320,15 @@ def _setup(
 ) -> Dict[str, ConfigsRecordValues]:
     # Assigning parameter values to object fields
     sec_agg_param_dict = configs
-    state.sample_num = cast(int, sec_agg_param_dict[KEY_SAMPLE_NUMBER])
-    state.sid = cast(int, sec_agg_param_dict[KEY_SECURE_ID])
+    state.sample_num = cast(int, sec_agg_param_dict[Key.SAMPLE_NUMBER])
+    state.sid = cast(int, sec_agg_param_dict[Key.SECURE_ID])
     log(INFO, "Client %d: starting stage 0...", state.sid)
 
-    state.share_num = cast(int, sec_agg_param_dict[KEY_SHARE_NUMBER])
-    state.threshold = cast(int, sec_agg_param_dict[KEY_THRESHOLD])
-    state.clipping_range = cast(float, sec_agg_param_dict[KEY_CLIPPING_RANGE])
-    state.target_range = cast(int, sec_agg_param_dict[KEY_TARGET_RANGE])
-    state.mod_range = cast(int, sec_agg_param_dict[KEY_MOD_RANGE])
+    state.share_num = cast(int, sec_agg_param_dict[Key.SHARE_NUMBER])
+    state.threshold = cast(int, sec_agg_param_dict[Key.THRESHOLD])
+    state.clipping_range = cast(float, sec_agg_param_dict[Key.CLIPPING_RANGE])
+    state.target_range = cast(int, sec_agg_param_dict[Key.TARGET_RANGE])
+    state.mod_range = cast(int, sec_agg_param_dict[Key.MOD_RANGE])
 
     # Dictionaries containing client secure IDs as keys
     # and their respective secret shares as values.
@@ -367,7 +347,7 @@ def _setup(
     state.sk1, state.pk1 = private_key_to_bytes(sk1), public_key_to_bytes(pk1)
     state.sk2, state.pk2 = private_key_to_bytes(sk2), public_key_to_bytes(pk2)
     log(INFO, "Client %d: stage 0 completes. uploading public keys...", state.sid)
-    return {KEY_PUBLIC_KEY_1: state.pk1, KEY_PUBLIC_KEY_2: state.pk2}
+    return {Key.PUBLIC_KEY_1: state.pk1, Key.PUBLIC_KEY_2: state.pk2}
 
 
 # pylint: disable-next=too-many-locals
@@ -429,7 +409,7 @@ def _share_keys(
             ciphertexts.append(ciphertext)
 
     log(INFO, "Client %d: stage 1 completes. uploading key shares...", state.sid)
-    return {KEY_DESTINATION_LIST: dsts, KEY_CIPHERTEXT_LIST: ciphertexts}
+    return {Key.DESTINATION_LIST: dsts, Key.CIPHERTEXT_LIST: ciphertexts}
 
 
 # pylint: disable-next=too-many-locals
@@ -440,8 +420,8 @@ def _collect_masked_input(
 ) -> Dict[str, ConfigsRecordValues]:
     log(INFO, "Client %d: starting stage 2...", state.sid)
     available_clients: List[int] = []
-    ciphertexts = cast(List[bytes], configs[KEY_CIPHERTEXT_LIST])
-    srcs = cast(List[int], configs[KEY_SOURCE_LIST])
+    ciphertexts = cast(List[bytes], configs[Key.CIPHERTEXT_LIST])
+    srcs = cast(List[int], configs[Key.SOURCE_LIST])
     if len(ciphertexts) + 1 < state.threshold:
         raise ValueError("Not enough available neighbour clients.")
 
@@ -505,7 +485,7 @@ def _collect_masked_input(
     quantized_parameters = parameters_mod(quantized_parameters, state.mod_range)
     log(INFO, "Client %d: stage 2 completes. uploading masked parameters...", state.sid)
     return {
-        KEY_MASKED_PARAMETERS: [ndarray_to_bytes(arr) for arr in quantized_parameters]
+        Key.MASKED_PARAMETERS: [ndarray_to_bytes(arr) for arr in quantized_parameters]
     }
 
 
@@ -514,8 +494,8 @@ def _unmask(
 ) -> Dict[str, ConfigsRecordValues]:
     log(INFO, "Client %d: starting stage 3...", state.sid)
 
-    active_sids = cast(List[int], configs[KEY_ACTIVE_SECURE_ID_LIST])
-    dead_sids = cast(List[int], configs[KEY_DEAD_SECURE_ID_LIST])
+    active_sids = cast(List[int], configs[Key.ACTIVE_SECURE_ID_LIST])
+    dead_sids = cast(List[int], configs[Key.DEAD_SECURE_ID_LIST])
     # Send private mask seed share for every avaliable client (including itclient)
     # Send first private key share for building pairwise mask for every dropped client
     if len(active_sids) < state.threshold:
@@ -528,4 +508,4 @@ def _unmask(
     shares += [state.sk1_share_dict[sid] for sid in dead_sids]
 
     log(INFO, "Client %d: stage 3 completes. uploading key shares...", state.sid)
-    return {KEY_SECURE_ID_LIST: sids, KEY_SHARE_LIST: shares}
+    return {Key.SECURE_ID_LIST: sids, Key.SHARE_LIST: shares}

flwr/common/secure_aggregation/secaggplus_constants.py

@@ -14,33 +14,55 @@
 # ==============================================================================
 """Constants for the SecAgg/SecAgg+ protocol."""
 
+
+from __future__ import annotations
+
 RECORD_KEY_STATE = "secaggplus_state"
 RECORD_KEY_CONFIGS = "secaggplus_configs"
 
-# Names of stages
-STAGE_SETUP = "setup"
-STAGE_SHARE_KEYS = "share_keys"
-STAGE_COLLECT_MASKED_INPUT = "collect_masked_input"
-STAGE_UNMASK = "unmask"
-STAGES = (STAGE_SETUP, STAGE_SHARE_KEYS, STAGE_COLLECT_MASKED_INPUT, STAGE_UNMASK)
-
-# All valid keys in received/replied `named_values` dictionaries
-KEY_STAGE = "stage"
-KEY_SAMPLE_NUMBER = "sample_num"
-KEY_SECURE_ID = "secure_id"
-KEY_SHARE_NUMBER = "share_num"
-KEY_THRESHOLD = "threshold"
-KEY_CLIPPING_RANGE = "clipping_range"
-KEY_TARGET_RANGE = "target_range"
-KEY_MOD_RANGE = "mod_range"
-KEY_PUBLIC_KEY_1 = "pk1"
-KEY_PUBLIC_KEY_2 = "pk2"
-KEY_DESTINATION_LIST = "dsts"
-KEY_CIPHERTEXT_LIST = "ctxts"
-KEY_SOURCE_LIST = "srcs"
-KEY_PARAMETERS = "params"
-KEY_MASKED_PARAMETERS = "masked_params"
-KEY_ACTIVE_SECURE_ID_LIST = "active_sids"
-KEY_DEAD_SECURE_ID_LIST = "dead_sids"
-KEY_SECURE_ID_LIST = "sids"
-KEY_SHARE_LIST = "shares"
+
+class Stage:
+    """Stages for the SecAgg+ protocol."""
+
+    SETUP = "setup"
+    SHARE_KEYS = "share_keys"
+    COLLECT_MASKED_INPUT = "collect_masked_input"
+    UNMASK = "unmask"
+    _stages = (SETUP, SHARE_KEYS, COLLECT_MASKED_INPUT, UNMASK)
+
+    @classmethod
+    def all(cls) -> tuple[str, str, str, str]:
+        """Return all stages."""
+        return cls._stages
+
+    def __new__(cls) -> Stage:
+        """Prevent instantiation."""
+        raise TypeError(f"{cls.__name__} cannot be instantiated.")
+
+
+class Key:
+    """Keys for the configs in the ConfigsRecord."""
+
+    STAGE = "stage"
+    SAMPLE_NUMBER = "sample_num"
+    SECURE_ID = "secure_id"
+    SHARE_NUMBER = "share_num"
+    THRESHOLD = "threshold"
+    CLIPPING_RANGE = "clipping_range"
+    TARGET_RANGE = "target_range"
+    MOD_RANGE = "mod_range"
+    PUBLIC_KEY_1 = "pk1"
+    PUBLIC_KEY_2 = "pk2"
+    DESTINATION_LIST = "dsts"
+    CIPHERTEXT_LIST = "ctxts"
+    SOURCE_LIST = "srcs"
+    PARAMETERS = "params"
+    MASKED_PARAMETERS = "masked_params"
+    ACTIVE_SECURE_ID_LIST = "active_sids"
+    DEAD_SECURE_ID_LIST = "dead_sids"
+    SECURE_ID_LIST = "sids"
+    SHARE_LIST = "shares"
+
+    def __new__(cls) -> Key:
+        """Prevent instantiation."""
+        raise TypeError(f"{cls.__name__} cannot be instantiated.")

flwr/proto/error_pb2.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: flwr/proto/error.proto
+# Protobuf Python Version: 4.25.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x16\x66lwr/proto/error.proto\x12\nflwr.proto\"%\n\x05\x45rror\x12\x0c\n\x04\x63ode\x18\x01 \x01(\x12\x12\x0e\n\x06reason\x18\x02 \x01(\tb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flwr.proto.error_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  _globals['_ERROR']._serialized_start=38
+  _globals['_ERROR']._serialized_end=75
+# @@protoc_insertion_point(module_scope)

flwr/proto/error_pb2.pyi

@@ -0,0 +1,25 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+import builtins
+import google.protobuf.descriptor
+import google.protobuf.message
+import typing
+import typing_extensions
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+class Error(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+    CODE_FIELD_NUMBER: builtins.int
+    REASON_FIELD_NUMBER: builtins.int
+    code: builtins.int
+    reason: typing.Text
+    def __init__(self,
+        *,
+        code: builtins.int = ...,
+        reason: typing.Text = ...,
+        ) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["code",b"code","reason",b"reason"]) -> None: ...
+global___Error = Error

flwr/proto/error_pb2_grpc.py

@@ -0,0 +1,4 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+

flwr/proto/error_pb2_grpc.pyi

@@ -0,0 +1,4 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""

flwr/proto/task_pb2.py

@@ -15,19 +15,20 @@ _sym_db = _symbol_database.Default()
 from flwr.proto import node_pb2 as flwr_dot_proto_dot_node__pb2
 from flwr.proto import recordset_pb2 as flwr_dot_proto_dot_recordset__pb2
 from flwr.proto import transport_pb2 as flwr_dot_proto_dot_transport__pb2
+from flwr.proto import error_pb2 as flwr_dot_proto_dot_error__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15\x66lwr/proto/task.proto\x12\nflwr.proto\x1a\x15\x66lwr/proto/node.proto\x1a\x1a\x66lwr/proto/recordset.proto\x1a\x1a\x66lwr/proto/transport.proto\"\xd4\x01\n\x04Task\x12\"\n\x08producer\x18\x01 \x01(\x0b\x32\x10.flwr.proto.Node\x12\"\n\x08\x63onsumer\x18\x02 \x01(\x0b\x32\x10.flwr.proto.Node\x12\x12\n\ncreated_at\x18\x03 \x01(\t\x12\x14\n\x0c\x64\x65livered_at\x18\x04 \x01(\t\x12\x0b\n\x03ttl\x18\x05 \x01(\t\x12\x10\n\x08\x61ncestry\x18\x06 \x03(\t\x12\x11\n\ttask_type\x18\x07 \x01(\t\x12(\n\trecordset\x18\x08 \x01(\x0b\x32\x15.flwr.proto.RecordSet\"\\\n\x07TaskIns\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x10\n\x08group_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\x12\x12\x1e\n\x04task\x18\x04 \x01(\x0b\x32\x10.flwr.proto.Task\"\\\n\x07TaskRes\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x10\n\x08group_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\x12\x12\x1e\n\x04task\x18\x04 \x01(\x0b\x32\x10.flwr.proto.Taskb\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15\x66lwr/proto/task.proto\x12\nflwr.proto\x1a\x15\x66lwr/proto/node.proto\x1a\x1a\x66lwr/proto/recordset.proto\x1a\x1a\x66lwr/proto/transport.proto\x1a\x16\x66lwr/proto/error.proto\"\xf6\x01\n\x04Task\x12\"\n\x08producer\x18\x01 \x01(\x0b\x32\x10.flwr.proto.Node\x12\"\n\x08\x63onsumer\x18\x02 \x01(\x0b\x32\x10.flwr.proto.Node\x12\x12\n\ncreated_at\x18\x03 \x01(\t\x12\x14\n\x0c\x64\x65livered_at\x18\x04 \x01(\t\x12\x0b\n\x03ttl\x18\x05 \x01(\t\x12\x10\n\x08\x61ncestry\x18\x06 \x03(\t\x12\x11\n\ttask_type\x18\x07 \x01(\t\x12(\n\trecordset\x18\x08 \x01(\x0b\x32\x15.flwr.proto.RecordSet\x12 \n\x05\x65rror\x18\t \x01(\x0b\x32\x11.flwr.proto.Error\"\\\n\x07TaskIns\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x10\n\x08group_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\x12\x12\x1e\n\x04task\x18\x04 \x01(\x0b\x32\x10.flwr.proto.Task\"\\\n\x07TaskRes\x12\x0f\n\x07task_id\x18\x01 \x01(\t\x12\x10\n\x08group_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\x12\x12\x1e\n\x04task\x18\x04 \x01(\x0b\x32\x10.flwr.proto.Taskb\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
 _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flwr.proto.task_pb2', _globals)
 if _descriptor._USE_C_DESCRIPTORS == False:
   DESCRIPTOR._options = None
-  _globals['_TASK']._serialized_start=117
-  _globals['_TASK']._serialized_end=329
-  _globals['_TASKINS']._serialized_start=331
-  _globals['_TASKINS']._serialized_end=423
-  _globals['_TASKRES']._serialized_start=425
-  _globals['_TASKRES']._serialized_end=517
+  _globals['_TASK']._serialized_start=141
+  _globals['_TASK']._serialized_end=387
+  _globals['_TASKINS']._serialized_start=389
+  _globals['_TASKINS']._serialized_end=481
+  _globals['_TASKRES']._serialized_start=483
+  _globals['_TASKRES']._serialized_end=575
 # @@protoc_insertion_point(module_scope)

flwr/proto/task_pb2.pyi

@@ -3,6 +3,7 @@
 isort:skip_file
 """
 import builtins
+import flwr.proto.error_pb2
 import flwr.proto.node_pb2
 import flwr.proto.recordset_pb2
 import google.protobuf.descriptor
@@ -23,6 +24,7 @@ class Task(google.protobuf.message.Message):
     ANCESTRY_FIELD_NUMBER: builtins.int
     TASK_TYPE_FIELD_NUMBER: builtins.int
     RECORDSET_FIELD_NUMBER: builtins.int
+    ERROR_FIELD_NUMBER: builtins.int
     @property
     def producer(self) -> flwr.proto.node_pb2.Node: ...
     @property
@@ -35,6 +37,8 @@ class Task(google.protobuf.message.Message):
     task_type: typing.Text
     @property
     def recordset(self) -> flwr.proto.recordset_pb2.RecordSet: ...
+    @property
+    def error(self) -> flwr.proto.error_pb2.Error: ...
     def __init__(self,
         *,
         producer: typing.Optional[flwr.proto.node_pb2.Node] = ...,
@@ -45,9 +49,10 @@ class Task(google.protobuf.message.Message):
         ancestry: typing.Optional[typing.Iterable[typing.Text]] = ...,
         task_type: typing.Text = ...,
         recordset: typing.Optional[flwr.proto.recordset_pb2.RecordSet] = ...,
+        error: typing.Optional[flwr.proto.error_pb2.Error] = ...,
         ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["consumer",b"consumer","producer",b"producer","recordset",b"recordset"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["ancestry",b"ancestry","consumer",b"consumer","created_at",b"created_at","delivered_at",b"delivered_at","producer",b"producer","recordset",b"recordset","task_type",b"task_type","ttl",b"ttl"]) -> None: ...
+    def HasField(self, field_name: typing_extensions.Literal["consumer",b"consumer","error",b"error","producer",b"producer","recordset",b"recordset"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing_extensions.Literal["ancestry",b"ancestry","consumer",b"consumer","created_at",b"created_at","delivered_at",b"delivered_at","error",b"error","producer",b"producer","recordset",b"recordset","task_type",b"task_type","ttl",b"ttl"]) -> None: ...
 global___Task = Task
 
 class TaskIns(google.protobuf.message.Message):

flwr/server/strategy/__init__.py

@@ -16,10 +16,17 @@
 
 
 from .bulyan import Bulyan as Bulyan
-from .dp_adaptive_clipping import DifferentialPrivacyClientSideAdaptiveClipping
+from .dp_adaptive_clipping import (
+    DifferentialPrivacyClientSideAdaptiveClipping as DifferentialPrivacyClientSideAdaptiveClipping,
+)
+from .dp_adaptive_clipping import (
+    DifferentialPrivacyServerSideAdaptiveClipping as DifferentialPrivacyServerSideAdaptiveClipping,
+)
+from .dp_fixed_clipping import (
+    DifferentialPrivacyClientSideFixedClipping as DifferentialPrivacyClientSideFixedClipping,
+)
 from .dp_fixed_clipping import (
-    DifferentialPrivacyClientSideFixedClipping,
-    DifferentialPrivacyServerSideFixedClipping,
+    DifferentialPrivacyServerSideFixedClipping as DifferentialPrivacyServerSideFixedClipping,
 )
 from .dpfedavg_adaptive import DPFedAvgAdaptive as DPFedAvgAdaptive
 from .dpfedavg_fixed import DPFedAvgFixed as DPFedAvgFixed
@@ -46,6 +53,7 @@ __all__ = [
     "DPFedAvgAdaptive",
     "DPFedAvgFixed",
     "DifferentialPrivacyClientSideAdaptiveClipping",
+    "DifferentialPrivacyServerSideAdaptiveClipping",
     "DifferentialPrivacyClientSideFixedClipping",
     "DifferentialPrivacyServerSideFixedClipping",
     "FedAdagrad",

flwr/server/strategy/dp_adaptive_clipping.py

@@ -24,8 +24,19 @@ from typing import Dict, List, Optional, Tuple, Union
 
 import numpy as np
 
-from flwr.common import EvaluateIns, EvaluateRes, FitIns, FitRes, Parameters, Scalar
+from flwr.common import (
+    EvaluateIns,
+    EvaluateRes,
+    FitIns,
+    FitRes,
+    NDArrays,
+    Parameters,
+    Scalar,
+    ndarrays_to_parameters,
+    parameters_to_ndarrays,
+)
 from flwr.common.differential_privacy import (
+    adaptive_clip_inputs_inplace,
     add_gaussian_noise_to_params,
     compute_adaptive_noise_params,
 )
@@ -40,6 +51,199 @@ from flwr.server.client_proxy import ClientProxy
 from flwr.server.strategy.strategy import Strategy
 
 
+class DifferentialPrivacyServerSideAdaptiveClipping(Strategy):
+    """Strategy wrapper for central DP with server-side adaptive clipping.
+
+    Parameters
+    ----------
+    strategy: Strategy
+        The strategy to which DP functionalities will be added by this wrapper.
+    noise_multiplier : float
+        The noise multiplier for the Gaussian mechanism for model updates.
+    num_sampled_clients : int
+        The number of clients that are sampled on each round.
+    initial_clipping_norm : float
+        The initial value of clipping norm. Deafults to 0.1.
+        Andrew et al. recommends to set to 0.1.
+    target_clipped_quantile : float
+        The desired quantile of updates which should be clipped. Defaults to 0.5.
+    clip_norm_lr : float
+        The learning rate for the clipping norm adaptation. Defaults to 0.2.
+        Andrew et al. recommends to set to 0.2.
+    clipped_count_stddev : float
+        The standard deviation of the noise added to the count of updates below the estimate.
+        Andrew et al. recommends to set to `expected_num_records/20`
+
+    Examples
+    --------
+    Create a strategy:
+
+    >>> strategy = fl.server.strategy.FedAvg( ... )
+
+    Wrap the strategy with the DifferentialPrivacyServerSideAdaptiveClipping wrapper
+
+    >>> dp_strategy = DifferentialPrivacyServerSideAdaptiveClipping(
+    >>>     strategy, cfg.noise_multiplier, cfg.num_sampled_clients, ...
+    >>> )
+    """
+
+    # pylint: disable=too-many-arguments,too-many-instance-attributes
+    def __init__(
+        self,
+        strategy: Strategy,
+        noise_multiplier: float,
+        num_sampled_clients: int,
+        initial_clipping_norm: float = 0.1,
+        target_clipped_quantile: float = 0.5,
+        clip_norm_lr: float = 0.2,
+        clipped_count_stddev: Optional[float] = None,
+    ) -> None:
+        super().__init__()
+
+        if strategy is None:
+            raise ValueError("The passed strategy is None.")
+
+        if noise_multiplier < 0:
+            raise ValueError("The noise multiplier should be a non-negative value.")
+
+        if num_sampled_clients <= 0:
+            raise ValueError(
+                "The number of sampled clients should be a positive value."
+            )
+
+        if initial_clipping_norm <= 0:
+            raise ValueError("The initial clipping norm should be a positive value.")
+
+        if not 0 <= target_clipped_quantile <= 1:
+            raise ValueError(
+                "The target clipped quantile must be between 0 and 1 (inclusive)."
+            )
+
+        if clip_norm_lr <= 0:
+            raise ValueError("The learning rate must be positive.")
+
+        if clipped_count_stddev is not None:
+            if clipped_count_stddev < 0:
+                raise ValueError("The `clipped_count_stddev` must be non-negative.")
+
+        self.strategy = strategy
+        self.num_sampled_clients = num_sampled_clients
+        self.clipping_norm = initial_clipping_norm
+        self.target_clipped_quantile = target_clipped_quantile
+        self.clip_norm_lr = clip_norm_lr
+        (
+            self.clipped_count_stddev,
+            self.noise_multiplier,
+        ) = compute_adaptive_noise_params(
+            noise_multiplier,
+            num_sampled_clients,
+            clipped_count_stddev,
+        )
+
+        self.current_round_params: NDArrays = []
+
+    def __repr__(self) -> str:
+        """Compute a string representation of the strategy."""
+        rep = "Differential Privacy Strategy Wrapper (Server-Side Adaptive Clipping)"
+        return rep
+
+    def initialize_parameters(
+        self, client_manager: ClientManager
+    ) -> Optional[Parameters]:
+        """Initialize global model parameters using given strategy."""
+        return self.strategy.initialize_parameters(client_manager)
+
+    def configure_fit(
+        self, server_round: int, parameters: Parameters, client_manager: ClientManager
+    ) -> List[Tuple[ClientProxy, FitIns]]:
+        """Configure the next round of training."""
+        self.current_round_params = parameters_to_ndarrays(parameters)
+        return self.strategy.configure_fit(server_round, parameters, client_manager)
+
+    def configure_evaluate(
+        self, server_round: int, parameters: Parameters, client_manager: ClientManager
+    ) -> List[Tuple[ClientProxy, EvaluateIns]]:
+        """Configure the next round of evaluation."""
+        return self.strategy.configure_evaluate(
+            server_round, parameters, client_manager
+        )
+
+    def aggregate_fit(
+        self,
+        server_round: int,
+        results: List[Tuple[ClientProxy, FitRes]],
+        failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
+    ) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
+        """Aggregate training results and update clip norms."""
+        if failures:
+            return None, {}
+
+        if len(results) != self.num_sampled_clients:
+            log(
+                WARNING,
+                CLIENTS_DISCREPANCY_WARNING,
+                len(results),
+                self.num_sampled_clients,
+            )
+
+        norm_bit_set_count = 0
+        for _, res in results:
+            param = parameters_to_ndarrays(res.parameters)
+            # Compute and clip update
+            model_update = [
+                np.subtract(x, y) for (x, y) in zip(param, self.current_round_params)
+            ]
+
+            norm_bit = adaptive_clip_inputs_inplace(model_update, self.clipping_norm)
+            norm_bit_set_count += norm_bit
+
+            for i, _ in enumerate(self.current_round_params):
+                param[i] = self.current_round_params[i] + model_update[i]
+            # Convert back to parameters
+            res.parameters = ndarrays_to_parameters(param)
+
+        # Noising the count
+        noised_norm_bit_set_count = float(
+            np.random.normal(norm_bit_set_count, self.clipped_count_stddev)
+        )
+        noised_norm_bit_set_fraction = noised_norm_bit_set_count / len(results)
+        # Geometric update
+        self.clipping_norm *= math.exp(
+            -self.clip_norm_lr
+            * (noised_norm_bit_set_fraction - self.target_clipped_quantile)
+        )
+
+        aggregated_params, metrics = self.strategy.aggregate_fit(
+            server_round, results, failures
+        )
+
+        # Add Gaussian noise to the aggregated parameters
+        if aggregated_params:
+            aggregated_params = add_gaussian_noise_to_params(
+                aggregated_params,
+                self.noise_multiplier,
+                self.clipping_norm,
+                self.num_sampled_clients,
+            )
+
+        return aggregated_params, metrics
+
+    def aggregate_evaluate(
+        self,
+        server_round: int,
+        results: List[Tuple[ClientProxy, EvaluateRes]],
+        failures: List[Union[Tuple[ClientProxy, EvaluateRes], BaseException]],
+    ) -> Tuple[Optional[float], Dict[str, Scalar]]:
+        """Aggregate evaluation losses using the given strategy."""
+        return self.strategy.aggregate_evaluate(server_round, results, failures)
+
+    def evaluate(
+        self, server_round: int, parameters: Parameters
+    ) -> Optional[Tuple[float, Dict[str, Scalar]]]:
+        """Evaluate model parameters using an evaluation function from the strategy."""
+        return self.strategy.evaluate(server_round, parameters)
+
+
 class DifferentialPrivacyClientSideAdaptiveClipping(Strategy):
     """Strategy wrapper for central DP with client-side adaptive clipping.
 

flwr/server/superlink/driver/driver_servicer.py

@@ -15,7 +15,7 @@
 """Driver API servicer."""
 
 
-from logging import INFO
+from logging import DEBUG, INFO
 from typing import List, Optional, Set
 from uuid import UUID
 
@@ -70,7 +70,7 @@ class DriverServicer(driver_pb2_grpc.DriverServicer):
         self, request: PushTaskInsRequest, context: grpc.ServicerContext
     ) -> PushTaskInsResponse:
         """Push a set of TaskIns."""
-        log(INFO, "DriverServicer.PushTaskIns")
+        log(DEBUG, "DriverServicer.PushTaskIns")
 
         # Validate request
         _raise_if(len(request.task_ins_list) == 0, "`task_ins_list` must not be empty")
@@ -95,7 +95,7 @@ class DriverServicer(driver_pb2_grpc.DriverServicer):
         self, request: PullTaskResRequest, context: grpc.ServicerContext
     ) -> PullTaskResResponse:
         """Pull a set of TaskRes."""
-        log(INFO, "DriverServicer.PullTaskRes")
+        log(DEBUG, "DriverServicer.PullTaskRes")
 
         # Convert each task_id str to UUID
         task_ids: Set[UUID] = {UUID(task_id) for task_id in request.task_ids}
@@ -105,7 +105,7 @@ class DriverServicer(driver_pb2_grpc.DriverServicer):
 
         # Register callback
         def on_rpc_done() -> None:
-            log(INFO, "DriverServicer.PullTaskRes callback: delete TaskIns/TaskRes")
+            log(DEBUG, "DriverServicer.PullTaskRes callback: delete TaskIns/TaskRes")
 
             if context.is_active():
                 return

flwr/simulation/__init__.py

@@ -17,6 +17,8 @@
 
 import importlib
 
+from flwr.simulation.run_simulation import run_simulation
+
 is_ray_installed = importlib.util.find_spec("ray") is not None
 
 if is_ray_installed:
@@ -36,4 +38,5 @@ To install the necessary dependencies, install `flwr` with the `simulation` extr
 
 __all__ = [
     "start_simulation",
+    "run_simulation",
 ]

flwr/simulation/run_simulation.py

@@ -0,0 +1,177 @@
+# Copyright 2024 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.
+# ==============================================================================
+"""Flower Simulation."""
+
+import argparse
+import asyncio
+import json
+import threading
+import traceback
+from logging import ERROR, INFO, WARNING
+
+import grpc
+
+from flwr.common import EventType, event, log
+from flwr.common.exit_handlers import register_exit_handlers
+from flwr.server.driver.driver import Driver
+from flwr.server.run_serverapp import run
+from flwr.server.superlink.driver.driver_grpc import run_driver_api_grpc
+from flwr.server.superlink.fleet import vce
+from flwr.server.superlink.state import StateFactory
+from flwr.simulation.ray_transport.utils import enable_tf_gpu_growth
+
+
+def run_simulation() -> None:
+    """Run Simulation Engine."""
+    args = _parse_args_run_simulation().parse_args()
+
+    # Load JSON config
+    backend_config_dict = json.loads(args.backend_config)
+
+    # Enable GPU memory growth (relevant only for TF)
+    if args.enable_tf_gpu_growth:
+        log(INFO, "Enabling GPU growth for Tensorflow on the main thread.")
+        enable_tf_gpu_growth()
+        # Check that Backend config has also enabled using GPU growth
+        use_tf = backend_config_dict.get("tensorflow", False)
+        if not use_tf:
+            log(WARNING, "Enabling GPU growth for your backend.")
+            backend_config_dict["tensorflow"] = True
+
+    # Convert back to JSON stream
+    backend_config = json.dumps(backend_config_dict)
+
+    # Initialize StateFactory
+    state_factory = StateFactory(":flwr-in-memory-state:")
+
+    # Start Driver API
+    driver_server: grpc.Server = run_driver_api_grpc(
+        address=args.driver_api_address,
+        state_factory=state_factory,
+        certificates=None,
+    )
+
+    # SuperLink with Simulation Engine
+    f_stop = asyncio.Event()
+    superlink_th = threading.Thread(
+        target=vce.start_vce,
+        kwargs={
+            "num_supernodes": args.num_supernodes,
+            "client_app_module_name": args.client_app,
+            "backend_name": args.backend,
+            "backend_config_json_stream": backend_config,
+            "working_dir": args.dir,
+            "state_factory": state_factory,
+            "f_stop": f_stop,
+        },
+        daemon=False,
+    )
+
+    superlink_th.start()
+    event(EventType.RUN_SUPERLINK_ENTER)
+
+    try:
+        # Initialize Driver
+        driver = Driver(
+            driver_service_address=args.driver_api_address,
+            root_certificates=None,
+        )
+
+        # Launch server app
+        run(args.server_app, driver, args.dir)
+
+    except Exception as ex:
+
+        log(ERROR, "An exception occurred: %s", ex)
+        log(ERROR, traceback.format_exc())
+        raise RuntimeError(
+            "An error was encountered by the Simulation Engine. Ending simulation."
+        ) from ex
+
+    finally:
+
+        del driver
+
+        # Trigger stop event
+        f_stop.set()
+
+        register_exit_handlers(
+            grpc_servers=[driver_server],
+            bckg_threads=[superlink_th],
+            event_type=EventType.RUN_SUPERLINK_LEAVE,
+        )
+        superlink_th.join()
+
+
+def _parse_args_run_simulation() -> argparse.ArgumentParser:
+    """Parse flower-simulation command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Start a Flower simulation",
+    )
+    parser.add_argument(
+        "--client-app",
+        required=True,
+        help="For example: `client:app` or `project.package.module:wrapper.app`",
+    )
+    parser.add_argument(
+        "--server-app",
+        required=True,
+        help="For example: `server:app` or `project.package.module:wrapper.app`",
+    )
+    parser.add_argument(
+        "--driver-api-address",
+        default="0.0.0.0:9091",
+        type=str,
+        help="For example: `server:app` or `project.package.module:wrapper.app`",
+    )
+    parser.add_argument(
+        "--num-supernodes",
+        type=int,
+        required=True,
+        help="Number of simulated SuperNodes.",
+    )
+    parser.add_argument(
+        "--backend",
+        default="ray",
+        type=str,
+        help="Simulation backend that executes the ClientApp.",
+    )
+    parser.add_argument(
+        "--enable-tf-gpu-growth",
+        action="store_true",
+        help="Enables GPU growth on the main thread. This is desirable if you make "
+        "use of a TensorFlow model on your `ServerApp` while having your `ClientApp` "
+        "running on the same GPU. Without enabling this, you might encounter an "
+        "out-of-memory error becasue TensorFlow by default allocates all GPU memory."
+        "Read mor about how `tf.config.experimental.set_memory_growth()` works in "
+        "the TensorFlow documentation: https://www.tensorflow.org/api/stable.",
+    )
+    parser.add_argument(
+        "--backend-config",
+        type=str,
+        default='{"client_resources": {"num_cpus":2, "num_gpus":0.0}, "tensorflow": 0}',
+        help='A JSON formatted stream, e.g \'{"<keyA>":<value>, "<keyB>":<value>}\' to '
+        "configure a backend. Values supported in <value> are those included by "
+        "`flwr.common.typing.ConfigsRecordValues`. ",
+    )
+    parser.add_argument(
+        "--dir",
+        default="",
+        help="Add specified directory to the PYTHONPATH and load"
+        "ClientApp and ServerApp from there."
+        " Default: current working directory.",
+    )
+
+    return parser

{flwr_nightly-1.8.0.dev20240228.dist-info → flwr_nightly-1.8.0.dev20240229.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.8.0.dev20240228
+Version: 1.8.0.dev20240229
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0

{flwr_nightly-1.8.0.dev20240228.dist-info → flwr_nightly-1.8.0.dev20240229.dist-info}/RECORD

@@ -32,7 +32,7 @@ flwr/client/message_handler/task_handler.py,sha256=ZDJBKmrn2grRMNl1rU1iGs7FiMHL5
 flwr/client/mod/__init__.py,sha256=w6r7n6fWIrrm4lEk36lh9f1Ix6LXgAzQUrgjmMspY98,961
 flwr/client/mod/centraldp_mods.py,sha256=aHbzGjSbyRENuU5vzad_tkJ9UDb48uHEvUq-zgydBwo,4954
 flwr/client/mod/secure_aggregation/__init__.py,sha256=AzCdezuzX2BfXUuxVRwXdv8-zUIXoU-Bf6u4LRhzvg8,796
-flwr/client/mod/secure_aggregation/secaggplus_mod.py,sha256=z_5t1YzqLs91ZLW5Yoo7Ozqw9_nyVuEpJ7Noa2a34bs,19890
+flwr/client/mod/secure_aggregation/secaggplus_mod.py,sha256=Zc5b2C58SYeyQVXIbLRESOIq4rMUOuzMHNAjdSAPt6I,19434
 flwr/client/mod/utils.py,sha256=lvETHcCYsSWz7h8I772hCV_kZspxqlMqzriMZ-SxmKc,1226
 flwr/client/node_state.py,sha256=KTTs_l4I0jBM7IsSsbAGjhfL_yZC3QANbzyvyfZBRDM,1778
 flwr/client/node_state_tests.py,sha256=gPwz0zf2iuDSa11jedkur_u3Xm7lokIDG5ALD2MCvSw,2195
@@ -68,7 +68,7 @@ flwr/common/secure_aggregation/crypto/shamir.py,sha256=yY35ZgHlB4YyGW_buG-1X-0M-
 flwr/common/secure_aggregation/crypto/symmetric_encryption.py,sha256=-zDyQoTsHHQjR7o-92FNIikg1zM_Ke9yynaD5u2BXbQ,3546
 flwr/common/secure_aggregation/ndarrays_arithmetic.py,sha256=KAHCEHGSTJ6mCgnC8dTpIx6URk11s5XxWTHI_7ToGIg,2979
 flwr/common/secure_aggregation/quantization.py,sha256=appui7GGrkRPsupF59TkapeV4Na_CyPi73JtJ1pimdI,2310
-flwr/common/secure_aggregation/secaggplus_constants.py,sha256=pITi-nuzrNvKWR42XwVFBuejv1RdGLwmuErLp0X0t_Y,1686
+flwr/common/secure_aggregation/secaggplus_constants.py,sha256=2dYMKqiO2ja8DewFeZUAGqM0xujNfyYHVwShRxeRaIM,2132
 flwr/common/secure_aggregation/secaggplus_utils.py,sha256=PleDyDu7jHNAfbRoEaoQiOjxG6iMl9yA8rNKYTfnyFw,3155
 flwr/common/serde.py,sha256=0tmfTcywJVLA7Hsu4nAjMn2dVMVbjYZqePJbPcDt01Y,20726
 flwr/common/telemetry.py,sha256=JkFB6WBOskqAJfzSM-l6tQfRiSi2oiysClfg0-5T7NY,7782
@@ -79,6 +79,10 @@ flwr/proto/driver_pb2.py,sha256=JHIdjNPTgp6YHD-_lz5ZZFB0VIOR3_GmcaOTN4jndc4,3115
 flwr/proto/driver_pb2.pyi,sha256=xwl2AqIWn0SwAlg-x5RUQeqr6DC48eywnqmD7gbaaFs,4670
 flwr/proto/driver_pb2_grpc.py,sha256=qQBRdQUz4k2K4DVO7kSfWHx-62UJ85HaYKnKCr6JcU8,7304
 flwr/proto/driver_pb2_grpc.pyi,sha256=NpOM5eCrIPcuWdYrZAayQSDvvFp6cDCVflabhmuvMfo,2022
+flwr/proto/error_pb2.py,sha256=LarjKL90LbwkXKlhzNrDssgl4DXcvIPve8NVCXHpsKA,1084
+flwr/proto/error_pb2.pyi,sha256=ZNH4HhJTU_KfMXlyCeg8FwU-fcUYxTqEmoJPtWtHikc,734
+flwr/proto/error_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159
+flwr/proto/error_pb2_grpc.pyi,sha256=ff2TSiLVnG6IVQcTGzb2DIH3XRSoAvAo_RMcvbMFyc0,76
 flwr/proto/fleet_pb2.py,sha256=8rKQHu6Oa9ki_NG6kRNGtfPPYZp5kKBZhPW696_kn84,3852
 flwr/proto/fleet_pb2.pyi,sha256=QXYs9M7_dABghdCMfk5Rjf4w0LsZGDeQ1ojH00XaQME,6182
 flwr/proto/fleet_pb2_grpc.py,sha256=hF1uPaioZzQMRCP9yPlv9LC0mi_DTuhn-IkQJzWIPCs,7505
@@ -91,8 +95,8 @@ flwr/proto/recordset_pb2.py,sha256=un8L0kvBcgFXQIiQweOseeIJBjlOozUvQY9uTQ42Dqo,6
 flwr/proto/recordset_pb2.pyi,sha256=NPzCJWAj1xLWzeZ_xZ6uaObQjQfWGnnqlLtn4J-SoFY,14161
 flwr/proto/recordset_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159
 flwr/proto/recordset_pb2_grpc.pyi,sha256=ff2TSiLVnG6IVQcTGzb2DIH3XRSoAvAo_RMcvbMFyc0,76
-flwr/proto/task_pb2.py,sha256=0iZTgNnrypfuO9AqjXqvV79VGaS9lkpi6oohMFeoTso,2272
-flwr/proto/task_pb2.pyi,sha256=k3Bulbd7pbYszemI5ntWJtuaYlSz_wnhhBZSyGSwjF8,3937
+flwr/proto/task_pb2.py,sha256=-UX3TqskOIRbPu8U3YwgW9ul2k9ZN6MJGgbIOX3pTqg,2431
+flwr/proto/task_pb2.pyi,sha256=IgXggFya0RpL64z2o2K_qLnZHyZ1mg_WzLxFwEKrpL0,4171
 flwr/proto/task_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159
 flwr/proto/task_pb2_grpc.pyi,sha256=ff2TSiLVnG6IVQcTGzb2DIH3XRSoAvAo_RMcvbMFyc0,76
 flwr/proto/transport_pb2.py,sha256=cURzfpCgZvH7GEvBPLvTYijE3HvhK1MePjINk4xYArk,9781
@@ -118,10 +122,10 @@ flwr/server/run_serverapp.py,sha256=7LLE1cVQz0Rl-hZnY7DLXvFxWCdep8xgLgEVC-yffi0,
 flwr/server/server.py,sha256=JLc2lg-qCchD-Jyg_hTBZQN3rXsnfAGx6qJAo0vqH2Y,17812
 flwr/server/server_app.py,sha256=avNQ7AMMKsn09ly81C3UBgOfHhM_R29l4MrzlalGoj8,5892
 flwr/server/server_config.py,sha256=yOHpkdyuhOm--Gy_4Vofvu6jCDxhyECEDpIy02beuCg,1018
-flwr/server/strategy/__init__.py,sha256=xKnjkTQQT4PjoCXrUXW4LJ85H_iXNszKZ4u6W__VWp8,2460
+flwr/server/strategy/__init__.py,sha256=7eVZ3hQEg2BgA_usAeL6tsLp9T6XI1VYYoFy08Xn-ew,2836
 flwr/server/strategy/aggregate.py,sha256=QyRIJtI5gnuY1NbgrcrOvkHxGIxBvApq7d9Y4xl-6W4,13468
 flwr/server/strategy/bulyan.py,sha256=8GsSVJzRSoSWE2zQUKqC3Z795grdN9xpmc3MSGGXnzM,6532
-flwr/server/strategy/dp_adaptive_clipping.py,sha256=DIfQA4PDXNFpEYKTf5aHFzvNn7t-_6Bv1MZdKGrJsc8,9261
+flwr/server/strategy/dp_adaptive_clipping.py,sha256=BVvX1LivyukvEtOZVZnpgVpzH8BBjvA3OmdGwFxgRuQ,16679
 flwr/server/strategy/dp_fixed_clipping.py,sha256=v9YyX53jt2RatGnFxTK4ZMO_3SN7EdL9YCaaJtn9Fcc,12125
 flwr/server/strategy/dpfedavg_adaptive.py,sha256=hLJkPQJl1bHjwrBNg3PSRFKf3no0hg5EHiFaWhHlWqw,4877
 flwr/server/strategy/dpfedavg_fixed.py,sha256=G0yYxrPoM-MHQ889DYN3OeNiEeU0yQrjgAzcq0G653w,7219
@@ -145,7 +149,7 @@ flwr/server/strategy/strategy.py,sha256=g6VoIFogEviRub6G4QsKdIp6M_Ek6GhBhqcdNx5u
 flwr/server/superlink/__init__.py,sha256=8tHYCfodUlRD8PCP9fHgvu8cz5N31A2QoRVL0jDJ15E,707
 flwr/server/superlink/driver/__init__.py,sha256=STB1_DASVEg7Cu6L7VYxTzV7UMkgtBkFim09Z82Dh8I,712
 flwr/server/superlink/driver/driver_grpc.py,sha256=1qSGDs1k_OVPWxp2ofxvQgtYXExrMeC3N_rNPVWH65M,1932
-flwr/server/superlink/driver/driver_servicer.py,sha256=69-QMkdefgd8BDDAuy4TSJHVcmZAGqq8Yy9ZPDq2kks,4563
+flwr/server/superlink/driver/driver_servicer.py,sha256=p1rlocgqU2I4s5IwdU8rTZBkQ73yPmuWtK_aUlB7V84,4573
 flwr/server/superlink/fleet/__init__.py,sha256=C6GCSD5eP5Of6_dIeSe1jx9HnV0icsvWyQ5EKAUHJRU,711
 flwr/server/superlink/fleet/grpc_bidi/__init__.py,sha256=mgGJGjwT6VU7ovC1gdnnqttjyBPlNIcZnYRqx4K3IBQ,735
 flwr/server/superlink/fleet/grpc_bidi/flower_service_servicer.py,sha256=57b3UL5-baGdLwgCtB0dCUTTSbmmfMAXcXV5bjPZNWQ,5993
@@ -174,14 +178,15 @@ flwr/server/utils/tensorboard.py,sha256=k0G6bqsLx7wfYbH2KtXsDYcOCfyIeE12-hefXA7l
 flwr/server/utils/validator.py,sha256=IJN2475yyD_i_9kg_SJ_JodIuZh58ufpWGUDQRAqu2s,4740
 flwr/server/workflow/__init__.py,sha256=2YrKq5wUwge8Tm1xaAdf2P3l4LbM4olka6tO_0_Mu9A,787
 flwr/server/workflow/default_workflows.py,sha256=DKSt14WY5m19ujwh6UDP4a31kRs-j6V_NZm5cXn01ZY,12705
-flwr/simulation/__init__.py,sha256=E2eD5FlTmZZ80u21FmWCkacrM7O4mrEHD8iXqeCaBUQ,1278
+flwr/simulation/__init__.py,sha256=jdrJeTnLLj9Eyl8BRPXMewqkhTnxD7fvXDgyjfspy0Q,1359
 flwr/simulation/app.py,sha256=WqJxdXTEuehwMW605p5NMmvBbKYx5tuqnV3Mp7jSWXM,13904
 flwr/simulation/ray_transport/__init__.py,sha256=FsaAnzC4cw4DqoouBCix6496k29jACkfeIam55BvW9g,734
 flwr/simulation/ray_transport/ray_actor.py,sha256=zRETW_xuCAOLRFaYnQ-q3IBSz0LIv_0RifGuhgWaYOg,19872
 flwr/simulation/ray_transport/ray_client_proxy.py,sha256=DpmrBC87_sX3J4WrrwzyEDIjONUeliBZx9T-gZGuPmQ,6799
 flwr/simulation/ray_transport/utils.py,sha256=TYdtfg1P9VfTdLMOJlifInGpxWHYs9UfUqIv2wfkRLA,2392
-flwr_nightly-1.8.0.dev20240228.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-flwr_nightly-1.8.0.dev20240228.dist-info/METADATA,sha256=ftdjOdLrEKow1vhHw6KFjaP741hpdqxPz2TN75s_ykc,15184
-flwr_nightly-1.8.0.dev20240228.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-flwr_nightly-1.8.0.dev20240228.dist-info/entry_points.txt,sha256=S1zLNFLrz0uPWs4Zrgo2EPY0iQiIcCJHrIAlnQkkOBI,262
-flwr_nightly-1.8.0.dev20240228.dist-info/RECORD,,
+flwr/simulation/run_simulation.py,sha256=NYUFJ6cG5QtuwEl6f2IWJNMRo_jDmmA41DABqISpq-Q,5950
+flwr_nightly-1.8.0.dev20240229.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+flwr_nightly-1.8.0.dev20240229.dist-info/METADATA,sha256=bnkE4rD-5EY00NUOdT-ZzoeuextoRXX3zZL0MLR6PbU,15184
+flwr_nightly-1.8.0.dev20240229.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+flwr_nightly-1.8.0.dev20240229.dist-info/entry_points.txt,sha256=qz6t0YdMrV_PLbEarJ6ITIWSIRrTbG_jossZAYfXBZQ,311
+flwr_nightly-1.8.0.dev20240229.dist-info/RECORD,,

{flwr_nightly-1.8.0.dev20240228.dist-info → flwr_nightly-1.8.0.dev20240229.dist-info}/entry_points.txt

@@ -3,6 +3,7 @@ flower-client-app=flwr.client:run_client_app
 flower-driver-api=flwr.server:run_driver_api
 flower-fleet-api=flwr.server:run_fleet_api
 flower-server-app=flwr.server:run_server_app
+flower-simulation=flwr.simulation:run_simulation
 flower-superlink=flwr.server:run_superlink
 flwr=flwr.cli.app:app