MEDfl 2.0.3__tar.gz → 2.0.4__tar.gz

medfl-2.0.4/MEDfl/rw/server.py

@@ -0,0 +1,82 @@
+import flwr as fl
+from flwr.server.strategy import FedAvg
+from flwr.server.server import ServerConfig
+from typing import Optional, Any, List, Tuple, Dict, Callable
+from MEDfl.rw.strategy import Strategy
+from MEDfl.rw.verbose_server import VerboseServer
+import time
+from flwr.server.client_manager import ClientManager
+from flwr.server.client_proxy import ClientProxy
+from flwr.common import GetPropertiesIns
+import asyncio
+
+class FederatedServer:
+    """
+    Wrapper for launching a Flower federated-learning server,
+    using a Strategy instance as its strategy attribute.
+    Now with client connection tracking.
+    """
+    def __init__(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 8080,
+        num_rounds: int = 3,
+        strategy: Optional[Strategy] = None,
+        certificates: Optional[Any] = None,
+    ):
+        self.server_address = f"{host}:{port}"
+        self.server_config = ServerConfig(num_rounds=num_rounds)
+        # If no custom strategy provided, use default
+        self.strategy_wrapper = strategy or Strategy()
+        # Build the actual Flower strategy object
+        self.strategy_wrapper.create_strategy()
+        if self.strategy_wrapper.strategy_object is None:
+            raise ValueError("Strategy object not initialized. Call create_strategy() first.")
+        self.strategy = self.strategy_wrapper.strategy_object
+        self.certificates = certificates
+        self.connected_clients = []
+
+    def start(self) -> None:
+        """
+        Start the Flower server with the configured strategy.
+        Now tracks and logs client connections before starting.
+        """
+        print(f"Using strategy: {self.strategy_wrapper.name}")
+        print(f"Starting Flower server on {self.server_address} with strategy {self.strategy_wrapper.name}")
+        
+        # Create a custom client manager to track connections
+        client_manager = TrackingClientManager(self)
+        
+        fl.server.start_server(
+            server_address=self.server_address,
+            config=self.server_config,
+            strategy=self.strategy,
+            certificates=self.certificates,
+            client_manager=client_manager,
+        )
+
+class TrackingClientManager(fl.server.client_manager.SimpleClientManager):
+    """
+    Custom client manager that tracks and logs client connections.
+    """
+    def __init__(self, server: FederatedServer):
+        super().__init__()
+        self.server = server
+        self.client_properties = {}  # Store client properties
+
+    def register(self, client: ClientProxy) -> bool:
+        success = super().register(client)
+        if success and client.cid not in self.server.connected_clients:
+            # Run the async fetch synchronously
+            asyncio.run(self._fetch_and_log_hostname(client))
+        return success
+
+    async def _fetch_and_log_hostname(self, client: ClientProxy):
+        # try:
+        #     ins = GetPropertiesIns(config={})
+        #     props = await client.get_properties(ins=ins, timeout=10.0, group_id=0)
+        #     hostname = props.properties.get("hostname", "unknown")
+        # except Exception as e:
+        #     hostname = f"Error: {e}"
+        print(f"✅ Client connected - CID: {client.cid}")
+        self.server.connected_clients.append(client.cid)

{medfl-2.0.3 → medfl-2.0.4}/MEDfl/rw/strategy.py

@@ -105,18 +105,36 @@ class Strategy:
         # 2) Wrap aggregate_fit to log
         original_agg_fit = strat.aggregate_fit
         def logged_aggregate_fit(rnd, results, failures):
+            # Print individual client fit metrics
+            print(f"\n[Server] 🔄 Round {rnd} - Client Training Metrics:")
+            for i, (client_id, fit_res) in enumerate(results):
+                print(f"  Client {client_id.cid}: {fit_res.metrics}")
+
+            # Call original aggregation function
             aggregated_params, metrics = original_agg_fit(rnd, results, failures)
-            print(f"[Server] ✔ Round {rnd} fit complete → Metrics: {metrics}")
+
+            # Print aggregated metrics
+            print(f"[Server] ✅ Round {rnd} - Aggregated Training Metrics: {metrics}\n")
             return aggregated_params, metrics
+
         strat.aggregate_fit = logged_aggregate_fit  # type: ignore
 
         # 3) Wrap aggregate_evaluate to log
         original_agg_eval = strat.aggregate_evaluate
         def logged_aggregate_evaluate(rnd, results, failures):
+            # Print individual client evaluation metrics
+            print(f"\n[Server] 📊 Round {rnd} - Client Evaluation Metrics:")
+            for i, (client_id, eval_res) in enumerate(results):
+                print(f"  Client {client_id.cid}: {eval_res.metrics}")
+
+            # Call original aggregation function
             loss, metrics = original_agg_eval(rnd, results, failures)
