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

flwr/client/mod/__init__.py

@@ -15,12 +15,13 @@
 """Mods."""
 
 
-from .centraldp_mods import fixedclipping_mod
+from .centraldp_mods import adaptiveclipping_mod, fixedclipping_mod
 from .secure_aggregation.secaggplus_mod import secaggplus_mod
 from .utils import make_ffn
 
 __all__ = [
+    "adaptiveclipping_mod",
+    "fixedclipping_mod",
     "make_ffn",
     "secaggplus_mod",
-    "fixedclipping_mod",
 ]

flwr/client/mod/centraldp_mods.py

@@ -20,8 +20,11 @@ from flwr.common import ndarrays_to_parameters, parameters_to_ndarrays
 from flwr.common import recordset_compat as compat
 from flwr.common.constant import MESSAGE_TYPE_FIT
 from flwr.common.context import Context
-from flwr.common.differential_privacy import compute_clip_model_update
-from flwr.common.differential_privacy_constants import KEY_CLIPPING_NORM
+from flwr.common.differential_privacy import (
+    compute_adaptive_clip_model_update,
+    compute_clip_model_update,
+)
+from flwr.common.differential_privacy_constants import KEY_CLIPPING_NORM, KEY_NORM_BIT
 from flwr.common.message import Message
 
 
