flwr-nightly 1.22.0.dev20250916__tar.gz → 1.22.0.dev20250917__tar.gz

{flwr_nightly-1.22.0.dev20250916 → flwr_nightly-1.22.0.dev20250917}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.22.0.dev20250916
+Version: 1.22.0.dev20250917
 Summary: Flower: A Friendly Federated AI Framework
 License: Apache-2.0
 Keywords: Artificial Intelligence,Federated AI,Federated Analytics,Federated Evaluation,Federated Learning,Flower,Machine Learning

{flwr_nightly-1.22.0.dev20250916 → flwr_nightly-1.22.0.dev20250917}/py/flwr/cli/app.py

@@ -25,6 +25,7 @@ from .log import log
 from .login import login
 from .ls import ls
 from .new import new
+from .pull import pull
 from .run import run
 from .stop import stop
 
@@ -46,6 +47,7 @@ app.command()(log)
 app.command()(ls)
 app.command()(stop)
 app.command()(login)
+app.command()(pull)
 
 typer_click_object = get_command(app)
 

{flwr_nightly-1.22.0.dev20250916 → flwr_nightly-1.22.0.dev20250917}/py/flwr/cli/new/new.py

@@ -201,7 +201,7 @@ def new(
         }
 
         # Challenge specific context
-        fraction_fit = "0.2" if llm_challenge_str == "code" else "0.1"
+        fraction_train = "0.2" if llm_challenge_str == "code" else "0.1"
         if llm_challenge_str == "generalnlp":
             challenge_name = "General NLP"
             num_clients = "20"
@@ -220,7 +220,7 @@ def new(
             dataset_name = "flwrlabs/code-alpaca-20k"
 
         context["llm_challenge_str"] = llm_challenge_str
-        context["fraction_fit"] = fraction_fit
+        context["fraction_train"] = fraction_train
         context["challenge_name"] = challenge_name
         context["num_clients"] = num_clients
         context["dataset_name"] = dataset_name

{flwr_nightly-1.22.0.dev20250916 → flwr_nightly-1.22.0.dev20250917}/py/flwr/cli/new/templates/app/README.flowertune.md.tpl

@@ -26,7 +26,7 @@ pip install -e .
 ## Experimental setup
 
 The dataset is divided into $num_clients partitions in an IID fashion, a partition is assigned to each ClientApp.
-We randomly sample a fraction ($fraction_fit) of the total nodes to participate in each round, for a total of `200` rounds.
+We randomly sample a fraction ($fraction_train) of the total nodes to participate in each round, for a total of `200` rounds.
 All settings are defined in `pyproject.toml`.
 
 > [!IMPORTANT]

flwr_nightly-1.22.0.dev20250917/py/flwr/cli/new/templates/app/code/client.baseline.py.tpl

@@ -0,0 +1,75 @@
+"""$project_name: A Flower Baseline."""
+
+import torch
+from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
+
+from $import_name.dataset import load_data
+from $import_name.model import Net
+from $import_name.model import test as test_fn
+from $import_name.model import train as train_fn
+
+# Flower ClientApp
+app = ClientApp()
+
+
+@app.train()
+def train(msg: Message, context: Context):
+    """Train the model on local data."""
+
+    # Load the model and initialize it with the received weights
+    model = Net()
+    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+    # Load the data
+    partition_id = int(context.node_config["partition-id"])
+    num_partitions = int(context.node_config["num-partitions"])
+    trainloader, _ = load_data(partition_id, num_partitions)
+    local_epochs = context.run_config["local-epochs"]
+
+    # Call the training function
+    train_loss = train_fn(
+        model,
+        trainloader,
+        local_epochs,
+        device,
+    )
+
+    # Construct and return reply Message
+    model_record = ArrayRecord(model.state_dict())
+    metrics = {
+        "train_loss": train_loss,
+        "num-examples": len(trainloader.dataset),
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"arrays": model_record, "metrics": metric_record})
+    return Message(content=content, reply_to=msg)
+
+
+@app.evaluate()
+def evaluate(msg: Message, context: Context):
+    """Evaluate the model on local data."""
+
+    # Load the model and initialize it with the received weights
+    model = Net()
+    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+    # Load the data
+    partition_id = int(context.node_config["partition-id"])
+    num_partitions = int(context.node_config["num-partitions"])
+    _, valloader = load_data(partition_id, num_partitions)
+
+    # Call the evaluation function
+    eval_loss, eval_acc = test_fn(model, valloader, device)
+
+    # Construct and return reply Message
+    metrics = {
+        "eval_loss": eval_loss,
+        "eval_acc": eval_acc,
+        "num-examples": len(valloader.dataset),
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"metrics": metric_record})
+    return Message(content=content, reply_to=msg)

