syft-flwr 0.4.3__py3-none-any.whl

syft_flwr/run.py

@@ -0,0 +1,63 @@
+import warnings
+from pathlib import Path
+from uuid import uuid4
+
+from flwr.clientapp.client_app import LoadClientAppError
+from flwr.common import Context
+from flwr.common.object_ref import load_app
+from flwr.common.record import RecordDict
+from flwr.server.server_app import LoadServerAppError
+
+from syft_flwr.config import load_flwr_pyproject
+from syft_flwr.flower_client import syftbox_flwr_client
+from syft_flwr.flower_server import syftbox_flwr_server
+from syft_flwr.run_simulation import run
+
+__all__ = ["syftbox_run_flwr_client", "syftbox_run_flwr_server", "run"]
+
+
+# Suppress Pydantic deprecation warnings
+warnings.filterwarnings("ignore", category=DeprecationWarning, module="pydantic")
+
+
+def syftbox_run_flwr_client(flower_project_dir: Path) -> None:
+    pyproject_conf = load_flwr_pyproject(flower_project_dir)
+    client_ref = pyproject_conf["tool"]["flwr"]["app"]["components"]["clientapp"]
+    app_name = pyproject_conf["tool"]["syft_flwr"]["app_name"]
+
+    context = Context(
+        run_id=uuid4().int,
+        node_id=uuid4().int,
+        node_config=pyproject_conf["tool"]["flwr"]["app"]["config"],
+        state=RecordDict(),
+        run_config=pyproject_conf["tool"]["flwr"]["app"]["config"],
+    )
+    client_app = load_app(
+        client_ref,
+        LoadClientAppError,
+        flower_project_dir,
+    )
+
+    syftbox_flwr_client(client_app, context, app_name)
+
+
+def syftbox_run_flwr_server(flower_project_dir: Path) -> None:
+    pyproject_conf = load_flwr_pyproject(flower_project_dir)
+    datasites = pyproject_conf["tool"]["syft_flwr"]["datasites"]
+    server_ref = pyproject_conf["tool"]["flwr"]["app"]["components"]["serverapp"]
+    app_name = pyproject_conf["tool"]["syft_flwr"]["app_name"]
+
+    context = Context(
+        run_id=uuid4().int,
+        node_id=uuid4().int,
+        node_config=pyproject_conf["tool"]["flwr"]["app"]["config"],
+        state=RecordDict(),
+        run_config=pyproject_conf["tool"]["flwr"]["app"]["config"],
+    )
+    server_app = load_app(
+        server_ref,
+        LoadServerAppError,
+        flower_project_dir,
+    )
+
+    syftbox_flwr_server(server_app, context, datasites, app_name)

syft_flwr/run_simulation.py

