MEDfl 2.0.4.dev1__py3-none-any.whl → 2.0.4.dev3__py3-none-any.whl

MEDfl/rw/client.py

@@ -1,39 +1,108 @@
+# client.py
+"""
+Federated Learning Client with Optional Differential Privacy.
+
+"""
+
+import argparse
+import pandas as pd
 import flwr as fl
 import torch
 import torch.nn as nn
 import torch.optim as optim
-from model import Net
+from torch.utils.data import TensorDataset, DataLoader
+from sklearn.metrics import accuracy_score, roc_auc_score
+from model import Net  # Local model definition
+import socket
+import platform
+
+
+class DPConfig:
+    """
+    Configuration for Differential Privacy (DP) settings.
+
+    Attributes:
+        noise_multiplier (float): Noise multiplier for DP.
+        max_grad_norm (float): Maximum gradient norm (clipping threshold).
+        batch_size (int): Batch size for training.
+        secure_rng (bool): Whether to use a secure RNG for DP noise.
+    """
+
+    def __init__(
+        self,
+        noise_multiplier: float = 1.0,
+        max_grad_norm: float = 1.0,
+        batch_size: int = 32,
+        secure_rng: bool = False,
+    ):
+        self.noise_multiplier = noise_multiplier
+        self.max_grad_norm = max_grad_norm
+        self.batch_size = batch_size
+        self.secure_rng = secure_rng
 
-# Dummy training data
-X_train = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
-y_train = torch.tensor([[1.0], [0.0]])
 
 class FlowerClient(fl.client.NumPyClient):
-    def __init__(self):
-        self.model = Net()
-        self.loss_fn = nn.MSELoss()
+    """
+    FlowerClient: A federated learning client that trains a PyTorch model
+    and optionally applies differential privacy.
+
+    """
+
+    def __init__(
+        self,
+        server_address: str,
+        data_path: str = "data/data.csv",
+        dp_config: DPConfig = None,
+    ):
+        """
+        Initialize client by loading data, creating model, optimizer,
+        and optionally enabling DP.
+
+        Args:
+            server_address (str): Flower server address.
+            data_path (str): Path to CSV dataset.
+            dp_config (DPConfig): Optional DP configuration.
+        """
+        self.server_address = server_address
+
+        # ---------- Load Data ----------
+        df = pd.read_csv(data_path)
+        X = df.iloc[:, :-1].values
+        y = df.iloc[:, -1].values
+
+        self.X_tensor = torch.tensor(X, dtype=torch.float32)
+        self.y_tensor = torch.tensor(y, dtype=torch.float32)
+
+        batch_size = dp_config.batch_size if dp_config else 32
+        dataset = TensorDataset(self.X_tensor, self.y_tensor)
+        self.train_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
+
+        # ---------- Model and Optimizer ----------
+        input_dim = X.shape[1]
+        self.model = Net(input_dim)
+        self.criterion = nn.BCEWithLogitsLoss()
         self.optimizer = optim.SGD(self.model.parameters(), lr=0.01)
 
+        # ---------- Differential Privacy ----------
+        self.privacy_engine = None
+        if dp_config is not None:
+            try:
+                from opacus import PrivacyEngine
+
+                self.privacy_engine = PrivacyEngine()
+                self.model, self.optimizer, self.train_loader = self.privacy_engine.make_private(
+                    module=self.model,
+                    optimizer=self.optimizer,
+                    data_loader=self.train_loader,
+                    noise_multiplier=dp_config.noise_multiplier,
+                    max_grad_norm=dp_config.max_grad_norm,
+                    secure_rng=dp_config.secure_rng,
+                )
+            except ImportError:
+                print("⚠️ Opacus not installed, running without DP.")
+
     def get_parameters(self, config):
-        return [val.cpu().numpy() for val in self.model.state_dict().values()]
-
-    def set_parameters(self, parameters):
-        params_dict = zip(self.model.state_dict().keys(), parameters)
-        state_dict = {k: torch.tensor(v) for k, v in params_dict}
-        self.model.load_state_dict(state_dict, strict=True)
-
-    def fit(self, parameters, config):
-        self.set_parameters(parameters)
-        self.model.train()
-        for _ in range(5):
-            self.optimizer.zero_grad()
-            output = self.model(X_train)
-            loss = self.loss_fn(output, y_train)
-            loss.backward()
-            self.optimizer.step()
-        return self.get_parameters(config), len(X_train), {}
-
-    def evaluate(self, parameters, config):
-        return 0.5, len(X_train), {}
-
-fl.client.start_numpy_client(server_address="100.65.215.27:8080", client=FlowerClient())
+        """
+        Get model parameters as a list of NumPy arrays.
+        """
+        return [val.cpu().numpy() for val in self.mo]()

