syft-flwr 0.1.7__py3-none-any.whl → 0.2.0__py3-none-any.whl

syft_flwr/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.7"
+__version__ = "0.2.0"
 
 from syft_flwr.bootstrap import bootstrap
 from syft_flwr.run import run

syft_flwr/consts.py

@@ -0,0 +1,2 @@
+# Environment variable to control encryption
+SYFT_FLWR_ENCRYPTION_ENABLED = "SYFT_FLWR_ENCRYPTION_ENABLED"

syft_flwr/flower_client.py

@@ -1,3 +1,4 @@
+import base64
 import sys
 import traceback
 
@@ -8,85 +9,175 @@ from flwr.common.message import Error, Message
 from loguru import logger
 from syft_event import SyftEvents
 from syft_event.types import Request
+from typing_extensions import Optional, Union
 
 from syft_flwr.flwr_compatibility import RecordDict, create_flwr_message
 from syft_flwr.serde import bytes_to_flower_message, flower_message_to_bytes
+from syft_flwr.utils import setup_client
 
 
-def _handle_normal_message(
-    message: Message, client_app: ClientApp, context: Context
-) -> bytes:
-    # Normal message handling
-    logger.info(f"Receive message with metadata: {message.metadata}")
-    reply_message: Message = client_app(message=message, context=context)
-    res_bytes: bytes = flower_message_to_bytes(reply_message)
-    logger.info(f"Reply message size: {len(res_bytes)/2**20} MB")
-    return res_bytes
-
-
-def _create_error_reply(message: Message, error: Error) -> bytes:
-    """Create and return error reply message in bytes."""
-    error_reply: Message = create_flwr_message(
-        content=RecordDict(),
-        reply_to=message,
-        message_type=message.metadata.message_type,
-        src_node_id=message.metadata.dst_node_id,
-        dst_node_id=message.metadata.src_node_id,
-        group_id=message.metadata.group_id,
-        run_id=message.metadata.run_id,
-        error=error,
-    )
-    error_bytes: bytes = flower_message_to_bytes(error_reply)
-    logger.info(f"Error reply message size: {len(error_bytes)/2**20} MB")
-    return error_bytes
+class MessageHandler:
+    """Handles message processing for Flower client."""
 
+    def __init__(
+        self, client_app: ClientApp, context: Context, encryption_enabled: bool
+    ):
+        self.client_app = client_app
+        self.context = context
+        self.encryption_enabled = encryption_enabled
 
-def syftbox_flwr_client(client_app: ClientApp, context: Context, app_name: str):
-    """Run the Flower ClientApp with SyftBox."""
-    syft_flwr_app_name = f"flwr/{app_name}"
-    box = SyftEvents(syft_flwr_app_name)
-    client_email = box.client.email
-    logger.info(f"Started SyftBox Flower Client on: {client_email}")
-    logger.info(f"syft_flwr app name: {syft_flwr_app_name}")
+    def prepare_reply(self, data: bytes) -> Union[str, bytes]:
+        """Prepare reply data based on encryption setting."""
+        if self.encryption_enabled:
+            logger.info(f"🔒 Preparing ENCRYPTED reply, size: {len(data)/2**20:.2f} MB")
+            return base64.b64encode(data).decode("utf-8")
+        else:
+            logger.info(f"📤 Preparing PLAINTEXT reply, size: {len(data)/2**20:.2f} MB")
+            return data
+
+    def process_message(self, message: Message) -> Union[str, bytes]:
+        """Process normal Flower message and return reply."""
+        logger.info(f"Processing message with metadata: {message.metadata}")
+        reply_message = self.client_app(message=message, context=self.context)
+        reply_bytes = flower_message_to_bytes(reply_message)
+        return self.prepare_reply(reply_bytes)
+
+    def create_error_reply(
+        self, message: Optional[Message], error: Error
+    ) -> Union[str, bytes]:
+        """Create error reply message."""
+        error_reply = create_flwr_message(
+            content=RecordDict(),
+            reply_to=message,
+            message_type=message.metadata.message_type if message else MessageType.TASK,
+            src_node_id=message.metadata.dst_node_id if message else 0,
+            dst_node_id=message.metadata.src_node_id if message else 0,
+            group_id=message.metadata.group_id if message else "",
+            run_id=message.metadata.run_id if message else 0,
+            error=error,
+        )
+        error_bytes = flower_message_to_bytes(error_reply)
+        logger.info(f"Error reply size: {len(error_bytes)/2**20:.2f} MB")
+        return self.prepare_reply(error_bytes)
+
+
+class RequestProcessor:
+    """Processes incoming requests and handles encryption/decryption."""
+
+    def __init__(
+        self, message_handler: MessageHandler, box: SyftEvents, client_email: str
+    ):
+        self.message_handler = message_handler
+        self.box = box
+        self.client_email = client_email
+
+    def decode_request_body(self, request_body: Union[bytes, str]) -> bytes:
+        """Decode request body, handling base64 if encrypted."""
+        if not self.message_handler.encryption_enabled:
+            return request_body
+
+        try:
+            # Convert to string if bytes
+            if isinstance(request_body, bytes):
+                request_body_str = request_body.decode("utf-8")
+            else:
+                request_body_str = request_body
+            # Decode base64
+            decoded = base64.b64decode(request_body_str)
+            logger.debug("🔓 Decoded base64 message")
+            return decoded
+        except Exception:
+            # Not base64 or decoding failed, use as-is
+            return request_body
+
+    def is_stop_signal(self, message: Message) -> bool:
+        """Check if message is a stop signal."""
+        if message.metadata.message_type != MessageType.SYSTEM:
+            return False
+
+        # Check for stop action in config
+        if "config" in message.content and "action" in message.content["config"]:
+            return message.content["config"]["action"] == "stop"
+
+        # Alternative stop signal format
+        return message.metadata.group_id == "final"
+
+    def process(self, request: Request) -> Optional[Union[str, bytes]]:
+        """Process incoming request and return response."""
+        original_sender = request.headers.get("X-Syft-Original-Sender", "unknown")
+        encryption_status = (
+            "🔐 ENCRYPTED"
+            if self.message_handler.encryption_enabled
+            else "📥 PLAINTEXT"
+        )
 