@@ -0,0 +1,328 @@
+import asyncio
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+from typing import TypeAlias
+
+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 import init_session
+from syft_rds.client.rds_client import RDSClient
+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
+
+PathLike: TypeAlias = Union[str, os.PathLike, Path]
+
+
+def remove_rds_stack_dir(
+    key: str = "shared_client_dir", root_dir: Optional[PathLike] = None
+) -> None:
+    root_path = (
+        Path(root_dir).resolve() / key if root_dir else Path(tempfile.gettempdir(), key)
+    )
+
+    if not root_path.exists():
+        logger.warning(f"⚠️ Skipping removal, as path {root_path} does not exist")
+        return None
+
+    try:
+        shutil.rmtree(root_path)
+        logger.info(f"✅ Successfully removed directory {root_path}")
+    except Exception as e:
+        logger.error(f"❌ Failed to remove directory {root_path}: {e}")
+
+
+def _setup_mock_rds_clients(
+    project_dir: Path, aggregator: str, datasites: list[str]
+) -> tuple[Path, list[RDSClient], RDSClient]:
+    """Setup mock RDS clients for the given project directory"""
+    simulated_syftbox_network_dir = Path(tempfile.gettempdir(), project_dir.name)
+    remove_rds_stack_dir(root_dir=simulated_syftbox_network_dir)
+
+    ds_syftbox_client = create_temp_client(
+        email=aggregator, workspace_dir=simulated_syftbox_network_dir
+    )
+    ds_rds_client = init_session(
+        host=aggregator, email=aggregator, syftbox_client=ds_syftbox_client
+    )
+
+    do_rds_clients = []
+    for datasite in datasites:
+        do_syftbox_client = create_temp_client(
+            email=datasite, workspace_dir=simulated_syftbox_network_dir
+        )
+        do_rds_client = init_session(
+            host=datasite, email=datasite, syftbox_client=do_syftbox_client
+        )
+        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"
+    )
+
+    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(
+    main_py_path: Path,
+    config_path: Path,
+    client_email: str,
+    log_dir: Path,
+    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"
+
+    # setting up env variables
+    env = os.environ.copy()
+    env["SYFTBOX_CLIENT_CONFIG_PATH"] = str(config_path)
+    env["DATA_DIR"] = str(dataset_path)
+
+    # running the main.py file asynchronously in a subprocess
+    try:
+        with open(log_file_path, "w") as f:
+            process = await asyncio.create_subprocess_exec(
+                sys.executable,  # Use the current Python executable
+                str(main_py_path),
+                "-s",
+                stdout=f,
+                stderr=f,
+                env=env,
+            )
+            return_code = await process.wait()
+            logger.debug(
+                f"`{client_email}` returns code {return_code} for running `{main_py_path}`"
+            )
+            return return_code
+    except Exception as e:
+        logger.error(f"Error running `{main_py_path}` for `{client_email}`: {e}")
+        return 1
+
+
+async def _run_simulated_flwr_project(
+    project_dir: Path,
+    do_clients: list[RDSClient],
+    ds_client: RDSClient,
+    mock_dataset_paths: list[Union[str, Path]],
+) -> bool:
+    """Run all clients and server concurrently"""
+    run_success = True
+
+    log_dir = project_dir / "simulation_logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    logger.info(f"📝 Log directory: {log_dir}")
+
+    main_py_path = project_dir / "main.py"
+
+    logger.info(
+        f"Running DS client '{ds_client.email}' with config path {ds_client._syftbox_client.config_path}"
+    )
+    ds_task: asyncio.Task = asyncio.create_task(
+        _run_main_py(
+            main_py_path,
+            ds_client._syftbox_client.config_path,
+            ds_client.email,
+            log_dir,
+        )
+    )
+
+    client_tasks: list[asyncio.Task] = []
+    for client, mock_dataset_path in zip(do_clients, mock_dataset_paths):
+        # check if the client has a mock dataset path
+        logger.info(
+            f"Running DO client '{client.email}' with config path {client._syftbox_client.config_path} on mock dataset {mock_dataset_path}"
+        )
+        client_tasks.append(
+            asyncio.create_task(
+                _run_main_py(
+                    main_py_path,
+                    client._syftbox_client.config_path,
+                    client.email,
+                    log_dir,
+                    mock_dataset_path,
+                )
+            )
+        )
+
+    ds_return_code = await ds_task
+    if ds_return_code != 0:
+        run_success = False
+
+    # log out ds client logs
+    with open(log_dir / f"{ds_client.email}.log", "r") as log_file:
+        log_content = log_file.read().strip()
+        logger.info(f"DS client '{ds_client.email}' logs:\n{log_content}")
+
+    # cancel all client tasks if DS client returns
+    logger.debug("Cancelling DO client tasks as DS client returned")
+    for task in client_tasks:
+        if not task.done():
+            task.cancel()
+
+    await asyncio.gather(*client_tasks, return_exceptions=True)
+
+    return run_success
+
+
+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")
+
+    if not project_dir.is_dir():
+        raise NotADirectoryError(f"Project directory {project_dir} is not a directory")
+
+    if not (project_dir / "main.py").exists():
+        raise FileNotFoundError(f"main.py not found at {project_dir}")
+
+    if not (project_dir / "pyproject.toml").exists():
+        raise FileNotFoundError(f"pyproject.toml not found at {project_dir}")
+
+
+def _validate_mock_dataset_paths(mock_dataset_paths: list[str]) -> list[Path]:
+    """Validate the mock dataset paths"""
+    resolved_paths = []
+    for path in mock_dataset_paths:
+        path = Path(path).expanduser().resolve()
+        if not path.exists():
+            raise ValueError(f"Mock dataset path {path} does not exist")
+        resolved_paths.append(path)
+    return resolved_paths
+
+
+def run(
+    project_dir: Union[str, Path], mock_dataset_paths: list[Union[str, Path]]
+) -> 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)
+    mock_dataset_paths = _validate_mock_dataset_paths(mock_dataset_paths)
+
+    # 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"]
+
+    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(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)
+        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)
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        loop.run_until_complete(main())
+        loop.close()
+        return simulation_success  # Return success status for synchronous execution

syft_flwr/serde.py