MEDfl/rw/model.py

@@ -2,18 +2,46 @@ import torch.nn as nn
 import torch.nn.functional as F
 
 class Net(nn.Module):
+    """
+    Net defines a simple feedforward neural network with two hidden layers
+
+    """
+
     def __init__(self, input_dim):
+        """
+        Initialize the layers of the network.
+
+        Args:
+            input_dim (int): Number of input features.
+        """
         super().__init__()
+        # First fully connected layer: input_dim → 64
         self.fc1 = nn.Linear(input_dim, 64)
+        # Second fully connected layer: 64 → 32
         self.fc2 = nn.Linear(64, 32)
+        # Output layer: 32 → 1
         self.fc3 = nn.Linear(32, 1)
+        # Dropout with 30% probability
         self.dropout = nn.Dropout(0.3)
+        # Batch normalization layers for hidden layers
         self.batchnorm1 = nn.BatchNorm1d(64)
         self.batchnorm2 = nn.BatchNorm1d(32)
 
     def forward(self, x):
+        """
+        Define the forward pass of the network.
+
+        Args:
+            x (torch.Tensor): Input tensor of shape (batch_size, input_dim).
+
+        Returns:
+            torch.Tensor: Output logits of shape (batch_size, 1).
+        """
+        # Hidden layer 1: linear → batchnorm → ReLU → dropout
         x = F.relu(self.batchnorm1(self.fc1(x)))
         x = self.dropout(x)
+        # Hidden layer 2: linear → batchnorm → ReLU → dropout
         x = F.relu(self.batchnorm2(self.fc2(x)))
         x = self.dropout(x)
+        # Output layer: linear
         return self.fc3(x)  # raw logits for BCEWithLogitsLoss

MEDfl/rw/server.py

@@ -1,21 +1,32 @@
 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 typing import Optional, Any
 from MEDfl.rw.strategy import Strategy
-from MEDfl.rw.verbose_server import VerboseServer
-import time
+import asyncio
 from flwr.server.client_manager import ClientManager
 from flwr.server.client_proxy import ClientProxy
 from flwr.common import GetPropertiesIns
-import asyncio
+from flwr.common import GetPropertiesIns
+
 
 class FederatedServer:
     """
-    Wrapper for launching a Flower federated-learning server,
-    using a Strategy instance as its strategy attribute.
-    Now with client connection tracking.
+    FederatedServer wraps the launch and configuration of a Flower federated learning server.
+
+    Attributes:
+        server_address (str): Server host and port in the format "host:port".
+        server_config (ServerConfig): Configuration for the Flower server.
+        strategy_wrapper (Strategy): Wrapper around the actual Flower strategy.
+        strategy (flwr.server.Strategy): Actual Flower strategy instance.
+        certificates (Any): Optional TLS certificates.
+        connected_clients (list): List of connected client IDs.
+
+    Methods:
+        start():
+            Launch the Flower server with the specified strategy and log client connections.
     """
+
     def __init__(
         self,
         host: str = "0.0.0.0",
@@ -24,29 +35,42 @@ class FederatedServer:
         strategy: Optional[Strategy] = None,
         certificates: Optional[Any] = None,
     ):
+        """
+        Initialize the FederatedServer.
+
+        Args:
+            host (str): Hostname or IP to bind the server to.
+            port (int): Port to listen on.
+            num_rounds (int): Number of federated learning rounds to execute.
+            strategy (Optional[Strategy]): Optional custom strategy wrapper.
+            certificates (Optional[Any]): Optional TLS certificates.
+        """
+        # Server address and configuration
         self.server_address = f"{host}:{port}"
         self.server_config = ServerConfig(num_rounds=num_rounds)
-        # If no custom strategy provided, use default
+
+        # Use custom or default strategy
         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 = []
+        self.connected_clients = []  # Track connected client IDs
+
 
     def start(self) -> None:
         """
-        Start the Flower server with the configured strategy.
-        Now tracks and logs client connections before starting.
+        Start the Flower server with the configured strategy and track client connections.
         """
         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
+
+        # Use a custom client manager that logs client connections
         client_manager = TrackingClientManager(self)