flwr_nightly-1.22.0.dev20250917/py/flwr/cli/new/templates/app/code/flwr_tune/client_app.py.tpl

@@ -0,0 +1,92 @@
+"""$project_name: A Flower / FlowerTune app."""
+
+import os
+import warnings
+
+from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
+from flwr.common.config import unflatten_dict
+from omegaconf import DictConfig
+from peft import get_peft_model_state_dict, set_peft_model_state_dict
+from transformers import TrainingArguments
+from trl import SFTTrainer
+
+from $import_name.dataset import (
+    get_tokenizer_and_data_collator_and_propt_formatting,
+    load_data,
+    replace_keys,
+)
+from $import_name.models import cosine_annealing, get_model
+
+# Avoid warnings
+os.environ["TOKENIZERS_PARALLELISM"] = "true"
+os.environ["RAY_DISABLE_DOCKER_CPU_WARNING"] = "1"
+warnings.filterwarnings("ignore", category=UserWarning)
+
+
+# Avoid warnings
+os.environ["TOKENIZERS_PARALLELISM"] = "true"
+os.environ["RAY_DISABLE_DOCKER_CPU_WARNING"] = "1"
+warnings.filterwarnings("ignore", category=UserWarning)
+
+
+# Flower ClientApp
+app = ClientApp()
+
+
+@app.train()
+def train(msg: Message, context: Context):
+    """Train the model on local data."""
+    # Parse config
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    num_rounds = context.run_config["num-server-rounds"]
+    cfg = DictConfig(replace_keys(unflatten_dict(context.run_config)))
+    training_arguments = TrainingArguments(**cfg.train.training_arguments)
+
+    # Let's get the client partition
+    trainset = load_data(partition_id, num_partitions, cfg.static.dataset.name)
+    (
+        tokenizer,
+        data_collator,
+        formatting_prompts_func,
+    ) = get_tokenizer_and_data_collator_and_propt_formatting(cfg.model.name)
+
+    # Load the model and initialize it with the received weights
+    model = get_model(cfg.model)
+    set_peft_model_state_dict(model, msg.content["arrays"].to_torch_state_dict())
+
+    # Set learning rate for current round
+    new_lr = cosine_annealing(
+        msg.content["config"]["server-round"],
+        num_rounds,
+        cfg.train.learning_rate_max,
+        cfg.train.learning_rate_min,
+    )
+
+    training_arguments.learning_rate = new_lr
+    training_arguments.output_dir = msg.content["config"]["save_path"]
+
+    # Construct trainer
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tokenizer,
+        args=training_arguments,
+        max_seq_length=cfg.train.seq_length,
+        train_dataset=trainset,
+        formatting_func=formatting_prompts_func,
+        data_collator=data_collator,
+    )
+
+    # Do local training
+    results = trainer.train()
+
+    # Construct and return reply Message
+    model_record = ArrayRecord(get_peft_model_state_dict(model))
+    metrics = {
+        "train_loss": results.training_loss,
+        "num-examples": len(trainset),
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"arrays": model_record, "metrics": metric_record})
+    return Message(content=content, reply_to=msg)

