flwr-nightly 1.18.0.dev20250407__py3-none-any.whl → 1.18.0.dev20250409__py3-none-any.whl

flwr/cli/new/new.py

@@ -201,15 +201,15 @@ def new(
         if llm_challenge_str == "generalnlp":
             challenge_name = "General NLP"
             num_clients = "20"
-            dataset_name = "vicgalle/alpaca-gpt4"
+            dataset_name = "flwrlabs/alpaca-gpt4"
         elif llm_challenge_str == "finance":
             challenge_name = "Finance"
             num_clients = "50"
-            dataset_name = "FinGPT/fingpt-sentiment-train"
+            dataset_name = "flwrlabs/fingpt-sentiment-train"
         elif llm_challenge_str == "medical":
             challenge_name = "Medical"
             num_clients = "20"
-            dataset_name = "medalpaca/medical_meadow_medical_flashcards"
+            dataset_name = "flwrlabs/medical-meadow-medical-flashcards"
         else:
             challenge_name = "Code"
             num_clients = "10"

flwr/client/app.py

@@ -158,33 +158,33 @@ def start_client(
 
     Examples
     --------
-    Starting a gRPC client with an insecure server connection:
-
-    >>> start_client(
-    >>>     server_address=localhost:8080,
-    >>>     client_fn=client_fn,
-    >>> )
-
-    Starting an SSL-enabled gRPC client using system certificates:
-
-    >>> def client_fn(context: Context):
-    >>>     return FlowerClient().to_client()
-    >>>
-    >>> start_client(
-    >>>     server_address=localhost:8080,
-    >>>     client_fn=client_fn,
-    >>>     insecure=False,
-    >>> )
-
-    Starting an SSL-enabled gRPC client using provided certificates:
-
-    >>> from pathlib import Path
-    >>>
-    >>> start_client(
-    >>>     server_address=localhost:8080,
-    >>>     client_fn=client_fn,
-    >>>     root_certificates=Path("/crts/root.pem").read_bytes(),
-    >>> )
+    Starting a gRPC client with an insecure server connection::
+
+        start_client(
+            server_address=localhost:8080,
+            client_fn=client_fn,
+        )
+
+    Starting a TLS-enabled gRPC client using system certificates::
+
+        def client_fn(context: Context):
+            return FlowerClient().to_client()
+
+        start_client(
+            server_address=localhost:8080,
+            client_fn=client_fn,
+            insecure=False,
+        )
+
+    Starting a TLS-enabled gRPC client using provided certificates::
+
+        from pathlib import Path
+
+        start_client(
+            server_address=localhost:8080,
+            client_fn=client_fn,
+            root_certificates=Path("/crts/root.pem").read_bytes(),
+        )
     """
     msg = (
         "flwr.client.start_client() is deprecated."
@@ -684,30 +684,30 @@ def start_numpy_client(
 
     Examples
     --------
-    Starting a gRPC client with an insecure server connection:
-
-    >>> start_numpy_client(
-    >>>     server_address=localhost:8080,
-    >>>     client=FlowerClient(),
-    >>> )
-
-    Starting an SSL-enabled gRPC client using system certificates:
-
-    >>> start_numpy_client(
-    >>>     server_address=localhost:8080,
-    >>>     client=FlowerClient(),
-    >>>     insecure=False,
-    >>> )
-
-    Starting an SSL-enabled gRPC client using provided certificates:
-
-    >>> from pathlib import Path
-    >>>
-    >>> start_numpy_client(
-    >>>     server_address=localhost:8080,
-    >>>     client=FlowerClient(),
-    >>>     root_certificates=Path("/crts/root.pem").read_bytes(),
-    >>> )
+    Starting a gRPC client with an insecure server connection::
+
+        start_numpy_client(
+            server_address=localhost:8080,
+            client=FlowerClient(),
+        )
+
+    Starting a TLS-enabled gRPC client using system certificates::
+
+        start_numpy_client(
+            server_address=localhost:8080,
+            client=FlowerClient(),
+            insecure=False,
+        )
+
+    Starting a TLS-enabled gRPC client using provided certificates::
+
+        from pathlib import Path
+
+        start_numpy_client(
+            server_address=localhost:8080,
+            client=FlowerClient(),
+            root_certificates=Path("/crts/root.pem").read_bytes(),
+        )
     """
     mssg = (
         "flwr.client.start_numpy_client() is deprecated. \n\tInstead, use "

flwr/client/client_app.py

@@ -95,16 +95,16 @@ class ClientApp:
 
     Examples
     --------
-    Assuming a typical `Client` implementation named `FlowerClient`, you can wrap it in
-    a `ClientApp` as follows:
-
-    >>> class FlowerClient(NumPyClient):
-    >>>     # ...
-    >>>
-    >>> def client_fn(context: Context):
-    >>>    return FlowerClient().to_client()
-    >>>
-    >>> app = ClientApp(client_fn)
+    Assuming a typical ``Client`` implementation named ``FlowerClient``, you can wrap
+    it in a ``ClientApp`` as follows::
+
+        class FlowerClient(NumPyClient):
+            # ...
+
+        def client_fn(context: Context):
+           return FlowerClient().to_client()
+
+        app = ClientApp(client_fn)
     """
 
     def __init__(
@@ -181,39 +181,39 @@ class ClientApp:
 
         Examples
         --------
-        Registering a train function:
-
-        >>> app = ClientApp()
-        >>>
-        >>> @app.train()
-        >>> def train(message: Message, context: Context) -> Message:
-        >>>     print("Executing default train function")
-        >>>     # Create and return an echo reply message
-        >>>     return Message(message.content, reply_to=message)
-
-        Registering a train function with a custom action name:
-
-        >>> app = ClientApp()
-        >>>
-        >>> # Messages with `message_type="train.custom_action"` will be
-        >>> # routed to this function.
-        >>> @app.train("custom_action")
-        >>> def custom_action(message: Message, context: Context) -> Message:
-        >>>     print("Executing train function for custom action")
-        >>>     return Message(message.content, reply_to=message)
-
-        Registering a train function with a function-specific Flower Mod:
-
-        >>> from flwr.client.mod import message_size_mod
-        >>>
-        >>> app = ClientApp()
-        >>>
-        >>> # Using the `mods` argument to apply a function-specific mod.
-        >>> @app.train(mods=[message_size_mod])
-        >>> def train(message: Message, context: Context) -> Message:
-        >>>     print("Executing train function with message size mod")
-        >>>     # Create and return an echo reply message
-        >>>     return Message(message.content, reply_to=message)
+        Registering a train function::
+
+            app = ClientApp()
+
+            @app.train()
+            def train(message: Message, context: Context) -> Message:
+                print("Executing default train function")
+                # Create and return an echo reply message
+                return Message(message.content, reply_to=message)
+
+        Registering a train function with a custom action name::
+
+            app = ClientApp()
+
+            # Messages with `message_type="train.custom_action"` will be
+            # routed to this function.
+            @app.train("custom_action")
+            def custom_action(message: Message, context: Context) -> Message:
+                print("Executing train function for custom action")
+                return Message(message.content, reply_to=message)
+
+        Registering a train function with a function-specific Flower Mod::
+
+            from flwr.client.mod import message_size_mod
+
+            app = ClientApp()
+
+            # Using the `mods` argument to apply a function-specific mod.
+            @app.train(mods=[message_size_mod])
+            def train(message: Message, context: Context) -> Message:
+                print("Executing train function with message size mod")
+                # Create and return an echo reply message
+                return Message(message.content, reply_to=message)
         """
         return _get_decorator(self, MessageType.TRAIN, action, mods)
 
@@ -236,39 +236,39 @@ class ClientApp:
 
         Examples
         --------
-        Registering an evaluate function:
-
-        >>> app = ClientApp()
-        >>>
-        >>> @app.evaluate()
-        >>> def evaluate(message: Message, context: Context) -> Message:
-        >>>     print("Executing default evaluate function")
-        >>>     # Create and return an echo reply message
-        >>>     return Message(message.content, reply_to=message)
-
-        Registering an evaluate function with a custom action name:
-
-        >>> app = ClientApp()
-        >>>
-        >>> # Messages with `message_type="evaluate.custom_action"` will be
-        >>> # routed to this function.
-        >>> @app.evaluate("custom_action")
-        >>> def custom_action(message: Message, context: Context) -> Message:
-        >>>     print("Executing evaluate function for custom action")
-        >>>     return Message(message.content, reply_to=message)
-
-        Registering an evaluate function with a function-specific Flower Mod:
-
-        >>> from flwr.client.mod import message_size_mod
-        >>>
-        >>> app = ClientApp()
-        >>>
-        >>> # Using the `mods` argument to apply a function-specific mod.
-        >>> @app.evaluate(mods=[message_size_mod])
-        >>> def evaluate(message: Message, context: Context) -> Message:
-        >>>     print("Executing evaluate function with message size mod")
-        >>>     # Create and return an echo reply message
-        >>>     return Message(message.content, reply_to=message)
+        Registering an evaluate function::
+
+            app = ClientApp()
+
+            @app.evaluate()
+            def evaluate(message: Message, context: Context) -> Message:
+                print("Executing default evaluate function")
+                # Create and return an echo reply message
+                return Message(message.content, reply_to=message)
+
+        Registering an evaluate function with a custom action name::
+
+            app = ClientApp()
+
+            # Messages with `message_type="evaluate.custom_action"` will be
+            # routed to this function.
+            @app.evaluate("custom_action")
+            def custom_action(message: Message, context: Context) -> Message:
+                print("Executing evaluate function for custom action")
+                return Message(message.content, reply_to=message)
+
+        Registering an evaluate function with a function-specific Flower Mod::
+
+            from flwr.client.mod import message_size_mod
+
+            app = ClientApp()
+
+            # Using the `mods` argument to apply a function-specific mod.
+            @app.evaluate(mods=[message_size_mod])
+            def evaluate(message: Message, context: Context) -> Message:
+                print("Executing evaluate function with message size mod")
+                # Create and return an echo reply message
+                return Message(message.content, reply_to=message)
         """
         return _get_decorator(self, MessageType.EVALUATE, action, mods)
 
@@ -291,39 +291,39 @@ class ClientApp:
 
         Examples
         --------
-        Registering a query function:
-
-        >>> app = ClientApp()
-        >>>
-        >>> @app.query()
-        >>> def query(message: Message, context: Context) -> Message:
-        >>>     print("Executing default query function")
-        >>>     # Create and return an echo reply message
-        >>>     return Message(message.content, reply_to=message)
-
-        Registering a query function with a custom action name:
-
-        >>> app = ClientApp()
-        >>>
-        >>> # Messages with `message_type="query.custom_action"` will be
-        >>> # routed to this function.
-        >>> @app.query("custom_action")
-        >>> def custom_action(message: Message, context: Context) -> Message:
-        >>>     print("Executing query function for custom action")
-        >>>     return Message(message.content, reply_to=message)
-
-        Registering a query function with a function-specific Flower Mod:
-
-        >>> from flwr.client.mod import message_size_mod
-        >>>
-        >>> app = ClientApp()
-        >>>
-        >>> # Using the `mods` argument to apply a function-specific mod.
-        >>> @app.query(mods=[message_size_mod])
-        >>> def query(message: Message, context: Context) -> Message:
-        >>>     print("Executing query function with message size mod")
-        >>>     # Create and return an echo reply message
-        >>>     return Message(message.content, reply_to=message)
+        Registering a query function::
+
+            app = ClientApp()
+
+            @app.query()
+            def query(message: Message, context: Context) -> Message:
+                print("Executing default query function")
+                # Create and return an echo reply message
+                return Message(message.content, reply_to=message)
+
+        Registering a query function with a custom action name::
+
+            app = ClientApp()
+
+            # Messages with `message_type="query.custom_action"` will be
+            # routed to this function.
+            @app.query("custom_action")
+            def custom_action(message: Message, context: Context) -> Message:
+                print("Executing query function for custom action")
+                return Message(message.content, reply_to=message)
+
+        Registering a query function with a function-specific Flower Mod::
+
+            from flwr.client.mod import message_size_mod
+
+            app = ClientApp()
+
+            # Using the `mods` argument to apply a function-specific mod.
+            @app.query(mods=[message_size_mod])
+            def query(message: Message, context: Context) -> Message:
+                print("Executing query function with message size mod")
+                # Create and return an echo reply message
+                return Message(message.content, reply_to=message)
         """
         return _get_decorator(self, MessageType.QUERY, action, mods)
 
@@ -339,17 +339,19 @@ class ClientApp:
 
         Examples
         --------
-        >>> app = ClientApp()
-        >>>
-        >>> @app.lifespan()
-        >>> def lifespan(context: Context) -> None:
-        >>>     # Perform initialization tasks before the app starts
-        >>>     print("Initializing ClientApp")
-        >>>
-        >>>     yield  # ClientApp is running
-        >>>
-        >>>     # Perform cleanup tasks after the app stops
-        >>>     print("Cleaning up ClientApp")
+        ::
+
+                app = ClientApp()
+
+                @app.lifespan()
+                def lifespan(context: Context) -> None:
+                    # Perform initialization tasks before the app starts
+                    print("Initializing ClientApp")
+
+                    yield  # ClientApp is running
+
+                    # Perform cleanup tasks after the app stops
+                    print("Cleaning up ClientApp")
         """
 
         def lifespan_decorator(
@@ -436,24 +438,24 @@ def _registration_error(fn_name: str) -> ValueError:
 
         Use the `ClientApp` with an existing `client_fn`:
 
-        >>> class FlowerClient(NumPyClient):
-        >>>     # ...
-        >>>
-        >>> def client_fn(context: Context):
-        >>>     return FlowerClient().to_client()
-        >>>
-        >>> app = ClientApp(
-        >>>     client_fn=client_fn,
-        >>> )
+        class FlowerClient(NumPyClient):
+            # ...
+
+            def client_fn(context: Context):
+                return FlowerClient().to_client()
+
+            app = ClientApp(
+                client_fn=client_fn,
+            )
 
         Use the `ClientApp` with a custom {fn_name} function:
 
-        >>> app = ClientApp()
-        >>>
-        >>> @app.{fn_name}()
-        >>> def {fn_name}(message: Message, context: Context) -> Message:
-        >>>    print("ClientApp {fn_name} running")
-        >>>    # Create and return an echo reply message
-        >>>    return Message(message.content, reply_to=message)
+            app = ClientApp()
+
+            @app.{fn_name}()
+            def {fn_name}(message: Message, context: Context) -> Message:
+                print("ClientApp {fn_name} running")
+                # Create and return an echo reply message
+                return Message(message.content, reply_to=message)
         """,
     )

flwr/client/grpc_client/connection.py

@@ -104,18 +104,18 @@ def grpc_connection(  # pylint: disable=R0913,R0915,too-many-positional-argument
 
     Examples
     --------
-    Establishing a SSL-enabled connection to the server:
-
-    >>> from pathlib import Path
-    >>> with grpc_connection(
-    >>>     server_address,
-    >>>     max_message_length=max_message_length,
-    >>>     root_certificates=Path("/crts/root.pem").read_bytes(),
-    >>> ) as conn:
-    >>>     receive, send = conn
-    >>>     server_message = receive()
-    >>>     # do something here
-    >>>     send(client_message)
+    Establishing a TLS-enabled connection to the server::
+
+        from pathlib import Path
+        with grpc_connection(
+            server_address,
+            max_message_length=max_message_length,
+            root_certificates=Path("/crts/root.pem").read_bytes(),
+        ) as conn:
+            receive, send = conn
+            server_message = receive()
+            # do something here
+            send(client_message)
     """
     if isinstance(root_certificates, str):
         root_certificates = Path(root_certificates).read_bytes()

flwr/client/mod/localdp_mod.py

@@ -57,12 +57,12 @@ class LocalDpMod:
 
     Examples
     --------
-    Create an instance of the local DP mod and add it to the client-side mods:
+    Create an instance of the local DP mod and add it to the client-side mods::
 
-    >>> local_dp_mod = LocalDpMod( ... )
-    >>> app = fl.client.ClientApp(
-    >>>     client_fn=client_fn, mods=[local_dp_mod]
-    >>> )
+        local_dp_mod = LocalDpMod( ... )
+        app = fl.client.ClientApp(
+            client_fn=client_fn, mods=[local_dp_mod]
+        )
     """
 
     def __init__(

flwr/common/exit/exit.py

@@ -37,13 +37,13 @@ def flwr_exit(
 ) -> NoReturn:
     """Handle application exit with an optional message.
 
-    The exit message logged and displayed will follow this structure:
+    The exit message logged and displayed will follow this structure::
 
-    >>> Exit Code: <code>
-    >>> <message>
-    >>> <short-help-message>
-    >>>
-    >>> For more information, visit: <help-page-url>
+        Exit Code: <code>
+        <message>
+        <short-help-message>
+
+        For more information, visit: <help-page-url>
 
     - `<code>`: The unique exit code representing the termination reason.
     - `<message>`: Optional context or additional information about the exit.

flwr/common/record/arrayrecord.py

@@ -96,24 +96,24 @@ class Array:
 
     Examples
     --------
-    Initializing by specifying all fields directly:
+    Initializing by specifying all fields directly::
 
-    >>> arr1 = Array(
-    >>>     dtype="float32",
-    >>>     shape=[3, 3],
-    >>>     stype="numpy.ndarray",
-    >>>     data=b"serialized_data...",
-    >>> )
+        arr1 = Array(
+            dtype="float32",
+            shape=[3, 3],
+            stype="numpy.ndarray",
+            data=b"serialized_data...",
+        )
 
-    Initializing with a NumPy ndarray:
+    Initializing with a NumPy ndarray::
 
-    >>> import numpy as np
-    >>> arr2 = Array(np.random.randn(3, 3))
+        import numpy as np
+        arr2 = Array(np.random.randn(3, 3))
 
-    Initializing with a PyTorch tensor:
+    Initializing with a PyTorch tensor::
 
-    >>> import torch
-    >>> arr3 = Array(torch.randn(3, 3))
+        import torch
+        arr3 = Array(torch.randn(3, 3))
     """
 
     dtype: str
@@ -315,33 +315,33 @@ class ArrayRecord(TypedDict[str, Array]):
 
     Examples
     --------
-    Initializing an empty ArrayRecord:
+    Initializing an empty ArrayRecord::
 
-    >>> record = ArrayRecord()
+        record = ArrayRecord()
 
-    Initializing with a dictionary of :class:`Array`:
+    Initializing with a dictionary of :class:`Array`::
 
-    >>> arr = Array("float32", [5, 5], "numpy.ndarray", b"serialized_data...")
-    >>> record = ArrayRecord({"weight": arr})
+        arr = Array("float32", [5, 5], "numpy.ndarray", b"serialized_data...")
+        record = ArrayRecord({"weight": arr})
 
-    Initializing with a list of NumPy arrays:
+    Initializing with a list of NumPy arrays::
 
-    >>> import numpy as np
-    >>> arr1 = np.random.randn(3, 3)
-    >>> arr2 = np.random.randn(2, 2)
-    >>> record = ArrayRecord([arr1, arr2])
+        import numpy as np
+        arr1 = np.random.randn(3, 3)
+        arr2 = np.random.randn(2, 2)
+        record = ArrayRecord([arr1, arr2])
 
-    Initializing with a PyTorch model state_dict:
+    Initializing with a PyTorch model state_dict::
 
-    >>> import torch.nn as nn
-    >>> model = nn.Linear(10, 5)
-    >>> record = ArrayRecord(model.state_dict())
+        import torch.nn as nn
+        model = nn.Linear(10, 5)
+        record = ArrayRecord(model.state_dict())
 
-    Initializing with a TensorFlow model weights (a list of NumPy arrays):
+    Initializing with a TensorFlow model weights (a list of NumPy arrays)::
 
-    >>> import tensorflow as tf
-    >>> model = tf.keras.Sequential([tf.keras.layers.Dense(5, input_shape=(10,))])
-    >>> record = ArrayRecord(model.get_weights())
+        import tensorflow as tf
+        model = tf.keras.Sequential([tf.keras.layers.Dense(5, input_shape=(10,))])
+        record = ArrayRecord(model.get_weights())
     """
 
     @overload