-        
+
+        # Launch the Flower server
         fl.server.start_server(
             server_address=self.server_address,
             config=self.server_config,
@@ -55,28 +79,57 @@ class FederatedServer:
             client_manager=client_manager,
         )
 
+
 class TrackingClientManager(fl.server.client_manager.SimpleClientManager):
     """
-    Custom client manager that tracks and logs client connections.
+    TrackingClientManager extends the default SimpleClientManager to log client connections.
+
+    Attributes:
+        server (FederatedServer): The FederatedServer instance this manager belongs to.
+        client_properties (dict): Placeholder for storing client-specific properties.
     """
+
     def __init__(self, server: FederatedServer):
+        """
+        Initialize the TrackingClientManager.
+
+        Args:
+            server (FederatedServer): Reference to the FederatedServer.
+        """
         super().__init__()
         self.server = server
-        self.client_properties = {}  # Store client properties
+        self.client_properties = {}
 
     def register(self, client: ClientProxy) -> bool:
+        """
+        Register a client and log its connection.
+
+        Args:
+            client (ClientProxy): The client proxy being registered.
+
+        Returns:
+            bool: True if the client was registered successfully.
+        """
         success = super().register(client)
         if success and client.cid not in self.server.connected_clients:
-            # Run the async fetch synchronously
+            # Run the asynchronous hostname fetch synchronously
             asyncio.run(self._fetch_and_log_hostname(client))
         return success
 
     async def _fetch_and_log_hostname(self, client: ClientProxy):
+        """
+        Asynchronously fetch and log the client's hostname or CID.
+
+        Args:
+            client (ClientProxy): The client proxy.
+        """
+        # Optional: uncomment to fetch hostname from client properties
         # 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/rw/strategy.py

@@ -1,53 +1,43 @@
 import flwr as fl
 from typing import Callable, Optional, Dict, Any, Tuple, List
+from flwr.common import GetPropertiesIns
+from flwr.server.client_manager import ClientManager
+from flwr.server.client_proxy import ClientProxy
 
-# Custom aggregation for client-returned metrics
+# ===================================================
+# Custom metric aggregation functions
+# ===================================================
 
-from typing import List, Tuple, Dict
-
-# Custom aggregation for client-returned metrics
 def aggregate_fit_metrics(
     results: List[Tuple[int, Dict[str, float]]]
 ) -> Dict[str, float]:
-    """
-    Weighted aggregation of training metrics across clients.
-    Expects each tuple (num_examples, metrics_dict) to include
-    'train_loss', 'train_accuracy', 'train_auc'.
-    """
-    # Sum total examples
-    total_examples = sum(num_examples for num_examples, _ in results)
-    # Weighted averages
-    loss = sum(metrics.get("train_loss", 0.0) * num_examples
-               for num_examples, metrics in results) / total_examples
-    accuracy = sum(metrics.get("train_accuracy", 0.0) * num_examples
-                   for num_examples, metrics in results) / total_examples
-    auc = sum(metrics.get("train_auc", 0.0) * num_examples
-              for num_examples, metrics in results) / total_examples
-    return {"train_loss": loss, "train_accuracy": accuracy, "train_auc": auc}
-
+    total = sum(n for n, _ in results)
+    loss = sum(m.get("train_loss", 0.0) * n for n, m in results) / total
+    acc = sum(m.get("train_accuracy", 0.0) * n for n, m in results) / total
+    auc = sum(m.get("train_auc", 0.0) * n for n, m in results) / total
+    return {"train_loss": loss, "train_accuracy": acc, "train_auc": auc}
 
 def aggregate_eval_metrics(
     results: List[Tuple[int, Dict[str, float]]]
 ) -> Dict[str, float]:
