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

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,16 @@ import re
 import zlib
 from pathlib import Path
 
+from flwr.common import Metadata
+from flwr.common.message import Error, Message
+from flwr.common.record import RecordDict
+from loguru import logger
+from syft_core import Client, SyftClientConfig
+from syft_crypto.x3dh_bootstrap import ensure_bootstrap
+from typing_extensions import Optional, Tuple
+
+from syft_flwr.consts import SYFT_FLWR_ENCRYPTION_ENABLED
+
 EMAIL_REGEX = r"^[^@]+@[^@]+\.[^@]+$"
 
 
@@ -34,3 +44,72 @@ 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}"
+
+
+def check_reply_to_field(metadata: Metadata) -> bool:
+    """Check if reply_to field is empty (Flower 1.17+ format)."""
+    return metadata.reply_to_message_id == ""
+
+
+def create_flwr_message(
+    content: RecordDict,
+    message_type: str,
+    dst_node_id: int,
+    group_id: str,
+    ttl: Optional[float] = None,
+    error: Optional[Error] = None,
+    reply_to: Optional[Message] = None,
+) -> Message:
+    """Create a Flower message (requires Flower >= 1.17)."""
+    if reply_to is not None:
+        if error is not None:
+            return Message(reply_to=reply_to, error=error)
+        return Message(content=content, reply_to=reply_to)
+    else:
+        if error is not None:
+            raise ValueError("Error and reply_to cannot both be None")
+        return Message(
+            content=content,
+            dst_node_id=dst_node_id,
+            message_type=message_type,
+            ttl=ttl,
+            group_id=group_id,
+        )

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

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: syft-flwr
-Version: 0.1.7
+Version: 0.2.1
 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.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+syft_flwr/__init__.py,sha256=BdzYWTvuUs7ihkPtvHRELRjlOoSsnXcXPd63Ys6VpKI,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=dBM8QPJSyQmeoG41w2m9nXM5451VmqUviQz117z4FM4,7066
+syft_flwr/flower_server.py,sha256=ZNDUR1U79M0BaG7n39TGUkVHV2NYi-LDsN8FqKJFfFQ,1508
+syft_flwr/grid.py,sha256=5rbv6ncLKK2S1PAifkavaOG36gih-QexPJHh8nnwLws,20309
+syft_flwr/mounts.py,sha256=hp0TKVot16SaPYO10Y_mSJGei7aiNteJfK4U4vynWmU,2330
+syft_flwr/run.py,sha256=oy_ovAVmO84teKisLYYrY8a5ZmWH8tpWVDwXKB-O0rU,2144
+syft_flwr/run_simulation.py,sha256=frHytbsxYLjiCM4r4m1NVQOc1j98hm4sQQoBLeagJi8,11539
+syft_flwr/serde.py,sha256=5fCI-cRUOh5wE7cXQd4J6jex1grRGnyD1Jx-VlEDOXM,495
+syft_flwr/utils.py,sha256=KYwijACpHOR7pkvezNBqbCE48y3o4G9OUtnvdm1NkaU,3672
+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.1.dist-info/METADATA,sha256=3qRf-wHKTe-uZGPY3bzgX3BsoT5Sp4q2FA07TN03TKY,1254
+syft_flwr-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+syft_flwr-0.2.1.dist-info/entry_points.txt,sha256=o7oT0dCoHn-3WyIwdDw1lBh2q-GvhB_8s0hWeJU4myc,49
+syft_flwr-0.2.1.dist-info/licenses/LICENSE,sha256=0msOUar8uPZTqkAOTBp4rCzd7Jl9eRhfKiNufwrsg7k,11361
+syft_flwr-0.2.1.dist-info/RECORD,,

syft_flwr/flwr_compatibility.py

@@ -1,121 +0,0 @@
-import flwr
-from flwr.common import Metadata
-from flwr.common.message import Error, Message
-from packaging.version import Version
-from typing_extensions import Optional
-
-
-def flwr_later_than_1_17():
-    return Version(flwr.__version__) >= Version("1.17.0")
-
-
-# Version-dependent imports
-if flwr_later_than_1_17():
-    from flwr.common.record import RecordDict
-    from flwr.server.grid import Grid
-else:
-    from flwr.common.record import RecordSet as RecordDict
-    from flwr.server.driver import Driver as Grid
-
-
-__all__ = ["Grid", "RecordDict"]
-
-
-def check_reply_to_field(metadata: Metadata) -> bool:
-    """Check if reply_to field is empty based on Flower version."""
-    if flwr_later_than_1_17():
-        return metadata.reply_to_message_id == ""
-    else:
-        return metadata.reply_to_message == ""
-
-
-def create_flwr_message(
-    content: RecordDict,
-    message_type: str,
-    src_node_id: int,
-    dst_node_id: int,
-    group_id: str,
-    run_id: int,
-    ttl: Optional[float] = None,
-    error: Optional[Error] = None,
-    reply_to: Optional[Message] = None,
-) -> Message:
-    """Create a Flower message with version-compatible parameters."""
-    if flwr_later_than_1_17():
-        return _create_message_v1_17_plus(
-            content,
-            message_type,
-            dst_node_id,
-            group_id,
-            ttl,
-            error,
-            reply_to,
-        )
-    else:
-        return _create_message_pre_v1_17(
-            content,
-            message_type,
-            src_node_id,
-            dst_node_id,
-            group_id,
-            run_id,
-            ttl,
-            error,
-        )
-
-
-def _create_message_v1_17_plus(
-    content: RecordDict,
-    message_type: str,
-    dst_node_id: int,
-    group_id: str,
-    ttl: Optional[float],
-    error: Optional[Error],
-    reply_to: Optional[Message],
-) -> Message:
-    """Create message for Flower version 1.17+."""
-    if reply_to is not None:
-        if error is not None:
-            return Message(reply_to=reply_to, error=error)
-        return Message(content=content, reply_to=reply_to)
-    else:
-        if error is not None:
-            raise ValueError("Error and reply_to cannot both be None")
-        return Message(
-            content=content,
-            dst_node_id=dst_node_id,
-            message_type=message_type,
-            ttl=ttl,
-            group_id=group_id,
-        )
-
-
-def _create_message_pre_v1_17(
-    content: RecordDict,
-    message_type: str,
-    src_node_id: int,
-    dst_node_id: int,
-    group_id: str,
-    run_id: int,
-    ttl: Optional[float],
-    error: Optional[Error],
-) -> Message:
-    """Create message for Flower versions before 1.17."""
-    from flwr.common import DEFAULT_TTL
-
-    ttl_ = DEFAULT_TTL if ttl is None else ttl
-    metadata = Metadata(
-        run_id=run_id,
-        message_id="",  # Will be set when saving to file
-        src_node_id=src_node_id,
-        dst_node_id=dst_node_id,
-        reply_to_message="",
-        group_id=group_id,
-        ttl=ttl_,
-        message_type=message_type,
-    )
-
-    if error is not None:
-        return Message(metadata=metadata, error=error)
-    else:
-        return Message(metadata=metadata, content=content)

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,,