-    @box.on_request("/messages")
-    def handle_messages(request: Request) -> None:
         logger.info(
-            f"Received request id: {request.id}, size: {len(request.body) / 1024 / 1024} (MB)"
+            f"{encryption_status} Received request from {original_sender}, "
+            f"id: {request.id}, size: {len(request.body) / 1024 / 1024:.2f} MB"
         )
-        message: Message = bytes_to_flower_message(request.body)
+
+        # Parse message
         try:
-            # Handle stop signal
-            if message.metadata.message_type == MessageType.SYSTEM:
-                # Check for stop action in various possible formats
-                is_stop_signal = False
-                if (
-                    "config" in message.content
-                    and "action" in message.content["config"]
-                ):
-                    is_stop_signal = message.content["config"]["action"] == "stop"
-                elif message.metadata.group_id == "final":
-                    # Alternative stop signal format
-                    is_stop_signal = True
-
-                if is_stop_signal:
-                    logger.info(f"Received stop message: {message}")
-                    box._stop_event.set()
-                    return None
-
-            return _handle_normal_message(message, client_app, context)
+            request_body = self.decode_request_body(request.body)
+            message = bytes_to_flower_message(request_body)
+
+            if self.message_handler.encryption_enabled:
+                logger.debug(
+                    f"🔓 Successfully decrypted message from {original_sender}"
+                )
+        except Exception as e:
+            logger.error(
+                f"❌ Failed to deserialize message from {original_sender}: {e}"
+            )
+            error = Error(
+                code=ErrorCode.CLIENT_APP_RAISED_EXCEPTION,
+                reason=f"Message deserialization failed: {e}",
+            )
+            return self.message_handler.create_error_reply(None, error)
+
+        # Handle message
+        try:
+            # Check for stop signal
+            if self.is_stop_signal(message):
+                logger.info("Received stop signal")
+                self.box._stop_event.set()
+                return None
+
+            # Process normal message
+            return self.message_handler.process_message(message)
 
         except Exception as e:
-            error_traceback = traceback.format_exc()
-            error_message = f"Client: '{client_email}'. Error: {str(e)}. Traceback: {error_traceback}"
+            error_message = f"Client: '{self.client_email}'. Error: {str(e)}. Traceback: {traceback.format_exc()}"
             logger.error(error_message)
 
             error = Error(
                 code=ErrorCode.CLIENT_APP_RAISED_EXCEPTION, reason=error_message
             )
-            box._stop_event.set()
-            return _create_error_reply(message, error)
+            self.box._stop_event.set()
+            return self.message_handler.create_error_reply(message, error)
+
+
+def syftbox_flwr_client(client_app: ClientApp, context: Context, app_name: str):
+    """Run the Flower ClientApp with SyftBox."""
+    # Setup
+    client, encryption_enabled, syft_flwr_app_name = setup_client(app_name)
+    box = SyftEvents(app_name=syft_flwr_app_name, client=client)
+
+    logger.info(f"Started SyftBox Flower Client on: {box.client.email}")
+    logger.info(f"syft_flwr app name: {syft_flwr_app_name}")
+
+    # Create handlers
+    message_handler = MessageHandler(client_app, context, encryption_enabled)
+    processor = RequestProcessor(message_handler, box, box.client.email)
+
+    # Register message handler
+    @box.on_request(
+        "/messages", auto_decrypt=encryption_enabled, encrypt_reply=encryption_enabled
+    )
+    def handle_messages(request: Request) -> Optional[Union[str, bytes]]:
+        return processor.process(request)
 
+    # Run
     try:
         box.run_forever()
     except Exception as e:

syft_flwr/flower_server.py

@@ -1,12 +1,13 @@
 import traceback
 from random import randint
 
-from loguru import logger
-
 from flwr.common import Context
 from flwr.server import ServerApp
 from flwr.server.run_serverapp import run as run_server
+from loguru import logger
+
 from syft_flwr.grid import SyftGrid