-    """
-    Weighted aggregation of evaluation metrics across clients.
-    Expects each tuple (num_examples, metrics_dict) to include
-    'eval_loss', 'eval_accuracy', 'eval_auc'.
-    """
-    total_examples = sum(num_examples for num_examples, _ in results)
-    loss = sum(metrics.get("eval_loss", 0.0) * num_examples
-               for num_examples, metrics in results) / total_examples
-    accuracy = sum(metrics.get("eval_accuracy", 0.0) * num_examples
-                   for num_examples, metrics in results) / total_examples
-    auc = sum(metrics.get("eval_auc", 0.0) * num_examples
-              for num_examples, metrics in results) / total_examples
-    return {"eval_loss": loss, "eval_accuracy": accuracy, "eval_auc": auc}
+    total = sum(n for n, _ in results)
+    loss = sum(m.get("eval_loss", 0.0) * n for n, m in results) / total
+    acc = sum(m.get("eval_accuracy", 0.0) * n for n, m in results) / total
+    auc = sum(m.get("eval_auc", 0.0) * n for n, m in results) / total
+    return {"eval_loss": loss, "eval_accuracy": acc, "eval_auc": auc}
+
+# ===================================================
+# Strategy Wrapper
+# ===================================================
 
 class Strategy:
     """
-    A wrapper for Flower server strategies, with custom metric aggregation
-    and console logs on aggregation/evaluation completion.
+    Flower Strategy wrapper:
+    - Custom metric aggregation
+    - Per-client & aggregated metric logging
+    - Synchronous get_properties() inspection in configure_fit()
     """
+
     def __init__(
         self,
         name: str = "FedAvg",
@@ -57,16 +47,9 @@ class Strategy:
         min_evaluate_clients: int = 2,
         min_available_clients: int = 2,
         initial_parameters: Optional[List[Any]] = None,
-        evaluate_fn: Optional[Callable[
-            [int, fl.common.Parameters, Dict[str, Any]],
-            Tuple[float, Dict[str, float]]
-        ]] = None,
-        fit_metrics_aggregation_fn: Optional[
-            Callable[[List[Tuple[int, fl.common.FitRes]]], Dict[str, float]]
-        ] = None,
-        evaluate_metrics_aggregation_fn: Optional[
-            Callable[[List[Tuple[int, fl.common.EvaluateRes]]], Dict[str, float]]
-        ] = None,
+        evaluate_fn: Optional[Callable] = None,
+        fit_metrics_aggregation_fn: Optional[Callable] = None,
+        evaluate_metrics_aggregation_fn: Optional[Callable] = None,
     ) -> None:
         self.name = name
         self.fraction_fit = fraction_fit
@@ -76,13 +59,13 @@ class Strategy:
         self.min_available_clients = min_available_clients
         self.initial_parameters = initial_parameters or []
         self.evaluate_fn = evaluate_fn
-        # Use custom aggregators if provided, else default to ours
+
         self.fit_metrics_aggregation_fn = fit_metrics_aggregation_fn or aggregate_fit_metrics
         self.evaluate_metrics_aggregation_fn = evaluate_metrics_aggregation_fn or aggregate_eval_metrics
+
         self.strategy_object: Optional[fl.server.strategy.Strategy] = None
 
     def create_strategy(self) -> None:
-        # 1) Instantiate the underlying Flower strategy
         StrategyClass = getattr(fl.server.strategy, self.name)
         params: Dict[str, Any] = {
             "fraction_fit": self.fraction_fit,
@@ -91,50 +74,61 @@ class Strategy:
             "min_evaluate_clients": self.min_evaluate_clients,
             "min_available_clients": self.min_available_clients,
             "evaluate_fn": self.evaluate_fn,
-            # Plug in our custom aggregators
             "fit_metrics_aggregation_fn": self.fit_metrics_aggregation_fn,
             "evaluate_metrics_aggregation_fn": self.evaluate_metrics_aggregation_fn,
         }
         if self.initial_parameters:
-            params["initial_parameters"] = fl.common.ndarrays_to_parameters(
-                self.initial_parameters
-            )
+            params["initial_parameters"] = fl.common.ndarrays_to_parameters(self.initial_parameters)
 
         strat = StrategyClass(**params)
 
-        # 2) Wrap aggregate_fit to log
+        # Wrap aggregate_fit to log metrics
         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:")
+        def logged_agg_fit(server_round, results, failures):
+            print(f"\n[Server] 🔄 Round {server_round} - Client Training Metrics:")
             for i, (client_id, fit_res) in enumerate(results):
-                print(f" CTM Round {rnd} Client:{client_id.cid}: {fit_res.metrics}")
-
-            # Call original aggregation function
-            aggregated_params, metrics = original_agg_fit(rnd, results, failures)
-
-            # 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
+                print(f" CTM Round {server_round} Client:{client_id.cid}: {fit_res.metrics}")
+            agg_params, metrics = original_agg_fit(server_round, results, failures)
+            print(f"[Server] ✅ Round {server_round} - Aggregated Training Metrics: {metrics}\n")
+            return agg_params, metrics
+        strat.aggregate_fit = logged_agg_fit
 
