flwr 1.16.0__py3-none-any.whl → 1.17.0__py3-none-any.whl

flwr/cli/new/templates/app/code/flwr_tune/client_app.py.tpl

@@ -35,7 +35,7 @@ warnings.filterwarnings("ignore", category=UserWarning)
 # pylint: disable=too-many-arguments
 # pylint: disable=too-many-instance-attributes
 class FlowerClient(NumPyClient):
-    """Standard Flower client for CNN training."""
+    """Flower client for LLM fine-tuning."""
 
     def __init__(
         self,

flwr/cli/new/templates/app/pyproject.baseline.toml.tpl

@@ -8,7 +8,7 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.16.0",
+    "flwr[simulation]>=1.17.0",
     "flwr-datasets[vision]>=0.5.0",
     "torch==2.5.1",
     "torchvision==0.20.1",

flwr/cli/new/templates/app/pyproject.flowertune.toml.tpl

@@ -8,7 +8,7 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.16.0",
+    "flwr[simulation]>=1.17.0",
     "flwr-datasets>=0.5.0",
     "torch==2.3.1",
     "trl==0.8.1",

flwr/cli/new/templates/app/pyproject.huggingface.toml.tpl

@@ -8,7 +8,7 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.16.0",
+    "flwr[simulation]>=1.17.0",
     "flwr-datasets>=0.5.0",
     "torch==2.5.1",
     "transformers>=4.30.0,<5.0",

flwr/cli/new/templates/app/pyproject.jax.toml.tpl

@@ -8,7 +8,7 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.16.0",
+    "flwr[simulation]>=1.17.0",
     "jax==0.4.30",
     "jaxlib==0.4.30",
     "scikit-learn==1.6.1",

flwr/cli/new/templates/app/pyproject.mlx.toml.tpl

@@ -8,7 +8,7 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.16.0",
+    "flwr[simulation]>=1.17.0",
     "flwr-datasets[vision]>=0.5.0",
     "mlx==0.21.1",
 ]

flwr/cli/new/templates/app/pyproject.numpy.toml.tpl

@@ -8,7 +8,7 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.16.0",
+    "flwr[simulation]>=1.17.0",
     "numpy>=2.0.2",
 ]
 

flwr/cli/new/templates/app/pyproject.pytorch.toml.tpl

@@ -8,7 +8,7 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.16.0",
+    "flwr[simulation]>=1.17.0",
     "flwr-datasets[vision]>=0.5.0",
     "torch==2.5.1",
     "torchvision==0.20.1",

flwr/cli/new/templates/app/pyproject.sklearn.toml.tpl

@@ -8,7 +8,7 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.16.0",
+    "flwr[simulation]>=1.17.0",
     "flwr-datasets[vision]>=0.5.0",
     "scikit-learn>=1.6.1",
 ]

flwr/cli/new/templates/app/pyproject.tensorflow.toml.tpl

@@ -8,7 +8,7 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.16.0",
+    "flwr[simulation]>=1.17.0",
     "flwr-datasets[vision]>=0.5.0",
     "tensorflow>=2.11.1,<2.18.0",
 ]

flwr/cli/run/run.py

@@ -35,15 +35,11 @@ from flwr.cli.constant import FEDERATION_CONFIG_HELP_MESSAGE
 from flwr.common.config import (
     flatten_dict,
     parse_config_args,
-    user_config_to_configsrecord,
+    user_config_to_configrecord,
 )
 from flwr.common.constant import CliOutputFormat
 from flwr.common.logger import print_json_error, redirect_output, restore_output
-from flwr.common.serde import (
-    configs_record_to_proto,
-    fab_to_proto,
-    user_config_to_proto,
-)
+from flwr.common.serde import config_record_to_proto, fab_to_proto, user_config_to_proto
 from flwr.common.typing import Fab
 from flwr.proto.exec_pb2 import StartRunRequest  # pylint: disable=E0611
 from flwr.proto.exec_pb2_grpc import ExecStub
@@ -171,14 +167,14 @@ def _run_with_exec_api(
 
     fab = Fab(fab_hash, content)
 
-    # Construct a `ConfigsRecord` out of a flattened `UserConfig`
+    # Construct a `ConfigRecord` out of a flattened `UserConfig`
     fed_conf = flatten_dict(federation_config.get("options", {}))
-    c_record = user_config_to_configsrecord(fed_conf)
+    c_record = user_config_to_configrecord(fed_conf)
 
     req = StartRunRequest(
         fab=fab_to_proto(fab),
         override_config=user_config_to_proto(parse_config_args(config_overrides)),
-        federation_options=configs_record_to_proto(c_record),
+        federation_options=config_record_to_proto(c_record),
     )
     with unauthenticated_exc_handler():
         res = stub.StartRun(req)

flwr/client/app.py

@@ -495,8 +495,9 @@ def start_client_internal(
                     context = run_info_store.retrieve_context(run_id=run_id)
                     # Create an error reply message that will never be used to prevent
                     # the used-before-assignment linting error
-                    reply_message = message.create_error_reply(
-                        error=Error(code=ErrorCode.UNKNOWN, reason="Unknown")
+                    reply_message = Message(
+                        Error(code=ErrorCode.UNKNOWN, reason="Unknown"),
+                        reply_to=message,
                     )
 
                     # Handle app loading and task message
@@ -593,8 +594,9 @@ def start_client_internal(
                         log(ERROR, "%s raised an exception", exc_entity, exc_info=ex)
 
                         # Create error message
-                        reply_message = message.create_error_reply(
-                            error=Error(code=e_code, reason=reason)
+                        reply_message = Message(
+                            Error(code=e_code, reason=reason),
+                            reply_to=message,
                         )
                     else:
                         # No exception, update node state

flwr/client/client_app.py

@@ -27,10 +27,13 @@ from flwr.client.message_handler.message_handler import (
 from flwr.client.mod.utils import make_ffn
 from flwr.client.typing import ClientFnExt, Mod
 from flwr.common import Context, Message, MessageType
-from flwr.common.logger import warn_deprecated_feature, warn_preview_feature
+from flwr.common.logger import warn_deprecated_feature
+from flwr.common.message import validate_message_type
 
 from .typing import ClientAppCallable
 
+DEFAULT_ACTION = "default"
+
 
 def _alert_erroneous_client_fn() -> None:
     raise ValueError(
@@ -110,6 +113,7 @@ class ClientApp:
         mods: Optional[list[Mod]] = None,
     ) -> None:
         self._mods: list[Mod] = mods if mods is not None else []
+        self._registered_funcs: dict[str, ClientAppCallable] = {}
 
         # Create wrapper function for `handle`
         self._call: Optional[ClientAppCallable] = None
@@ -129,10 +133,7 @@ class ClientApp:
             # Wrap mods around the wrapped handle function
             self._call = make_ffn(ffn, mods if mods is not None else [])
 
-        # Step functions
-        self._train: Optional[ClientAppCallable] = None
-        self._evaluate: Optional[ClientAppCallable] = None
-        self._query: Optional[ClientAppCallable] = None
+        # Lifespan function
         self._lifespan = _empty_lifespan
 
     def __call__(self, message: Message, context: Context) -> Message:
@@ -142,27 +143,41 @@ class ClientApp:
             if self._call:
                 return self._call(message, context)
 
-            # Execute message using a new
-            if message.metadata.message_type == MessageType.TRAIN:
-                if self._train:
-                    return self._train(message, context)
-                raise ValueError("No `train` function registered")
-            if message.metadata.message_type == MessageType.EVALUATE:
-                if self._evaluate:
-                    return self._evaluate(message, context)
-                raise ValueError("No `evaluate` function registered")
-            if message.metadata.message_type == MessageType.QUERY:
-                if self._query:
-                    return self._query(message, context)
-                raise ValueError("No `query` function registered")
-
-            # Message type did not match one of the known message types abvoe
-            raise ValueError(f"Unknown message_type: {message.metadata.message_type}")
+            # Get the category and the action
+            # A valid message type is of the form "<category>" or "<category>.<action>",
+            # where <category> must be "train"/"evaluate"/"query", and <action> is a
+            # valid Python identifier
+            if not validate_message_type(message.metadata.message_type):
+                raise ValueError(
+                    f"Invalid message type: {message.metadata.message_type}"
+                )
+
+            category, action = message.metadata.message_type, DEFAULT_ACTION
+            if "." in category:
+                category, action = category.split(".")
+
+            # Check if the function is registered
+            if (full_name := f"{category}.{action}") in self._registered_funcs:
+                return self._registered_funcs[full_name](message, context)
+
+            raise ValueError(f"No {category} function registered with name '{action}'")
 
     def train(
-        self, mods: Optional[list[Mod]] = None
+        self, action: str = DEFAULT_ACTION, *, mods: Optional[list[Mod]] = None
     ) -> Callable[[ClientAppCallable], ClientAppCallable]:
-        """Return a decorator that registers the train fn with the client app.
+        """Register a train function with the ``ClientApp``.
+
+        Parameters
+        ----------
+        action : str (default: "default")
+            The action name used to route messages. Defaults to "default".
+        mods : Optional[list[Mod]] (default: None)
+            A list of function-specific modifiers.
+
+        Returns
+        -------
+        Callable[[ClientAppCallable], ClientAppCallable]
+            A decorator that registers a train function with the ``ClientApp``.
 
         Examples
         --------
@@ -172,42 +187,52 @@ class ClientApp:
         >>>
         >>> @app.train()
         >>> def train(message: Message, context: Context) -> Message:
-        >>>    print("ClientApp training running")
-        >>>    # Create and return an echo reply message
-        >>>    return message.create_reply(content=message.content())
+        >>>     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 function-specific modifier:
+        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("ClientApp training running with message size mod")
-        >>>    return message.create_reply(content=message.content())
+        >>>     print("Executing train function with message size mod")
+        >>>     # Create and return an echo reply message
+        >>>     return Message(message.content, reply_to=message)
         """
-
-        def train_decorator(train_fn: ClientAppCallable) -> ClientAppCallable:
-            """Register the train fn with the ServerApp object."""
-            if self._call:
-                raise _registration_error(MessageType.TRAIN)
-
-            warn_preview_feature("ClientApp-register-train-function")
-
-            # Register provided function with the ClientApp object
-            # Wrap mods around the wrapped step function
-            self._train = make_ffn(train_fn, self._mods + (mods or []))
-
-            # Return provided function unmodified
-            return train_fn
-
-        return train_decorator
+        return _get_decorator(self, MessageType.TRAIN, action, mods)
 
     def evaluate(
-        self, mods: Optional[list[Mod]] = None
+        self, action: str = DEFAULT_ACTION, *, mods: Optional[list[Mod]] = None
     ) -> Callable[[ClientAppCallable], ClientAppCallable]:
-        """Return a decorator that registers the evaluate fn with the client app.
+        """Register an evaluate function with the ``ClientApp``.
+
+        Parameters
+        ----------
+        action : str (default: "default")
+            The action name used to route messages. Defaults to "default".
+        mods : Optional[list[Mod]] (default: None)
+            A list of function-specific modifiers.
+
+        Returns
+        -------
+        Callable[[ClientAppCallable], ClientAppCallable]
+            A decorator that registers an evaluate function with the ``ClientApp``.
 
         Examples
         --------
@@ -217,43 +242,52 @@ class ClientApp:
         >>>
         >>> @app.evaluate()
         >>> def evaluate(message: Message, context: Context) -> Message:
-        >>>    print("ClientApp evaluation running")
-        >>>    # Create and return an echo reply message
-        >>>    return message.create_reply(content=message.content())
+        >>>     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 function-specific modifier:
+        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("ClientApp evaluation running with message size mod")
-        >>>    # Create and return an echo reply message
-        >>>    return message.create_reply(content=message.content())
+        >>>     print("Executing evaluate function with message size mod")
+        >>>     # Create and return an echo reply message
+        >>>     return Message(message.content, reply_to=message)
         """
-
-        def evaluate_decorator(evaluate_fn: ClientAppCallable) -> ClientAppCallable:
-            """Register the evaluate fn with the ServerApp object."""
-            if self._call:
-                raise _registration_error(MessageType.EVALUATE)
-
-            warn_preview_feature("ClientApp-register-evaluate-function")
-
-            # Register provided function with the ClientApp object
-            # Wrap mods around the wrapped step function
-            self._evaluate = make_ffn(evaluate_fn, self._mods + (mods or []))
-
-            # Return provided function unmodified
-            return evaluate_fn
-
-        return evaluate_decorator
+        return _get_decorator(self, MessageType.EVALUATE, action, mods)
 
     def query(
-        self, mods: Optional[list[Mod]] = None
+        self, action: str = DEFAULT_ACTION, *, mods: Optional[list[Mod]] = None
     ) -> Callable[[ClientAppCallable], ClientAppCallable]:
-        """Return a decorator that registers the query fn with the client app.
+        """Register a query function with the ``ClientApp``.
+
+        Parameters
+        ----------
+        action : str (default: "default")
+            The action name used to route messages. Defaults to "default".
+        mods : Optional[list[Mod]] (default: None)
+            A list of function-specific modifiers.
+
+        Returns
+        -------
+        Callable[[ClientAppCallable], ClientAppCallable]
+            A decorator that registers a query function with the ``ClientApp``.
 
         Examples
         --------
@@ -263,38 +297,35 @@ class ClientApp:
         >>>
         >>> @app.query()
         >>> def query(message: Message, context: Context) -> Message:
-        >>>    print("ClientApp query running")
-        >>>    # Create and return an echo reply message
-        >>>    return message.create_reply(content=message.content())
+        >>>     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:
 
-        Registering a query function with a function-specific modifier:
+        >>> 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("ClientApp query running with message size mod")
-        >>>    # Create and return an echo reply message
-        >>>    return message.create_reply(content=message.content())
+        >>>     print("Executing query function with message size mod")
+        >>>     # Create and return an echo reply message
+        >>>     return Message(message.content, reply_to=message)
         """
-
-        def query_decorator(query_fn: ClientAppCallable) -> ClientAppCallable:
-            """Register the query fn with the ServerApp object."""
-            if self._call:
-                raise _registration_error(MessageType.QUERY)
-
-            warn_preview_feature("ClientApp-register-query-function")
-
-            # Register provided function with the ClientApp object
-            # Wrap mods around the wrapped step function
-            self._query = make_ffn(query_fn, self._mods + (mods or []))
-
-            # Return provided function unmodified
-            return query_fn
-
-        return query_decorator
+        return _get_decorator(self, MessageType.QUERY, action, mods)
 
     def lifespan(
         self,
@@ -325,7 +356,6 @@ class ClientApp:
             lifespan_fn: Callable[[Context], Iterator[None]]
         ) -> Callable[[Context], Iterator[None]]:
             """Register the lifespan fn with the ServerApp object."""
-            warn_preview_feature("ClientApp-register-lifespan-function")
 
             @contextmanager
             def decorated_lifespan(context: Context) -> Iterator[None]:
@@ -365,6 +395,41 @@ class LoadClientAppError(Exception):
     """Error when trying to load `ClientApp`."""
 
 
+def _get_decorator(
+    app: ClientApp, category: str, action: str, mods: Optional[list[Mod]]
+) -> Callable[[ClientAppCallable], ClientAppCallable]:
+    """Get the decorator for the given category and action."""
+    # pylint: disable=protected-access
+    if app._call:
+        raise _registration_error(category)
+
+    def decorator(fn: ClientAppCallable) -> ClientAppCallable:
+
+        # Check if the name is a valid Python identifier
+        if not action.isidentifier():
+            raise ValueError(
+                f"Cannot register {category} function with name '{action}'. "
+                "The name must follow Python's function naming rules."
+            )
+
+        # Check if the name is already registered
+        full_name = f"{category}.{action}"  # Full name of the message type
+        if full_name in app._registered_funcs:
+            raise ValueError(
+                f"Cannot register {category} function with name '{action}'. "
+                f"A {category} function with the name '{action}' is already registered."
+            )
+
+        # Register provided function with the ClientApp object
+        app._registered_funcs[full_name] = make_ffn(fn, app._mods + (mods or []))
+
+        # Return provided function unmodified
+        return fn
+
+    # pylint: enable=protected-access
+    return decorator
+
+
 def _registration_error(fn_name: str) -> ValueError:
     return ValueError(
         f"""Use either `@app.{fn_name}()` or `client_fn`, but not both.
@@ -389,8 +454,6 @@ def _registration_error(fn_name: str) -> ValueError:
         >>> def {fn_name}(message: Message, context: Context) -> Message:
         >>>    print("ClientApp {fn_name} running")
         >>>    # Create and return an echo reply message
-        >>>    return message.create_reply(
-        >>>        content=message.content()
-        >>>    )
+        >>>    return Message(message.content, reply_to=message)
         """,
     )

flwr/client/clientapp/app.py

@@ -152,8 +152,8 @@ def run_clientapp(  # pylint: disable=R0914
                 log(ERROR, "%s raised an exception", exc_entity, exc_info=ex)
 
                 # Create error message
-                reply_message = message.create_error_reply(
-                    error=Error(code=e_code, reason=reason)
+                reply_message = Message(
+                    Error(code=e_code, reason=reason), reply_to=message
                 )
 
             # Push Message and Context to SuperNode