flwr 1.21.0__py3-none-any.whl → 1.22.0__py3-none-any.whl

flwr/serverapp/strategy/qfedavg.py

@@ -0,0 +1,252 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Fair Resource Allocation in Federated Learning [Li et al., 2020] strategy.
+
+Paper: openreview.net/pdf?id=ByexElSYDr
+"""
+
+
+from collections import OrderedDict
+from collections.abc import Iterable
+from logging import INFO
+from typing import Callable, Optional
+
+import numpy as np
+
+from flwr.common import (
+    Array,
+    ArrayRecord,
+    ConfigRecord,
+    Message,
+    MetricRecord,
+    NDArray,
+    RecordDict,
+)
+from flwr.common.logger import log
+from flwr.server import Grid
+
+from ..exception import AggregationError
+from .fedavg import FedAvg
+
+
+class QFedAvg(FedAvg):
+    """Q-FedAvg strategy.
+
+    Implementation based on openreview.net/pdf?id=ByexElSYDr
+
+    Parameters
+    ----------
+    client_learning_rate : float
+        Local learning rate used by clients during training. This value is used by
+        the strategy to approximate the base Lipschitz constant L, via
+        L = 1 / client_learning_rate.
+    q : float (default: 0.1)
+        The parameter q that controls the degree of fairness of the algorithm. Please
+        tune this parameter based on your use case.
+        When set to 0, q-FedAvg is equivalent to FedAvg.
+    train_loss_key : str (default: "train_loss")
+        The key within the MetricRecord whose value is used as the training loss when
+        aggregating ArrayRecords following q-FedAvg.
+    fraction_train : float (default: 1.0)
+        Fraction of nodes used during training. In case `min_train_nodes`
+        is larger than `fraction_train * total_connected_nodes`, `min_train_nodes`
+        will still be sampled.
+    fraction_evaluate : float (default: 1.0)
+        Fraction of nodes used during validation. In case `min_evaluate_nodes`
+        is larger than `fraction_evaluate * total_connected_nodes`,
+        `min_evaluate_nodes` will still be sampled.
+    min_train_nodes : int (default: 2)
+        Minimum number of nodes used during training.
+    min_evaluate_nodes : int (default: 2)
+        Minimum number of nodes used during validation.
+    min_available_nodes : int (default: 2)
+        Minimum number of total nodes in the system.
+    weighted_by_key : str (default: "num-examples")
+        The key within each MetricRecord whose value is used as the weight when
+        computing weighted averages for MetricRecords.
+    arrayrecord_key : str (default: "arrays")
+        Key used to store the ArrayRecord when constructing Messages.
+    configrecord_key : str (default: "config")
+        Key used to store the ConfigRecord when constructing Messages.
+    train_metrics_aggr_fn : Optional[callable] (default: None)
+        Function with signature (list[RecordDict], str) -> MetricRecord,
+        used to aggregate MetricRecords from training round replies.
+        If `None`, defaults to `aggregate_metricrecords`, which performs a weighted
+        average using the provided weight factor key.
+    evaluate_metrics_aggr_fn : Optional[callable] (default: None)
+        Function with signature (list[RecordDict], str) -> MetricRecord,
+        used to aggregate MetricRecords from training round replies.
+        If `None`, defaults to `aggregate_metricrecords`, which performs a weighted
+        average using the provided weight factor key.
+    """
+
+    def __init__(  # pylint: disable=R0913, R0917
+        self,
+        client_learning_rate: float,
+        q: float = 0.1,
+        train_loss_key: str = "train_loss",
+        fraction_train: float = 1.0,
+        fraction_evaluate: float = 1.0,
+        min_train_nodes: int = 2,
+        min_evaluate_nodes: int = 2,
+        min_available_nodes: int = 2,
+        weighted_by_key: str = "num-examples",
+        arrayrecord_key: str = "arrays",
+        configrecord_key: str = "config",
+        train_metrics_aggr_fn: Optional[
+            Callable[[list[RecordDict], str], MetricRecord]
+        ] = None,
+        evaluate_metrics_aggr_fn: Optional[
+            Callable[[list[RecordDict], str], MetricRecord]
+        ] = None,
+    ) -> None:
+        super().__init__(
+            fraction_train=fraction_train,
+            fraction_evaluate=fraction_evaluate,
+            min_train_nodes=min_train_nodes,
+            min_evaluate_nodes=min_evaluate_nodes,
+            min_available_nodes=min_available_nodes,
+            weighted_by_key=weighted_by_key,
+            arrayrecord_key=arrayrecord_key,
+            configrecord_key=configrecord_key,
+            train_metrics_aggr_fn=train_metrics_aggr_fn,
+            evaluate_metrics_aggr_fn=evaluate_metrics_aggr_fn,
+        )
+        self.q = q
+        self.client_learning_rate = client_learning_rate
+        self.train_loss_key = train_loss_key
+        self.current_arrays: Optional[ArrayRecord] = None
+
+    def summary(self) -> None:
+        """Log summary configuration of the strategy."""
+        log(INFO, "\t├──> q-FedAvg settings:")
+        log(INFO, "\t│\t├── client_learning_rate: %s", self.client_learning_rate)
+        log(INFO, "\t│\t├── q: %s", self.q)
+        log(INFO, "\t│\t└── train_loss_key: '%s'", self.train_loss_key)
+        super().summary()
+
+    def configure_train(
+        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
+    ) -> Iterable[Message]:
+        """Configure the next round of federated training."""
+        self.current_arrays = arrays.copy()
+        return super().configure_train(server_round, arrays, config, grid)
+
+    def aggregate_train(  # pylint: disable=too-many-locals
+        self,
+        server_round: int,
+        replies: Iterable[Message],
+    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
+        # Call FedAvg aggregate_train to perform validation and aggregation
+        valid_replies, _ = self._check_and_log_replies(replies, is_train=True)
+
+        if not valid_replies:
+            return None, None
+
+        # Compute estimate of Lipschitz constant L
+        L = 1.0 / self.client_learning_rate  # pylint: disable=C0103
+
+        # q-FedAvg aggregation
+        if self.current_arrays is None:
+            raise AggregationError(
+                "Current global model weights are not available. Make sure to call"
+                "`configure_train` before calling `aggregate_train`."
+            )
+        array_keys = list(self.current_arrays.keys())  # Preserve keys
+        global_weights = self.current_arrays.to_numpy_ndarrays(keep_input=False)
+        sum_delta = None
+        sum_h = 0.0
+
+        for msg in valid_replies:
+            # Extract local weights and training loss from Message
+            local_weights = get_local_weights(msg)
+            loss = get_train_loss(msg, self.train_loss_key)
+
+            # Compute delta and h
+            delta, h = compute_delta_and_h(
+                global_weights, local_weights, self.q, L, loss
+            )
+
+            # Compute sum of deltas and sum of h
+            if sum_delta is None:
+                sum_delta = delta
+            else:
+                sum_delta = [sd + d for sd, d in zip(sum_delta, delta)]
+            sum_h += h
+
+        # Compute new global weights and convert to Array type
+        # `np.asarray` can convert numpy scalars to 0-dim arrays
+        assert sum_delta is not None  # Make mypy happy
+        array_list = [
+            Array(np.asarray(gw - (d / sum_h)))
+            for gw, d in zip(global_weights, sum_delta)
+        ]
+
+        # Aggregate MetricRecords
+        metrics = self.train_metrics_aggr_fn(
+            [msg.content for msg in valid_replies],
+            self.weighted_by_key,
+        )
+        return ArrayRecord(OrderedDict(zip(array_keys, array_list))), metrics
+
+
+def get_train_loss(msg: Message, loss_key: str) -> float:
+    """Extract training loss from a Message."""
+    metrics = list(msg.content.metric_records.values())[0]
+    if (loss := metrics.get(loss_key)) is None or not isinstance(loss, (int, float)):
+        raise AggregationError(
+            "Missing or invalid training loss. "
+            f"The strategy expected a float value for the key '{loss_key}' "
+            "as the training loss in each MetricRecord from the clients. "
+            f"Ensure that '{loss_key}' is present and maps to a valid float."
+        )
+    return float(loss)
+
+
+def get_local_weights(msg: Message) -> list[NDArray]:
+    """Extract local weights from a Message."""
+    arrays = list(msg.content.array_records.values())[0]
+    return arrays.to_numpy_ndarrays(keep_input=False)
+
+
+def l2_norm(ndarrays: list[NDArray]) -> float:
+    """Compute the squared L2 norm of a list of numpy.ndarray."""
+    return float(sum(np.sum(np.square(g)) for g in ndarrays))
+
+
+def compute_delta_and_h(
+    global_weights: list[NDArray],
+    local_weights: list[NDArray],
+    q: float,
+    L: float,  # Lipschitz constant  # pylint: disable=C0103
+    loss: float,
+) -> tuple[list[NDArray], float]:
+    """Compute delta and h used in q-FedAvg aggregation."""
+    # Compute gradient_k = L * (w - w_k)
+    for gw, lw in zip(global_weights, local_weights):
+        np.subtract(gw, lw, out=lw)
+        lw *= L
+    grad = local_weights  # After in-place operations, local_weights is now grad
+    # Compute ||w_k - w||^2
+    norm = l2_norm(grad)
+    # Compute delta_k = loss_k^q * gradient_k
+    loss_pow_q: float = np.float_power(loss + 1e-10, q)
+    for g in grad:
+        g *= loss_pow_q
+    delta = grad  # After in-place multiplication, grad is now delta
+    # Compute h_k
+    h = q * np.float_power(loss + 1e-10, q - 1) * norm + L * loss_pow_q
+    return delta, h

flwr/serverapp/strategy/strategy_utils.py

@@ -15,6 +15,7 @@
 """Flower message-based strategy utilities."""
 
 
+import json
 import random
 from collections import OrderedDict
 from logging import INFO
@@ -249,3 +250,50 @@ def validate_message_reply_consistency(
             "must be a single value (int or float), but a list was found. Skipping "
             "aggregation."
         )
+
+
+def aggregate_bagging(
+    bst_prev_org: bytes,
+    bst_curr_org: bytes,
+) -> bytes:
+    """Conduct bagging aggregation for given trees."""
+    if bst_prev_org == b"":
+        return bst_curr_org
+
+    # Get the tree numbers
+    tree_num_prev, _ = _get_tree_nums(bst_prev_org)
+    _, paral_tree_num_curr = _get_tree_nums(bst_curr_org)
+
+    bst_prev = json.loads(bytearray(bst_prev_org))
+    bst_curr = json.loads(bytearray(bst_curr_org))
+
+    previous_model = bst_prev["learner"]["gradient_booster"]["model"]
+    previous_model["gbtree_model_param"]["num_trees"] = str(
+        tree_num_prev + paral_tree_num_curr
+    )
+    iteration_indptr = previous_model["iteration_indptr"]
+    previous_model["iteration_indptr"].append(
+        iteration_indptr[-1] + paral_tree_num_curr
+    )
+
+    # Aggregate new trees
+    trees_curr = bst_curr["learner"]["gradient_booster"]["model"]["trees"]
+    for tree_count in range(paral_tree_num_curr):
+        trees_curr[tree_count]["id"] = tree_num_prev + tree_count
+        previous_model["trees"].append(trees_curr[tree_count])
+        previous_model["tree_info"].append(0)
+
+    bst_prev_bytes = bytes(json.dumps(bst_prev), "utf-8")
+
+    return bst_prev_bytes
+
+
+def _get_tree_nums(xgb_model_org: bytes) -> tuple[int, int]:
+    xgb_model = json.loads(bytearray(xgb_model_org))
+
+    # Access model parameters
+    model_param = xgb_model["learner"]["gradient_booster"]["model"][
+        "gbtree_model_param"
+    ]
+    # Return the number of trees and the number of parallel trees
+    return int(model_param["num_trees"]), int(model_param["num_parallel_tree"])

flwr/simulation/app.py

@@ -245,7 +245,7 @@ def run_simulation_process(  # pylint: disable=R0913, R0914, R0915, R0917, W0212
             run=run,
             enable_tf_gpu_growth=enable_tf_gpu_growth,
             verbose_logging=verbose,
-            server_app_run_config=fused_config,
+            server_app_context=context,
             is_app=True,
             exit_event=EventType.FLWR_SIMULATION_RUN_LEAVE,
         )

flwr/simulation/run_simulation.py

@@ -143,6 +143,15 @@ def run_simulation_from_cli() -> None:
     run = Run.create_empty(run_id)
     run.override_config = override_config
 
+    # Create Context
+    server_app_context = Context(
+        run_id=run_id,
+        node_id=0,
+        node_config=UserConfig(),
+        state=RecordDict(),
+        run_config=fused_config,
+    )
+
     _ = _run_simulation(
         server_app_attr=server_app_attr,
         client_app_attr=client_app_attr,
@@ -153,7 +162,7 @@ def run_simulation_from_cli() -> None:
         run=run,
         enable_tf_gpu_growth=args.enable_tf_gpu_growth,
         verbose_logging=args.verbose,
-        server_app_run_config=fused_config,
+        server_app_context=server_app_context,
         is_app=True,
         exit_event=EventType.CLI_FLOWER_SIMULATION_LEAVE,
     )
@@ -241,13 +250,12 @@ def run_simulation(
 def run_serverapp_th(
     server_app_attr: Optional[str],
     server_app: Optional[ServerApp],
-    server_app_run_config: UserConfig,
+    server_app_context: Context,
     grid: Grid,
     app_dir: str,
     f_stop: threading.Event,
     has_exception: threading.Event,
     enable_tf_gpu_growth: bool,
-    run_id: int,
     ctx_queue: "Queue[Context]",
 ) -> threading.Thread:
     """Run SeverApp in a thread."""
@@ -258,7 +266,6 @@ def run_serverapp_th(
         exception_event: threading.Event,
         _grid: Grid,
         _server_app_dir: str,
-        _server_app_run_config: UserConfig,
         _server_app_attr: Optional[str],
         _server_app: Optional[ServerApp],
         _ctx_queue: "Queue[Context]",
@@ -272,19 +279,10 @@ def run_serverapp_th(
                 log(INFO, "Enabling GPU growth for Tensorflow on the server thread.")
                 enable_gpu_growth()
 
-            # Initialize Context
-            context = Context(
-                run_id=run_id,
-                node_id=0,
-                node_config={},
-                state=RecordDict(),
-                run_config=_server_app_run_config,
-            )
-
             # Run ServerApp
             updated_context = _run(
                 grid=_grid,
-                context=context,
+                context=server_app_context,
                 server_app_dir=_server_app_dir,
                 server_app_attr=_server_app_attr,
                 loaded_server_app=_server_app,
@@ -310,7 +308,6 @@ def run_serverapp_th(
             has_exception,
             grid,
             app_dir,
-            server_app_run_config,
             server_app_attr,
             server_app,
             ctx_queue,
@@ -335,7 +332,7 @@ def _main_loop(
     client_app_attr: Optional[str] = None,
     server_app: Optional[ServerApp] = None,
     server_app_attr: Optional[str] = None,
-    server_app_run_config: Optional[UserConfig] = None,
+    server_app_context: Optional[Context] = None,
 ) -> Context:
     """Start ServerApp on a separate thread, then launch Simulation Engine."""
     # Initialize StateFactory
@@ -346,13 +343,15 @@ def _main_loop(
     server_app_thread_has_exception = threading.Event()
     serverapp_th = None
     success = True
-    updated_context = Context(
-        run_id=run.run_id,
-        node_id=0,
-        node_config=UserConfig(),
-        state=RecordDict(),
-        run_config=UserConfig(),
-    )
+    if server_app_context is None:
+        server_app_context = Context(
+            run_id=run.run_id,
+            node_id=0,
+            node_config=UserConfig(),
+            state=RecordDict(),
+            run_config=UserConfig(),
+        )
+    updated_context = server_app_context
     try:
         # Register run
         log(DEBUG, "Pre-registering run with id %s", run.run_id)
@@ -361,9 +360,6 @@ def _main_loop(
         run.running_at = run.starting_at
         state_factory.state().run_ids[run.run_id] = RunRecord(run=run)  # type: ignore
 
-        if server_app_run_config is None:
-            server_app_run_config = {}
-
         # Initialize Grid
         grid = InMemoryGrid(state_factory=state_factory)
         grid.set_run(run_id=run.run_id)
@@ -373,13 +369,12 @@ def _main_loop(
         serverapp_th = run_serverapp_th(
             server_app_attr=server_app_attr,
             server_app=server_app,
-            server_app_run_config=server_app_run_config,
+            server_app_context=server_app_context,
             grid=grid,
             app_dir=app_dir,
             f_stop=f_stop,
             has_exception=server_app_thread_has_exception,
             enable_tf_gpu_growth=enable_tf_gpu_growth,
-            run_id=run.run_id,
             ctx_queue=output_context_queue,
         )
 
@@ -438,7 +433,7 @@ def _run_simulation(
     backend_config: Optional[BackendConfig] = None,
     client_app_attr: Optional[str] = None,
     server_app_attr: Optional[str] = None,
-    server_app_run_config: Optional[UserConfig] = None,
+    server_app_context: Optional[Context] = None,
     app_dir: str = "",
     flwr_dir: Optional[str] = None,
     run: Optional[Run] = None,
@@ -502,7 +497,7 @@ def _run_simulation(
         client_app_attr,
         server_app,
         server_app_attr,
-        server_app_run_config,
+        server_app_context,
     )
     # Detect if there is an Asyncio event loop already running.
     # If yes, disable logger propagation. In environmnets

flwr/supercore/cli/flower_superexec.py

@@ -17,7 +17,9 @@
 
 import argparse
 from logging import INFO
-from typing import Optional
+from typing import Any, Optional
+
+import yaml
 
 from flwr.common import EventType, event
 from flwr.common.constant import ExecPluginType
@@ -26,6 +28,7 @@ from flwr.common.logger import log
 from flwr.proto.clientappio_pb2_grpc import ClientAppIoStub
 from flwr.proto.serverappio_pb2_grpc import ServerAppIoStub
 from flwr.proto.simulationio_pb2_grpc import SimulationIoStub
+from flwr.supercore.constant import EXEC_PLUGIN_SECTION
 from flwr.supercore.grpc_health import add_args_health
 from flwr.supercore.superexec.plugin import (
     ClientAppExecPlugin,
@@ -36,6 +39,7 @@ from flwr.supercore.superexec.plugin import (
 from flwr.supercore.superexec.run_superexec import run_superexec
 
 try:
+    from flwr.ee import add_ee_args_superexec
     from flwr.ee.constant import ExecEePluginType
     from flwr.ee.exec_plugin import get_ee_plugin_and_stub_class
 except ImportError:
@@ -54,6 +58,10 @@ except ImportError:
         """Get the EE plugin class and stub class based on the plugin type."""
         return None
 
+    # pylint: disable-next=unused-argument
+    def add_ee_args_superexec(parser: argparse.ArgumentParser) -> None:
+        """Add EE-specific arguments to the parser."""
+
 
 def flower_superexec() -> None:
     """Run `flower-superexec` command."""
@@ -70,12 +78,28 @@ def flower_superexec() -> None:
     # Trigger telemetry event
     event(EventType.RUN_SUPEREXEC_ENTER, {"plugin_type": args.plugin_type})
 
+    # Load plugin config from YAML file if provided
+    plugin_config = None
+    if plugin_config_path := getattr(args, "plugin_config", None):
+        try:
+            with open(plugin_config_path, encoding="utf-8") as file:
+                yaml_config: Optional[dict[str, Any]] = yaml.safe_load(file)
+                if yaml_config is None or EXEC_PLUGIN_SECTION not in yaml_config:
+                    raise ValueError(f"Missing '{EXEC_PLUGIN_SECTION}' section.")
+                plugin_config = yaml_config[EXEC_PLUGIN_SECTION]
+        except (FileNotFoundError, yaml.YAMLError, ValueError) as e:
+            flwr_exit(
+                ExitCode.SUPEREXEC_INVALID_PLUGIN_CONFIG,
+                f"Failed to load plugin config from '{plugin_config_path}': {e!r}",
+            )
+
     # Get the plugin class and stub class based on the plugin type
     plugin_class, stub_class = _get_plugin_and_stub_class(args.plugin_type)
     run_superexec(
         plugin_class=plugin_class,
         stub_class=stub_class,  # type: ignore
         appio_api_address=args.appio_api_address,
+        plugin_config=plugin_config,
         flwr_dir=args.flwr_dir,
         parent_pid=args.parent_pid,
         health_server_address=args.health_server_address,
@@ -122,6 +146,7 @@ def _parse_args() -> argparse.ArgumentParser:
         help="The PID of the parent process. When set, the process will terminate "
         "when the parent process exits.",
     )
+    add_ee_args_superexec(parser)
     add_args_health(parser)
     return parser
 

flwr/supercore/constant.py

@@ -0,0 +1,19 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Constants for Flower infrastructure."""
+
+
+# Top-level key in YAML config for exec plugin settings
+EXEC_PLUGIN_SECTION = "exec_plugin"