+from syft_flwr.utils import setup_client
 
 
 def syftbox_flwr_server(
@@ -16,10 +17,17 @@ def syftbox_flwr_server(
     app_name: str,
 ) -> Context:
     """Run the Flower ServerApp with SyftBox."""
-    syft_flwr_app_name = f"flwr/{app_name}"
-    syft_grid = SyftGrid(app_name=syft_flwr_app_name, datasites=datasites)
+    client, _, syft_flwr_app_name = setup_client(app_name)
+
+    # Construct the SyftGrid
+    syft_grid = SyftGrid(
+        app_name=syft_flwr_app_name, datasites=datasites, client=client
+    )
+
+    # Set the run id (random for now)
     run_id = randint(0, 1000)
     syft_grid.set_run(run_id)
+
     logger.info(f"Started SyftBox Flower Server on: {syft_grid._client.email}")
     logger.info(f"syft_flwr app name: {syft_flwr_app_name}")
 

syft_flwr/grid.py

@@ -1,6 +1,6 @@
+import base64
 import os
 import time
-from typing import Iterable, cast
 
 from flwr.common import ConfigRecord
 from flwr.common.constant import MessageType
@@ -9,9 +9,11 @@ from flwr.common.typing import Run
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from loguru import logger
 from syft_core import Client
-from syft_rpc import rpc, rpc_db
-from typing_extensions import Optional
+from syft_crypto import EncryptedPayload, decrypt_message
+from syft_rpc import SyftResponse, rpc, rpc_db
+from typing_extensions import Dict, Iterable, List, Optional, Tuple, cast
 
+from syft_flwr.consts import SYFT_FLWR_ENCRYPTION_ENABLED
 from syft_flwr.flwr_compatibility import (
     Grid,
     RecordDict,
@@ -24,7 +26,6 @@ from syft_flwr.utils import str_to_int
 # this is what superlink super node do
 AGGREGATOR_NODE_ID = 1
 
-
 # env vars
 SYFT_FLWR_MSG_TIMEOUT = "SYFT_FLWR_MSG_TIMEOUT"
 
@@ -36,39 +37,66 @@ class SyftGrid(Grid):
         datasites: list[str] = [],
         client: Client = None,
     ) -> None:
+        """
+        SyftGrid is the server-side message orchestrator for federated learning in syft_flwr.
+        It acts as a bridge between Flower's server logic and SyftBox's communication layer:
+
+        Flower Server → SyftGrid → syft_rpc → SyftBox network → FL Clients
+                            ↑                                          ↓
+                            └──────────── responses ←─────────────────┘
+
+        SyftGrid enables Flower's centralized server to communicate with distributed SyftBox
+        clients without knowing the underlying transport details.
+
+        Core functionalities:
+        - push_messages(): Sends messages to clients via syft_rpc, returns future IDs
+        - pull_messages(): Retrieves responses using futures
+        - send_and_receive(): Combines push/pull with timeout handling
+        """
         self._client = Client.load() if client is None else client
         self._run: Optional[Run] = None
         self.node = Node(node_id=AGGREGATOR_NODE_ID)
         self.datasites = datasites
         self.client_map = {str_to_int(ds): ds for ds in self.datasites}
+
+        # Check if encryption is enabled (default: True for production)
+        self._encryption_enabled = (
+            os.environ.get(SYFT_FLWR_ENCRYPTION_ENABLED, "true").lower() != "false"
+        )
+
         logger.debug(
             f"Initialize SyftGrid for '{self._client.email}' with datasites: {self.datasites}"
         )
+        if self._encryption_enabled:
+            logger.info("🔐 End-to-end encryption is ENABLED for FL messages")
+        else:
+            logger.warning(
+                "⚠️ End-to-end encryption is DISABLED for FL messages (development mode / insecure)"
+            )
+
         self.app_name = app_name
 
     def set_run(self, run_id: int) -> None:
-        # TODO: In Grpc Grid case, the superlink is the one which sets up the run id,
-        # do we need to do the same here, where the run id is set from an external context.
+        """Set the run ID for this federated learning session.
 
+        Args:
+            run_id: Unique identifier for the FL run/session
+
+        Note:
+            In Grpc Grid case, the superlink sets up the run id.
+            Here, the run id is set from an external context.
+        """
         # Convert to Flower Run object
         self._run = Run.create_empty(run_id)
 
     @property
     def run(self) -> Run:
-        """Run ID."""
-        return Run(**vars(cast(Run, self._run)))
+        """Get the current Flower Run object.
 
-    def _check_message(self, message: Message) -> None:
-        # Check if the message is valid
-        if not (
-            message.metadata.run_id == cast(Run, self._run).run_id
-            and message.metadata.src_node_id == self.node.node_id
-            and message.metadata.message_id == ""
-            and check_reply_to_field(message.metadata)
-            and message.metadata.ttl > 0
-        ):
-            logger.debug(f"Invalid message with metadata: {message.metadata}")
-            raise ValueError(f"Invalid message: {message}")
+        Returns:
+            A copy of the current Run object with run metadata
+        """
+        return Run(**vars(cast(Run, self._run)))
 
     def create_message(
         self,
@@ -78,7 +106,21 @@ class SyftGrid(Grid):
         group_id: str,
         ttl: Optional[float] = None,
     ) -> Message:
-        """Create a new message with specified parameters."""
+        """Create a new Flower message with proper metadata.
+
+        Args:
+            content: Message payload as RecordDict (e.g., model parameters, metrics)
+            message_type: Type of FL message (e.g., MessageType.TRAIN, MessageType.EVALUATE)
+            dst_node_id: Destination node ID (client identifier)
+            group_id: Message group identifier for related messages
+            ttl: Time-to-live in seconds (optional, for message expiration)
+
+        Returns:
+            A Flower Message object ready to be sent to a client
+
+        Note:
+            Automatically adds current run_id and server's node_id to metadata.
+        """
         return create_flwr_message(
             content=content,
             message_type=message_type,
@@ -90,69 +132,82 @@ class SyftGrid(Grid):
         )
 
     def get_node_ids(self) -> list[int]:
-        """Get node IDs of all connected nodes."""
-        # it is map from datasites to node id
+        """Get node IDs of all connected FL clients.
+
+        Returns:
+            List of integer node IDs representing connected datasites/clients
+
+        Note:
+            Node IDs are deterministically generated from datasite email addresses
+            using str_to_int() for consistent client identification.
+        """
         return list(self.client_map.keys())
 
     def push_messages(self, messages: Iterable[Message]) -> Iterable[str]:
-        """Push messages to specified node IDs."""
-        # Construct Messages
-        run_id = cast(Run, self._run).run_id
+        """Push FL messages to specified clients asynchronously.
+
+        Args:
+            messages: Iterable of Flower Messages to send to clients
+
+        Returns:
+            List of future IDs that can be used to retrieve responses
+        """
         message_ids = []
+
         for msg in messages:
-            # Set metadata
-            msg.metadata.__dict__["_run_id"] = run_id
-            msg.metadata.__dict__["_src_node_id"] = self.node.node_id
-            # RPC URL
-            dest_datasite = self.client_map[msg.metadata.dst_node_id]
-            url = rpc.make_url(
-                dest_datasite, app_name=self.app_name, endpoint="messages"
-            )
-            # Check message
-            self._check_message(msg)
-            # Serialize message
-            msg_bytes = flower_message_to_bytes(msg)
+            # Prepare message
+            dest_datasite, url, msg_bytes = self._prepare_message(msg)
+
             # Send message
-            future = rpc.send(url=url, body=msg_bytes, client=self._client)
-            logger.debug(
-                f"Pushed message to {url} with metadata {msg.metadata}; size {len(msg_bytes) / 1024 / 1024} (Mb)"
-            )
-            # Save future
-            rpc_db.save_future(
-                future=future, namespace=self.app_name, client=self._client
-            )
-            message_ids.append(future.id)
+            if self._encryption_enabled:
+                future_id = self._send_encrypted_message(
+                    url, msg_bytes, dest_datasite, msg
+                )
+            else:
+                future_id = self._send_unencrypted_message(
+                    url, msg_bytes, dest_datasite, msg
+                )
+
+            if future_id:
+                message_ids.append(future_id)
 
         return message_ids
 
-    def pull_messages(self, message_ids):
-        """Pull messages based on message IDs."""
+    def pull_messages(self, message_ids: List[str]) -> Dict[str, Message]:
+        """Pull response messages from clients using future IDs.
+
+        Args:
+            message_ids: List of future IDs from push_messages()
+
+        Returns:
+            Dict mapping message_id to Flower Message response
+        """
         messages = {}
 
         for msg_id in message_ids:
-            future = rpc_db.get_future(future_id=msg_id, client=self._client)
-            response = future.resolve()
-            if response is None:
-                continue
+            try:
+                # Get and resolve future
+                future = rpc_db.get_future(future_id=msg_id, client=self._client)
+                response = future.resolve()
 
-            response.raise_for_status()
+                if response is None:
+                    continue  # Message not ready yet
 
-            if not response.body:
-                raise ValueError(f"Empty response: {response}")
+                response.raise_for_status()
 
-            message: Message = bytes_to_flower_message(response.body)
-            if message.has_error():
-                error = message.error
-                logger.error(
-                    f"Message {msg_id} error with code={error.code}, reason={error.reason}"
-                )
+                # Process the response
+                message = self._process_response(response, msg_id)
+
+                if message:
+                    messages[msg_id] = message
+                    rpc_db.delete_future(future_id=msg_id, client=self._client)
+
+            except Exception as e:
+                logger.error(f"❌ Unexpected error pulling message {msg_id}: {e}")
                 continue
 
-            logger.debug(
-                f"Pulled message from {response.url} with metadata: {message.metadata}, size: {len(response.body) / 1024 / 1024} (Mb)"
-            )
-            messages[msg_id] = message
-            rpc_db.delete_future(future_id=msg_id, client=self._client)
+        # Log summary
+        self._log_pull_summary(messages, message_ids)
 
         return messages
 
@@ -164,47 +219,49 @@ class SyftGrid(Grid):
     ) -> Iterable[Message]:
         """Push messages to specified node IDs and pull the reply messages.
 
-        This method sends a list of messages to their destination node IDs and then
-        waits for the replies. It continues to pull replies until either all replies are
-        received or the specified timeout duration (in seconds) is exceeded.
+        This method sends messages to their destination nodes and waits for replies.
+        It continues polling until all replies are received or timeout is reached.
+
+        Args:
+            messages: Messages to send
+            timeout: Maximum time to wait for replies (seconds).
+                    Can be overridden by SYFT_FLWR_MSG_TIMEOUT env var.
+
+        Returns:
+            Collection of reply messages received
         """
