flwr-nightly 1.19.0.dev20250528__py3-none-any.whl → 1.19.0.dev20250530__py3-none-any.whl

flwr/supercore/object_store/in_memory_object_store.py

@@ -19,7 +19,7 @@ from typing import Optional
 
 from flwr.common.inflatable import get_object_id, is_valid_sha256_hash
 
-from .object_store import ObjectStore
+from .object_store import NoObjectInStoreError, ObjectStore
 
 
 class InMemoryObjectStore(ObjectStore):
@@ -48,7 +48,9 @@ class InMemoryObjectStore(ObjectStore):
         """Put an object into the store."""
         # Only allow adding the object if it has been preregistered
         if object_id not in self.store:
-            raise KeyError(f"Object with id {object_id} was not preregistered.")
+            raise NoObjectInStoreError(
+                f"Object with ID '{object_id}' was not pre-registered."
+            )
 
         # Verify object_id and object_content match
         if self.verify:
@@ -71,6 +73,11 @@ class InMemoryObjectStore(ObjectStore):
 
     def get_message_descendant_ids(self, msg_object_id: str) -> list[str]:
         """Retrieve the object IDs of all descendants of a given Message."""
+        if msg_object_id not in self.msg_children_objects_mapping:
+            raise NoObjectInStoreError(
+                f"No message registered in Object Store with ID '{msg_object_id}'. "
+                "Mapping to descendants could not be found."
+            )
         return self.msg_children_objects_mapping[msg_object_id]
 
     def get(self, object_id: str) -> Optional[bytes]:

flwr/supercore/object_store/object_store.py

@@ -19,6 +19,18 @@ import abc
 from typing import Optional
 
 