-        # 3) Wrap aggregate_evaluate to log
+        # Wrap aggregate_evaluate to log metrics
         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:")
+        def logged_agg_eval(server_round, results, failures):
+            print(f"\n[Server] 📊 Round {server_round} - Client Evaluation Metrics:")
             for i, (client_id, eval_res) in enumerate(results):
-                print(f" CEM Round {rnd} Client:{client_id.cid}: {eval_res.metrics}")
-
-            # Call original aggregation function
-            loss, metrics = original_agg_eval(rnd, results, failures)
-
-            # Print aggregated metrics
-            print(f"[Server] ✅ Round {rnd} - Aggregated Evaluation Metrics:")
-            print(f"  Loss: {loss}, Metrics: {metrics}\n")
+                print(f" CEM Round {server_round} Client:{client_id.cid}: {eval_res.metrics}")
+            loss, metrics = original_agg_eval(server_round, results, failures)
+            print(f"[Server] ✅ Round {server_round} - Aggregated Evaluation Metrics:")
+            print(f"    Loss: {loss}, Metrics: {metrics}\n")
             return loss, metrics
+        strat.aggregate_evaluate = logged_agg_eval
+
+        # Wrap configure_fit to inspect client properties synchronously
+        original_conf_fit = strat.configure_fit
+        def wrapped_conf_fit(
+            server_round: int,
+            parameters,
+            client_manager: ClientManager
+        ):
+            selected = original_conf_fit(
+                server_round=server_round,
+                parameters=parameters,
+                client_manager=client_manager
+            )
+
+            # Synchronously fetch & log properties
+            ins = GetPropertiesIns(config={})
+            for client, _ in selected:
+                try:
+                    props = client.get_properties(ins=ins, timeout=10.0, group_id=0)
+                    print(f"\n📋 [Round {server_round}] Client {client.cid} Properties: {props.properties}")
+                    
+                except Exception as e:
+                    print(f"⚠️ Failed to get properties from {client.cid}: {e}")
 
-        strat.aggregate_evaluate = logged_aggregate_evaluate  # type: ignore
+            return selected
 
+        strat.configure_fit = wrapped_conf_fit
         self.strategy_object = strat