flwr/supercore/superexec/plugin/exec_plugin.py

@@ -17,7 +17,7 @@
 
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from typing import Callable, Optional
+from typing import Any, Callable, Optional
 
 from flwr.common.typing import Run
 
@@ -69,3 +69,13 @@ class ExecPlugin(ABC):
            The ID of the run associated with the token, used for tracking or
            logging purposes.
         """
+
+    # This method is optional to implement
+    def load_config(self, yaml_config: dict[str, Any]) -> None:
+        """Load configuration from a YAML dictionary.
+
+        Parameters
+        ----------
+        yaml_config : dict[str, Any]
+            A dictionary representing the YAML configuration.
+        """

flwr/supercore/superexec/run_superexec.py

@@ -17,10 +17,10 @@
 
 import time
 from logging import WARN
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 from flwr.common.config import get_flwr_dir
-from flwr.common.exit import register_signal_handlers
+from flwr.common.exit import ExitCode, flwr_exit, register_signal_handlers
 from flwr.common.grpc import create_channel, on_channel_state_change
 from flwr.common.logger import log
 from flwr.common.retry_invoker import _make_simple_grpc_retry_invoker, _wrap_stub
@@ -47,6 +47,7 @@ def run_superexec(  # pylint: disable=R0913,R0914,R0917
         type[ClientAppIoStub], type[ServerAppIoStub], type[SimulationIoStub]
     ],
     appio_api_address: str,
+    plugin_config: Optional[dict[str, Any]] = None,
     flwr_dir: Optional[str] = None,
     parent_pid: Optional[int] = None,
     health_server_address: Optional[str] = None,
@@ -61,6 +62,9 @@ def run_superexec(  # pylint: disable=R0913,R0914,R0917
         The gRPC stub class for the AppIO API.
     appio_api_address : str
         The address of the AppIO API.
+    plugin_config : Optional[dict[str, Any]] (default: None)
+        The configuration dictionary for the plugin. If `None`, the plugin will use
+        its default configuration.
     flwr_dir : Optional[str] (default: None)
         The Flower directory.
     parent_pid : Optional[int] (default: None)
@@ -113,6 +117,16 @@ def run_superexec(  # pylint: disable=R0913,R0914,R0917
         get_run=get_run,
     )
 
+    # Load plugin configuration from file if provided
+    try:
+        if plugin_config is not None:
+            plugin.load_config(plugin_config)
+    except (KeyError, ValueError) as e:
+        flwr_exit(
+            code=ExitCode.SUPEREXEC_INVALID_PLUGIN_CONFIG,
+            message=f"Invalid plugin config: {e!r}",
+        )
+
     # Start the main loop
     try:
         while True:

flwr/superlink/artifact_provider/__init__.py

@@ -0,0 +1,22 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""ArtifactProvider for SuperLink."""
+
+
+from .artifact_provider import ArtifactProvider
+
+__all__ = [
+    "ArtifactProvider",
+]