@@ -74,3 +77,61 @@ def fixedclipping_mod(
     fit_res.parameters = ndarrays_to_parameters(client_to_server_params)
     out_msg.content = compat.fitres_to_recordset(fit_res, keep_input=True)
     return out_msg
+
+
+def adaptiveclipping_mod(
+    msg: Message, ctxt: Context, call_next: ClientAppCallable
+) -> Message:
+    """Client-side adaptive clipping modifier.
+
+    This mod needs to be used with the DifferentialPrivacyClientSideAdaptiveClipping
+    server-side strategy wrapper.
+
+    The wrapper sends the clipping_norm value to the client.
+
+    This mod clips the client model updates before sending them to the server.
+
+    It also sends KEY_NORM_BIT to the server for computing the new clipping value.
+
+    It operates on messages with type MESSAGE_TYPE_FIT.
+
+    Notes
+    -----
+    Consider the order of mods when using multiple.
+
+    Typically, adaptiveclipping_mod should be the last to operate on params.
+    """
+    if msg.metadata.message_type != MESSAGE_TYPE_FIT:
+        return call_next(msg, ctxt)
+
+    fit_ins = compat.recordset_to_fitins(msg.content, keep_input=True)
+
+    if KEY_CLIPPING_NORM not in fit_ins.config:
+        raise KeyError(
+            f"The {KEY_CLIPPING_NORM} value is not supplied by the "
+            f"DifferentialPrivacyClientSideFixedClipping wrapper at"
+            f" the server side."
+        )
+    if not isinstance(fit_ins.config[KEY_CLIPPING_NORM], float):
+        raise ValueError(f"{KEY_CLIPPING_NORM} should be a float value.")
+    clipping_norm = float(fit_ins.config[KEY_CLIPPING_NORM])
+    server_to_client_params = parameters_to_ndarrays(fit_ins.parameters)
+
+    # Call inner app
+    out_msg = call_next(msg, ctxt)
+    fit_res = compat.recordset_to_fitres(out_msg.content, keep_input=True)
+
+    client_to_server_params = parameters_to_ndarrays(fit_res.parameters)
+
+    # Clip the client update
+    norm_bit = compute_adaptive_clip_model_update(
+        client_to_server_params,
+        server_to_client_params,
+        clipping_norm,
+    )
+
+    fit_res.parameters = ndarrays_to_parameters(client_to_server_params)
+
+    fit_res.metrics[KEY_NORM_BIT] = norm_bit
+    out_msg.content = compat.fitres_to_recordset(fit_res, keep_input=True)
+    return out_msg

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

@@ -15,6 +15,9 @@
 """Utility functions for differential privacy."""
 
 
+from logging import WARNING
+from typing import Optional, Tuple
+
 import numpy as np
 
 from flwr.common import (
@@ -23,6 +26,7 @@ from flwr.common import (
     ndarrays_to_parameters,
     parameters_to_ndarrays,
 )
+from flwr.common.logger import log
 
 
 def get_norm(input_arrays: NDArrays) -> float:
@@ -72,6 +76,36 @@ def compute_clip_model_update(
         param1[i] = param2[i] + model_update[i]
 
 
+def adaptive_clip_inputs_inplace(input_arrays: NDArrays, clipping_norm: float) -> bool:
+    """Clip model update based on the clipping norm in-place.
+
+    It returns true if scaling_factor < 1 which is used for norm_bit
+    FlatClip method of the paper: https://arxiv.org/abs/1710.06963
+    """
+    input_norm = get_norm(input_arrays)
+    scaling_factor = min(1, clipping_norm / input_norm)
+    for array in input_arrays:
+        array *= scaling_factor
+    return scaling_factor < 1
+
+
+def compute_adaptive_clip_model_update(
+    param1: NDArrays, param2: NDArrays, clipping_norm: float
+) -> bool:
+    """Compute model update, clip it, then add the clipped value to param1.
+
+    model update = param1 - param2
+    Return the norm_bit
+    """
+    model_update = [np.subtract(x, y) for (x, y) in zip(param1, param2)]
+    norm_bit = adaptive_clip_inputs_inplace(model_update, clipping_norm)
+
+    for i, _ in enumerate(param2):
+        param1[i] = param2[i] + model_update[i]
+
+    return norm_bit
+
+
 def add_gaussian_noise_to_params(
     model_params: Parameters,
     noise_multiplier: float,
@@ -85,3 +119,46 @@ def add_gaussian_noise_to_params(
         compute_stdv(noise_multiplier, clipping_norm, num_sampled_clients),
     )
     return ndarrays_to_parameters(model_params_ndarrays)
+
+
+def compute_adaptive_noise_params(
+    noise_multiplier: float,
+    num_sampled_clients: float,
+    clipped_count_stddev: Optional[float],
+) -> Tuple[float, float]:
+    """Compute noising parameters for the adaptive clipping.
+
+    Paper: https://arxiv.org/abs/1905.03871
+    """
+    if noise_multiplier > 0:
+        if clipped_count_stddev is None:
+            clipped_count_stddev = num_sampled_clients / 20
+        if noise_multiplier >= 2 * clipped_count_stddev:
+            raise ValueError(
+                f"If not specified, `clipped_count_stddev` is set to "
+                f"`num_sampled_clients`/20 by default. This value "
+                f"({num_sampled_clients / 20}) is too low to achieve the "
+                f"desired effective `noise_multiplier` ({noise_multiplier}). "
+                f"Consider increasing `clipped_count_stddev` or decreasing "
+                f"`noise_multiplier`."
+            )
+        noise_multiplier_value = (
+            noise_multiplier ** (-2) - (2 * clipped_count_stddev) ** (-2)
+        ) ** -0.5
+
+        adding_noise = noise_multiplier_value / noise_multiplier
+        if adding_noise >= 2:
+            log(
+                WARNING,
+                "A significant amount of noise (%s) has to be "
+                "added. Consider increasing `clipped_count_stddev` or "
+                "`num_sampled_clients`.",
+                adding_noise,
+            )
+
+    else:
+        if clipped_count_stddev is None:
+            clipped_count_stddev = 0.0
+        noise_multiplier_value = 0.0
+
+    return clipped_count_stddev, noise_multiplier_value

flwr/common/differential_privacy_constants.py

@@ -16,6 +16,7 @@
 
 
 KEY_CLIPPING_NORM = "clipping_norm"
+KEY_NORM_BIT = "norm_bit"
 CLIENTS_DISCREPANCY_WARNING = (
     "The number of clients returning parameters (%s)"
     " differs from the number of sampled clients (%s)."

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)