@@ -0,0 +1,15 @@
+from flwr.common.message import Message
+from flwr.common.serde import message_from_proto, message_to_proto
+from flwr.proto.message_pb2 import Message as ProtoMessage
+
+
+def bytes_to_flower_message(data: bytes) -> Message:
+    message_pb = ProtoMessage()
+    message_pb.ParseFromString(data)
+    message = message_from_proto(message_pb)
+    return message
+
+
+def flower_message_to_bytes(message: Message) -> bytes:
+    msg_proto = message_to_proto(message)
+    return msg_proto.SerializeToString()

syft_flwr/strategy/__init__.py

@@ -0,0 +1,3 @@
+from syft_flwr.strategy.fedavg import FedAvgWithModelSaving
+
+__all__ = ["FedAvgWithModelSaving"]

syft_flwr/strategy/fedavg.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+from loguru import logger
+from safetensors.numpy import save_file
+
+from flwr.common import parameters_to_ndarrays
+from flwr.server.strategy import FedAvg
+
+
+class FedAvgWithModelSaving(FedAvg):
+    """This is a custom strategy that behaves exactly like
+    FedAvg with the difference of storing of the state of
+    the global model to disk after each round.
+    Ref: https://discuss.flower.ai/t/how-do-i-save-the-global-model-after-training/71/2
+    """
+
+    def __init__(self, save_path: str, *args, **kwargs):
+        self.save_path = Path(save_path)
+        self.save_path.mkdir(exist_ok=True, parents=True)
+        super().__init__(*args, **kwargs)
+
+    def _save_global_model(self, server_round: int, parameters):
+        """A new method to save the parameters to disk."""
+        ndarrays = parameters_to_ndarrays(parameters)
+        tensor_dict = {f"layer_{i}": array for i, array in enumerate(ndarrays)}
+        filename = self.save_path / f"parameters_round_{server_round}.safetensors"
+        if not self.save_path.exists():
+            logger.error(
+                f"Save directory {self.save_path} does NOT exist! Maybe it's deleted or moved."
+            )
+        else:
+            save_file(tensor_dict, str(filename))
+            logger.info(f"Checkpoint saved to: {filename}")
+
+    def evaluate(self, server_round: int, parameters):
+        """Evaluate model parameters using an evaluation function."""
+        self._save_global_model(server_round, parameters)
+        return super().evaluate(server_round, parameters)

syft_flwr/templates/main.py.tpl

@@ -0,0 +1,31 @@
+import os
+import sys
+from pathlib import Path
+
+from syft_core import Client
+
+from syft_flwr.config import load_flwr_pyproject
+from syft_flwr.run import syftbox_run_flwr_client, syftbox_run_flwr_server
+
+DATA_DIR = os.getenv("DATA_DIR")
+OUTPUT_DIR = os.getenv("OUTPUT_DIR")
+
+
+flower_project_dir = Path(__file__).parent.absolute()
+client = Client.load()
+config = load_flwr_pyproject(flower_project_dir)
+
+is_client = client.email in config["tool"]["syft_flwr"]["datasites"]
+is_server = client.email in config["tool"]["syft_flwr"]["aggregator"]
+
+if is_client:
+    # run by each DO
+    syftbox_run_flwr_client(flower_project_dir)
+    sys.exit(0)  # Exit cleanly after client work completes
+elif is_server:
+    # run by the DS
+    syftbox_run_flwr_server(flower_project_dir)
+    sys.exit(0)  # Exit cleanly after server work completes
+else:
+    raise ValueError(f"{client.email} is not in config.datasites or config.aggregator")
+    sys.exit(1)  # Exit with error code

syft_flwr/utils.py

@@ -0,0 +1,126 @@
+import os
+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"^[^@]+@[^@]+\.[^@]+$"
+
+
+def is_valid_datasite(datasite: str) -> bool:
+    return re.match(EMAIL_REGEX, datasite)
+
+
+def str_to_int(input_string: str) -> int:
+    """Convert a string to an int32"""
+    return zlib.crc32(input_string.encode())
+
+
+def get_syftbox_dataset_path() -> Path:
+    """Get the path to the syftbox dataset from the environment variable"""
+    data_dir = Path(os.getenv("DATA_DIR", ".data/"))
+    if not data_dir.exists():
+        raise FileNotFoundError(
+            f"Path {data_dir} does not exist (must be a valid file or directory)"
+        )
+    return data_dir
+
+
+def run_syft_flwr() -> bool:
+    """Util function to check if we are running with syft_flwr or plain flwr
+    Currently only checks the `DATA_DIR` environment variable.
+    """
+    try:
+        get_syftbox_dataset_path()
+        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:
+        # Allow standalone error messages when we can't parse the original message
+        if error is not None:
+            logger.warning(
+                "Creating error message without reply_to (failed to parse request)"
+            )
+            return Message(
+                content=RecordDict(),
+                dst_node_id=dst_node_id,
+                message_type=message_type,
+                ttl=ttl,
+                group_id=group_id,
+                error=error,
+            )
+        return Message(
+            content=content,
+            dst_node_id=dst_node_id,
+            message_type=message_type,
+            ttl=ttl,
+            group_id=group_id,
+        )