+class NoObjectInStoreError(Exception):
+    """Error when trying to access an element in the ObjectStore that does not exist."""
+
+    def __init__(self, message: str):
+        super().__init__(message)
+        self.message = message
+
+    def __str__(self) -> str:
+        """Return formatted exception message string."""
+        return f"NoObjectInStoreError: {self.message}"
+
+
 class ObjectStore(abc.ABC):
     """Abstract base class for `ObjectStore` implementations.
 

flwr/superexec/exec_grpc.py

@@ -21,7 +21,7 @@ from typing import Optional
 import grpc
 
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
-from flwr.common.auth_plugin import ExecAuthPlugin
+from flwr.common.auth_plugin import ExecAuthPlugin, ExecAuthzPlugin
 from flwr.common.event_log_plugin import EventLogWriterPlugin
 from flwr.common.grpc import generic_create_grpc_server
 from flwr.common.logger import log
@@ -45,6 +45,7 @@ def run_exec_api_grpc(
     certificates: Optional[tuple[bytes, bytes, bytes]],
     config: UserConfig,
     auth_plugin: Optional[ExecAuthPlugin] = None,
+    authz_plugin: Optional[ExecAuthzPlugin] = None,
     event_log_plugin: Optional[EventLogWriterPlugin] = None,
 ) -> grpc.Server:
     """Run Exec API (gRPC, request-response)."""
@@ -57,8 +58,8 @@ def run_exec_api_grpc(
         auth_plugin=auth_plugin,
     )
     interceptors: list[grpc.ServerInterceptor] = []
-    if auth_plugin is not None:
-        interceptors.append(ExecUserAuthInterceptor(auth_plugin))
+    if auth_plugin is not None and authz_plugin is not None:
+        interceptors.append(ExecUserAuthInterceptor(auth_plugin, authz_plugin))
     # Event log interceptor must be added after user auth interceptor
     if event_log_plugin is not None:
         interceptors.append(ExecEventLogInterceptor(event_log_plugin))

flwr/superexec/exec_user_auth_interceptor.py

@@ -16,11 +16,11 @@
 
 
 import contextvars
-from typing import Any, Callable, Union, cast
+from typing import Any, Callable, Union
 
 import grpc
 
-from flwr.common.auth_plugin import ExecAuthPlugin
+from flwr.common.auth_plugin import ExecAuthPlugin, ExecAuthzPlugin
 from flwr.common.typing import UserInfo
 from flwr.proto.exec_pb2 import (  # pylint: disable=E0611
     GetAuthTokensRequest,
@@ -56,8 +56,10 @@ class ExecUserAuthInterceptor(grpc.ServerInterceptor):  # type: ignore
     def __init__(
         self,
         auth_plugin: ExecAuthPlugin,
+        authz_plugin: ExecAuthzPlugin,
     ):
         self.auth_plugin = auth_plugin
+        self.authz_plugin = authz_plugin
 
     def intercept_service(
         self,
@@ -95,13 +97,40 @@ class ExecUserAuthInterceptor(grpc.ServerInterceptor):  # type: ignore
                 metadata
             )
             if valid_tokens:
+                if user_info is None:
+                    context.abort(
+                        grpc.StatusCode.UNAUTHENTICATED,
+                        "Tokens validated, but user info not found",
+                    )
+                    raise grpc.RpcError()
                 # Store user info in contextvars for authenticated users
-                shared_user_info.set(cast(UserInfo, user_info))
+                shared_user_info.set(user_info)
+                # Check if the user is authorized
+                if not self.authz_plugin.verify_user_authorization(user_info):
+                    context.abort(
+                        grpc.StatusCode.PERMISSION_DENIED, "User not authorized"
+                    )
+                    raise grpc.RpcError()
                 return call(request, context)  # type: ignore
 
             # If the user is not authenticated, refresh tokens
-            tokens = self.auth_plugin.refresh_tokens(context.invocation_metadata())
+            tokens, user_info = self.auth_plugin.refresh_tokens(metadata)
             if tokens is not None:
+                if user_info is None:
+                    context.abort(
+                        grpc.StatusCode.UNAUTHENTICATED,
+                        "Tokens refreshed, but user info not found",
+                    )
+                    raise grpc.RpcError()
+                # Store user info in contextvars for authenticated users
+                shared_user_info.set(user_info)
+                # Check if the user is authorized
+                if not self.authz_plugin.verify_user_authorization(user_info):
+                    context.abort(
+                        grpc.StatusCode.PERMISSION_DENIED, "User not authorized"
+                    )
+                    raise grpc.RpcError()
+
                 context.send_initial_metadata(tokens)
                 return call(request, context)  # type: ignore
 

flwr/supernode/start_client_internal.py

@@ -40,7 +40,6 @@ from flwr.client.clientapp.clientappio_servicer import (
 )
 from flwr.client.grpc_adapter_client.connection import grpc_adapter
 from flwr.client.grpc_rere_client.connection import grpc_request_response
-from flwr.client.message_handler.message_handler import handle_control_message
 from flwr.client.run_info_store import DeprecatedRunInfoStore
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH, Message
 from flwr.common.address import parse_address
@@ -151,186 +150,161 @@ def start_client_internal(
 
     runs: dict[int, Run] = {}
 
-    while True:
-        sleep_duration: int = 0
-        with _init_connection(
-            transport=transport,
-            server_address=server_address,
-            insecure=insecure,
-            root_certificates=root_certificates,
-            authentication_keys=authentication_keys,
-            max_retries=max_retries,
-            max_wait_time=max_wait_time,
-        ) as conn:
-            receive, send, create_node, delete_node, get_run, get_fab = conn
-
-            # Register node when connecting the first time
-            if run_info_store is None:
-                # Call create_node fn to register node
-                # and store node_id in state
-                if (node_id := create_node()) is None:
-                    raise ValueError("Failed to register SuperNode with the SuperLink")
-                state.set_node_id(node_id)
-                run_info_store = DeprecatedRunInfoStore(
-                    node_id=state.get_node_id(),
-                    node_config=node_config,
-                )
+    with _init_connection(
+        transport=transport,
+        server_address=server_address,
+        insecure=insecure,
+        root_certificates=root_certificates,
+        authentication_keys=authentication_keys,
+        max_retries=max_retries,
+        max_wait_time=max_wait_time,
+    ) as conn:
+        receive, send, create_node, _, get_run, get_fab = conn
+
+        # Register node when connecting the first time
+        if run_info_store is None:
+            # Call create_node fn to register node
+            # and store node_id in state
+            if (node_id := create_node()) is None:
+                raise ValueError("Failed to register SuperNode with the SuperLink")
+            state.set_node_id(node_id)
+            run_info_store = DeprecatedRunInfoStore(
+                node_id=state.get_node_id(),
+                node_config=node_config,
+            )
 
-            # pylint: disable=too-many-nested-blocks
-            while True:
-                try:
-                    # Receive
-                    message = receive()
-                    if message is None:
-                        time.sleep(3)  # Wait for 3s before asking again
-                        continue
-
-                    log(INFO, "")
-                    if len(message.metadata.group_id) > 0:
-                        log(
-                            INFO,
-                            "[RUN %s, ROUND %s]",
-                            message.metadata.run_id,
-                            message.metadata.group_id,
-                        )
+        # pylint: disable=too-many-nested-blocks
+        while True:
+            try:
+                # Receive
+                message = receive()
+                if message is None:
+                    time.sleep(3)  # Wait for 3s before asking again
+                    continue
+
+                log(INFO, "")
+                if len(message.metadata.group_id) > 0:
                     log(
                         INFO,
-                        "Received: %s message %s",
-                        message.metadata.message_type,
-                        message.metadata.message_id,
+                        "[RUN %s, ROUND %s]",
+                        message.metadata.run_id,
+                        message.metadata.group_id,
                     )
+                log(
+                    INFO,
+                    "Received: %s message %s",
+                    message.metadata.message_type,
+                    message.metadata.message_id,
+                )
 
-                    # Handle control message
-                    out_message, sleep_duration = handle_control_message(message)
-                    if out_message:
-                        send(out_message)
-                        break
-
-                    # Get run info
-                    run_id = message.metadata.run_id
-                    if run_id not in runs:
-                        runs[run_id] = get_run(run_id)
-
-                    run: Run = runs[run_id]
-                    if get_fab is not None and run.fab_hash:
-                        fab = get_fab(run.fab_hash, run_id)
-                        fab_id, fab_version = get_fab_metadata(fab.content)
-                    else:
-                        fab = None
-                        fab_id, fab_version = run.fab_id, run.fab_version
-
-                    run.fab_id, run.fab_version = fab_id, fab_version
-
-                    # Register context for this run
-                    run_info_store.register_context(
-                        run_id=run_id,
-                        run=run,
-                        flwr_path=flwr_path,
-                        fab=fab,
-                    )
+                # Get run info
+                run_id = message.metadata.run_id
+                if run_id not in runs:
+                    runs[run_id] = get_run(run_id)
+
+                run: Run = runs[run_id]
+                if get_fab is not None and run.fab_hash:
+                    fab = get_fab(run.fab_hash, run_id)
+                    fab_id, fab_version = get_fab_metadata(fab.content)
+                else:
+                    fab = None
+                    fab_id, fab_version = run.fab_id, run.fab_version
+
+                run.fab_id, run.fab_version = fab_id, fab_version
+
+                # Register context for this run
+                run_info_store.register_context(
+                    run_id=run_id,
+                    run=run,
+                    flwr_path=flwr_path,
+                    fab=fab,
+                )
 
-                    # Retrieve context for this run
-                    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(
-                        Error(code=ErrorCode.UNKNOWN, reason="Unknown"),
-                        reply_to=message,
-                    )
+                # Retrieve context for this run
+                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(
+                    Error(code=ErrorCode.UNKNOWN, reason="Unknown"),
+                    reply_to=message,
+                )
 
-                    # Two isolation modes:
-                    # 1. `subprocess`: SuperNode is starting the ClientApp
-                    #    process as a subprocess.
-                    # 2. `process`: ClientApp process gets started separately
-                    #    (via `flwr-clientapp`), for example, in a separate
-                    #    Docker container.
-
-                    # Generate SuperNode token
-                    token = int.from_bytes(urandom(RUN_ID_NUM_BYTES), "little")
-
-                    # Mode 1: SuperNode starts ClientApp as subprocess
-                    start_subprocess = isolation == ISOLATION_MODE_SUBPROCESS
-
-                    # Share Message and Context with servicer
-                    clientappio_servicer.set_inputs(
-                        clientapp_input=ClientAppInputs(
-                            message=message,
-                            context=context,
-                            run=run,
-                            fab=fab,
-                            token=token,
-                        ),
-                        token_returned=start_subprocess,
-                    )
+                # Two isolation modes:
+                # 1. `subprocess`: SuperNode is starting the ClientApp
+                #    process as a subprocess.
+                # 2. `process`: ClientApp process gets started separately
+                #    (via `flwr-clientapp`), for example, in a separate
+                #    Docker container.
 
-                    if start_subprocess:
-                        _octet, _colon, _port = clientappio_api_address.rpartition(":")
-                        io_address = (
-                            f"{CLIENT_OCTET}:{_port}"
-                            if _octet == SERVER_OCTET
-                            else clientappio_api_address
-                        )
-                        # Start ClientApp subprocess
-                        command = [
-                            "flwr-clientapp",
-                            "--clientappio-api-address",
-                            io_address,
-                            "--token",
-                            str(token),
-                        ]
-                        command.append("--insecure")
-
-                        proc = mp_spawn_context.Process(
-                            target=_run_flwr_clientapp,
-                            args=(command, os.getpid()),
-                            daemon=True,
-                        )
-                        proc.start()
-                        proc.join()
-                    else:
-                        # Wait for output to become available
-                        while not clientappio_servicer.has_outputs():
-                            time.sleep(0.1)
-
-                    outputs = clientappio_servicer.get_outputs()
-                    reply_message, context = outputs.message, outputs.context
-
-                    # Update node state
-                    run_info_store.update_context(
-                        run_id=run_id,
-                        context=context,
-                    )
+                # Generate SuperNode token
+                token = int.from_bytes(urandom(RUN_ID_NUM_BYTES), "little")
 
-                    # Send
-                    send(reply_message)
-                    log(INFO, "Sent reply")
+                # Mode 1: SuperNode starts ClientApp as subprocess
+                start_subprocess = isolation == ISOLATION_MODE_SUBPROCESS
 
-                except RunNotRunningException:
-                    log(INFO, "")
-                    log(
-                        INFO,
-                        "SuperNode aborted sending the reply message. "
-                        "Run ID %s is not in `RUNNING` status.",
-                        run_id,
+                # Share Message and Context with servicer
+                clientappio_servicer.set_inputs(
+                    clientapp_input=ClientAppInputs(
+                        message=message,
+                        context=context,
+                        run=run,
+                        fab=fab,
+                        token=token,
+                    ),
+                    token_returned=start_subprocess,
+                )
+
+                if start_subprocess:
+                    _octet, _colon, _port = clientappio_api_address.rpartition(":")
+                    io_address = (
+                        f"{CLIENT_OCTET}:{_port}"
+                        if _octet == SERVER_OCTET
+                        else clientappio_api_address
                     )
-                    log(INFO, "")
-            # pylint: enable=too-many-nested-blocks
-
-            # Unregister node
-            if delete_node is not None:
-                delete_node()  # pylint: disable=not-callable
-
-        if sleep_duration == 0:
-            log(INFO, "Disconnect and shut down")
-            break
-
-        # Sleep and reconnect afterwards
-        log(
-            INFO,
-            "Disconnect, then re-establish connection after %s second(s)",
-            sleep_duration,
-        )
-        time.sleep(sleep_duration)
+                    # Start ClientApp subprocess
+                    command = [
+                        "flwr-clientapp",
+                        "--clientappio-api-address",
+                        io_address,
+                        "--token",
+                        str(token),
+                    ]
+                    command.append("--insecure")
+
+                    proc = mp_spawn_context.Process(
+                        target=_run_flwr_clientapp,
+                        args=(command, os.getpid()),
+                        daemon=True,
+                    )
+                    proc.start()
+                    proc.join()
+                else:
+                    # Wait for output to become available
+                    while not clientappio_servicer.has_outputs():
+                        time.sleep(0.1)
+
+                outputs = clientappio_servicer.get_outputs()
+                reply_message, context = outputs.message, outputs.context
+
+                # Update node state
+                run_info_store.update_context(
+                    run_id=run_id,
+                    context=context,
+                )
+
+                # Send
+                send(reply_message)
+                log(INFO, "Sent reply")
+
+            except RunNotRunningException:
+                log(INFO, "")
+                log(
+                    INFO,
+                    "SuperNode aborted sending the reply message. "
+                    "Run ID %s is not in `RUNNING` status.",
+                    run_id,
+                )
+                log(INFO, "")
 
 
 @contextmanager

{flwr_nightly-1.19.0.dev20250528.dist-info → flwr_nightly-1.19.0.dev20250530.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.19.0.dev20250528
+Version: 1.19.0.dev20250530
 Summary: Flower: A Friendly Federated AI Framework
 License: Apache-2.0
 Keywords: Artificial Intelligence,Federated AI,Federated Analytics,Federated Evaluation,Federated Learning,Flower,Machine Learning