-        if os.environ.get(SYFT_FLWR_MSG_TIMEOUT) is not None:
-            timeout = float(os.environ.get(SYFT_FLWR_MSG_TIMEOUT))
-        if timeout is not None:
-            logger.debug(
-                f"syft_flwr messages timeout = {timeout}: Will move on after {timeout} (s) if no reply is received"
-            )
-        else:
-            logger.debug(
-                "syft_flwr messages timeout = None: Will wait indefinitely for replies"
-            )
+        # Get timeout from environment or parameter
+        timeout = self._get_timeout(timeout)
 
-        # Push messages
+        # Push messages and get IDs
         msg_ids = set(self.push_messages(messages))
+        if not msg_ids:
+            return []
 
-        # Pull messages
-        end_time = time.time() + (timeout if timeout is not None else 0.0)
-        ret = {}
-        while timeout is None or time.time() < end_time:
-            res_msgs = self.pull_messages(msg_ids)
-            ret.update(res_msgs)
-            msg_ids.difference_update(res_msgs.keys())
-            if len(msg_ids) == 0:  # All messages received
-                break
-            time.sleep(3)  # polling interval
-
-        if msg_ids:
-            logger.warning(
-                f"Timeout reached. {len(msg_ids)} message(s) sent out but not replied."
-            )
+        # Poll for responses
+        responses = self._poll_for_responses(msg_ids, timeout)
 
