flwr-nightly 1.11.0.dev20240813__py3-none-any.whl → 1.11.0.dev20240822__py3-none-any.whl

flwr/client/supernode/app.py

@@ -16,9 +16,9 @@
 
 import argparse
 import sys
-from logging import DEBUG, INFO, WARN
+from logging import DEBUG, ERROR, INFO, WARN
 from pathlib import Path
-from typing import Callable, Optional, Tuple
+from typing import Optional, Tuple
 
 from cryptography.exceptions import UnsupportedAlgorithm
 from cryptography.hazmat.primitives.asymmetric import ec
@@ -27,15 +27,8 @@ from cryptography.hazmat.primitives.serialization import (
     load_ssh_public_key,
 )
 
-from flwr.client.client_app import ClientApp, LoadClientAppError
 from flwr.common import EventType, event
-from flwr.common.config import (
-    get_flwr_dir,
-    get_metadata_from_config,
-    get_project_config,
-    get_project_dir,
-    parse_config_args,
-)
+from flwr.common.config import parse_config_args
 from flwr.common.constant import (
     TRANSPORT_TYPE_GRPC_ADAPTER,
     TRANSPORT_TYPE_GRPC_RERE,
@@ -43,9 +36,13 @@ from flwr.common.constant import (
 )
 from flwr.common.exit_handlers import register_exit_handlers
 from flwr.common.logger import log, warn_deprecated_feature
-from flwr.common.object_ref import load_app, validate
 
-from ..app import _start_client_internal
+from ..app import (
+    ISOLATION_MODE_PROCESS,
+    ISOLATION_MODE_SUBPROCESS,
+    start_client_internal,
+)
+from ..clientapp.utils import get_load_client_app_fn
 
 ADDRESS_FLEET_API_GRPC_RERE = "0.0.0.0:9092"
 
@@ -61,7 +58,7 @@ def run_supernode() -> None:
     _warn_deprecated_server_arg(args)
 
     root_certificates = _get_certificates(args)
-    load_fn = _get_load_client_app_fn(
+    load_fn = get_load_client_app_fn(
         default_app_ref="",
         app_path=args.app,
         flwr_dir=args.flwr_dir,
@@ -69,7 +66,9 @@ def run_supernode() -> None:
     )
     authentication_keys = _try_setup_client_authentication(args)
 
-    _start_client_internal(
+    log(DEBUG, "Isolation mode: %s", args.isolation)
+
+    start_client_internal(
         server_address=args.superlink,
         load_client_app_fn=load_fn,
         transport=args.transport,
@@ -79,7 +78,8 @@ def run_supernode() -> None:
         max_retries=args.max_retries,
         max_wait_time=args.max_wait_time,
         node_config=parse_config_args([args.node_config]),
-        flwr_path=get_flwr_dir(args.flwr_dir),
+        isolation=args.isolation,
+        supernode_address=args.supernode_address,
     )
 
     # Graceful shutdown
@@ -90,59 +90,13 @@ def run_supernode() -> None:
 
 def run_client_app() -> None:
     """Run Flower client app."""
-    log(INFO, "Long-running Flower client starting")
-
     event(EventType.RUN_CLIENT_APP_ENTER)
-
-    args = _parse_args_run_client_app().parse_args()
-
-    _warn_deprecated_server_arg(args)
-
-    root_certificates = _get_certificates(args)
-    load_fn = _get_load_client_app_fn(
-        default_app_ref=getattr(args, "client-app"),
-        app_path=args.dir,
-        multi_app=False,
-    )
-    authentication_keys = _try_setup_client_authentication(args)
-
-    _start_client_internal(
-        server_address=args.superlink,
-        node_config=parse_config_args([args.node_config]),
-        load_client_app_fn=load_fn,
-        transport=args.transport,
-        root_certificates=root_certificates,
-        insecure=args.insecure,
-        authentication_keys=authentication_keys,
-        max_retries=args.max_retries,
-        max_wait_time=args.max_wait_time,
-    )
-    register_exit_handlers(event_type=EventType.RUN_CLIENT_APP_LEAVE)
-
-
-def flwr_clientapp() -> None:
-    """Run process-isolated Flower ClientApp."""
-    log(INFO, "Starting Flower ClientApp")
-
-    parser = argparse.ArgumentParser(
-        description="Run a Flower ClientApp",
-    )
-    parser.add_argument(
-        "--address",
-        help="Address of SuperNode ClientAppIo gRPC servicer",
-    )
-    parser.add_argument(
-        "--token",
-        help="Unique token generated by SuperNode for each ClientApp execution",
-    )
-    args = parser.parse_args()
     log(
-        DEBUG,
-        "Staring isolated `ClientApp` connected to SuperNode ClientAppIo at %s "
-        "with the token %s",
-        args.address,
-        args.token,
+        ERROR,
+        "The command `flower-client-app` has been replaced by `flower-supernode`.",
     )
+    log(INFO, "Execute `flower-supernode --help` to learn how to use it.")
+    register_exit_handlers(event_type=EventType.RUN_CLIENT_APP_LEAVE)
 
 
 def _warn_deprecated_server_arg(args: argparse.Namespace) -> None:
@@ -200,85 +154,6 @@ def _get_certificates(args: argparse.Namespace) -> Optional[bytes]:
     return root_certificates
 
 
-def _get_load_client_app_fn(
-    default_app_ref: str,
-    app_path: Optional[str],
-    multi_app: bool,
-    flwr_dir: Optional[str] = None,
-) -> Callable[[str, str], ClientApp]:
-    """Get the load_client_app_fn function.
-
-    If `multi_app` is True, this function loads the specified ClientApp
-    based on `fab_id` and `fab_version`. If `fab_id` is empty, a default
-    ClientApp will be loaded.
-
-    If `multi_app` is False, it ignores `fab_id` and `fab_version` and
-    loads a default ClientApp.
-    """
-    if not multi_app:
-        log(
-            DEBUG,
-            "Flower SuperNode will load and validate ClientApp `%s`",
-            default_app_ref,
-        )
-
-        valid, error_msg = validate(default_app_ref, project_dir=app_path)
-        if not valid and error_msg:
-            raise LoadClientAppError(error_msg) from None
-
-    def _load(fab_id: str, fab_version: str) -> ClientApp:
-        runtime_app_dir = Path(app_path if app_path else "").absolute()
-        # If multi-app feature is disabled
-        if not multi_app:
-            # Set app reference
-            client_app_ref = default_app_ref
-        # If multi-app feature is enabled but app directory is provided
-        elif app_path is not None:
-            config = get_project_config(runtime_app_dir)
-            this_fab_version, this_fab_id = get_metadata_from_config(config)
-
-            if this_fab_version != fab_version or this_fab_id != fab_id:
-                raise LoadClientAppError(
-                    f"FAB ID or version mismatch: Expected FAB ID '{this_fab_id}' and "
-                    f"FAB version '{this_fab_version}', but received FAB ID '{fab_id}' "
-                    f"and FAB version '{fab_version}'.",
-                ) from None
-
-            # log(WARN, "FAB ID is not provided; the default ClientApp will be loaded.")
-
-            # Set app reference
-            client_app_ref = config["tool"]["flwr"]["app"]["components"]["clientapp"]
-        # If multi-app feature is enabled
-        else:
-            try:
-                runtime_app_dir = get_project_dir(
-                    fab_id, fab_version, get_flwr_dir(flwr_dir)
-                )
-                config = get_project_config(runtime_app_dir)
-            except Exception as e:
-                raise LoadClientAppError("Failed to load ClientApp") from e
-
-            # Set app reference
-            client_app_ref = config["tool"]["flwr"]["app"]["components"]["clientapp"]
-
-        # Load ClientApp
-        log(
-            DEBUG,
-            "Loading ClientApp `%s`",
-            client_app_ref,
-        )
-        client_app = load_app(client_app_ref, LoadClientAppError, runtime_app_dir)
-
-        if not isinstance(client_app, ClientApp):
-            raise LoadClientAppError(
-                f"Attribute {client_app_ref} is not of type {ClientApp}",
-            ) from None
-
-        return client_app
-
-    return _load
-
-
 def _parse_args_run_supernode() -> argparse.ArgumentParser:
     """Parse flower-supernode command line arguments."""
     parser = argparse.ArgumentParser(
@@ -308,27 +183,24 @@ def _parse_args_run_supernode() -> argparse.ArgumentParser:
         - `$HOME/.flwr/` in all other cases
     """,
     )
-
-    return parser
-
-
-def _parse_args_run_client_app() -> argparse.ArgumentParser:
-    """Parse flower-client-app command line arguments."""
-    parser = argparse.ArgumentParser(
-        description="Start a Flower client app",
-    )
-
     parser.add_argument(
-        "client-app",
-        help="For example: `client:app` or `project.package.module:wrapper.app`",
+        "--isolation",
+        default=None,
+        required=False,
+        choices=[
+            ISOLATION_MODE_SUBPROCESS,
+            ISOLATION_MODE_PROCESS,
+        ],
+        help="Isolation mode when running `ClientApp` (optional, possible values: "
+        "`subprocess`, `process`). By default, `ClientApp` runs in the same process "
+        "that executes the SuperNode. Use `subprocess` to configure SuperNode to run "
+        "`ClientApp` in a subprocess. Use `process` to indicate that a separate "
+        "independent process gets created outside of SuperNode.",
     )
-    _parse_args_common(parser=parser)
     parser.add_argument(
-        "--dir",
-        default="",
-        help="Add specified directory to the PYTHONPATH and load Flower "
-        "app from there."
-        " Default: current working directory.",
+        "--supernode-address",
+        default="0.0.0.0:9094",
+        help="Set the SuperNode gRPC server address. Defaults to `0.0.0.0:9094`.",
     )
 
     return parser
@@ -410,9 +282,9 @@ def _parse_args_common(parser: argparse.ArgumentParser) -> None:
     parser.add_argument(
         "--node-config",
         type=str,
-        help="A comma separated list of key/value pairs (separated by `=`) to "
+        help="A space separated list of key/value pairs (separated by `=`) to "
         "configure the SuperNode. "
-        "E.g. --node-config 'key1=\"value1\",partition-id=0,num-partitions=100'",
+        "E.g. --node-config 'key1=\"value1\" partition-id=0 num-partitions=100'",
     )
 
 

flwr/common/__init__.py

@@ -41,6 +41,7 @@ from .telemetry import event as event
 from .typing import ClientMessage as ClientMessage
 from .typing import Code as Code
 from .typing import Config as Config
+from .typing import ConfigsRecordValues as ConfigsRecordValues
 from .typing import DisconnectRes as DisconnectRes
 from .typing import EvaluateIns as EvaluateIns
 from .typing import EvaluateRes as EvaluateRes
@@ -52,6 +53,7 @@ from .typing import GetPropertiesIns as GetPropertiesIns
 from .typing import GetPropertiesRes as GetPropertiesRes
 from .typing import Metrics as Metrics
 from .typing import MetricsAggregationFn as MetricsAggregationFn
+from .typing import MetricsRecordValues as MetricsRecordValues
 from .typing import NDArray as NDArray
 from .typing import NDArrays as NDArrays
 from .typing import Parameters as Parameters
@@ -67,6 +69,7 @@ __all__ = [
     "Code",
     "Config",
     "ConfigsRecord",
+    "ConfigsRecordValues",
     "Context",
     "DEFAULT_TTL",
     "DisconnectRes",
@@ -88,6 +91,7 @@ __all__ = [
     "Metrics",
     "MetricsAggregationFn",
     "MetricsRecord",
+    "MetricsRecordValues",
     "NDArray",
     "NDArrays",
     "Parameters",

flwr/common/config.py

@@ -15,12 +15,13 @@
 """Provide functions for managing global Flower config."""
 
 import os
+import re
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union, cast, get_args
 
 import tomli
 
-from flwr.cli.config_utils import validate_fields
+from flwr.cli.config_utils import get_fab_config, validate_fields
 from flwr.common.constant import APP_DIR, FAB_CONFIG_FILE, FLWR_HOME
 from flwr.common.typing import Run, UserConfig, UserConfigValue
 
@@ -74,10 +75,15 @@ def get_project_config(project_dir: Union[str, Path]) -> Dict[str, Any]:
     return config
 
 
-def _fuse_dicts(
+def fuse_dicts(
     main_dict: UserConfig,
     override_dict: UserConfig,
 ) -> UserConfig:
+    """Merge a config with the overrides.
+
+    Remove the nesting by adding the nested keys as prefixes separated by dots, and fuse
+    it with the override dict.
+    """
     fused_dict = main_dict.copy()
 
     for key, value in override_dict.items():
@@ -96,7 +102,19 @@ def get_fused_config_from_dir(
     )
     flat_default_config = flatten_dict(default_config)
 
-    return _fuse_dicts(flat_default_config, override_config)
+    return fuse_dicts(flat_default_config, override_config)
+
+
+def get_fused_config_from_fab(fab_file: Union[Path, bytes], run: Run) -> UserConfig:
+    """Fuse default config in a `FAB` with overrides in a `Run`.
+
+    This enables obtaining a run-config without having to install the FAB. This
+    function mirrors `get_fused_config_from_dir`. This is useful when the execution
+    of the FAB is delegated to a different process.
+    """
+    default_config = get_fab_config(fab_file)["tool"]["flwr"]["app"].get("config", {})
+    flat_config_flat = flatten_dict(default_config)
+    return fuse_dicts(flat_config_flat, run.override_config)
 
 
 def get_fused_config(run: Run, flwr_dir: Optional[Path]) -> UserConfig:
@@ -160,7 +178,6 @@ def unflatten_dict(flat_dict: Dict[str, Any]) -> Dict[str, Any]:
 
 def parse_config_args(
     config: Optional[List[str]],
-    separator: str = ",",
 ) -> UserConfig:
     """Parse separator separated list of key-value pairs separated by '='."""
     overrides: UserConfig = {}
@@ -168,18 +185,22 @@ def parse_config_args(
     if config is None:
         return overrides
 
+    # Regular expression to capture key-value pairs with possible quoted values
+    pattern = re.compile(r"(\S+?)=(\'[^\']*\'|\"[^\"]*\"|\S+)")
+
     for config_line in config:
         if config_line:
-            overrides_list = config_line.split(separator)
+            matches = pattern.findall(config_line)
+
             if (
-                len(overrides_list) == 1
-                and "=" not in overrides_list
-                and overrides_list[0].endswith(".toml")
+                len(matches) == 1
+                and "=" not in matches[0][0]
+                and matches[0][0].endswith(".toml")
             ):
-                with Path(overrides_list[0]).open("rb") as config_file:
+                with Path(matches[0][0]).open("rb") as config_file:
                     overrides = flatten_dict(tomli.load(config_file))
             else:
-                toml_str = "\n".join(overrides_list)
+                toml_str = "\n".join(f"{k} = {v}" for k, v in matches)
                 overrides.update(tomli.loads(toml_str))
 
     return overrides

flwr/common/record/configsrecord.py

@@ -58,27 +58,61 @@ def _check_value(value: ConfigsRecordValues) -> None:
 
 
 class ConfigsRecord(TypedDict[str, ConfigsRecordValues]):
-    """Configs record."""
+    """Configs record.
+
+    A :code:`ConfigsRecord` is a Python dictionary designed to ensure that
+    each key-value pair adheres to specified data types. A :code:`ConfigsRecord`
+    is one of the types of records that a
+    `flwr.common.RecordSet <flwr.common.RecordSet.html#recordset>`_ supports and
+    can therefore be used to construct :code:`common.Message` objects.
+
+    Parameters
+    ----------
+    configs_dict : Optional[Dict[str, ConfigsRecordValues]]
+        A dictionary that stores basic types (i.e. `str`, `int`, `float`, `bytes` as
+        defined in `ConfigsScalar`) and lists of such types (see
+        `ConfigsScalarList`).
+    keep_input : bool (default: True)
+        A boolean indicating whether config passed should be deleted from the input
+        dictionary immediately after adding them to the record. When set
+        to True, the data is duplicated in memory. If memory is a concern, set
+        it to False.
+
+    Examples
+    --------
+    The usage of a :code:`ConfigsRecord` is envisioned for sending configuration values
+    telling the target node how to perform a certain action (e.g. train/evaluate a model
+    ). You can use standard Python built-in types such as :code:`float`, :code:`str`
+    , :code:`bytes`. All types allowed are defined in
+    :code:`flwr.common.ConfigsRecordValues`. While lists are supported, we
+    encourage you to use a :code:`ParametersRecord` instead if these are of high
+    dimensionality.
+
+    Let's see some examples of how to construct a :code:`ConfigsRecord` from scratch:
+
+    >>> from flwr.common import ConfigsRecord
+    >>>
+    >>> # A `ConfigsRecord` is a specialized Python dictionary
+    >>> record = ConfigsRecord({"lr": 0.1, "batch-size": 128})
+    >>> # You can add more content to an existing record
+    >>> record["compute-average"] = True
+    >>> # It also supports lists
+    >>> record["loss-fn-coefficients"] = [0.4, 0.25, 0.35]
+    >>> # And string values (among other types)
+    >>> record["path-to-S3"] = "s3://bucket_name/folder1/fileA.json"
+
+    Just like the other types of records in a :code:`flwr.common.RecordSet`, types are
+    enforced. If you need to add a custom data structure or object, we recommend to
+    serialise it into bytes and save it as such (bytes are allowed in a
+    :code:`ConfigsRecord`)
+    """
 
     def __init__(
         self,
         configs_dict: Optional[Dict[str, ConfigsRecordValues]] = None,
         keep_input: bool = True,
     ) -> None:
-        """Construct a ConfigsRecord object.
-
-        Parameters
-        ----------
-        configs_dict : Optional[Dict[str, ConfigsRecordValues]]
-            A dictionary that stores basic types (i.e. `str`, `int`, `float`, `bytes` as
-            defined in `ConfigsScalar`) and lists of such types (see
-            `ConfigsScalarList`).
-        keep_input : bool (default: True)
-            A boolean indicating whether config passed should be deleted from the input
-            dictionary immediately after adding them to the record. When set
-            to True, the data is duplicated in memory. If memory is a concern, set
-            it to False.
-        """
+
         super().__init__(_check_key, _check_value)
         if configs_dict:
             for k in list(configs_dict.keys()):

flwr/common/record/metricsrecord.py

@@ -58,26 +58,66 @@ def _check_value(value: MetricsRecordValues) -> None:
 
 
 class MetricsRecord(TypedDict[str, MetricsRecordValues]):
-    """Metrics record."""
+    """Metrics recod.
+
+    A :code:`MetricsRecord` is a Python dictionary designed to ensure that
+    each key-value pair adheres to specified data types. A :code:`MetricsRecord`
+    is one of the types of records that a
+    `flwr.common.RecordSet <flwr.common.RecordSet.html#recordset>`_ supports and
+    can therefore be used to construct :code:`common.Message` objects.
+
+    Parameters
+    ----------
+    metrics_dict : Optional[Dict[str, MetricsRecordValues]]
+        A dictionary that stores basic types (i.e. `int`, `float` as defined
+        in `MetricsScalar`) and list of such types (see `MetricsScalarList`).
+    keep_input : bool (default: True)
+        A boolean indicating whether metrics should be deleted from the input
+        dictionary immediately after adding them to the record. When set
+        to True, the data is duplicated in memory. If memory is a concern, set
+        it to False.
+
+    Examples
+    --------
+    The usage of a :code:`MetricsRecord` is envisioned for communicating results
+    obtained when a node performs an action. A few typical examples include:
+    communicating the training accuracy after a model is trained locally by a
+    :code:`ClientApp`, reporting the validation loss obtained at a :code:`ClientApp`,
+    or, more generally, the output of executing a query by the :code:`ClientApp`.
+    Common to these examples is that the output can be typically represented by
+    a single scalar (:code:`int`, :code:`float`) or list of scalars.
+
+    Let's see some examples of how to construct a :code:`MetricsRecord` from scratch:
+
+    >>> from flwr.common import MetricsRecord
+    >>>
+    >>> # A `MetricsRecord` is a specialized Python dictionary
+    >>> record = MetricsRecord({"accuracy": 0.94})
+    >>> # You can add more content to an existing record
+    >>> record["loss"] = 0.01
+    >>> # It also supports lists
+    >>> record["loss-historic"] = [0.9, 0.5, 0.01]
+
+    Since types are enforced, the types of the objects inserted are checked. For a
+    :code:`MetricsRecord`, value types allowed are those in defined in
+    :code:`flwr.common.MetricsRecordValues`. Similarly, only :code:`str` keys are
+    allowed.
+
+    >>> from flwr.common import MetricsRecord
+    >>>
+    >>> record = MetricsRecord() # an empty record
+    >>> # Add unsupported value
+    >>> record["something-unsupported"] = {'a': 123} # Will throw a `TypeError`
+
+    If you need a more versatily type of record try :code:`ConfigsRecord` or
+    :code:`ParametersRecord`.
+    """
 
     def __init__(
         self,
         metrics_dict: Optional[Dict[str, MetricsRecordValues]] = None,
         keep_input: bool = True,
     ):
-        """Construct a MetricsRecord object.
-
-        Parameters
-        ----------
-        metrics_dict : Optional[Dict[str, MetricsRecordValues]]
-            A dictionary that stores basic types (i.e. `int`, `float` as defined
-            in `MetricsScalar`) and list of such types (see `MetricsScalarList`).
-        keep_input : bool (default: True)
-            A boolean indicating whether metrics should be deleted from the input
-            dictionary immediately after adding them to the record. When set
-            to True, the data is duplicated in memory. If memory is a concern, set
-            it to False.
-        """
         super().__init__(_check_key, _check_value)
         if metrics_dict:
             for k in list(metrics_dict.keys()):

flwr/common/record/parametersrecord.py

@@ -83,11 +83,93 @@ def _check_value(value: Array) -> None:
 
 
 class ParametersRecord(TypedDict[str, Array]):
-    """Parameters record.
+    r"""Parameters record.
 
     A dataclass storing named Arrays in order. This means that it holds entries as an
     OrderedDict[str, Array]. ParametersRecord objects can be viewed as an equivalent to
-    PyTorch's state_dict, but holding serialised tensors instead.
+    PyTorch's state_dict, but holding serialised tensors instead. A
+    :code:`ParametersRecord`  is one of the types of records that a
+    `flwr.common.RecordSet <flwr.common.RecordSet.html#recordset>`_ supports and
+    can therefore be used to construct :code:`common.Message` objects.
+
+    Parameters
+    ----------
+    array_dict : Optional[OrderedDict[str, Array]]
+        A dictionary that stores serialized array-like or tensor-like objects.
+    keep_input : bool (default: False)
+        A boolean indicating whether parameters should be deleted from the input
+        dictionary immediately after adding them to the record. If False, the
+        dictionary passed to `set_parameters()` will be empty once exiting from that
+        function. This is the desired behaviour when working with very large
+        models/tensors/arrays. However, if you plan to continue working with your
+        parameters after adding it to the record, set this flag to True. When set
+        to True, the data is duplicated in memory.
+
+    Examples
+    --------
+    The usage of :code:`ParametersRecord` is envisioned for storing data arrays (e.g.
+    parameters of a machine learning model). These first need to be serialized into
+    a :code:`flwr.common.Array` data structure.
+
+    Let's see some examples:
+
+    >>> import numpy as np
+    >>> from flwr.common import ParametersRecord
+    >>> from flwr.common import array_from_numpy
+    >>>
+    >>> # Let's create a simple NumPy array
+    >>> arr_np = np.random.randn(3, 3)
+    >>>
+    >>> # If we print it
+    >>> array([[-1.84242409, -1.01539537, -0.46528405],
+    >>>      [ 0.32991896,  0.55540414,  0.44085534],
+    >>>      [-0.10758364,  1.97619858, -0.37120501]])
+    >>>
+    >>> # Let's create an Array out of it
+    >>> arr = array_from_numpy(arr_np)
+    >>>
+    >>> # If we print it you'll see (note the binary data)
+    >>> Array(dtype='float64', shape=[3,3], stype='numpy.ndarray', data=b'@\x99\x18...')
+    >>>
+    >>> # Adding it to a ParametersRecord:
+    >>> p_record = ParametersRecord({"my_array": arr})
+
+    Now that the NumPy array is embedded into a :code:`ParametersRecord` it could be
+    sent if added as part of a :code:`common.Message` or it could be saved as a
+    persistent state of a :code:`ClientApp` via its context. Regardless of the usecase,
+    we will sooner or later want to recover the array in its original NumPy
+    representation. For the example above, where the array was serialized using the
+    built-in utility function, deserialization can be done as follows:
+
+    >>> # Use the Array's built-in method
+    >>> arr_np_d = arr.numpy()
+    >>>
+    >>> # If printed, it will show the exact same data as above:
+    >>> array([[-1.84242409, -1.01539537, -0.46528405],
+    >>>      [ 0.32991896,  0.55540414,  0.44085534],
+    >>>      [-0.10758364,  1.97619858, -0.37120501]])
+
+    If you need finer control on how your arrays are serialized and deserialized, you
+    can construct :code:`Array` objects directly like this:
+
+    >>> from flwr.common import Array
+    >>> # Serialize your array and construct Array object
+    >>> arr = Array(
+    >>>         data=ndarray.tobytes(),
+    >>>         dtype=str(ndarray.dtype),
+    >>>         stype="",  # Could be used in a deserialization function
+    >>>         shape=list(ndarray.shape),
+    >>>       )
+    >>>
+    >>> # Then you can deserialize it like this
+    >>> arr_np_d = np.frombuffer(
+    >>>             buffer=array.data,
+    >>>             dtype=array.dtype,
+    >>>            ).reshape(array.shape)
+
+    Note that different arrays (e.g. from PyTorch, Tensorflow) might require different
+    serialization mechanism. Howerver, they often support a conversion to NumPy,
+    therefore allowing to use the same or similar steps as in the example above.
     """
 
     def __init__(
@@ -95,21 +177,6 @@ class ParametersRecord(TypedDict[str, Array]):
         array_dict: Optional[OrderedDict[str, Array]] = None,
         keep_input: bool = False,
     ) -> None:
-        """Construct a ParametersRecord object.
-
-        Parameters
-        ----------
-        array_dict : Optional[OrderedDict[str, Array]]
-            A dictionary that stores serialized array-like or tensor-like objects.
-        keep_input : bool (default: False)
-            A boolean indicating whether parameters should be deleted from the input
-            dictionary immediately after adding them to the record. If False, the
-            dictionary passed to `set_parameters()` will be empty once exiting from that
-            function. This is the desired behaviour when working with very large
-            models/tensors/arrays. However, if you plan to continue working with your
-            parameters after adding it to the record, set this flag to True. When set
-            to True, the data is duplicated in memory.
-        """
         super().__init__(_check_key, _check_value)
         if array_dict:
             for k in list(array_dict.keys()):