flwr-nightly 1.6.0.dev20231026__py3-none-any.whl → 1.6.0.dev20231101__py3-none-any.whl

flwr/client/app.py

@@ -19,7 +19,7 @@ import sys
 import time
 import warnings
 from logging import INFO
-from typing import Optional, Union
+from typing import Callable, ContextManager, Optional, Tuple, Union
 
 from flwr.client.client import Client
 from flwr.client.typing import ClientFn
@@ -33,6 +33,7 @@ from flwr.common.constant import (
     TRANSPORT_TYPES,
 )
 from flwr.common.logger import log
+from flwr.proto.task_pb2 import TaskIns, TaskRes
 
 from .grpc_client.connection import grpc_connection
 from .grpc_rere_client.connection import grpc_request_response
@@ -134,44 +135,15 @@ def start_client(
 
         client_fn = single_client_factory
 
-    # Parse IP address
-    parsed_address = parse_address(server_address)
-    if not parsed_address:
-        sys.exit(f"Server address ({server_address}) cannot be parsed.")
-    host, port, is_v6 = parsed_address
-    address = f"[{host}]:{port}" if is_v6 else f"{host}:{port}"
-
-    # Set the default transport layer
-    if transport is None:
-        transport = TRANSPORT_TYPE_GRPC_BIDI
-
-    # Use either gRPC bidirectional streaming or REST request/response
-    if transport == TRANSPORT_TYPE_REST:
-        try:
-            from .rest_client.connection import http_request_response
-        except ModuleNotFoundError:
-            sys.exit(MISSING_EXTRA_REST)
-        if server_address[:4] != "http":
-            sys.exit(
-                "When using the REST API, please provide `https://` or "
-                "`http://` before the server address (e.g. `http://127.0.0.1:8080`)"
-            )
-        connection = http_request_response
-    elif transport == TRANSPORT_TYPE_GRPC_RERE:
-        connection = grpc_request_response
-    elif transport == TRANSPORT_TYPE_GRPC_BIDI:
-        connection = grpc_connection
-    else:
-        raise ValueError(
-            f"Unknown transport type: {transport} (possible: {TRANSPORT_TYPES})"
-        )
+    # Initialize connection context manager
+    connection, address = _init_connection(transport, server_address)
 
     while True:
         sleep_duration: int = 0
         with connection(
             address,
-            max_message_length=grpc_max_message_length,
-            root_certificates=root_certificates,
+            grpc_max_message_length,
+            root_certificates,
         ) as conn:
             receive, send, create_node, delete_node = conn
 
@@ -285,3 +257,54 @@ def start_numpy_client(
         root_certificates=root_certificates,
         transport=transport,
     )
+
+
+def _init_connection(
+    transport: Optional[str], server_address: str
+) -> Tuple[
+    Callable[
+        [str, int, Union[bytes, str, None]],
+        ContextManager[
+            Tuple[
+                Callable[[], Optional[TaskIns]],
+                Callable[[TaskRes], None],
+                Optional[Callable[[], None]],
+                Optional[Callable[[], None]],
+            ]
+        ],
+    ],
+    str,
+]:
+    # Parse IP address
+    parsed_address = parse_address(server_address)
+    if not parsed_address:
+        sys.exit(f"Server address ({server_address}) cannot be parsed.")
+    host, port, is_v6 = parsed_address
+    address = f"[{host}]:{port}" if is_v6 else f"{host}:{port}"
+
+    # Set the default transport layer
+    if transport is None:
+        transport = TRANSPORT_TYPE_GRPC_BIDI
+
+    # Use either gRPC bidirectional streaming or REST request/response
+    if transport == TRANSPORT_TYPE_REST:
+        try:
+            from .rest_client.connection import http_request_response
+        except ModuleNotFoundError:
+            sys.exit(MISSING_EXTRA_REST)
+        if server_address[:4] != "http":
+            sys.exit(
+                "When using the REST API, please provide `https://` or "
+                "`http://` before the server address (e.g. `http://127.0.0.1:8080`)"
+            )
+        connection = http_request_response
+    elif transport == TRANSPORT_TYPE_GRPC_RERE:
+        connection = grpc_request_response
+    elif transport == TRANSPORT_TYPE_GRPC_BIDI:
+        connection = grpc_connection
+    else:
+        raise ValueError(
+            f"Unknown transport type: {transport} (possible: {TRANSPORT_TYPES})"
+        )
+
+    return connection, address

flwr/common/retry_invoker.py

@@ -0,0 +1,288 @@
+# 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.
+# 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.
+# ==============================================================================
+"""`RetryInvoker` to augment other callables with error handling and retries."""
+
+
+import itertools
+import random
+import time
+from dataclasses import dataclass
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+
+
+def exponential(
+    base_delay: float = 1,
+    multiplier: float = 2,
+    max_delay: Optional[int] = None,
+) -> Generator[float, None, None]:
+    """Wait time generator for exponential backoff strategy.
+
+    Parameters
+    ----------
+    base_delay: float (default: 1)
+        Initial delay duration before the first retry.
+    multiplier: float (default: 2)
+        Factor by which the delay is multiplied after each retry.
+    max_delay: Optional[float] (default: None)
+        The maximum delay duration between two consecutive retries.
+    """
+    delay = base_delay if max_delay is None else min(base_delay, max_delay)
+    while True:
+        yield delay
+        delay *= multiplier
+        if max_delay is not None:
+            delay = min(delay, max_delay)
+
+
+def constant(
+    interval: Union[float, Iterable[float]] = 1,
+) -> Generator[float, None, None]:
+    """Wait time generator for specified intervals.
+
+    Parameters
+    ----------
+    interval: Union[float, Iterable[float]] (default: 1)
+        A constant value to yield or an iterable of such values.
+    """
+    if not isinstance(interval, Iterable):
+        interval = itertools.repeat(interval)
+    yield from interval
+
+
+def full_jitter(max_value: float) -> float:
+    """Randomize a float between 0 and the given maximum value.
+
+    This function implements the "Full Jitter" algorithm as described in the
+    AWS article discussing the efficacy of different jitter algorithms.
+    Reference: https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
+
+    Parameters
+    ----------
+    max_value : float
+        The upper limit for the randomized value.
+    """
+    return random.uniform(0, max_value)
+
+
+@dataclass
+class RetryState:
+    """State for callbacks in RetryInvoker."""
+
+    target: Callable[..., Any]
+    args: Tuple[Any, ...]
+    kwargs: Dict[str, Any]
+    tries: int
+    elapsed_time: float
+    exception: Optional[Exception] = None
+    actual_wait: Optional[float] = None
+
+
+# pylint: disable-next=too-many-instance-attributes
+class RetryInvoker:
+    """Wrapper class for retry (with backoff) triggered by exceptions.
+
+    Parameters
+    ----------
+    wait_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`.
+    recoverable_exceptions: Union[Type[Exception], Tuple[Type[Exception]]]
+        An exception type (or tuple of types) that triggers backoff.
+    max_tries: Optional[int]
+        The maximum number of attempts to make before giving up. Once exhausted,
+        the exception will be allowed to escape. If set to None, there is no limit
+        to the number of tries.
+    max_time: Optional[float]
+        The maximum total amount of time to try before giving up. Once this time
+        has expired, this method won't be interrupted immediately, but the exception
+        will be allowed to escape. If set to None, there is no limit to the total time.
+    on_success: Optional[Callable[[RetryState], None]] (default: None)
+        A callable to be executed in the event of success. The parameter is a
+        data class object detailing the invocation.
+    on_backoff: Optional[Callable[[RetryState], None]] (default: None)
+        A callable to be executed in the event of a backoff. The parameter is a
+        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
+        `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
+        timing collisions across concurrent clients. Wait times are jittered by
+        default using the `full_jitter` function. To disable jittering, pass
+        `jitter=None`.
+    should_giveup: Optional[Callable[[Exception], bool]] (default: None)
+        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.
+
+    Examples
+    --------
+    Initialize a `RetryInvoker` with exponential backoff and invoke a function:
+
+    >>> invoker = RetryInvoker(
+    ...     exponential,  # Or use `lambda: exponential(3, 2)` to pass arguments
+    ...     grpc.RpcError,
+    ...     max_tries=3,
+    ...     max_time=None,
+    ... )
+    >>> invoker.invoke(my_func, arg1, arg2, kw1=kwarg1)
+    """
+
+    def __init__(
+        self,
+        wait_factory: Callable[[], Generator[float, None, None]],
+        recoverable_exceptions: Union[Type[Exception], Tuple[Type[Exception], ...]],
+        max_tries: Optional[int],
+        max_time: Optional[float],
+        *,
+        on_success: Optional[Callable[[RetryState], None]] = None,
+        on_backoff: Optional[Callable[[RetryState], None]] = None,
+        on_giveup: Optional[Callable[[RetryState], None]] = None,
+        jitter: Optional[Callable[[float], float]] = full_jitter,
+        should_giveup: Optional[Callable[[Exception], bool]] = None,
+    ) -> None:
+        self.wait_factory = wait_factory
+        self.recoverable_exceptions = recoverable_exceptions
+        self.max_tries = max_tries
+        self.max_time = max_time
+        self.on_success = on_success
+        self.on_backoff = on_backoff
+        self.on_giveup = on_giveup
+        self.jitter = jitter
+        self.should_giveup = should_giveup
+
+    # pylint: disable-next=too-many-locals
+    def invoke(
+        self,
+        target: Callable[..., Any],
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        """Safely invoke the provided callable with retry mechanisms.
+
+        This method attempts to invoke the given callable, and in the event of
+        a recoverable exception, employs a retry mechanism that considers
+        wait times, jitter, maximum attempts, and maximum time. During the
+        retry process, various callbacks (`on_backoff`, `on_success`, and
+        `on_giveup`) can be triggered based on the outcome.
+
+        Parameters
+        ----------
+        target: Callable[..., Any]
+            The callable to be invoked.
+        *args: Tuple[Any, ...]
+            Positional arguments to pass to `target`.
+        **kwargs: Dict[str, Any]
+            Keyword arguments to pass to `target`.
+
+        Returns
+        -------
+        Any
+            The result of the given callable invocation.
+
+        Raises
+        ------
+        Exception
+            If the number of tries exceeds `max_tries`, if the total time
+            exceeds `max_time`, if `wait_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()`
+        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.
+        """
+
+        def try_call_event_handler(
+            handler: Optional[Callable[[RetryState], None]]
+        ) -> None:
+            if handler is not None:
+                handler(cast(RetryState, ref_state[0]))
+
+        try_cnt = 0
+        wait_generator = self.wait_factory()
+        start = time.time()
+        ref_state: List[Optional[RetryState]] = [None]
+
+        while True:
+            try_cnt += 1
+            elapsed_time = time.time() - start
+            state = RetryState(
+                target=target,
+                args=args,
+                kwargs=kwargs,
+                tries=try_cnt,
+                elapsed_time=elapsed_time,
+            )
+            ref_state[0] = state
+
+            try:
+                ret = target(*args, **kwargs)
+            except self.recoverable_exceptions as err:
+                # Check if giveup event should be triggered
+                max_tries_exceeded = try_cnt == self.max_tries
+                max_time_exceeded = (
+                    self.max_time is not None and elapsed_time >= self.max_time
+                )
+
+                def giveup_check(_exception: Exception) -> bool:
+                    if self.should_giveup is None:
+                        return False
+                    return self.should_giveup(_exception)
+
+                if giveup_check(err) or max_tries_exceeded or max_time_exceeded:
+                    # Trigger giveup event
+                    try_call_event_handler(self.on_giveup)
+                    raise
+
+                try:
+                    wait_time = next(wait_generator)
+                    if self.jitter is not None:
+                        wait_time = self.jitter(wait_time)
+                    if self.max_time is not None:
+                        wait_time = min(wait_time, self.max_time - elapsed_time)
+                    state.actual_wait = wait_time
+                except StopIteration:
+                    # Trigger giveup event
+                    try_call_event_handler(self.on_giveup)
+                    raise err from None
+
+                # Trigger backoff event
+                try_call_event_handler(self.on_backoff)
+
+                # Sleep
+                time.sleep(wait_time)
+            else:
+                # Trigger success event
+                try_call_event_handler(self.on_success)
+                return ret

{flwr_nightly-1.6.0.dev20231026.dist-info → flwr_nightly-1.6.0.dev20231101.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.6.0.dev20231026
+Version: 1.6.0.dev20231101
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.dev
 License: Apache-2.0
@@ -71,22 +71,21 @@ Description-Content-Type: text/markdown
 Flower (`flwr`) is a framework for building federated learning systems. The
 design of Flower is based on a few guiding principles:
 
-* **Customizable**: Federated learning systems vary wildly from one use case to
+- **Customizable**: Federated learning systems vary wildly from one use case to
   another. Flower allows for a wide range of different configurations depending
   on the needs of each individual use case.
 
-* **Extendable**: Flower originated from a research project at the University of
+- **Extendable**: Flower originated from a research project at the University of
   Oxford, so it was built with AI research in mind. Many components can be
   extended and overridden to build new state-of-the-art systems.
 
-* **Framework-agnostic**: Different machine learning frameworks have different
+- **Framework-agnostic**: Different machine learning frameworks have different
   strengths. Flower can be used with any machine learning framework, for
   example, [PyTorch](https://pytorch.org),
-  [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [MXNet](https://mxnet.apache.org/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [fastai](https://www.fast.ai/), [Pandas](https://pandas.pydata.org/
-) for federated analytics, or even raw [NumPy](https://numpy.org/)
+  [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [MXNet](https://mxnet.apache.org/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [fastai](https://www.fast.ai/), [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
   for users who enjoy computing gradients by hand.
 
-* **Understandable**: Flower is written with maintainability in mind. The
+- **Understandable**: Flower is written with maintainability in mind. The
   community is encouraged to both read and contribute to the codebase.
 
 Meet the Flower community on [flower.dev](https://flower.dev)!
@@ -106,11 +105,11 @@ Flower's goal is to make federated learning accessible to everyone. This series
 2. **Using Strategies in Federated Learning**
 
    [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adap/flower/blob/main/doc/source/tutorial-use-a-federated-learning-strategy-pytorch.ipynb) (or open the [Jupyter Notebook](https://github.com/adap/flower/blob/main/doc/source/tutorial-use-a-federated-learning-strategy-pytorch.ipynb))
-   
+
 3. **Building Strategies for Federated Learning**
 
    [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adap/flower/blob/main/doc/source/tutorial-series-use-a-federated-learning-strategy-pytorch.ipynb) (or open the [Jupyter Notebook](https://github.com/adap/flower/blob/main/doc/source/tutorial-series-use-a-federated-learning-strategy-pytorch.ipynb))
-   
+
 4. **Custom Clients for Federated Learning**
 
    [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adap/flower/blob/main/doc/source/tutorial-series-customize-the-client-pytorch.ipynb) (or open the [Jupyter Notebook](https://github.com/adap/flower/blob/main/doc/source/tutorial-series-customize-the-client-pytorch.ipynb))
@@ -121,39 +120,39 @@ Stay tuned, more tutorials are coming soon. Topics include **Privacy and Securit
 
 [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adap/flower/blob/main/examples/flower-in-30-minutes/tutorial.ipynb) (or open the [Jupyter Notebook](https://github.com/adap/flower/blob/main/examples/flower-in-30-minutes/tutorial.ipynb))
 
-
 ## Documentation
 
 [Flower Docs](https://flower.dev/docs):
-* [Installation](https://flower.dev/docs/framework/how-to-install-flower.html)
-* [Quickstart (TensorFlow)](https://flower.dev/docs/framework/tutorial-quickstart-tensorflow.html)
-* [Quickstart (PyTorch)](https://flower.dev/docs/framework/tutorial-quickstart-pytorch.html)
-* [Quickstart (Hugging Face)](https://flower.dev/docs/framework/tutorial-quickstart-huggingface.html)
-* [Quickstart (PyTorch Lightning [code example])](https://flower.dev/docs/framework/tutorial-quickstart-pytorch-lightning.html)
-* [Quickstart (MXNet)](https://flower.dev/docs/framework/example-mxnet-walk-through.html)
-* [Quickstart (Pandas)](https://flower.dev/docs/framework/tutorial-quickstart-pandas.html)
-* [Quickstart (fastai)](https://flower.dev/docs/framework/tutorial-quickstart-fastai.html)
-* [Quickstart (JAX)](https://flower.dev/docs/framework/tutorial-quickstart-jax.html)
-* [Quickstart (scikit-learn)](https://flower.dev/docs/framework/tutorial-quickstart-scikitlearn.html)
-* [Quickstart (Android [TFLite])](https://flower.dev/docs/framework/tutorial-quickstart-android.html)
-* [Quickstart (iOS [CoreML])](https://flower.dev/docs/framework/tutorial-quickstart-ios.html)
+
+- [Installation](https://flower.dev/docs/framework/how-to-install-flower.html)
+- [Quickstart (TensorFlow)](https://flower.dev/docs/framework/tutorial-quickstart-tensorflow.html)
+- [Quickstart (PyTorch)](https://flower.dev/docs/framework/tutorial-quickstart-pytorch.html)
+- [Quickstart (Hugging Face)](https://flower.dev/docs/framework/tutorial-quickstart-huggingface.html)
+- [Quickstart (PyTorch Lightning [code example])](https://flower.dev/docs/framework/tutorial-quickstart-pytorch-lightning.html)
+- [Quickstart (MXNet)](https://flower.dev/docs/framework/example-mxnet-walk-through.html)
+- [Quickstart (Pandas)](https://flower.dev/docs/framework/tutorial-quickstart-pandas.html)
+- [Quickstart (fastai)](https://flower.dev/docs/framework/tutorial-quickstart-fastai.html)
+- [Quickstart (JAX)](https://flower.dev/docs/framework/tutorial-quickstart-jax.html)
+- [Quickstart (scikit-learn)](https://flower.dev/docs/framework/tutorial-quickstart-scikitlearn.html)
+- [Quickstart (Android [TFLite])](https://flower.dev/docs/framework/tutorial-quickstart-android.html)
+- [Quickstart (iOS [CoreML])](https://flower.dev/docs/framework/tutorial-quickstart-ios.html)
 
 ## Flower Baselines
 
 Flower Baselines is a collection of community-contributed experiments that reproduce the experiments performed in popular federated learning publications. Researchers can build on Flower Baselines to quickly evaluate new ideas:
 
-* [FedAvg](https://arxiv.org/abs/1602.05629):
-  * [MNIST](https://github.com/adap/flower/tree/main/baselines/flwr_baselines/flwr_baselines/publications/fedavg_mnist)
-* [FedProx](https://arxiv.org/abs/1812.06127):
-  * [MNIST](https://github.com/adap/flower/tree/main/baselines/fedprox/)
-* [FedBN: Federated Learning on non-IID Features via Local Batch Normalization](https://arxiv.org/abs/2102.07623):
-  * [Convergence Rate](https://github.com/adap/flower/tree/main/baselines/flwr_baselines/flwr_baselines/publications/fedbn/convergence_rate)
-* [Adaptive Federated Optimization](https://arxiv.org/abs/2003.00295):
-  * [CIFAR-10/100](https://github.com/adap/flower/tree/main/baselines/flwr_baselines/flwr_baselines/publications/adaptive_federated_optimization)
+- [FedAvg](https://arxiv.org/abs/1602.05629):
+  - [MNIST](https://github.com/adap/flower/tree/main/baselines/flwr_baselines/flwr_baselines/publications/fedavg_mnist)
+- [FedProx](https://arxiv.org/abs/1812.06127):
+  - [MNIST](https://github.com/adap/flower/tree/main/baselines/fedprox/)
+- [FedBN: Federated Learning on non-IID Features via Local Batch Normalization](https://arxiv.org/abs/2102.07623):
+  - [Convergence Rate](https://github.com/adap/flower/tree/main/baselines/flwr_baselines/flwr_baselines/publications/fedbn/convergence_rate)
+- [Adaptive Federated Optimization](https://arxiv.org/abs/2003.00295):
+  - [CIFAR-10/100](https://github.com/adap/flower/tree/main/baselines/flwr_baselines/flwr_baselines/publications/adaptive_federated_optimization)
 
-Check the Flower documentation to learn more: [Using Baselines](https://flower.dev/docs/baselines/using-baselines.html)
+Check the Flower documentation to learn more: [Using Baselines](https://flower.dev/docs/baselines/how-to-use-baselines.html)
 
-The Flower community loves contributions! Make your work more visible and enable others to build on it by contributing it as a baseline: [Contributing Baselines](https://flower.dev/docs/baselines/contributing-baselines.html)
+The Flower community loves contributions! Make your work more visible and enable others to build on it by contributing it as a baseline: [Contributing Baselines](https://flower.dev/docs/baselines/how-to-contribute-baselines.html)
 
 ## Flower Usage Examples
 
@@ -161,26 +160,26 @@ Several code examples show different usage scenarios of Flower (in combination w
 
 Quickstart examples:
 
-* [Quickstart (TensorFlow)](https://github.com/adap/flower/tree/main/examples/quickstart-tensorflow)
-* [Quickstart (PyTorch)](https://github.com/adap/flower/tree/main/examples/quickstart-pytorch)
-* [Quickstart (Hugging Face)](https://github.com/adap/flower/tree/main/examples/quickstart-huggingface)
-* [Quickstart (PyTorch Lightning)](https://github.com/adap/flower/tree/main/examples/quickstart-pytorch-lightning)
-* [Quickstart (fastai)](https://github.com/adap/flower/tree/main/examples/quickstart-fastai)
-* [Quickstart (Pandas)](https://github.com/adap/flower/tree/main/examples/quickstart-pandas)
-* [Quickstart (MXNet)](https://github.com/adap/flower/tree/main/examples/quickstart-mxnet)
-* [Quickstart (JAX)](https://github.com/adap/flower/tree/main/examples/quickstart-jax)
-* [Quickstart (scikit-learn)](https://github.com/adap/flower/tree/main/examples/sklearn-logreg-mnist)
-* [Quickstart (Android [TFLite])](https://github.com/adap/flower/tree/main/examples/android)
-* [Quickstart (iOS [CoreML])](https://github.com/adap/flower/tree/main/examples/ios)
+- [Quickstart (TensorFlow)](https://github.com/adap/flower/tree/main/examples/quickstart-tensorflow)
+- [Quickstart (PyTorch)](https://github.com/adap/flower/tree/main/examples/quickstart-pytorch)
+- [Quickstart (Hugging Face)](https://github.com/adap/flower/tree/main/examples/quickstart-huggingface)
+- [Quickstart (PyTorch Lightning)](https://github.com/adap/flower/tree/main/examples/quickstart-pytorch-lightning)
+- [Quickstart (fastai)](https://github.com/adap/flower/tree/main/examples/quickstart-fastai)
+- [Quickstart (Pandas)](https://github.com/adap/flower/tree/main/examples/quickstart-pandas)
+- [Quickstart (MXNet)](https://github.com/adap/flower/tree/main/examples/quickstart-mxnet)
+- [Quickstart (JAX)](https://github.com/adap/flower/tree/main/examples/quickstart-jax)
+- [Quickstart (scikit-learn)](https://github.com/adap/flower/tree/main/examples/sklearn-logreg-mnist)
+- [Quickstart (Android [TFLite])](https://github.com/adap/flower/tree/main/examples/android)
+- [Quickstart (iOS [CoreML])](https://github.com/adap/flower/tree/main/examples/ios)
 
 Other [examples](https://github.com/adap/flower/tree/main/examples):
 
-* [Raspberry Pi & Nvidia Jetson Tutorial](https://github.com/adap/flower/tree/main/examples/embedded-devices)
-* [PyTorch: From Centralized to Federated](https://github.com/adap/flower/tree/main/examples/pytorch-from-centralized-to-federated)
-* [MXNet: From Centralized to Federated](https://github.com/adap/flower/tree/main/examples/mxnet-from-centralized-to-federated)
-* [Advanced Flower with TensorFlow/Keras](https://github.com/adap/flower/tree/main/examples/advanced-tensorflow)
-* [Advanced Flower with PyTorch](https://github.com/adap/flower/tree/main/examples/advanced-pytorch)
-* Single-Machine Simulation of Federated Learning Systems ([PyTorch](https://github.com/adap/flower/tree/main/examples/simulation_pytorch)) ([Tensorflow](https://github.com/adap/flower/tree/main/examples/simulation_tensorflow))
+- [Raspberry Pi & Nvidia Jetson Tutorial](https://github.com/adap/flower/tree/main/examples/embedded-devices)
+- [PyTorch: From Centralized to Federated](https://github.com/adap/flower/tree/main/examples/pytorch-from-centralized-to-federated)
+- [MXNet: From Centralized to Federated](https://github.com/adap/flower/tree/main/examples/mxnet-from-centralized-to-federated)
+- [Advanced Flower with TensorFlow/Keras](https://github.com/adap/flower/tree/main/examples/advanced-tensorflow)
+- [Advanced Flower with PyTorch](https://github.com/adap/flower/tree/main/examples/advanced-pytorch)
+- Single-Machine Simulation of Federated Learning Systems ([PyTorch](https://github.com/adap/flower/tree/main/examples/simulation_pytorch)) ([Tensorflow](https://github.com/adap/flower/tree/main/examples/simulation_tensorflow))
 
 ## Community
 
@@ -192,12 +191,12 @@ Flower is built by a wonderful community of researchers and engineers. [Join Sla
 
 ## Citation
 
-If you publish work that uses Flower, please cite Flower as follows: 
+If you publish work that uses Flower, please cite Flower as follows:
 
 ```bibtex
 @article{beutel2020flower,
   title={Flower: A Friendly Federated Learning Research Framework},
-  author={Beutel, Daniel J and Topal, Taner and Mathur, Akhil and Qiu, Xinchi and Fernandez-Marques, Javier and Gao, Yan and Sani, Lorenzo and Kwing, Hei Li and Parcollet, Titouan and Gusmão, Pedro PB de and Lane, Nicholas D}, 
+  author={Beutel, Daniel J and Topal, Taner and Mathur, Akhil and Qiu, Xinchi and Fernandez-Marques, Javier and Gao, Yan and Sani, Lorenzo and Kwing, Hei Li and Parcollet, Titouan and Gusmão, Pedro PB de and Lane, Nicholas D},
   journal={arXiv preprint arXiv:2007.14390},
   year={2020}
 }

{flwr_nightly-1.6.0.dev20231026.dist-info → flwr_nightly-1.6.0.dev20231101.dist-info}/RECORD

@@ -1,6 +1,6 @@
 flwr/__init__.py,sha256=_lnE8lIgk0i4hpag6GWVGPPr1w4IrA5z4y_kFwIpZYM,959
 flwr/client/__init__.py,sha256=7GyT3nZpvzL0grFGMcKhXrVS_IpctJpUmMk9whAzFNE,1111
-flwr/client/app.py,sha256=qwvSYITDDnYS4QDU0rOavK1mCWWli3okQ5hm_r4aogY,10504
+flwr/client/app.py,sha256=-ohwtOxk9O2ESlnA_OeWNkishUoNt4hbO3tmNiChdBc,11111
 flwr/client/client.py,sha256=WPDQzzPQ3VePYZDEjMEMxKWUPDWB21sL_iP12NUPt5o,7894
 flwr/client/dpfedavg_numpy_client.py,sha256=LxUcPBO0mU3VScAx9vx2PlsghXjQZVEBOn3rolgrgio,7216
 flwr/client/grpc_client/__init__.py,sha256=LsnbqXiJhgQcB0XzAlUQgPx011Uf7Y7yabIC1HxivJ8,735
@@ -26,6 +26,7 @@ flwr/common/dp.py,sha256=hF45cPElXxcQsh4AoquAyaTrNi0xCrIcKx7xOcV_1XU,1782
 flwr/common/grpc.py,sha256=JmFrGeEqFjMKkf6Mn6NlMJdjk27pYHzsn7CquAfR4R0,1896
 flwr/common/logger.py,sha256=Plgdf5NULsv9leDeNOXTeCqK-7LkZh8R34RPT4EkOs8,3466
 flwr/common/parameter.py,sha256=-bFAUayToYDF50FZGrBC1hQYJCQDtB2bbr3ZuVLMtdE,2095
+flwr/common/retry_invoker.py,sha256=RBTiDnYyePWvhBH9GqcWZl0tQaUOVUqOVBwfGprXWEg,10810
 flwr/common/secure_aggregation/__init__.py,sha256=29nHIUO2L8-KhNHQ2KmIgRo_4CPkq4LgLCUN0on5FgI,731
 flwr/common/secure_aggregation/crypto/__init__.py,sha256=dz7pVx2aPrHxr_AwgO5mIiTzu4PcvUxRq9NLBbFcsf8,738
 flwr/common/secure_aggregation/crypto/shamir.py,sha256=yY35ZgHlB4YyGW_buG-1X-0M-ejXuQzISgYLgC_Z9TY,2792
@@ -121,8 +122,8 @@ flwr/simulation/ray_transport/__init__.py,sha256=FsaAnzC4cw4DqoouBCix6496k29jACk
 flwr/simulation/ray_transport/ray_actor.py,sha256=EiyXPRnur8pOzGu_h5ZU4t8C5M_amnVPAQWyPSbAnEU,16564
 flwr/simulation/ray_transport/ray_client_proxy.py,sha256=cPo3Ny1k5arqTLHD0bB5DSEuS66aE2SwEumtr8TzOGc,8778
 flwr/simulation/ray_transport/utils.py,sha256=MVOH4l1ZPt64WidgBBay--1M3lS82CQ3ebmwU9Cvlo0,3369
-flwr_nightly-1.6.0.dev20231026.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-flwr_nightly-1.6.0.dev20231026.dist-info/METADATA,sha256=sbAgePqdUg8CrO4n__nUbNsobNcLcELA03RLDqeyegY,13240
-flwr_nightly-1.6.0.dev20231026.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-flwr_nightly-1.6.0.dev20231026.dist-info/entry_points.txt,sha256=1uLlD5tIunkzALMfMWnqjdE_D5hRUX_I1iMmOMv6tZI,181
-flwr_nightly-1.6.0.dev20231026.dist-info/RECORD,,
+flwr_nightly-1.6.0.dev20231101.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+flwr_nightly-1.6.0.dev20231101.dist-info/METADATA,sha256=R2keD6GeJ359rUi7o0nVXaiIXrzkPfaZs71po_Ul96g,13241
+flwr_nightly-1.6.0.dev20231101.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+flwr_nightly-1.6.0.dev20231101.dist-info/entry_points.txt,sha256=1uLlD5tIunkzALMfMWnqjdE_D5hRUX_I1iMmOMv6tZI,181
+flwr_nightly-1.6.0.dev20231101.dist-info/RECORD,,