{MEDfl-2.0.4.dev1.dist-info → MEDfl-2.0.4.dev3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MEDfl
-Version: 2.0.4.dev1
+Version: 2.0.4.dev3
 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.4.dev3.dist-info/RECORD

@@ -0,0 +1,36 @@
+MEDfl/__init__.py,sha256=70DmtU4C3A-1XYoaYm0moXBe-YGJ2FhEe3ga5SQVTts,97
+MEDfl/LearningManager/__init__.py,sha256=IMHJVeyx5ew0U_90LNMNCd4QISzWv3XCCri7fQRvcsM,341
+MEDfl/LearningManager/client.py,sha256=9Y_Zb0yxvCxx3dVCPQ1bXS5mCKasylSBnoVj-RDN270,5933
+MEDfl/LearningManager/dynamicModal.py,sha256=q8u7xPpj_TdZnSr8kYj0Xx7Sdz-diXsKBAfVce8-qSU,10534
+MEDfl/LearningManager/federated_dataset.py,sha256=InsZ5Rys2dgqaPxVyP5G3TrJMwiCNHOoTd3tCpUwUVM,2081
+MEDfl/LearningManager/flpipeline.py,sha256=5lT2uod5EqnkRQ04cgm0gYyZz0djumfIYipCrzX1fdo,7111
+MEDfl/LearningManager/model.py,sha256=vp8FIMxBdz3FTF5wJaea2IO_WGeANLZgBxTKVe3gW3Q,7456
+MEDfl/LearningManager/params.yaml,sha256=Ix1cNtlWr3vDC0te6pipl5w8iLADO6dZvwm633-VaIA,436
+MEDfl/LearningManager/params_optimiser.py,sha256=8e0gCt4imwQHlNSJ3A2EAuc3wSr6yfSI6JDghohfmZQ,17618
+MEDfl/LearningManager/plot.py,sha256=A6Z8wC8J-H-OmWBPKqwK5eiTB9vzOBGMaFv1SaNA9Js,7698
+MEDfl/LearningManager/server.py,sha256=oTgW3K1UT6m4SQBk23FIf23km_BDq9vvjeC6OgY8DNw,7077
+MEDfl/LearningManager/strategy.py,sha256=BHXpwmt7jx07y45YLUs8FZry2gYQbpiV4vNbHhsksQ4,3435
+MEDfl/LearningManager/utils.py,sha256=B4RULJp-puJr724O6teI0PxnUyPV8NG-uPC6jqaiDKI,9605
+MEDfl/NetManager/__init__.py,sha256=OpgsIiBg7UA6Bfnu_kqGfEPxU8JfpPxSFU98TOeDTP0,273
+MEDfl/NetManager/database_connector.py,sha256=G8DAsD_pAIK1U67x3Q8gmSJGW7iJyxQ_NE5lWpT-P0Q,1474
+MEDfl/NetManager/dataset.py,sha256=HTV0jrJ4Qlhl2aSJzdFU1lkxGBKtmJ390eBpwfKf_4o,2777
+MEDfl/NetManager/flsetup.py,sha256=CVu_TIU7l3G6DDnwtY6JURbhIZk7gKC3unqWnU-YtlM,11434
+MEDfl/NetManager/net_helper.py,sha256=tyfxmpbleSdfPfo2ezKT0VOvZu660v9nhBuHCpl8pG4,6812
+MEDfl/NetManager/net_manager_queries.py,sha256=j-CLQPjtTLyZuFPhIcwJStD7L7xtZpkmkhe_h3pDuTs,4086
+MEDfl/NetManager/network.py,sha256=5t705fzWc-BRg-QPAbAcDv5ckDGzsPwj_Q5V0iTgkx0,6829
+MEDfl/NetManager/node.py,sha256=t90QuYZ8M1X_AG1bwTta0CnlOuodqkmpVda2K7NOgHc,6542
+MEDfl/rw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+MEDfl/rw/client.py,sha256=AQnLvM-pWVA2Md0GiRLB9C4s8S3TjcjjvN3U25ftpX4,3463
+MEDfl/rw/model.py,sha256=OAoTmOw4zGWPa_ncDqNanLeucwWHmUydKED6zlB5Hps,1510
+MEDfl/rw/server.py,sha256=TmcWUwMJ5BG7owqIVTtTC6w8bR02SESRT9lXh7BqlOg,4986
+MEDfl/rw/strategy.py,sha256=aNlyQhHslmPJdiuJjsK9hu-IUJdrWR1yuGp7pNk4LeA,5974
+MEDfl/scripts/__init__.py,sha256=Pq1weevsPaU7MRMHfBYeyT0EOFeWLeVM6Y1DVz6jw1A,48
+MEDfl/scripts/base.py,sha256=QrmG7gkiPYkAy-5tXxJgJmOSLGAKeIVH6i0jq7G9xnA,752
+MEDfl/scripts/create_db.py,sha256=MnFtZkTueRZ-3qXPNX4JsXjOKj-4mlkxoRhSFdRcvJw,3817
+alembic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+alembic/env.py,sha256=-aSZ6SlJeK1ZeqHgM-54hOi9LhJRFP0SZGjut-JnY-4,1588
+MEDfl-2.0.4.dev3.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+MEDfl-2.0.4.dev3.dist-info/METADATA,sha256=s5S0Ztt85jbo0x9kzkGRQDNrI9cMCed-qBWO4EA2q10,4326
+MEDfl-2.0.4.dev3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+MEDfl-2.0.4.dev3.dist-info/top_level.txt,sha256=dIL9X8HOFuaVSzpg40DVveDPrymWRoShHtspH7kkjdI,14
+MEDfl-2.0.4.dev3.dist-info/RECORD,,

MEDfl/rw/rwConfig.py

@@ -1,21 +0,0 @@
-from dataclasses import dataclass
-
-@dataclass
-class RealWorldConfig:
-    """
-    Configuration pour un déploiement fédéré en « real world ».
-
-    Attributes:
-        server_address: Adresse et port du serveur Flower (ex: "0.0.0.0:8080").
-        num_rounds: Nombre total de tours (rounds) de fédération.
-        fraction_fit: Fraction des clients participant à la phase de fit chaque round.
-        fraction_eval: Fraction des clients participant à la phase d'évaluation chaque round.
-        min_fit_clients: Nombre minimum de clients requis pour lancer la phase de fit.
-        min_eval_clients: Nombre minimum de clients requis pour la phase d'évaluation.
-    """
-    server_address: str
-    num_rounds: int
-    fraction_fit: float
-    fraction_eval: float
-    min_fit_clients: int
-    min_eval_clients: int

MEDfl/rw/verbose_server.py

@@ -1,21 +0,0 @@
-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}")