{flwr_nightly-1.22.0.dev20250916 → flwr_nightly-1.22.0.dev20250917}/py/flwr/cli/new/templates/app/code/flwr_tune/models.py.tpl

@@ -4,18 +4,10 @@ import math
 
 import torch
 from omegaconf import DictConfig
-from collections import OrderedDict
-from peft import (
-    LoraConfig,
-    get_peft_model,
-    get_peft_model_state_dict,
-    set_peft_model_state_dict,
-)
+from peft import LoraConfig, get_peft_model
 from peft.utils import prepare_model_for_kbit_training
 from transformers import AutoModelForCausalLM, BitsAndBytesConfig
 
-from flwr.common.typing import NDArrays
-
 
 def cosine_annealing(
     current_round: int,
@@ -62,17 +54,3 @@ def get_model(model_cfg: DictConfig):
         model.config.use_cache = False
 
     return get_peft_model(model, peft_config)
-
-
-def set_parameters(model, parameters: NDArrays) -> None:
-    """Change the parameters of the model using the given ones."""
-    peft_state_dict_keys = get_peft_model_state_dict(model).keys()
-    params_dict = zip(peft_state_dict_keys, parameters)
-    state_dict = OrderedDict({k: torch.Tensor(v) for k, v in params_dict})
-    set_peft_model_state_dict(model, state_dict)
-
-
-def get_parameters(model) -> NDArrays:
-    """Return the parameters of the current net."""
-    state_dict = get_peft_model_state_dict(model)
-    return [val.cpu().numpy() for _, val in state_dict.items()]

flwr_nightly-1.22.0.dev20250917/py/flwr/cli/new/templates/app/code/flwr_tune/server_app.py.tpl

@@ -0,0 +1,73 @@
+"""$project_name: A Flower / FlowerTune app."""
+
+import os
+from datetime import datetime
+
+from flwr.app import ArrayRecord, ConfigRecord, Context, MetricRecord
+from flwr.common.config import unflatten_dict
+from flwr.serverapp import Grid, ServerApp
+from omegaconf import DictConfig
+from peft import get_peft_model_state_dict, set_peft_model_state_dict
+
+from $import_name.dataset import replace_keys
+from $import_name.models import get_model
+from $import_name.strategy import FlowerTuneLlm
+
+# Create ServerApp
+app = ServerApp()
+
+
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Main entry point for the ServerApp."""
+    # Create output directory given current timestamp
+    current_time = datetime.now()
+    folder_name = current_time.strftime("%Y-%m-%d_%H-%M-%S")
+    save_path = os.path.join(os.getcwd(), f"results/{folder_name}")
+    os.makedirs(save_path, exist_ok=True)
+
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+    cfg = DictConfig(replace_keys(unflatten_dict(context.run_config)))
+
+    # Get initial model weights
+    init_model = get_model(cfg.model)
+    arrays = ArrayRecord(get_peft_model_state_dict(init_model))
+
+    # Define strategy
+    strategy = FlowerTuneLlm(
+        fraction_train=cfg.strategy.fraction_train,
+        fraction_evaluate=cfg.strategy.fraction_evaluate,
+    )
+
+    # Start strategy, run FedAvg for `num_rounds`
+    strategy.start(
+        grid=grid,
+        initial_arrays=arrays,
+        train_config=ConfigRecord({"save_path": save_path}),
+        num_rounds=num_rounds,
+        evaluate_fn=get_evaluate_fn(
+            cfg.model, cfg.train.save_every_round, num_rounds, save_path
+        ),
+    )
+
+
+# Get function that will be executed by the strategy
+# Here we use it to save global model checkpoints
+def get_evaluate_fn(model_cfg, save_every_round, total_round, save_path):
+    """Return an evaluation function for saving global model."""
+
+    def evaluate(server_round: int, arrays: ArrayRecord) -> MetricRecord:
+        # Save model
+        if server_round != 0 and (
+            server_round == total_round or server_round % save_every_round == 0
+        ):
+            # Init model
+            model = get_model(model_cfg)
+            set_peft_model_state_dict(model, arrays.to_torch_state_dict())
+
+            model.save_pretrained(f"{save_path}/peft_{server_round}")
+
+        return MetricRecord()
+
+    return evaluate

flwr_nightly-1.22.0.dev20250917/py/flwr/cli/new/templates/app/code/flwr_tune/strategy.py.tpl

@@ -0,0 +1,78 @@
+"""$project_name: A Flower / FlowerTune app."""
+
+from collections.abc import Iterable
+from logging import INFO, WARN
+from typing import Optional
+
+from flwr.app import ArrayRecord, ConfigRecord, Message, MetricRecord
+from flwr.common import log
+from flwr.serverapp import Grid
+from flwr.serverapp.strategy import FedAvg
+
+
+class FlowerTuneLlm(FedAvg):
+    """Customised FedAvg strategy implementation.
+
+    This class behaves just like FedAvg but also tracks the communication
+    costs associated with `train` over FL rounds.
+    """
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.comm_tracker = CommunicationTracker()
+
+    def configure_train(
+            self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
+    ) -> Iterable[Message]:
+        """Configure the next round of training."""
+        messages = super().configure_train(server_round, arrays, config, grid)
+
+        # Track communication costs
+        self.comm_tracker.track(messages)
+
+        return messages
+
+    def aggregate_train(
+            self,
+            server_round: int,
+            replies: Iterable[Message],
+    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
+        # Track communication costs
+        self.comm_tracker.track(replies)
+
+        arrays, metrics = super().aggregate_train(server_round, replies)
+
+        return arrays, metrics
+
+
+class CommunicationTracker:
+    """Communication costs tracker over FL rounds."""
+    def __init__(self):
+        self.curr_comm_cost = 0.0
+
+    def track(self, messages: Iterable[Message]):
+        comm_cost = (
+            sum(
+                record.count_bytes()
+                for msg in messages
+                if msg.has_content()
+                for record in msg.content.array_records.values()
+            )
+            / 1024**2
+        )
+
+        self.curr_comm_cost += comm_cost
+        log(
+            INFO,
+            "Communication budget: used %.2f MB (+%.2f MB this round) / 200,000 MB",
+            self.curr_comm_cost,
+            comm_cost,
+        )
+
+        if self.curr_comm_cost > 2e5:
+            log(
+                WARN,
+                "The accumulated communication cost has exceeded 200,000 MB. "
+                "Please consider reducing it if you plan to participate "
+                "FlowerTune LLM Leaderboard.",
+            )

{flwr_nightly-1.22.0.dev20250916 → flwr_nightly-1.22.0.dev20250917}/py/flwr/cli/new/templates/app/code/model.baseline.py.tpl

@@ -1,7 +1,5 @@
 """$project_name: A Flower Baseline."""
 
-from collections import OrderedDict
-
 import torch
 import torch.nn.functional as F
 from torch import nn
@@ -66,15 +64,3 @@ def test(net, testloader, device):
     accuracy = correct / len(testloader.dataset)
     loss = loss / len(testloader)
     return loss, accuracy
-
-
-def get_weights(net):
-    """Extract model parameters as numpy arrays from state_dict."""
-    return [val.cpu().numpy() for _, val in net.state_dict().items()]
-
-
-def set_weights(net, parameters):
-    """Apply parameters to an existing model."""
-    params_dict = zip(net.state_dict().keys(), parameters)
-    state_dict = OrderedDict({k: torch.from_numpy(v) for k, v in params_dict})
-    net.load_state_dict(state_dict, strict=True)

flwr_nightly-1.22.0.dev20250917/py/flwr/cli/new/templates/app/code/server.baseline.py.tpl

@@ -0,0 +1,43 @@
+"""$project_name: A Flower Baseline."""
+
+import torch
+from flwr.app import ArrayRecord, Context
+from flwr.serverapp import Grid, ServerApp
+from flwr.serverapp.strategy import FedAvg
+
+from $import_name.model import Net
+
+# Create ServerApp
+app = ServerApp()
+
+
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Main entry point for the ServerApp."""
+
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+    fraction_train = context.run_config["fraction-train"]
+
+    # Load global model
+    global_model = Net()
+    arrays = ArrayRecord(global_model.state_dict())
+
+    # Initialize FedAvg strategy
+    strategy = FedAvg(
+        fraction_train=fraction_train,
+        fraction_evaluate=1.0,
+        min_available_nodes=2,
+    )
+
+    # Start strategy, run FedAvg for `num_rounds`
+    result = strategy.start(
+        grid=grid,
+        initial_arrays=arrays,
+        num_rounds=num_rounds,
+    )
+
+    # Save final model to disk
+    print("\nSaving final model to disk...")
+    state_dict = result.arrays.to_torch_state_dict()
+    torch.save(state_dict, "final_model.pt")

{flwr_nightly-1.22.0.dev20250916 → flwr_nightly-1.22.0.dev20250917}/py/flwr/cli/new/templates/app/pyproject.baseline.toml.tpl

@@ -16,8 +16,8 @@ license = "Apache-2.0"
 dependencies = [
     "flwr[simulation]>=1.22.0",
     "flwr-datasets[vision]>=0.5.0",
-    "torch==2.7.1",
-    "torchvision==0.22.1",
+    "torch==2.8.0",
+    "torchvision==0.23.0",
 ]
 
 [tool.hatch.metadata]
@@ -132,7 +132,7 @@ clientapp = "$import_name.client_app:app"
 # Custom config values accessible via `context.run_config`
 [tool.flwr.app.config]
 num-server-rounds = 3
-fraction-fit = 0.5
+fraction-train = 0.5
 local-epochs = 1
 
 # Default federation to use when running the app

{flwr_nightly-1.22.0.dev20250916 → flwr_nightly-1.22.0.dev20250917}/py/flwr/cli/new/templates/app/pyproject.flowertune.toml.tpl

@@ -61,7 +61,7 @@ train.training-arguments.save-steps = 1000
 train.training-arguments.save-total-limit = 10
 train.training-arguments.gradient-checkpointing = true
 train.training-arguments.lr-scheduler-type = "constant"
-strategy.fraction-fit = $fraction_fit
+strategy.fraction-train = $fraction_train
 strategy.fraction-evaluate = 0.0
 num-server-rounds = 200
 

flwr_nightly-1.22.0.dev20250917/py/flwr/cli/pull.py

@@ -0,0 +1,100 @@
+# 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.
+# ==============================================================================
+"""Flower command line interface `pull` command."""
+
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from flwr.cli.config_utils import (
+    exit_if_no_address,
+    load_and_validate,
+    process_loaded_project_config,
+    validate_federation_in_project_config,
+)
+from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
+from flwr.common.constant import FAB_CONFIG_FILE
+from flwr.proto.control_pb2 import (  # pylint: disable=E0611
+    PullArtifactsRequest,
+    PullArtifactsResponse,
+)
+from flwr.proto.control_pb2_grpc import ControlStub
+
+from .utils import flwr_cli_grpc_exc_handler, init_channel, try_obtain_cli_auth_plugin
+
+
+def pull(  # pylint: disable=R0914
+    run_id: Annotated[
+        int,
+        typer.Option(
+            "--run-id",
+            help="Run ID to pull artifacts from.",
+        ),
+    ],
+    app: Annotated[
+        Path,
+        typer.Argument(help="Path of the Flower App to run."),
+    ] = Path("."),
+    federation: Annotated[
+        Optional[str],
+        typer.Argument(help="Name of the federation."),
+    ] = None,
+    federation_config_overrides: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--federation-config",
+            help=FEDERATION_CONFIG_HELP_MESSAGE,
+        ),
+    ] = None,
+) -> None:
+    """Pull artifacts from a Flower run."""
+    typer.secho("Loading project configuration... ", fg=typer.colors.BLUE)
+
+    pyproject_path = app / FAB_CONFIG_FILE if app else None
+    config, errors, warnings = load_and_validate(path=pyproject_path)
+    config = process_loaded_project_config(config, errors, warnings)
+    federation, federation_config = validate_federation_in_project_config(
+        federation, config, federation_config_overrides
+    )
+    exit_if_no_address(federation_config, "pull")
+    channel = None
+    try:
+
+        auth_plugin = try_obtain_cli_auth_plugin(app, federation, federation_config)
+        channel = init_channel(app, federation_config, auth_plugin)
+        stub = ControlStub(channel)
+        with flwr_cli_grpc_exc_handler():
+            res: PullArtifactsResponse = stub.PullArtifacts(
+                PullArtifactsRequest(run_id=run_id)
+            )
+
+        if not res.url:
+            typer.secho(
+                f"❌ A download URL for artifacts from run {run_id} couldn't be "
+                "obtained.",
+                fg=typer.colors.RED,
+                bold=True,
+            )
+            raise typer.Exit(code=1)
+
+        typer.secho(
+            f"✅ Artifacts for run {run_id} can be downloaded from: {res.url}",
+            fg=typer.colors.GREEN,
+        )
+    finally:
+        if channel:
+            channel.close()