syft_flwr-0.4.3.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: syft-flwr
+Version: 0.4.3
+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.14,>=3.11
+Requires-Dist: flwr-datasets[vision]>=0.5.0
+Requires-Dist: flwr[simulation]==1.23.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: safetensors>=0.6.2
+Requires-Dist: syft-rds>=0.5.0
+Requires-Dist: tomli-w>=1.2.0
+Requires-Dist: tomli>=2.3.0
+Requires-Dist: typing-extensions>=4.13.0
+Description-Content-Type: text/markdown
+
+# syft_flwr
+
+`syft_flwr` is an open source framework that facilitate federated learning (FL) projects using [Flower](https://github.com/adap/flower) over the [SyftBox](https://github.com/OpenMined/syftbox) protocol
+
+![FL Training Process](https://github.com/OpenMined/syft-flwr/raw/main/notebooks/fl-diabetes-prediction/images/fltraining.gif)
+
+## Example Usages
+Please look at the `notebooks/` folder for example use cases:
+-  [FL diabetes prediction](notebooks/fl-diabetes-prediction/README.md) shows how to train a federated model over distributed machines for multiple rounds
+-  [Federated analytics](notebooks/federated-analytics-diabetes/README.md) shows how to query statistics from private datasets from distributed machines and then aggregate them
+-  [FedRAG (Federated RAG)](notebooks/fedrag/README.md) demonstrates privacy-preserving question answering using Retrieval Augmented Generation across distributed document sources with remote data science workflow
+
+## Development
+### Releasing
+See [RELEASE.md](RELEASE.md) for the complete release process.

syft_flwr-0.4.3.dist-info/RECORD

@@ -0,0 +1,21 @@
+syft_flwr/__init__.py,sha256=qv6zlv2IIqGKbasMfg9lxF1seQFruuG0WPBMQ6KaVS0,426
+syft_flwr/bootstrap.py,sha256=mtEWo5z7HZwf73KvxYZOdgXFBzTsNMxRaugByRuYJyU,3578
+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=F6YA_abPjOlXdu0DNw9H6w1pVrXtkxMfpsAXLXBk8DU,7433
+syft_flwr/flower_server.py,sha256=ZNDUR1U79M0BaG7n39TGUkVHV2NYi-LDsN8FqKJFfFQ,1508
+syft_flwr/grid.py,sha256=WCEjrHJNZQBSnhIOKfU-gTAm7p_DIyBxNtTx-rdjmVE,21646
+syft_flwr/mounts.py,sha256=hp0TKVot16SaPYO10Y_mSJGei7aiNteJfK4U4vynWmU,2330
+syft_flwr/run.py,sha256=9KkRvT99yGX4beAMR2oKG0__b9gXdsE2Y2XKbAtELec,2147
+syft_flwr/run_simulation.py,sha256=KPokzKvS6XWselHE0vQ3ZsYjxhieuAFTdZBisOogIkw,12182
+syft_flwr/serde.py,sha256=5fCI-cRUOh5wE7cXQd4J6jex1grRGnyD1Jx-VlEDOXM,495
+syft_flwr/utils.py,sha256=7DNNPAFoy0GDxB3qV6Yt6uP0tGxb-ms6nt_QlcE6T7k,4063
+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=u6IbtNGv6YyEx60DxVM1FLSeMAFjXL-KSD1lNGWSifg,962
+syft_flwr-0.4.3.dist-info/METADATA,sha256=7NgLuczwcuf8McinTZ4GvS1YB3EsbJ_NaMR4JU96IZw,1615
+syft_flwr-0.4.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+syft_flwr-0.4.3.dist-info/entry_points.txt,sha256=o7oT0dCoHn-3WyIwdDw1lBh2q-GvhB_8s0hWeJU4myc,49
+syft_flwr-0.4.3.dist-info/licenses/LICENSE,sha256=0msOUar8uPZTqkAOTBp4rCzd7Jl9eRhfKiNufwrsg7k,11361
+syft_flwr-0.4.3.dist-info/RECORD,,

syft_flwr-0.4.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

syft_flwr-0.4.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+syft_flwr = syft_flwr.cli:main