flwr-nightly 1.8.0.dev20240315__py3-none-any.whl → 1.11.0.dev20240813__py3-none-any.whl

flwr/common/record/recordset.py

@@ -16,23 +16,21 @@
 
 
 from dataclasses import dataclass
-from typing import Callable, Dict, Optional, Type, TypeVar
+from typing import Dict, Optional, cast
 
 from .configsrecord import ConfigsRecord
 from .metricsrecord import MetricsRecord
 from .parametersrecord import ParametersRecord
 from .typeddict import TypedDict
 
-T = TypeVar("T")
-
 
 @dataclass
-class RecordSet:
-    """RecordSet stores groups of parameters, metrics and configs."""
+class RecordSetData:
+    """Inner data container for the RecordSet class."""
 
-    _parameters_records: TypedDict[str, ParametersRecord]
-    _metrics_records: TypedDict[str, MetricsRecord]
-    _configs_records: TypedDict[str, ConfigsRecord]
+    parameters_records: TypedDict[str, ParametersRecord]
+    metrics_records: TypedDict[str, MetricsRecord]
+    configs_records: TypedDict[str, ConfigsRecord]
 
     def __init__(
         self,
@@ -40,40 +38,93 @@ class RecordSet:
         metrics_records: Optional[Dict[str, MetricsRecord]] = None,
         configs_records: Optional[Dict[str, ConfigsRecord]] = None,
     ) -> None:
-        def _get_check_fn(__t: Type[T]) -> Callable[[T], None]:
-            def _check_fn(__v: T) -> None:
-                if not isinstance(__v, __t):
-                    raise TypeError(f"Expected `{__t}`, but `{type(__v)}` was passed.")
-
-            return _check_fn
-
-        self._parameters_records = TypedDict[str, ParametersRecord](
-            _get_check_fn(str), _get_check_fn(ParametersRecord)
+        self.parameters_records = TypedDict[str, ParametersRecord](
+            self._check_fn_str, self._check_fn_params
         )
-        self._metrics_records = TypedDict[str, MetricsRecord](
-            _get_check_fn(str), _get_check_fn(MetricsRecord)
+        self.metrics_records = TypedDict[str, MetricsRecord](
+            self._check_fn_str, self._check_fn_metrics
         )
-        self._configs_records = TypedDict[str, ConfigsRecord](
-            _get_check_fn(str), _get_check_fn(ConfigsRecord)
+        self.configs_records = TypedDict[str, ConfigsRecord](
+            self._check_fn_str, self._check_fn_configs
         )
         if parameters_records is not None:
-            self._parameters_records.update(parameters_records)
+            self.parameters_records.update(parameters_records)
         if metrics_records is not None:
-            self._metrics_records.update(metrics_records)
+            self.metrics_records.update(metrics_records)
         if configs_records is not None:
-            self._configs_records.update(configs_records)
+            self.configs_records.update(configs_records)
+
+    def _check_fn_str(self, key: str) -> None:
+        if not isinstance(key, str):
+            raise TypeError(
+                f"Expected `{str.__name__}`, but "
+                f"received `{type(key).__name__}` for the key."
+            )
+
+    def _check_fn_params(self, record: ParametersRecord) -> None:
+        if not isinstance(record, ParametersRecord):
+            raise TypeError(
+                f"Expected `{ParametersRecord.__name__}`, but "
+                f"received `{type(record).__name__}` for the value."
+            )
+
+    def _check_fn_metrics(self, record: MetricsRecord) -> None:
+        if not isinstance(record, MetricsRecord):
+            raise TypeError(
+                f"Expected `{MetricsRecord.__name__}`, but "
+                f"received `{type(record).__name__}` for the value."
+            )
+
+    def _check_fn_configs(self, record: ConfigsRecord) -> None:
+        if not isinstance(record, ConfigsRecord):
+            raise TypeError(
+                f"Expected `{ConfigsRecord.__name__}`, but "
+                f"received `{type(record).__name__}` for the value."
+            )
+
+
+class RecordSet:
+    """RecordSet stores groups of parameters, metrics and configs."""
+
+    def __init__(
+        self,
+        parameters_records: Optional[Dict[str, ParametersRecord]] = None,
+        metrics_records: Optional[Dict[str, MetricsRecord]] = None,
+        configs_records: Optional[Dict[str, ConfigsRecord]] = None,
+    ) -> None:
+        data = RecordSetData(
+            parameters_records=parameters_records,
+            metrics_records=metrics_records,
+            configs_records=configs_records,
+        )
+        self.__dict__["_data"] = data
 
     @property
     def parameters_records(self) -> TypedDict[str, ParametersRecord]:
         """Dictionary holding ParametersRecord instances."""
-        return self._parameters_records
+        data = cast(RecordSetData, self.__dict__["_data"])
+        return data.parameters_records
 
     @property
     def metrics_records(self) -> TypedDict[str, MetricsRecord]:
         """Dictionary holding MetricsRecord instances."""
-        return self._metrics_records
+        data = cast(RecordSetData, self.__dict__["_data"])
+        return data.metrics_records
 
     @property
     def configs_records(self) -> TypedDict[str, ConfigsRecord]:
         """Dictionary holding ConfigsRecord instances."""
-        return self._configs_records
+        data = cast(RecordSetData, self.__dict__["_data"])
+        return data.configs_records
+
+    def __repr__(self) -> str:
+        """Return a string representation of this instance."""
+        flds = ("parameters_records", "metrics_records", "configs_records")
+        view = ", ".join([f"{fld}={getattr(self, fld)!r}" for fld in flds])
+        return f"{self.__class__.__qualname__}({view})"
+
+    def __eq__(self, other: object) -> bool:
+        """Compare two instances of the class."""
+        if not isinstance(other, self.__class__):
+            raise NotImplementedError
+        return self.__dict__ == other.__dict__

flwr/common/recordset_compat.py

@@ -35,6 +35,8 @@ from .typing import (
     Status,
 )
 
+EMPTY_TENSOR_KEY = "_empty"
+
 
 def parametersrecord_to_parameters(
     record: ParametersRecord, keep_input: bool
@@ -59,7 +61,8 @@ def parametersrecord_to_parameters(
     parameters = Parameters(tensors=[], tensor_type="")
 
     for key in list(record.keys()):
-        parameters.tensors.append(record[key].data)
+        if key != EMPTY_TENSOR_KEY:
+            parameters.tensors.append(record[key].data)
 
         if not parameters.tensor_type:
             # Setting from first array in record. Recall the warning in the docstrings
@@ -103,6 +106,10 @@ def parameters_to_parametersrecord(
             data=tensor, dtype="", stype=tensor_type, shape=[]
         )
 
+    if num_arrays == 0:
+        ordered_dict[EMPTY_TENSOR_KEY] = Array(
+            data=b"", dtype="", stype=tensor_type, shape=[]
+        )
     return ParametersRecord(ordered_dict, keep_input=keep_input)
 
 

flwr/common/retry_invoker.py

@@ -107,7 +107,7 @@ class RetryInvoker:
 
     Parameters
     ----------
-    wait_factory: Callable[[], Generator[float, None, None]]
+    wait_gen_factory: Callable[[], Generator[float, None, None]]
         A generator yielding successive wait times in seconds. If the generator
         is finite, the giveup event will be triggered when the generator raises
         `StopIteration`.
@@ -129,12 +129,12 @@ class RetryInvoker:
         data class object detailing the invocation.
     on_giveup: Optional[Callable[[RetryState], None]] (default: None)
         A callable to be executed in the event that `max_tries` or `max_time` is
-        exceeded, `should_giveup` returns True, or `wait_factory()` generator raises
+        exceeded, `should_giveup` returns True, or `wait_gen_factory()` generator raises
         `StopInteration`. The parameter is a data class object detailing the
         invocation.
     jitter: Optional[Callable[[float], float]] (default: full_jitter)
-        A function of the value yielded by `wait_factory()` returning the actual time
-        to wait. This function helps distribute wait times stochastically to avoid
+        A function of the value yielded by `wait_gen_factory()` returning the actual
+        time to wait. This function helps distribute wait times stochastically to avoid
         timing collisions across concurrent clients. Wait times are jittered by
         default using the `full_jitter` function. To disable jittering, pass
         `jitter=None`.
@@ -142,6 +142,13 @@ class RetryInvoker:
         A function accepting an exception instance, returning whether or not
         to give up prematurely before other give-up conditions are evaluated.
         If set to None, the strategy is to never give up prematurely.
+    wait_function: Optional[Callable[[float], None]] (default: None)
+        A function that defines how to wait between retry attempts. It accepts
+        one argument, the wait time in seconds, allowing the use of various waiting
+        mechanisms (e.g., asynchronous waits or event-based synchronization) suitable
+        for different execution environments. If set to `None`, the `wait_function`
+        defaults to `time.sleep`, which is ideal for synchronous operations. Custom
+        functions should manage execution flow to prevent blocking or interference.
 
     Examples
     --------
@@ -159,7 +166,7 @@ class RetryInvoker:
     # pylint: disable-next=too-many-arguments
     def __init__(
         self,
-        wait_factory: Callable[[], Generator[float, None, None]],
+        wait_gen_factory: Callable[[], Generator[float, None, None]],
         recoverable_exceptions: Union[Type[Exception], Tuple[Type[Exception], ...]],
         max_tries: Optional[int],
         max_time: Optional[float],
@@ -169,8 +176,9 @@ class RetryInvoker:
         on_giveup: Optional[Callable[[RetryState], None]] = None,
         jitter: Optional[Callable[[float], float]] = full_jitter,
         should_giveup: Optional[Callable[[Exception], bool]] = None,
+        wait_function: Optional[Callable[[float], None]] = None,
     ) -> None:
-        self.wait_factory = wait_factory
+        self.wait_gen_factory = wait_gen_factory
         self.recoverable_exceptions = recoverable_exceptions
         self.max_tries = max_tries
         self.max_time = max_time
@@ -179,6 +187,9 @@ class RetryInvoker:
         self.on_giveup = on_giveup
         self.jitter = jitter
         self.should_giveup = should_giveup
+        if wait_function is None:
+            wait_function = time.sleep
+        self.wait_function = wait_function
 
     # pylint: disable-next=too-many-locals
     def invoke(
@@ -212,13 +223,13 @@ class RetryInvoker:
         Raises
         ------
         Exception
-            If the number of tries exceeds `max_tries`, if the total time
-            exceeds `max_time`, if `wait_factory()` generator raises `StopInteration`,
+            If the number of tries exceeds `max_tries`, if the total time exceeds
+            `max_time`, if `wait_gen_factory()` generator raises `StopInteration`,
             or if the `should_giveup` returns True for a raised exception.
 
         Notes
         -----
-        The time between retries is determined by the provided `wait_factory()`
+        The time between retries is determined by the provided `wait_gen_factory()`
         generator and can optionally be jittered using the `jitter` function.
         The recoverable exceptions that trigger a retry, as well as conditions to
         stop retries, are also determined by the class's initialization parameters.
@@ -231,13 +242,13 @@ class RetryInvoker:
                 handler(cast(RetryState, ref_state[0]))
 
         try_cnt = 0
-        wait_generator = self.wait_factory()
-        start = time.time()
+        wait_generator = self.wait_gen_factory()
+        start = time.monotonic()
         ref_state: List[Optional[RetryState]] = [None]
 
         while True:
             try_cnt += 1
-            elapsed_time = time.time() - start
+            elapsed_time = time.monotonic() - start
             state = RetryState(
                 target=target,
                 args=args,
@@ -250,6 +261,7 @@ class RetryInvoker:
             try:
                 ret = target(*args, **kwargs)
             except self.recoverable_exceptions as err:
+                state.exception = err
                 # Check if giveup event should be triggered
                 max_tries_exceeded = try_cnt == self.max_tries
                 max_time_exceeded = (
@@ -282,7 +294,7 @@ class RetryInvoker:
                 try_call_event_handler(self.on_backoff)
 
                 # Sleep
-                time.sleep(wait_time)
+                self.wait_function(state.actual_wait)
             else:
                 # Trigger success event
                 try_call_event_handler(self.on_success)

flwr/common/secure_aggregation/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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.

flwr/common/secure_aggregation/crypto/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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.

flwr/common/secure_aggregation/crypto/shamir.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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.

flwr/common/secure_aggregation/crypto/symmetric_encryption.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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.
@@ -18,8 +18,9 @@
 import base64
 from typing import Tuple, cast
 
+from cryptography.exceptions import InvalidSignature
 from cryptography.fernet import Fernet
-from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives import hashes, hmac, serialization
 from cryptography.hazmat.primitives.asymmetric import ec
 from cryptography.hazmat.primitives.kdf.hkdf import HKDF
 
@@ -98,3 +99,21 @@ def decrypt(key: bytes, ciphertext: bytes) -> bytes:
     # The input key must be url safe
     fernet = Fernet(key)
     return fernet.decrypt(ciphertext)
+
+
+def compute_hmac(key: bytes, message: bytes) -> bytes:
+    """Compute hmac of a message using key as hash."""
+    computed_hmac = hmac.HMAC(key, hashes.SHA256())
+    computed_hmac.update(message)
+    return computed_hmac.finalize()
+
+
+def verify_hmac(key: bytes, message: bytes, hmac_value: bytes) -> bool:
+    """Verify hmac of a message using key as hash."""
+    computed_hmac = hmac.HMAC(key, hashes.SHA256())
+    computed_hmac.update(message)
+    try:
+        computed_hmac.verify(hmac_value)
+        return True
+    except InvalidSignature:
+        return False

flwr/common/secure_aggregation/ndarrays_arithmetic.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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.

flwr/common/secure_aggregation/quantization.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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.

flwr/common/secure_aggregation/secaggplus_constants.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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.

flwr/common/secure_aggregation/secaggplus_utils.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2023 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.

flwr/common/serde.py

@@ -20,7 +20,11 @@ from typing import Any, Dict, List, MutableMapping, OrderedDict, Type, TypeVar,
 from google.protobuf.message import Message as GrpcMessage
 
 # pylint: disable=E0611
+from flwr.proto.clientappio_pb2 import ClientAppOutputCode, ClientAppOutputStatus
 from flwr.proto.error_pb2 import Error as ProtoError
+from flwr.proto.message_pb2 import Context as ProtoContext
+from flwr.proto.message_pb2 import Message as ProtoMessage
+from flwr.proto.message_pb2 import Metadata as ProtoMetadata
 from flwr.proto.node_pb2 import Node
 from flwr.proto.recordset_pb2 import Array as ProtoArray
 from flwr.proto.recordset_pb2 import BoolList, BytesList
@@ -32,6 +36,7 @@ from flwr.proto.recordset_pb2 import MetricsRecordValue as ProtoMetricsRecordVal
 from flwr.proto.recordset_pb2 import ParametersRecord as ProtoParametersRecord
 from flwr.proto.recordset_pb2 import RecordSet as ProtoRecordSet
 from flwr.proto.recordset_pb2 import Sint64List, StringList
+from flwr.proto.run_pb2 import Run as ProtoRun
 from flwr.proto.task_pb2 import Task, TaskIns, TaskRes
 from flwr.proto.transport_pb2 import (
     ClientMessage,
@@ -44,7 +49,15 @@ from flwr.proto.transport_pb2 import (
 )
 
 # pylint: enable=E0611
-from . import Array, ConfigsRecord, MetricsRecord, ParametersRecord, RecordSet, typing
+from . import (
+    Array,
+    ConfigsRecord,
+    Context,
+    MetricsRecord,
+    ParametersRecord,
+    RecordSet,
+    typing,
+)
 from .message import Error, Message, Metadata
 from .record.typeddict import TypedDict
 
@@ -575,6 +588,7 @@ def message_to_taskins(message: Message) -> TaskIns:
         task=Task(
             producer=Node(node_id=0, anonymous=True),  # Assume driver node
             consumer=Node(node_id=md.dst_node_id, anonymous=False),
+            created_at=md.created_at,
             ttl=md.ttl,
             ancestry=[md.reply_to_message] if md.reply_to_message != "" else [],
             task_type=md.message_type,
@@ -601,7 +615,7 @@ def message_from_taskins(taskins: TaskIns) -> Message:
     )
 
     # Construct Message
-    return Message(
+    message = Message(
         metadata=metadata,
         content=(
             recordset_from_proto(taskins.task.recordset)
@@ -614,6 +628,8 @@ def message_from_taskins(taskins: TaskIns) -> Message:
             else None
         ),
     )
+    message.metadata.created_at = taskins.task.created_at
+    return message
 
 
 def message_to_taskres(message: Message) -> TaskRes:
@@ -626,6 +642,7 @@ def message_to_taskres(message: Message) -> TaskRes:
         task=Task(
             producer=Node(node_id=md.src_node_id, anonymous=False),
             consumer=Node(node_id=0, anonymous=True),  # Assume driver node
+            created_at=md.created_at,
             ttl=md.ttl,
             ancestry=[md.reply_to_message] if md.reply_to_message != "" else [],
             task_type=md.message_type,
@@ -652,7 +669,7 @@ def message_from_taskres(taskres: TaskRes) -> Message:
     )
 
     # Construct the Message
-    return Message(
+    message = Message(
         metadata=metadata,
         content=(
             recordset_from_proto(taskres.task.recordset)
@@ -665,3 +682,192 @@ def message_from_taskres(taskres: TaskRes) -> Message:
             else None
         ),
     )
+    message.metadata.created_at = taskres.task.created_at
+    return message
+
+
+# === User configs ===
+
+
+def user_config_to_proto(user_config: typing.UserConfig) -> Any:
+    """Serialize `UserConfig` to ProtoBuf."""
+    proto = {}
+    for key, value in user_config.items():
+        proto[key] = user_config_value_to_proto(value)
+    return proto
+
+
+def user_config_from_proto(proto: Any) -> typing.UserConfig:
+    """Deserialize `UserConfig` from ProtoBuf."""
+    metrics = {}
+    for key, value in proto.items():
+        metrics[key] = user_config_value_from_proto(value)
+    return metrics
+
+
+def user_config_value_to_proto(user_config_value: typing.UserConfigValue) -> Scalar:
+    """Serialize `UserConfigValue` to ProtoBuf."""
+    if isinstance(user_config_value, bool):
+        return Scalar(bool=user_config_value)
+
+    if isinstance(user_config_value, float):
+        return Scalar(double=user_config_value)
+
+    if isinstance(user_config_value, int):
+        return Scalar(sint64=user_config_value)
+
+    if isinstance(user_config_value, str):
+        return Scalar(string=user_config_value)
+
+    raise ValueError(
+        f"Accepted types: {bool, float, int, str} (but not {type(user_config_value)})"
+    )
+
+
+def user_config_value_from_proto(scalar_msg: Scalar) -> typing.UserConfigValue:
+    """Deserialize `UserConfigValue` from ProtoBuf."""
+    scalar_field = scalar_msg.WhichOneof("scalar")
+    scalar = getattr(scalar_msg, cast(str, scalar_field))
+    return cast(typing.UserConfigValue, scalar)
+
+
+# === Metadata messages ===
+
+
+def metadata_to_proto(metadata: Metadata) -> ProtoMetadata:
+    """Serialize `Metadata` to ProtoBuf."""
+    proto = ProtoMetadata(  # pylint: disable=E1101
+        run_id=metadata.run_id,
+        message_id=metadata.message_id,
+        src_node_id=metadata.src_node_id,
+        dst_node_id=metadata.dst_node_id,
+        reply_to_message=metadata.reply_to_message,
+        group_id=metadata.group_id,
+        ttl=metadata.ttl,
+        message_type=metadata.message_type,
+    )
+    return proto
+
+
+def metadata_from_proto(metadata_proto: ProtoMetadata) -> Metadata:
+    """Deserialize `Metadata` from ProtoBuf."""
+    metadata = Metadata(
+        run_id=metadata_proto.run_id,
+        message_id=metadata_proto.message_id,
+        src_node_id=metadata_proto.src_node_id,
+        dst_node_id=metadata_proto.dst_node_id,
+        reply_to_message=metadata_proto.reply_to_message,
+        group_id=metadata_proto.group_id,
+        ttl=metadata_proto.ttl,
+        message_type=metadata_proto.message_type,
+    )
+    return metadata
+
+
+# === Message messages ===
+
+
+def message_to_proto(message: Message) -> ProtoMessage:
+    """Serialize `Message` to ProtoBuf."""
+    proto = ProtoMessage(
+        metadata=metadata_to_proto(message.metadata),
+        content=recordset_to_proto(message.content),
+        error=error_to_proto(message.error) if message.has_error() else None,
+    )
+    return proto
+
+
+def message_from_proto(message_proto: ProtoMessage) -> Message:
+    """Deserialize `Message` from ProtoBuf."""
+    message = Message(
+        metadata=metadata_from_proto(message_proto.metadata),
+        content=(
+            recordset_from_proto(message_proto.content)
+            if message_proto.HasField("content")
+            else None
+        ),
+        error=(
+            error_from_proto(message_proto.error)
+            if message_proto.HasField("error")
+            else None
+        ),
+    )
+    return message
+
+
+# === Context messages ===
+
+
+def context_to_proto(context: Context) -> ProtoContext:
+    """Serialize `Context` to ProtoBuf."""
+    proto = ProtoContext(
+        node_id=context.node_id,
+        node_config=user_config_to_proto(context.node_config),
+        state=recordset_to_proto(context.state),
+        run_config=user_config_to_proto(context.run_config),
+    )
+    return proto
+
+
+def context_from_proto(context_proto: ProtoContext) -> Context:
+    """Deserialize `Context` from ProtoBuf."""
+    context = Context(
+        node_id=context_proto.node_id,
+        node_config=user_config_from_proto(context_proto.node_config),
+        state=recordset_from_proto(context_proto.state),
+        run_config=user_config_from_proto(context_proto.run_config),
+    )
+    return context
+
+
+# === Run messages ===
+
+
+def run_to_proto(run: typing.Run) -> ProtoRun:
+    """Serialize `Run` to ProtoBuf."""
+    proto = ProtoRun(
+        run_id=run.run_id,
+        fab_id=run.fab_id,
+        fab_version=run.fab_version,
+        override_config=user_config_to_proto(run.override_config),
+        fab_hash="",
+    )
+    return proto
+
+
+def run_from_proto(run_proto: ProtoRun) -> typing.Run:
+    """Deserialize `Run` from ProtoBuf."""
+    run = typing.Run(
+        run_id=run_proto.run_id,
+        fab_id=run_proto.fab_id,
+        fab_version=run_proto.fab_version,
+        override_config=user_config_from_proto(run_proto.override_config),
+    )
+    return run
+
+
+# === ClientApp status messages ===
+
+
+def clientappstatus_to_proto(
+    status: typing.ClientAppOutputStatus,
+) -> ClientAppOutputStatus:
+    """Serialize `ClientAppOutputStatus` to ProtoBuf."""
+    code = ClientAppOutputCode.SUCCESS
+    if status.code == typing.ClientAppOutputCode.DEADLINE_EXCEEDED:
+        code = ClientAppOutputCode.DEADLINE_EXCEEDED
+    if status.code == typing.ClientAppOutputCode.UNKNOWN_ERROR:
+        code = ClientAppOutputCode.UNKNOWN_ERROR
+    return ClientAppOutputStatus(code=code, message=status.message)
+
+
+def clientappstatus_from_proto(
+    msg: ClientAppOutputStatus,
+) -> typing.ClientAppOutputStatus:
+    """Deserialize `ClientAppOutputStatus` from ProtoBuf."""
+    code = typing.ClientAppOutputCode.SUCCESS
+    if msg.code == ClientAppOutputCode.DEADLINE_EXCEEDED:
+        code = typing.ClientAppOutputCode.DEADLINE_EXCEEDED
+    if msg.code == ClientAppOutputCode.UNKNOWN_ERROR:
+        code = typing.ClientAppOutputCode.UNKNOWN_ERROR
+    return typing.ClientAppOutputStatus(code=code, message=msg.message)