{flwr_nightly-1.22.0.dev20250916 → flwr_nightly-1.22.0.dev20250917}/py/flwr/cli/utils.py

@@ -32,7 +32,9 @@ from flwr.common.constant import (
     AUTH_TYPE_JSON_KEY,
     CREDENTIALS_DIR,
     FLWR_DIR,
+    NO_ARTIFACT_PROVIDER_MESSAGE,
     NO_USER_AUTH_MESSAGE,
+    PULL_UNFINISHED_RUN_MESSAGE,
     RUN_ID_NOT_FOUND_MESSAGE,
 )
 from flwr.common.grpc import (
@@ -319,6 +321,12 @@ def flwr_cli_grpc_exc_handler() -> Iterator[None]:
                     fg=typer.colors.RED,
                     bold=True,
                 )
+            elif e.details() == NO_ARTIFACT_PROVIDER_MESSAGE:  # pylint: disable=E1101
+                typer.secho(
+                    "❌ The SuperLink does not support `flwr pull` command.",
+                    fg=typer.colors.RED,
+                    bold=True,
+                )
             else:
                 typer.secho(
                     "❌ The SuperLink cannot process this request. Please verify that "
@@ -356,4 +364,13 @@ def flwr_cli_grpc_exc_handler() -> Iterator[None]:
                 bold=True,
             )
             raise typer.Exit(code=1) from None
+        if e.code() == grpc.StatusCode.FAILED_PRECONDITION:
+            if e.details() == PULL_UNFINISHED_RUN_MESSAGE:  # pylint: disable=E1101
+                typer.secho(
+                    "❌ Run is not finished yet. Artifacts can only be pulled after "
+                    "the run is finished. You can check the run status with `flwr ls`.",
+                    fg=typer.colors.RED,
+                    bold=True,
+                )
+                raise typer.Exit(code=1) from None
         raise

{flwr_nightly-1.22.0.dev20250916 → flwr_nightly-1.22.0.dev20250917}/py/flwr/common/constant.py

@@ -155,6 +155,8 @@ PULL_BACKOFF_CAP = 10  # Maximum backoff time for pulling objects
 # ControlServicer constants
 RUN_ID_NOT_FOUND_MESSAGE = "Run ID not found"
 NO_USER_AUTH_MESSAGE = "ControlServicer initialized without user authentication"
+NO_ARTIFACT_PROVIDER_MESSAGE = "ControlServicer initialized without artifact provider"
+PULL_UNFINISHED_RUN_MESSAGE = "Cannot pull artifacts for an unfinished run"
 
 
 class MessageType: