flwr-nightly 1.17.0.dev20250314__py3-none-any.whl → 1.17.0.dev20250316__py3-none-any.whl

flwr/client/client_app.py

@@ -28,9 +28,12 @@ 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.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.create_reply(content=message.content)
+
+        Registering a train function with a custom action name:
 
-        Registering a train function with a function-specific modifier:
+        >>> 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.create_reply(content=message.content)
+
+        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.create_reply(content=message.content)
         """
-
-        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.create_reply(content=message.content)
+
+        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.create_reply(content=message.content)
 
-        Registering an evaluate function with a function-specific modifier:
+        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.create_reply(content=message.content)
         """
-
-        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.create_reply(content=message.content)
 
-        Registering a query function with a function-specific modifier:
+        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.create_reply(content=message.content)
+
+        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.create_reply(content=message.content)
         """
-
-        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,
@@ -365,6 +396,42 @@ 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:
+        warn_preview_feature(f"ClientApp-register-{category}-function")
+
+        # 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.

flwr/common/constant.py

@@ -127,6 +127,7 @@ class MessageType:
     TRAIN = "train"
     EVALUATE = "evaluate"
     QUERY = "query"
+    SYSTEM = "system"
 
     def __new__(cls) -> MessageType:
         """Prevent instantiation."""

flwr/common/message.py

@@ -21,7 +21,7 @@ import time
 from logging import WARNING
 from typing import Optional, cast
 
-from .constant import MESSAGE_TTL_TOLERANCE
+from .constant import MESSAGE_TTL_TOLERANCE, MessageType, MessageTypeLegacy
 from .logger import log
 from .record import RecordSet
 
@@ -75,6 +75,7 @@ class Metadata:  # pylint: disable=too-many-instance-attributes
             "_message_type": message_type,
         }
         self.__dict__.update(var_dict)
+        self.message_type = message_type  # Trigger validation
 
     @property
     def run_id(self) -> int:
@@ -154,6 +155,17 @@ class Metadata:  # pylint: disable=too-many-instance-attributes
     @message_type.setter
     def message_type(self, value: str) -> None:
         """Set message_type."""
+        # Validate message type
+        if validate_legacy_message_type(value):
+            pass  # Backward compatibility for legacy message types
+        elif not validate_message_type(value):
+            raise ValueError(
+                f"Invalid message type: '{value}'. "
+                "Expected format: '<category>' or '<category>.<action>', "
+                "where <category> must be 'train', 'evaluate', or 'query', "
+                "and <action> must be a valid Python identifier."
+            )
+
         self.__dict__["_message_type"] = value
 
     def __repr__(self) -> str:
@@ -417,3 +429,48 @@ def _create_reply_metadata(msg: Message, ttl: float) -> Metadata:
         ttl=ttl,
         message_type=msg.metadata.message_type,
     )
+
+
+def validate_message_type(message_type: str) -> bool:
+    """Validate if the message type is valid.
+
+    A valid message type format must be one of the following:
+
+    - "<category>"
+    - "<category>.<action>"
+
+    where `category` must be one of "train", "evaluate", or "query",
+    and `action` must be a valid Python identifier.
+    """
+    # Check if conforming to the format "<category>"
+    valid_types = {
+        MessageType.TRAIN,
+        MessageType.EVALUATE,
+        MessageType.QUERY,
+        MessageType.SYSTEM,
+    }
+    if message_type in valid_types:
+        return True
+
+    # Check if conforming to the format "<category>.<action>"
+    if message_type.count(".") != 1:
+        return False
+
+    category, action = message_type.split(".")
+    if category in valid_types and action.isidentifier():
+        return True
+
+    return False
+
+
+def validate_legacy_message_type(message_type: str) -> bool:
+    """Validate if the legacy message type is valid."""
+    # Backward compatibility for legacy message types
+    if message_type in (
+        MessageTypeLegacy.GET_PARAMETERS,
+        MessageTypeLegacy.GET_PROPERTIES,
+        "reconnect",
+    ):
+        return True
+
+    return False

flwr/server/superlink/linkstate/utils.py

@@ -20,7 +20,13 @@ from typing import Optional
 from uuid import UUID, uuid4
 
 from flwr.common import ConfigsRecord, Context, Error, Message, Metadata, now, serde
-from flwr.common.constant import SUPERLINK_NODE_ID, ErrorCode, Status, SubStatus
+from flwr.common.constant import (
+    SUPERLINK_NODE_ID,
+    ErrorCode,
+    MessageType,
+    Status,
+    SubStatus,
+)
 from flwr.common.typing import RunStatus
 
 # pylint: disable=E0611
@@ -266,7 +272,7 @@ def create_message_error_unavailable_ins_message(reply_to_message: UUID) -> Mess
         dst_node_id=SUPERLINK_NODE_ID,
         reply_to_message=str(reply_to_message),
         group_id="",  # Unknown
-        message_type="",  # Unknown
+        message_type=MessageType.SYSTEM,
         ttl=0,
     )
 

{flwr_nightly-1.17.0.dev20250314.dist-info → flwr_nightly-1.17.0.dev20250316.dist-info}/METADATA

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

{flwr_nightly-1.17.0.dev20250314.dist-info → flwr_nightly-1.17.0.dev20250316.dist-info}/RECORD

@@ -74,7 +74,7 @@ flwr/cli/utils.py,sha256=D9XcpxzwkGPNdwX16o0kI-sYnRDMlWYyKNIpz6npRhQ,11236
 flwr/client/__init__.py,sha256=DGDoO0AEAfz-0CUFmLdyUUweAS64-07AOnmDfWUefK4,1192
 flwr/client/app.py,sha256=tNnef5wGVfqMiiGiWzAuULyy1QpvCKukiRmNi_a2cQc,34261
 flwr/client/client.py,sha256=8o58nd9o6ZFcMIaVYPGcV4MSjBG4H0oFgWiv8ZEO3oA,7895
-flwr/client/client_app.py,sha256=mRj5AXokCV9WYivgkNEdBPUHXjNr_ZOQ50Dou0REhkw,14481
+flwr/client/client_app.py,sha256=8PpAlN7KT8oNFBFVWbGGi39Zw-fhKBZYLGAs4s1aMdY,17312
 flwr/client/clientapp/__init__.py,sha256=kZqChGnTChQ1WGSUkIlW2S5bc0d0mzDubCAmZUGRpEY,800
 flwr/client/clientapp/app.py,sha256=B3GrIMP8BMvltYf4n4xbtlRR1jEPT5-F93KnBCPuPJM,9069
 flwr/client/clientapp/clientappio_servicer.py,sha256=5L6bjw_j3Mnx9kRFwYwxDNABKurBO5q1jZOWE_X11wQ,8522
@@ -116,7 +116,7 @@ flwr/common/args.py,sha256=2gGT2a3SPJ0-LTNKnhBsZ-ESIoW9FGpw-9xkUSs8qwk,5417
 flwr/common/auth_plugin/__init__.py,sha256=1Y8Oj3iB49IHDu9tvDih1J74Ygu7k85V9s2A4WORPyA,887
 flwr/common/auth_plugin/auth_plugin.py,sha256=dQU5U4uJIA5XqgOJ3PankHWq-uXCaMvO74khaMPGdiU,3938
 flwr/common/config.py,sha256=SAkG3BztnA6iupXxF3GAIpGmWVVCH0ptyMpC9yjr_14,13965
-flwr/common/constant.py,sha256=lAnqe63ZzW0NcS306rnEVICpJSXCFNoPj4L1X-p0FCA,6853
+flwr/common/constant.py,sha256=2AHf9ujmfkf9YerhtqBe8hAW6iMDJTmnKnyYdlEXEM0,6875
 flwr/common/context.py,sha256=uJ-mnoC_8y_udEb3kAX-r8CPphNTWM72z1AlsvQEu54,2403
 flwr/common/date.py,sha256=NHHpESce5wYqEwoDXf09gp9U9l_5Bmlh2BsOcwS-kDM,1554
 flwr/common/differential_privacy.py,sha256=YA01NqjddKNAEVmf7hXmOVxOjhekgzvJudk3mBGq-2k,6148
@@ -130,7 +130,7 @@ flwr/common/exit/exit_code.py,sha256=PNEnCrZfOILjfDAFu5m-2YWEJBrk97xglq4zCUlqV7E
 flwr/common/exit_handlers.py,sha256=yclujry30954o0lI7vtknTajskPCvK8TXw2V3RdldXU,3174
 flwr/common/grpc.py,sha256=7sHNP34LcNZv7J1GewJxXh509XTEbYvoHvXL5tQ3tcw,9798
 flwr/common/logger.py,sha256=Hund1C6bEhMw3GemlzuFK22tXZ27YeHLrFB0b4LP5f8,13041
-flwr/common/message.py,sha256=rWH_JIPnIo263-pC6Ps6XWmIgakRJA_AMBYwhE0qHcQ,14251
+flwr/common/message.py,sha256=dbaIKvw1hJZrLpipbdX6hUw1nhzrxDMXCS7EADQUwE8,16060
 flwr/common/object_ref.py,sha256=DXL8NtbN17DSYaR-Zc8WYhaG8rv0_D_cclvP7Sa66So,9134
 flwr/common/parameter.py,sha256=-bFAUayToYDF50FZGrBC1hQYJCQDtB2bbr3ZuVLMtdE,2095
 flwr/common/pyproject.py,sha256=vEAxl800XiJ1JNJDui8vuVV-08msnB6hLt7o95viZl0,1386
@@ -293,7 +293,7 @@ flwr/server/superlink/linkstate/in_memory_linkstate.py,sha256=Ss64nq7MgbHwx4LOER
 flwr/server/superlink/linkstate/linkstate.py,sha256=YB3SryGNvt-bE-unYjoloJt9d3xAUPBNLK4mor8gk3M,11851
 flwr/server/superlink/linkstate/linkstate_factory.py,sha256=ISSMjDlwuN7swxjOeYlTNpI_kuZ8PGkMcJnf1dbhUSE,2069
 flwr/server/superlink/linkstate/sqlite_linkstate.py,sha256=Wsx5gD6WRIMLlKarvVV1_dlS7jmfno-yTVW1-rgcIto,38276
-flwr/server/superlink/linkstate/utils.py,sha256=UunwphV90p9XzvGFJpZr3C64HgIyXjhRPNBVS3HSL8M,12696
+flwr/server/superlink/linkstate/utils.py,sha256=b26MJdMQyt83EDnhB7FAiq8BFttV_qNHF_E_3d3oBlA,12739
 flwr/server/superlink/simulation/__init__.py,sha256=mg-oapC9dkzEfjXPQFior5lpWj4g9kwbLovptyYM_g0,718
 flwr/server/superlink/simulation/simulationio_grpc.py,sha256=8aUrZZLdvprKUfLLqFID4aItus9beU6m1qLQYIPB7k0,2224
 flwr/server/superlink/simulation/simulationio_servicer.py,sha256=J_TmdqM-Bxgp-iPEI3tvCuBpykw1UX0FouMQalEYAF4,6907
@@ -326,8 +326,8 @@ flwr/superexec/exec_servicer.py,sha256=4UpzJqPUHkBG2PZNe2lrX7XFVDOL6yw_HcoBHxuXE
 flwr/superexec/exec_user_auth_interceptor.py,sha256=2kXjjJcrZyff893QTFLQD6zxC4pdVwtN4Rc66jHptfE,4440
 flwr/superexec/executor.py,sha256=_B55WW2TD1fBINpabSSDRenVHXYmvlfhv-k8hJKU4lQ,3115
 flwr/superexec/simulation.py,sha256=WQDon15oqpMopAZnwRZoTICYCfHqtkvFSqiTQ2hLD_g,4088
-flwr_nightly-1.17.0.dev20250314.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-flwr_nightly-1.17.0.dev20250314.dist-info/METADATA,sha256=PsL8Jgg_8fxGXcMbpUmfL8DJpXTNmAh2d0N97QtQYqE,15877
-flwr_nightly-1.17.0.dev20250314.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-flwr_nightly-1.17.0.dev20250314.dist-info/entry_points.txt,sha256=2-1L-GNKhwGw2_7_RoH55vHw2SIHjdAQy3HAVAWl9PY,374
-flwr_nightly-1.17.0.dev20250314.dist-info/RECORD,,
+flwr_nightly-1.17.0.dev20250316.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+flwr_nightly-1.17.0.dev20250316.dist-info/METADATA,sha256=TnKc9Jev3kwItLFLia2uS8FGkO_wKw1BrR0maimYi3Y,15877
+flwr_nightly-1.17.0.dev20250316.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+flwr_nightly-1.17.0.dev20250316.dist-info/entry_points.txt,sha256=2-1L-GNKhwGw2_7_RoH55vHw2SIHjdAQy3HAVAWl9PY,374
+flwr_nightly-1.17.0.dev20250316.dist-info/RECORD,,