-            print(results)
-            print(f"[Server] ✔ Round {rnd} eval complete → Loss: {loss}, Metrics: {metrics}")
+
+            # Print aggregated metrics
+            print(f"[Server] ✅ Round {rnd} - Aggregated Evaluation Metrics:")
+            print(f"  Loss: {loss}, Metrics: {metrics}\n")
             return loss, metrics
+
         strat.aggregate_evaluate = logged_aggregate_evaluate  # type: ignore
 
         self.strategy_object = strat

medfl-2.0.4/MEDfl/rw/verbose_server.py

@@ -0,0 +1,21 @@
+from flwr.server import Server
+from flwr.server.client_manager import SimpleClientManager
+from flwr.server.client_proxy import ClientProxy
+from flwr.common.logger import log
+from logging import INFO
+
+class VerboseServer(Server):
+    def __init__(self, strategy):
+        super().__init__(client_manager=SimpleClientManager(), strategy=strategy)
+
+    def client_manager_fn(self):
+        return self.client_manager
+
+    def on_client_connect(self, client: ClientProxy):
+        super().on_client_connect(client)
+        log(INFO, f"[Server] ➕ Client connected: {client.cid}")
+        log(INFO, f"[Server] Currently connected: {len(self.client_manager.all().values())} clients")
+
+    def on_client_disconnect(self, client: ClientProxy):
+        super().on_client_disconnect(client)
+        log(INFO, f"[Server] ❌ Client disconnected: {client.cid}")

{medfl-2.0.3 → medfl-2.0.4}/MEDfl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MEDfl
-Version: 2.0.3
+Version: 2.0.4
 Summary: Python Open-source package for simulating federated learning and differential privacy
 Home-page: https://github.com/MEDomics-UdeS/MEDfl
 Author: MEDomics consortium

{medfl-2.0.3 → medfl-2.0.4}/MEDfl.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ MEDfl/rw/model.py
 MEDfl/rw/rwConfig.py
 MEDfl/rw/server.py
 MEDfl/rw/strategy.py
+MEDfl/rw/verbose_server.py
 MEDfl/scripts/__init__.py
 MEDfl/scripts/base.py
 MEDfl/scripts/create_db.py

{medfl-2.0.3 → medfl-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MEDfl
-Version: 2.0.3
+Version: 2.0.4
 Summary: Python Open-source package for simulating federated learning and differential privacy
 Home-page: https://github.com/MEDomics-UdeS/MEDfl
 Author: MEDomics consortium

{medfl-2.0.3 → medfl-2.0.4}/setup.py

@@ -14,7 +14,7 @@ with open('requirements.txt') as f:
 
 setup(
     name="MEDfl",
-    version="2.0.3",
+    version="2.0.4",
     author="MEDomics consortium",
     author_email="medomics.info@gmail.com",
     description="Python Open-source package for simulating federated learning and differential privacy",

medfl-2.0.3/MEDfl/rw/server.py

@@ -1,42 +0,0 @@
-
-import flwr as fl
-from flwr.server.strategy import FedAvg
-from flwr.server.server import ServerConfig
-from typing import  Optional, Any
-from MEDfl.rw.strategy import Strategy
-
-class FederatedServer:
-    """
-    Wrapper for launching a Flower federated-learning server,
-    using a Strategy instance as its strategy attribute.
-    """
-    def __init__(
-        self,
-        host: str = "0.0.0.0",
-        port: int = 8080,
-        num_rounds: int = 3,
-        strategy: Optional[Strategy] = None,
-        certificates: Optional[Any] = None,
-    ):
-        self.server_address = f"{host}:{port}"
-        self.server_config = ServerConfig(num_rounds=num_rounds)
-        # If no custom strategy provided, use default
-        self.strategy_wrapper = strategy or Strategy()
-        # Build the actual Flower strategy object
-        self.strategy_wrapper.create_strategy()
-        if self.strategy_wrapper.strategy_object is None:
-            raise ValueError("Strategy object not initialized. Call create_strategy() first.")
-        self.strategy = self.strategy_wrapper.strategy_object
-        self.certificates = certificates
-
-    def start(self) -> None:
-        """
-        Start the Flower server with the configured strategy.
-        """
-        print(f"Starting Flower server on {self.server_address} with strategy {self.strategy_wrapper.name}")
-        fl.server.start_server(
-            server_address=self.server_address,
-            config=self.server_config,
-            strategy=self.strategy,
-            certificates=self.certificates,
-        )