flwr-nightly 1.18.0.dev20250404__py3-none-any.whl → 1.18.0.dev20250408__py3-none-any.whl

flwr/common/record/configrecord.py

@@ -60,7 +60,7 @@ def _check_value(value: ConfigRecordValues) -> None:
 
 
 class ConfigRecord(TypedDict[str, ConfigRecordValues]):
-    """Configs record.
+    """Config record.
 
     A :code:`ConfigRecord` is a Python dictionary designed to ensure that
     each key-value pair adheres to specified data types. A :code:`ConfigRecord`
@@ -90,18 +90,18 @@ class ConfigRecord(TypedDict[str, ConfigRecordValues]):
     encourage you to use a :code:`ArrayRecord` instead if these are of high
     dimensionality.
 
-    Let's see some examples of how to construct a :code:`ConfigRecord` from scratch:
-
-    >>> from flwr.common import ConfigRecord
-    >>>
-    >>> # A `ConfigRecord` is a specialized Python dictionary
-    >>> record = ConfigRecord({"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"
+    Let's see some examples of how to construct a :code:`ConfigRecord` from scratch::
+
+        from flwr.common import ConfigRecord
+
+        # A `ConfigRecord` is a specialized Python dictionary
+        record = ConfigRecord({"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.RecordDict`, types are
     enforced. If you need to add a custom data structure or object, we recommend to

flwr/common/record/metricrecord.py

@@ -60,7 +60,7 @@ def _check_value(value: MetricRecordValues) -> None:
 
 
 class MetricRecord(TypedDict[str, MetricRecordValues]):
-    """Metrics recod.
+    """Metric record.
 
     A :code:`MetricRecord` is a Python dictionary designed to ensure that
     each key-value pair adheres to specified data types. A :code:`MetricRecord`
@@ -89,27 +89,27 @@ class MetricRecord(TypedDict[str, MetricRecordValues]):
     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:`MetricRecord` from scratch:
+    Let's see some examples of how to construct a :code:`MetricRecord` from scratch::
 
-    >>> from flwr.common import MetricRecord
-    >>>
-    >>> # A `MetricRecord` is a specialized Python dictionary
-    >>> record = MetricRecord({"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]
+        from flwr.common import MetricRecord
+
+        # A `MetricRecord` is a specialized Python dictionary
+        record = MetricRecord({"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:`MetricRecord`, value types allowed are those in defined in
     :code:`flwr.common.MetricRecordValues`. Similarly, only :code:`str` keys are
-    allowed.
+    allowed::
+
+        from flwr.common import MetricRecord
 
-    >>> from flwr.common import MetricRecord
-    >>>
-    >>> record = MetricRecord() # an empty record
-    >>> # Add unsupported value
-    >>> record["something-unsupported"] = {'a': 123} # Will throw a `TypeError`
+        record = MetricRecord() # 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:`ConfigRecord` or
     :code:`ArrayRecord`.

flwr/common/record/recorddict.py

@@ -103,40 +103,40 @@ class RecordDict(TypedDict[str, RecordType]):
     are Python dictionaries designed to ensure that each key-value pair
     adheres to specified data types.
 
-    Let's see an example.
-
-    >>>  from flwr.common import RecordDict
-    >>>  from flwr.common import ArrayRecord, ConfigRecord, MetricRecord
-    >>>
-    >>>  # Let's begin with an empty record
-    >>>  my_records = RecordDict()
-    >>>
-    >>>  # We can create a ConfigRecord
-    >>>  c_record = ConfigRecord({"lr": 0.1, "batch-size": 128})
-    >>>  # Adding it to the RecordDict would look like this
-    >>>  my_records["my_config"] = c_record
-    >>>
-    >>>  # We can create a MetricRecord following a similar process
-    >>>  m_record = MetricRecord({"accuracy": 0.93, "losses": [0.23, 0.1]})
-    >>>  # Adding it to the RecordDict would look like this
-    >>>  my_records["my_metrics"] = m_record
+    Let's see an example::
+
+        from flwr.common import RecordDict
+        from flwr.common import ArrayRecord, ConfigRecord, MetricRecord
+
+        # Let's begin with an empty record
+        my_records = RecordDict()
+
+        # We can create a ConfigRecord
+        c_record = ConfigRecord({"lr": 0.1, "batch-size": 128})
+        # Adding it to the RecordDict would look like this
+        my_records["my_config"] = c_record
+
+        # We can create a MetricRecord following a similar process
+        m_record = MetricRecord({"accuracy": 0.93, "losses": [0.23, 0.1]})
+        # Adding it to the RecordDict would look like this
+        my_records["my_metrics"] = m_record
 
     Adding an :code:`ArrayRecord` follows the same steps as above but first,
     the array needs to be serialized and represented as a :code:`flwr.common.Array`.
-    For example:
-
-    >>>  from flwr.common import Array
-    >>>  # Creating an ArrayRecord would look like this
-    >>>  arr_np = np.random.randn(3, 3)
-    >>>
-    >>>  # You can use the built-in tool to serialize the array
-    >>>  arr = Array(arr_np)
-    >>>
-    >>>  # Finally, create the record
-    >>>  arr_record = ArrayRecord({"my_array": arr})
-    >>>
-    >>>  # Adding it to the RecordDict would look like this
-    >>>  my_records["my_parameters"] = arr_record
+    For example::
+
+        from flwr.common import Array
+        # Creating an ArrayRecord would look like this
+        arr_np = np.random.randn(3, 3)
+
+        # You can use the built-in tool to serialize the array
+        arr = Array(arr_np)
+
+        # Finally, create the record
+        arr_record = ArrayRecord({"my_array": arr})
+
+        # Adding it to the RecordDict would look like this
+        my_records["my_parameters"] = arr_record
 
     For additional examples on how to construct each of the records types shown
     above, please refer to the documentation for :code:`ConfigRecord`,

flwr/common/retry_invoker.py

@@ -166,15 +166,15 @@ class RetryInvoker:
 
     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)
+    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)
     """
 
     # pylint: disable-next=too-many-arguments

flwr/server/app.py

@@ -183,19 +183,19 @@ def start_server(  # pylint: disable=too-many-arguments,too-many-locals
 
     Examples
     --------
-    Starting an insecure server:
+    Starting an insecure server::
 
-    >>> start_server()
+        start_server()
 
-    Starting an SSL-enabled server:
+    Starting a TLS-enabled server::
 
-    >>> start_server(
-    >>>     certificates=(
-    >>>         Path("/crts/root.pem").read_bytes(),
-    >>>         Path("/crts/localhost.crt").read_bytes(),
-    >>>         Path("/crts/localhost.key").read_bytes()
-    >>>     )
-    >>> )
+        start_server(
+            certificates=(
+                Path("/crts/root.pem").read_bytes(),
+                Path("/crts/localhost.crt").read_bytes(),
+                Path("/crts/localhost.key").read_bytes()
+            )
+        )
     """
     msg = (
         "flwr.server.start_server() is deprecated."

flwr/server/grid/grid.py

@@ -172,7 +172,7 @@ class Driver(Grid):
 
     .. warning::
         ``Driver`` is deprecated and will be removed in a future release.
-        Use `Grid` in the signature of your ServerApp.
+        Use ``Grid`` in the signature of your ServerApp.
 
     Examples
     --------

flwr/server/server_app.py

@@ -52,6 +52,30 @@ GRID_USAGE_EXAMPLE = """
                     # Your existing ServerApp code ...
 """
 
+BOTH_MAIN_FN_SERVER_FN_PROVIDED_ERROR_MSG = (
+    "Use either a custom main function or a `Strategy`, but not both."
+    """
+
+Use the `ServerApp` with an existing `Strategy`:
+
+    server_config = ServerConfig(num_rounds=3)
+    strategy = FedAvg()
+
+    app = ServerApp(
+        server_config=server_config,
+        strategy=strategy,
+    )
+
+Use the `ServerApp` with a custom main function:
+
+    app = ServerApp()
+
+    @app.main()
+    def main(grid: Grid, context: Context) -> None:
+        print("ServerApp running")
+"""
+)
+
 DRIVER_DEPRECATION_MSG = """
             The `Driver` class is deprecated, it will be removed in a future release.
 """
@@ -70,25 +94,25 @@ class ServerApp:  # pylint: disable=too-many-instance-attributes
 
     Examples
     --------
-    Use the ``ServerApp`` with an existing ``Strategy``:
-
-    >>> def server_fn(context: Context):
-    >>>     server_config = ServerConfig(num_rounds=3)
-    >>>     strategy = FedAvg()
-    >>>     return ServerAppComponents(
-    >>>         strategy=strategy,
-    >>>         server_config=server_config,
-    >>>     )
-    >>>
-    >>> app = ServerApp(server_fn=server_fn)
-
-    Use the ``ServerApp`` with a custom main function:
-
-    >>> app = ServerApp()
-    >>>
-    >>> @app.main()
-    >>> def main(grid: Grid, context: Context) -> None:
-    >>>    print("ServerApp running")
+    Use the ``ServerApp`` with an existing ``Strategy``::
+
+        def server_fn(context: Context):
+            server_config = ServerConfig(num_rounds=3)
+            strategy = FedAvg()
+            return ServerAppComponents(
+                strategy=strategy,
+                server_config=server_config,
+            )
+
+        app = ServerApp(server_fn=server_fn)
+
+    Use the ``ServerApp`` with a custom main function::
+
+        app = ServerApp()
+
+        @app.main()
+        def main(grid: Grid, context: Context) -> None:
+           print("ServerApp running")
     """
 
     # pylint: disable=too-many-arguments,too-many-positional-arguments
@@ -156,38 +180,19 @@ class ServerApp:  # pylint: disable=too-many-instance-attributes
 
         Examples
         --------
-        >>> app = ServerApp()
-        >>>
-        >>> @app.main()
-        >>> def main(grid: Grid, context: Context) -> None:
-        >>>    print("ServerApp running")
+        ::
+
+            app = ServerApp()
+
+            @app.main()
+            def main(grid: Grid, context: Context) -> None:
+                print("ServerApp running")
         """
 
         def main_decorator(main_fn: ServerAppCallable) -> ServerAppCallable:
             """Register the main fn with the ServerApp object."""
             if self._server or self._config or self._strategy or self._client_manager:
-                raise ValueError(
-                    """Use either a custom main function or a `Strategy`, but not both.
-
-                    Use the `ServerApp` with an existing `Strategy`:
-
-                    >>> server_config = ServerConfig(num_rounds=3)
-                    >>> strategy = FedAvg()
-                    >>>
-                    >>> app = ServerApp(
-                    >>>     server_config=server_config,
-                    >>>     strategy=strategy,
-                    >>> )
-
-                    Use the `ServerApp` with a custom main function:
-
-                    >>> app = ServerApp()
-                    >>>
-                    >>> @app.main()
-                    >>> def main(grid: Grid, context: Context) -> None:
-                    >>>    print("ServerApp running")
-                    """,
-                )
+                raise ValueError(BOTH_MAIN_FN_SERVER_FN_PROVIDED_ERROR_MSG)
 
             sig = inspect.signature(main_fn)
             param = list(sig.parameters.values())[0]
@@ -219,17 +224,19 @@ class ServerApp:  # pylint: disable=too-many-instance-attributes
 
         Examples
         --------
-        >>> app = ServerApp()
-        >>>
-        >>> @app.lifespan()
-        >>> def lifespan(context: Context) -> None:
-        >>>     # Perform initialization tasks before the app starts
-        >>>     print("Initializing ServerApp")
-        >>>
-        >>>     yield  # ServerApp is running
-        >>>
-        >>>     # Perform cleanup tasks after the app stops
-        >>>     print("Cleaning up ServerApp")
+        ::
+
+            app = ServerApp()
+
+            @app.lifespan()
+            def lifespan(context: Context) -> None:
+                # Perform initialization tasks before the app starts
+                print("Initializing ServerApp")
+
+                yield  # ServerApp is running
+
+                # Perform cleanup tasks after the app stops
+                print("Cleaning up ServerApp")
         """
 
         def lifespan_decorator(

flwr/server/strategy/dp_adaptive_clipping.py

@@ -77,15 +77,15 @@ class DifferentialPrivacyServerSideAdaptiveClipping(Strategy):
 
     Examples
     --------
-    Create a strategy:
+    Create a strategy::
 
-    >>> strategy = fl.server.strategy.FedAvg( ... )
+        strategy = fl.server.strategy.FedAvg( ... )
 
-    Wrap the strategy with the DifferentialPrivacyServerSideAdaptiveClipping wrapper
+    Wrap the strategy with the DifferentialPrivacyServerSideAdaptiveClipping wrapper::
 
-    >>> dp_strategy = DifferentialPrivacyServerSideAdaptiveClipping(
-    >>>     strategy, cfg.noise_multiplier, cfg.num_sampled_clients, ...
-    >>> )
+        dp_strategy = DifferentialPrivacyServerSideAdaptiveClipping(
+            strategy, cfg.noise_multiplier, cfg.num_sampled_clients, ...
+        )
     """
 
     # pylint: disable=too-many-arguments,too-many-instance-attributes,too-many-positional-arguments
@@ -290,21 +290,21 @@ class DifferentialPrivacyClientSideAdaptiveClipping(Strategy):
 
     Examples
     --------
-    Create a strategy:
+    Create a strategy::
 
-    >>> strategy = fl.server.strategy.FedAvg(...)
+        strategy = fl.server.strategy.FedAvg(...)
 
-    Wrap the strategy with the `DifferentialPrivacyClientSideAdaptiveClipping` wrapper:
+    Wrap the strategy with the `DifferentialPrivacyClientSideAdaptiveClipping` wrapper::
 
-    >>> dp_strategy = DifferentialPrivacyClientSideAdaptiveClipping(
-    >>>     strategy, cfg.noise_multiplier, cfg.num_sampled_clients
-    >>> )
+        dp_strategy = DifferentialPrivacyClientSideAdaptiveClipping(
+            strategy, cfg.noise_multiplier, cfg.num_sampled_clients
+        )
 
-    On the client, add the `adaptiveclipping_mod` to the client-side mods:
+    On the client, add the `adaptiveclipping_mod` to the client-side mods::
 
-    >>> app = fl.client.ClientApp(
-    >>>     client_fn=client_fn, mods=[adaptiveclipping_mod]
-    >>> )
+        app = fl.client.ClientApp(
+            client_fn=client_fn, mods=[adaptiveclipping_mod]
+        )
     """
 
     # pylint: disable=too-many-arguments,too-many-instance-attributes,too-many-positional-arguments

flwr/server/strategy/dp_fixed_clipping.py

@@ -64,15 +64,15 @@ class DifferentialPrivacyServerSideFixedClipping(Strategy):
 
     Examples
     --------
-    Create a strategy:
+    Create a strategy::
 
-    >>> strategy = fl.server.strategy.FedAvg( ... )
+        strategy = fl.server.strategy.FedAvg( ... )
 
-    Wrap the strategy with the DifferentialPrivacyServerSideFixedClipping wrapper
+    Wrap the strategy with the DifferentialPrivacyServerSideFixedClipping wrapper::
 
-    >>> dp_strategy = DifferentialPrivacyServerSideFixedClipping(
-    >>>     strategy, cfg.noise_multiplier, cfg.clipping_norm, cfg.num_sampled_clients
-    >>> )
+        dp_strategy = DifferentialPrivacyServerSideFixedClipping(
+            strategy, cfg.noise_multiplier, cfg.clipping_norm, cfg.num_sampled_clients
+        )
     """
 
     # pylint: disable=too-many-arguments,too-many-instance-attributes
@@ -228,21 +228,21 @@ class DifferentialPrivacyClientSideFixedClipping(Strategy):
 
     Examples
     --------
-    Create a strategy:
+    Create a strategy::
 
-    >>> strategy = fl.server.strategy.FedAvg(...)
+        strategy = fl.server.strategy.FedAvg(...)
 
-    Wrap the strategy with the `DifferentialPrivacyClientSideFixedClipping` wrapper:
+    Wrap the strategy with the `DifferentialPrivacyClientSideFixedClipping` wrapper::
 
-    >>> dp_strategy = DifferentialPrivacyClientSideFixedClipping(
-    >>>     strategy, cfg.noise_multiplier, cfg.clipping_norm, cfg.num_sampled_clients
-    >>> )
+        dp_strategy = DifferentialPrivacyClientSideFixedClipping(
+            strategy, cfg.noise_multiplier, cfg.clipping_norm, cfg.num_sampled_clients
+        )
 
-    On the client, add the `fixedclipping_mod` to the client-side mods:
+    On the client, add the `fixedclipping_mod` to the client-side mods::
 
-    >>> app = fl.client.ClientApp(
-    >>>     client_fn=client_fn, mods=[fixedclipping_mod]
-    >>> )
+        app = fl.client.ClientApp(
+            client_fn=client_fn, mods=[fixedclipping_mod]
+        )
     """
 
     # pylint: disable=too-many-arguments,too-many-instance-attributes

flwr/server/superlink/fleet/grpc_bidi/grpc_server.py

@@ -96,18 +96,18 @@ def start_grpc_server(  # pylint: disable=too-many-arguments,R0917
 
     Examples
     --------
-    Starting a SSL-enabled server.
-
-    >>> from pathlib import Path
-    >>> start_grpc_server(
-    >>>     client_manager=ClientManager(),
-    >>>     server_address="localhost:8080",
-    >>>     certificates=(
-    >>>         Path("/crts/root.pem").read_bytes(),
-    >>>         Path("/crts/localhost.crt").read_bytes(),
-    >>>         Path("/crts/localhost.key").read_bytes(),
-    >>>     ),
-    >>> )
+    Starting a TLS-enabled server::
+
+        from pathlib import Path
+        start_grpc_server(
+            client_manager=ClientManager(),
+            server_address="localhost:8080",
+            certificates=(
+                Path("/crts/root.pem").read_bytes(),
+                Path("/crts/localhost.crt").read_bytes(),
+                Path("/crts/localhost.key").read_bytes(),
+            ),
+        )
     """
     servicer = FlowerServiceServicer(client_manager)
     add_servicer_to_server_fn = add_FlowerServiceServicer_to_server

{flwr_nightly-1.18.0.dev20250404.dist-info → flwr_nightly-1.18.0.dev20250408.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.18.0.dev20250404
+Version: 1.18.0.dev20250408
 Summary: Flower: A Friendly Federated AI Framework
 Home-page: https://flower.ai
 License: Apache-2.0