-        return ret.values()
+        return responses.values()
 
     def send_stop_signal(
         self, group_id: str, reason: str = "Training complete", ttl: float = 60.0
-    ) -> list[Message]:
-        """Send a stop signal to all datasites (clients)."""
-        stop_messages: list[Message] = [
+    ) -> List[Message]:
+        """Send a stop signal to all connected FL clients.
+
+        Args:
+            group_id: Identifier for this group of stop messages
+            reason: Human-readable reason for stopping (default: "Training complete")
+            ttl: Time-to-live for stop messages in seconds (default: 60.0)
+
+        Returns:
+            List of stop Messages that were sent
+
+        Note:
+            Used to gracefully terminate FL clients when training completes or
+            when the server encounters an error. Clients will shut down upon
+            receiving this SYSTEM message with action="stop".
+        """
+        stop_messages: List[Message] = [
             self.create_message(
                 content=RecordDict(
                     {"config": ConfigRecord({"action": "stop", "reason": reason})}
@@ -219,3 +276,219 @@ class SyftGrid(Grid):
         self.push_messages(stop_messages)
 
         return stop_messages
+
+    def _check_message(self, message: Message) -> None:
+        """Validate a Flower message before sending.
+
+        Args:
+            message: The Flower Message to validate
+
+        Raises:
+            ValueError: If message metadata is invalid (wrong run_id, src_node_id,
+                    missing ttl, or invalid reply_to field)
+
+        Note:
+            Ensures message belongs to current run and originates from this server node.
+        """
+        if not (
+            message.metadata.run_id == cast(Run, self._run).run_id
+            and message.metadata.src_node_id == self.node.node_id
+            and message.metadata.message_id == ""
+            and check_reply_to_field(message.metadata)
+            and message.metadata.ttl > 0
+        ):
+            logger.debug(f"Invalid message with metadata: {message.metadata}")
+            raise ValueError(f"Invalid message: {message}")
+
+    def _prepare_message(self, msg: Message) -> Tuple[str, str, bytes]:
+        """Prepare a message for sending.
+
+        Returns:
+            Tuple of (destination_datasite, url, message_bytes)
+        """
+        run_id = cast(Run, self._run).run_id
+        msg.metadata.__dict__["_run_id"] = run_id
+        msg.metadata.__dict__["_src_node_id"] = self.node.node_id
+
+        dest_datasite = self.client_map[msg.metadata.dst_node_id]
+        url = rpc.make_url(dest_datasite, app_name=self.app_name, endpoint="messages")
+
+        self._check_message(msg)
+        msg_bytes = flower_message_to_bytes(msg)
+
+        return dest_datasite, url, msg_bytes
+
+    def _send_encrypted_message(
+        self, url: str, msg_bytes: bytes, dest_datasite: str, msg: Message
+    ) -> Optional[str]:
+        """Send an encrypted message and return future ID if successful."""
+        try:
+            future = rpc.send(
+                url=url,
+                body=base64.b64encode(msg_bytes).decode("utf-8"),
+                client=self._client,
+                encrypt=True,
+            )
+            logger.debug(
+                f"🔐 Pushed ENCRYPTED message to {dest_datasite} at {url} "
+                f"with metadata {msg.metadata}; size {len(msg_bytes) / 1024 / 1024:.2f} MB"
+            )
+            rpc_db.save_future(
+                future=future, namespace=self.app_name, client=self._client
+            )
+            return future.id
+
+        except (KeyError, ValueError) as e:
+            error_type = (
+                "Encryption key" if isinstance(e, KeyError) else "Encryption parameter"
+            )
+            logger.error(
+                f"❌ {error_type} error for {dest_datasite}: {e}. "
+                f"Skipping message to node {msg.metadata.dst_node_id}"
+            )
+            return None
+
+        except Exception as e:
+            logger.warning(
+                f"⚠️ Encryption failed for {dest_datasite}: {e}. "
+                f"Falling back to unencrypted transmission"
+            )
+            return self._send_unencrypted_message(url, msg_bytes, dest_datasite, msg)
+
+    def _send_unencrypted_message(
+        self, url: str, msg_bytes: bytes, dest_datasite: str, msg: Message
+    ) -> Optional[str]:
+        """Send an unencrypted message and return future ID if successful."""
+        try:
+            future = rpc.send(url=url, body=msg_bytes, client=self._client)
+            logger.debug(
+                f"📤 Pushed PLAINTEXT message to {dest_datasite} at {url} "
+                f"with metadata {msg.metadata}; size {len(msg_bytes) / 1024 / 1024:.2f} MB"
+            )
+            rpc_db.save_future(
+                future=future, namespace=self.app_name, client=self._client
+            )
+            return future.id
+
+        except Exception as e:
+            logger.error(f"❌ Failed to send message to {dest_datasite}: {e}")
+            return None
+
+    def _poll_for_responses(
+        self, msg_ids: set, timeout: Optional[float]
+    ) -> Dict[str, Message]:
+        """Poll for responses until all received or timeout."""
+        end_time = time.time() + (timeout if timeout is not None else float("inf"))
+        responses = {}
+        pending_ids = msg_ids.copy()
+
+        while pending_ids and (timeout is None or time.time() < end_time):
+            # Pull available messages
+            batch = self.pull_messages(pending_ids)
+            responses.update(batch)
+            pending_ids.difference_update(batch.keys())
+
+            if pending_ids:
+                time.sleep(3)  # Polling interval
+
+        # Log any missing responses
+        if pending_ids:
+            logger.warning(
+                f"Timeout reached. {len(pending_ids)} message(s) not received."
+            )
+
+        return responses
+
+    def _process_response(
+        self, response: SyftResponse, msg_id: str
+    ) -> Optional[Message]:
+        """Process a single response and return the deserialized message."""
+        if not response.body:
+            logger.warning(f"⚠️ Empty response for message {msg_id}, skipping")
+            return None
+
+        response_body = response.body
+
+        # Try to decrypt if encryption is enabled
+        if self._encryption_enabled:
+            response_body = self._try_decrypt_response(response.body, msg_id)
+
+        # Deserialize message
+        try:
+            message = bytes_to_flower_message(response_body)
+        except Exception as e:
+            logger.error(
+                f"❌ Failed to deserialize message {msg_id}: {e}. "
+                f"Message may be corrupted or in incompatible format."
+            )
+            return None
+
+        # Check for errors in message
+        if message.has_error():
+            error = message.error
+            logger.error(
+                f"❌ Message {msg_id} returned error with code={error.code}, "
+                f"reason={error.reason}"
+            )
+            return None
+
+        # Log successful pull
+        encryption_status = (
+            "🔐 ENCRYPTED" if self._encryption_enabled else "📥 PLAINTEXT"
+        )
+        logger.debug(
+            f"{encryption_status} Pulled message from {response.url} "
+            f"with metadata: {message.metadata}, "
+            f"size: {len(response_body) / 1024 / 1024:.2f} MB"
+        )
+
+        return message
+
+    def _try_decrypt_response(self, body: bytes, msg_id: str) -> bytes:
+        """Try to decrypt response body if it's encrypted."""
+        try:
+            # Try to parse as encrypted payload
+            encrypted_payload = EncryptedPayload.model_validate_json(body.decode())
+            # Decrypt the message
+            decrypted_body = decrypt_message(encrypted_payload, client=self._client)
+            # The decrypted body should be a base64-encoded string
+            response_body = base64.b64decode(decrypted_body)
+            logger.debug(f"🔓 Successfully decrypted response for message {msg_id}")
+            return response_body
+        except Exception as e:
+            # If decryption fails, assume plaintext
+            logger.debug(
+                f"📥 Response appears to be plaintext or decryption not needed "
+                f"for message {msg_id}: {e}"
+            )
+            return body
+
+    def _log_pull_summary(
+        self, messages: Dict[str, Message], message_ids: List[str]
+    ) -> None:
+        """Log summary of pulled messages."""
+        if messages:
+            if self._encryption_enabled:
+                logger.info(
+                    f"🔐 Successfully pulled {len(messages)} messages (encryption enabled)"
+                )
+            else:
+                logger.info(f"📥 Successfully pulled {len(messages)} messages")
+        elif message_ids:
+            logger.debug(
+                f"No messages pulled yet from {len(message_ids)} attempts "
+                f"(clients may still be processing)"
+            )
+
+    def _get_timeout(self, timeout: Optional[float]) -> Optional[float]:
+        """Get timeout value from environment or parameter."""
+        env_timeout = os.environ.get(SYFT_FLWR_MSG_TIMEOUT)
+        if env_timeout is not None:
+            timeout = float(env_timeout)
+
+        if timeout is not None:
+            logger.debug(f"Message timeout: {timeout}s")
+        else:
+            logger.debug("No timeout - will wait indefinitely for replies")
+
+        return timeout

syft_flwr/mounts.py

@@ -1,13 +1,13 @@
 import json
 import os
 from pathlib import Path
-from typing import List
 
 import tomli
 from loguru import logger
 from syft_core import Client
 from syft_rds.models import DockerMount, JobConfig
 from syft_rds.syft_runtime.mounts import MountProvider
+from typing_extensions import List
 
 
 class SyftFlwrMountProvider(MountProvider):

syft_flwr/run_simulation.py

@@ -1,33 +1,109 @@
 import asyncio
 import os
-import uuid
+import sys
+import tempfile
 from pathlib import Path
 
 from loguru import logger
+from syft_core import Client
+from syft_crypto import did_path, ensure_bootstrap, get_did_document, private_key_path
 from syft_rds.client.rds_client import RDSClient
-from syft_rds.orchestra import remove_rds_stack_dir, setup_rds_server
-from typing_extensions import Union
+from syft_rds.orchestra import SingleRDSStack, remove_rds_stack_dir
+from typing_extensions import Optional, Union
 
 from syft_flwr.config import load_flwr_pyproject
+from syft_flwr.consts import SYFT_FLWR_ENCRYPTION_ENABLED
+from syft_flwr.utils import create_temp_client
 
 
 def _setup_mock_rds_clients(
     project_dir: Path, aggregator: str, datasites: list[str]
-) -> tuple[str, list[RDSClient], RDSClient]:
+) -> tuple[Path, list[RDSClient], RDSClient]:
     """Setup mock RDS clients for the given project directory"""
-    key = project_dir.name + "_" + str(uuid.uuid4())
-    remove_rds_stack_dir(key)
+    simulated_syftbox_network_dir = Path(tempfile.gettempdir(), project_dir.name)
+    remove_rds_stack_dir(root_dir=simulated_syftbox_network_dir)
 
-    ds_stack = setup_rds_server(email=aggregator, key=key)
-    ds_client = ds_stack.init_session(host=aggregator)
+    ds_syftbox_client = create_temp_client(
+        email=aggregator, workspace_dir=simulated_syftbox_network_dir
+    )
+    ds_stack = SingleRDSStack(client=ds_syftbox_client)
+    ds_rds_client = ds_stack.init_session(host=aggregator)
 
-    do_clients = []
+    do_rds_clients = []
     for datasite in datasites:
-        do_stack = setup_rds_server(email=datasite, key=key)
-        do_client = do_stack.init_session(host=datasite)
-        do_clients.append(do_client)
+        do_syftbox_client = create_temp_client(
+            email=datasite, workspace_dir=simulated_syftbox_network_dir
+        )
+        do_stack = SingleRDSStack(client=do_syftbox_client)
+        do_rds_client = do_stack.init_session(host=datasite)
+        do_rds_clients.append(do_rds_client)
+
+    return simulated_syftbox_network_dir, do_rds_clients, ds_rds_client
+
+
+def _bootstrap_encryption_keys(
+    do_clients: list[RDSClient], ds_client: RDSClient
+) -> None:
+    """Bootstrap the encryption keys for all clients if encryption is enabled."""
+    # Check if encryption is enabled
+    encryption_enabled = (
+        os.environ.get(SYFT_FLWR_ENCRYPTION_ENABLED, "true").lower() != "false"
+    )
 
-    return key, do_clients, ds_client
+    if not encryption_enabled:
+        logger.warning("⚠️ Encryption disabled - skipping key bootstrap")
+        return
+
+    logger.info("🔐 Bootstrapping encryption keys for all participants...")
+
+    all_syftbox_clients: list[Client] = []
+
+    # Bootstrap server
+    try:
+        server_client: Client = ds_client._syftbox_client
+        ensure_bootstrap(server_client)
+        server_client_did_path = did_path(server_client, server_client.email)
+        server_client_private_key_path = private_key_path(server_client)
+        logger.debug(
+            f"✅ Server {ds_client.email} bootstrapped with private encryption keys at {server_client_private_key_path} and did path at {server_client_did_path}"
+        )
+        all_syftbox_clients.append(server_client)
+    except Exception as e:
+        logger.error(f"❌ Failed to bootstrap server {ds_client.email}: {e}")
+        raise
+
+    # Bootstrap each client
+    for do_client in do_clients:
+        try:
+            client: Client = do_client._syftbox_client
+            ensure_bootstrap(client)
+            client_did_path = did_path(client, client.email)
+            client_did_doc = get_did_document(client, client.email)
+            client_private_key_path = private_key_path(client)
+            logger.debug(
+                f"✅ Client {do_client.email} bootstrapped with private encryption keys at {client_private_key_path} and did path at {client_did_path} with content: {client_did_doc}"
+            )
+            all_syftbox_clients.append(client)
+        except Exception as e:
+            logger.error(f"❌ Failed to bootstrap client {do_client.email}: {e}")
+            raise
+
+    # Verify all DID documents are accessible
+    for checking_client in all_syftbox_clients:
+        for target_client in all_syftbox_clients:
+            if checking_client.email != target_client.email:
+                # Verify that checking_client can see target_client's DID document
+                did_file_path = did_path(checking_client, target_client.email)
+                if did_file_path.exists():
+                    logger.debug(
+                        f"✅ {checking_client.email} can see {target_client.email}'s DID at {did_file_path}"
+                    )
+                else:
+                    logger.warning(
+                        f"⚠️ {checking_client.email} cannot find {target_client.email}'s DID at {did_file_path}"
+                    )
+
+    logger.info("🔐 All participants bootstrapped for E2E encryption ✅✅✅")
 
 
 async def _run_main_py(
@@ -35,7 +111,7 @@ async def _run_main_py(
     config_path: Path,
     client_email: str,
     log_dir: Path,
-    dataset_path: Union[str, Path] | None = None,
+    dataset_path: Optional[Union[str, Path]] = None,
 ) -> int:
     """Run the `main.py` file for a given client"""
     log_file_path = log_dir / f"{client_email}.log"
@@ -49,7 +125,7 @@ async def _run_main_py(
     try:
         with open(log_file_path, "w") as f:
             process = await asyncio.create_subprocess_exec(
-                "python",
+                sys.executable,  # Use the current Python executable
                 str(main_py_path),
                 "-s",
                 stdout=f,
@@ -131,7 +207,7 @@ async def _run_simulated_flwr_project(
     return run_success
 
 
-def _validate_bootstraped_project(project_dir: Path) -> None:
+def validate_bootstraped_project(project_dir: Path) -> None:
     """Validate a bootstraped `syft_flwr` project directory"""
     if not project_dir.exists():
         raise FileNotFoundError(f"Project directory {project_dir} does not exist")
@@ -159,42 +235,65 @@ def _validate_mock_dataset_paths(mock_dataset_paths: list[str]) -> list[Path]:
 
 def run(
     project_dir: Union[str, Path], mock_dataset_paths: list[Union[str, Path]]
-) -> None:
-    """Run a syft_flwr project in simulation mode over mock data"""
+) -> Union[bool, asyncio.Task]:
+    """Run a syft_flwr project in simulation mode over mock data.
+
+    Returns:
+        bool: True if simulation succeeded, False otherwise (synchronous execution)
+        asyncio.Task: Task handle if running in async environment (e.g., Jupyter)
+    """
 
     project_dir = Path(project_dir).expanduser().resolve()
-    _validate_bootstraped_project(project_dir)
+    validate_bootstraped_project(project_dir)
     mock_dataset_paths = _validate_mock_dataset_paths(mock_dataset_paths)
 
-    pyproject_conf = load_flwr_pyproject(project_dir)
+    # Skip module validation during testing to avoid parallel test issues
+    skip_module_check = (
+        os.environ.get("SYFT_FLWR_SKIP_MODULE_CHECK", "false").lower() == "true"
+    )
+    pyproject_conf = load_flwr_pyproject(
+        project_dir, check_module=not skip_module_check
+    )
     datasites = pyproject_conf["tool"]["syft_flwr"]["datasites"]
     aggregator = pyproject_conf["tool"]["syft_flwr"]["aggregator"]
 
-    key, do_clients, ds_client = _setup_mock_rds_clients(
+    simulated_syftbox_network_dir, do_clients, ds_client = _setup_mock_rds_clients(
         project_dir, aggregator, datasites
     )
 
+    _bootstrap_encryption_keys(do_clients, ds_client)
+
+    simulation_success = False  # Track success status
+
     async def main():
+        nonlocal simulation_success
         try:
             run_success = await _run_simulated_flwr_project(
                 project_dir, do_clients, ds_client, mock_dataset_paths
             )
+            simulation_success = run_success
             if run_success:
                 logger.success("Simulation completed successfully ✅")
             else:
                 logger.error("Simulation failed ❌")
         except Exception as e:
             logger.error(f"Simulation failed ❌: {e}")
+            simulation_success = False
         finally:
             # Clean up the RDS stack
-            remove_rds_stack_dir(key)
-            logger.debug(f"Removed RDS stack: {key}")
+            remove_rds_stack_dir(simulated_syftbox_network_dir)
+            logger.debug(f"Removed RDS stack: {simulated_syftbox_network_dir}")
+            # Also remove the .syftbox folder that saves the config files and private keys
+            remove_rds_stack_dir(simulated_syftbox_network_dir.parent / ".syftbox")
+
+        return simulation_success
 
     try:
         loop = asyncio.get_running_loop()
         logger.debug(f"Running in an environment with an existing event loop {loop}")
         # We are in an environment with an existing event loop (like Jupyter)
-        asyncio.create_task(main())
+        task = asyncio.create_task(main())
+        return task  # Return the task so callers can await it
     except RuntimeError:
         logger.debug("No existing event loop, creating and running one")
         # No existing event loop, create and run one (for scripts)
@@ -202,3 +301,4 @@ def run(
         asyncio.set_event_loop(loop)
         loop.run_until_complete(main())
         loop.close()
+        return simulation_success  # Return success status for synchronous execution

syft_flwr/utils.py

@@ -3,6 +3,13 @@ import re
 import zlib
 from pathlib import Path
 
+from loguru import logger
+from syft_core import Client, SyftClientConfig
+from syft_crypto.x3dh_bootstrap import ensure_bootstrap
+from typing_extensions import Tuple
+
+from syft_flwr.consts import SYFT_FLWR_ENCRYPTION_ENABLED
+
 EMAIL_REGEX = r"^[^@]+@[^@]+\.[^@]+$"
 
 
@@ -34,3 +41,41 @@ def run_syft_flwr() -> bool:
         return True
     except FileNotFoundError:
         return False
+
+
+def create_temp_client(email: str, workspace_dir: Path) -> Client:
+    """Create a temporary Client instance for testing"""
+    workspace_hash = hash(str(workspace_dir)) % 10000
+    server_port = 8080 + workspace_hash
+    client_port = 8082 + workspace_hash
+    config: SyftClientConfig = SyftClientConfig(
+        email=email,
+        data_dir=workspace_dir,
+        server_url=f"http://localhost:{server_port}",
+        client_url=f"http://localhost:{client_port}",
+        path=workspace_dir / ".syftbox" / f"{email.split('@')[0]}_config.json",
+    ).save()
+    logger.debug(f"Created temp client {email} with config {config}")
+    return Client(config)
+
+
+def setup_client(app_name: str) -> Tuple[Client, bool, str]:
+    """Setup SyftBox client and encryption."""
+    client = Client.load()
+
+    # Check encryption setting
+    encryption_enabled = (
+        os.environ.get(SYFT_FLWR_ENCRYPTION_ENABLED, "true").lower() != "false"
+    )
+
+    # Bootstrap encryption if needed
+    if encryption_enabled:
+        client = ensure_bootstrap(client)
+        logger.info("🔐 End-to-end encryption is ENABLED for FL messages")
+    else:
+        logger.warning("⚠️ Encryption disabled - skipping client key bootstrap")
+        logger.warning(
+            "⚠️ End-to-end encryption is DISABLED for FL messages (development mode / insecure)"
+        )
+
+    return client, encryption_enabled, f"flwr/{app_name}"

{syft_flwr-0.1.7.dist-info → syft_flwr-0.2.0.dist-info}/METADATA

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: syft-flwr
-Version: 0.1.7
+Version: 0.2.0
 Summary: syft_flwr is an open source framework that facilitate federated learning projects using Flower over the SyftBox protocol
 License-File: LICENSE
-Requires-Python: >=3.9.2
+Requires-Python: >=3.10
 Requires-Dist: flwr-datasets[vision]>=0.5.0
 Requires-Dist: flwr[simulation]>=1.20.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: safetensors>=0.6.2
-Requires-Dist: syft-rds==0.1.5
+Requires-Dist: syft-rds>=0.2.1
 Requires-Dist: tomli-w>=1.2.0
 Requires-Dist: tomli>=2.2.1
 Requires-Dist: typing-extensions>=4.13.0

syft_flwr-0.2.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+syft_flwr/__init__.py,sha256=ayTCluE-u-ttvrPNq2REmFOfBOd6Zmr_QBF9oh2BpJc,426
+syft_flwr/bootstrap.py,sha256=-T6SRh_p6u6uWpbTPZ6-URsAfMQAI2jakpjZAh0UUlw,3690
+syft_flwr/cli.py,sha256=imctwdQMxQeGQZaiKSX1Mo2nU_-RmA-cGB3H4huuUeA,3274
+syft_flwr/config.py,sha256=4hwkovGtFOLNULjJwoGYcA0uT4y3vZSrxndXqYXquMY,821
+syft_flwr/consts.py,sha256=u3QK-Wp8D2Va7iZcp5z4ormVm_FAUDeK4u-w81UL_eY,107
+syft_flwr/flower_client.py,sha256=-HsPp2Uw0RlILthezQHzZdwyVAzklbh_VHnl_nANgx8,7210
+syft_flwr/flower_server.py,sha256=ZNDUR1U79M0BaG7n39TGUkVHV2NYi-LDsN8FqKJFfFQ,1508
+syft_flwr/flwr_compatibility.py,sha256=vURf9rfsZ1uPm04szw6RpGYxtlG3BE4tW3YijptiGyk,3197
+syft_flwr/grid.py,sha256=zjhkKHIYxRoCmda75Bw1L1Qra7b5DXhMTpY7L3Ujy_4,17799
+syft_flwr/mounts.py,sha256=hp0TKVot16SaPYO10Y_mSJGei7aiNteJfK4U4vynWmU,2330
+syft_flwr/run.py,sha256=OPW9bVt366DT-U-SxMpMLNXASwTZjp7XNNXfDP767f4,2153
+syft_flwr/run_simulation.py,sha256=frHytbsxYLjiCM4r4m1NVQOc1j98hm4sQQoBLeagJi8,11539
+syft_flwr/serde.py,sha256=5fCI-cRUOh5wE7cXQd4J6jex1grRGnyD1Jx-VlEDOXM,495
+syft_flwr/utils.py,sha256=SC-lnCydP9t2_FNlUZEUFDcb6wtIE9v0soiW8nH7G0w,2594
+syft_flwr/strategy/__init__.py,sha256=mpUmExjjFkqU8gg41XsOBKfO3aqCBe7XPJSU-_P7smU,97
+syft_flwr/strategy/fedavg.py,sha256=N8jULUkjvuaBIEVINowyQln8W8yFhkO-J8k0-iPcGMA,1562
+syft_flwr/templates/main.py.tpl,sha256=p0uK97jvLGk3LJdy1_HF1R5BQgIjaTGkYnr-csfh39M,791
+syft_flwr-0.2.0.dist-info/METADATA,sha256=R6CudwzWKXVdL-wKi-iJd_Fm7yEGc9eNXgiTSu5sPsM,1254
+syft_flwr-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+syft_flwr-0.2.0.dist-info/entry_points.txt,sha256=o7oT0dCoHn-3WyIwdDw1lBh2q-GvhB_8s0hWeJU4myc,49
+syft_flwr-0.2.0.dist-info/licenses/LICENSE,sha256=0msOUar8uPZTqkAOTBp4rCzd7Jl9eRhfKiNufwrsg7k,11361
+syft_flwr-0.2.0.dist-info/RECORD,,

syft_flwr-0.1.7.dist-info/RECORD

@@ -1,21 +0,0 @@
-syft_flwr/__init__.py,sha256=oGfKpHbO65Irb9RHFJHb7-RyS-rlcszl_tIxbssgdXU,426
-syft_flwr/bootstrap.py,sha256=-T6SRh_p6u6uWpbTPZ6-URsAfMQAI2jakpjZAh0UUlw,3690
-syft_flwr/cli.py,sha256=imctwdQMxQeGQZaiKSX1Mo2nU_-RmA-cGB3H4huuUeA,3274
-syft_flwr/config.py,sha256=4hwkovGtFOLNULjJwoGYcA0uT4y3vZSrxndXqYXquMY,821
-syft_flwr/flower_client.py,sha256=5UrtfwSTUDwPQlir7mQWLLVxulGcT4Mcy17uz1-UAlk,3685
-syft_flwr/flower_server.py,sha256=sJwSEqePmkmWKGFXm2E44Ugoc6aaz-6tM7UaeWM2-co,1353
-syft_flwr/flwr_compatibility.py,sha256=vURf9rfsZ1uPm04szw6RpGYxtlG3BE4tW3YijptiGyk,3197
-syft_flwr/grid.py,sha256=Me2tivW0v1ApTjdjQffUc9f1UCHh1LtkYcKUjE82iZ8,7735
-syft_flwr/mounts.py,sha256=ry3_3eD4aPkRahk9eibfu88TpQjgp_KQ96G7yj692x4,2319
-syft_flwr/run.py,sha256=OPW9bVt366DT-U-SxMpMLNXASwTZjp7XNNXfDP767f4,2153
-syft_flwr/run_simulation.py,sha256=t3shhfzAWDUlf6iQmwf5sS9APZQE9mkaZ9MLCYs9Ng0,6922
-syft_flwr/serde.py,sha256=5fCI-cRUOh5wE7cXQd4J6jex1grRGnyD1Jx-VlEDOXM,495
-syft_flwr/utils.py,sha256=3dDYEB7btq9hxZ9UsfQWh3i44OerAhGXc5XaX5wO3-o,955
-syft_flwr/strategy/__init__.py,sha256=mpUmExjjFkqU8gg41XsOBKfO3aqCBe7XPJSU-_P7smU,97
-syft_flwr/strategy/fedavg.py,sha256=N8jULUkjvuaBIEVINowyQln8W8yFhkO-J8k0-iPcGMA,1562
-syft_flwr/templates/main.py.tpl,sha256=p0uK97jvLGk3LJdy1_HF1R5BQgIjaTGkYnr-csfh39M,791
-syft_flwr-0.1.7.dist-info/METADATA,sha256=-FVHhD66zCCZ3FUZDGwzISjNFJuKhzWp3gHlKKRDqb4,1255
-syft_flwr-0.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-syft_flwr-0.1.7.dist-info/entry_points.txt,sha256=o7oT0dCoHn-3WyIwdDw1lBh2q-GvhB_8s0hWeJU4myc,49
-syft_flwr-0.1.7.dist-info/licenses/LICENSE,sha256=0msOUar8uPZTqkAOTBp4rCzd7Jl9eRhfKiNufwrsg7k,11361
-syft_flwr-0.1.7.dist-info/RECORD,,