federated-learning-framework 0.0.61__py3-none-any.whl

federated_learning_framework/__init__.py

@@ -0,0 +1,9 @@
+from .active_learning import query_active_learning
+from .central_server import CentralServer
+from .client_device import ClientDevice
+from .connection import ConnectionServer, ConnectionClient
+from .decorators import federated_learning_decorator, encryption_decorator
+from .encryption import create_context, encrypt_weights, decrypt_weights
+from .models.tensorflow_model import TensorFlowModel
+from .models.pytorch_model import PyTorchModel
+from .utils import setup_logging

federated_learning_framework/active_learning.py

@@ -0,0 +1,7 @@
+import numpy as np
+
+def query_active_learning(model, unlabeled_data, num_samples):
+    predictions = model.predict(unlabeled_data)
+    uncertainty = predictions.max(axis=1)
+    selected_indices = np.argsort(uncertainty)[:num_samples]
+    return selected_indices

federated_learning_framework/central_server.py

@@ -0,0 +1,56 @@
+import asyncio
+import logging
+import numpy as np
+from federated_learning_framework.connection import ConnectionServer
+from websockets.exceptions import ConnectionClosedError
+from federated_learning_framework.encryption import create_context
+
+class CentralServer:
+    def __init__(self, connection_type='websocket', host='0.0.0.0', port=8089, context=None):
+        self.model_weights = None
+        self.lock = asyncio.Lock()
+        self.clients = set()
+        self.logger = logging.getLogger(__name__)
+        self.connection = ConnectionServer(connection_type, host, port, self.handle_client)
+        self.context = context or create_context()
+
+    async def run_server(self):
+        self.logger.info("Central Server is starting...")
+        await self.connection.start()
+
+    async def handle_client(self, websocket, client_id):
+        self.clients.add(client_id)
+        self.logger.info(f"Central Server: Client {client_id} connected")
+        try:
+            while True:
+                message = await self.connection.receive(client_id)
+                if isinstance(message, dict):
+                    if 'weights' in message:
+                        await self.transmit_weights(message['weights'])
+                    elif 'data_request' in message:
+                        data = await self.get_data_from_client(client_id)
+                        await self.send_data_to_client(client_id, {'data': data})
+        except ConnectionClosedError:
+            self.logger.info(f"Central Server: Client {client_id} disconnected")
+        finally:
+            self.clients.remove(client_id)
+
+    async def transmit_weights(self, weights):
+        async with self.lock:
+            self.model_weights = weights
+            await asyncio.gather(*[self.connection.send(client_id, {'weights': self.model_weights}) for client_id in self.clients])
+            self.logger.info("Central Server: Transmitted weights to clients")
+
+    async def send_data_to_client(self, client_id, data):
+        self.logger.info(f"Central Server: Sending data to client {client_id}")
+        await self.connection.send(client_id, data)
+
+    async def get_data_from_client(self, client_id):
+        self.logger.info(f"Central Server: Requesting data from client {client_id}. Simulating response.")
+        await asyncio.sleep(1)
+        return np.random.rand(10, 3072)
+
+    def query_active_learning(self, unlabeled_data, model):
+        uncertainty = model.predict(unlabeled_data)
+        selected_indices = np.argsort(uncertainty.max(axis=1))[:5]
+        return selected_indices

federated_learning_framework/client_device.py

@@ -0,0 +1,59 @@
+import asyncio
+import logging
+import tensorflow as tf
+from federated_learning_framework.encryption import encrypt_weights, decrypt_weights
+from federated_learning_framework.models.tensorflow_model import TensorFlowModel
+import websockets
+
+class ClientDevice:
+    def __init__(self, client_id, model: TensorFlowModel, context):
+        self.client_id = client_id
+        self.model = model
+        self.context = context
+        self.connection = None
+        self.logger = logging.getLogger(__name__)
+
+    async def connect_to_central_server(self, uri):
+        try:
+            self.connection = await websockets.connect(uri)
+            await self.connection.send({'client_id': self.client_id})
+            self.logger.info(f"Client {self.client_id}: Connected to central server at {uri}")
+        except Exception as e:
+            self.logger.error(f"Client {self.client_id}: Error connecting to central server: {e}")
+
+    async def federated_learning(self, x_train, y_train):
+        try:
+            while True:
+                weights = await self.receive_weights()
+                if weights is None:
+                    break
+                self.model.set_weights(decrypt_weights(self.context, weights))
+                self.model.train(x_train, y_train, epochs=1)
+                new_weights = self.model.get_weights()
+                await self.send_weights(encrypt_weights(self.context, new_weights))
+        except Exception as e:
+            self.logger.error(f"Client {self.client_id}: Error in federated learning loop: {e}")
+
+    async def receive_weights(self):
+        try:
+            message = await self.connection.recv()
+            self.logger.info(f"Client {self.client_id}: Received weights")
+            return message['weights']
+        except Exception as e:
+            self.logger.error(f"Client {self.client_id}: Error receiving weights: {e}")
+
+    async def send_weights(self, weights):
+        try:
+            await self.connection.send({'weights': weights})
+            self.logger.info(f"Client {self.client_id}: Sent weights to central server")
+        except Exception as e:
+            self.logger.error(f"Client {self.client_id}: Error sending weights: {e}")
+
+    async def request_data(self):
+        try:
+            await self.connection.send({'data_request': True})
+            data = await self.connection.recv()
+            self.logger.info(f"Client {self.client_id}: Received data from central server")
+            return data['data']
+        except Exception as e:
+            self.logger.error(f"Client {self.client_id}: Error requesting data: {e}")

federated_learning_framework/connection.py

@@ -0,0 +1,54 @@
+import asyncio
+import websockets
+import pickle
+from websockets.exceptions import ConnectionClosedError
+
+class ConnectionServer:
+    def __init__(self, connection_type, host, port, client_handler):
+        self.connection_type = connection_type
+        self.host = host
+        self.port = port
+        self.client_handler = client_handler
+        self.clients = {}
+
+    async def start(self):
+        if self.connection_type == 'websocket':
+            async with websockets.serve(self.handle_client, self.host, self.port):
+                await asyncio.Future()  # Run forever
+        else:
+            raise NotImplementedError(f"Connection type {self.connection_type} not supported")
+
+    async def handle_client(self, websocket, path):
+        client_id = len(self.clients) + 1
+        self.clients[client_id] = websocket
+        await self.client_handler(websocket, client_id)
+
+    async def send(self, client_id, message):
+        client = self.clients[client_id]
+        serialized_message = pickle.dumps(message)
+        await client.send(serialized_message)
+
+    async def receive(self, client_id):
+        client = self.clients[client_id]
+        message = await client.recv()
+        return pickle.loads(message)
+
+class ConnectionClient:
+    def __init__(self, connection_type, uri):
+        self.connection_type = connection_type
+        self.uri = uri
+        self.connection = None
+
+    async def connect(self):
+        if self.connection_type == 'websocket':
+            self.connection = await websockets.connect(self.uri)
+        else:
+            raise NotImplementedError(f"Connection type {self.connection_type} not supported")
+
+    async def send(self, message):
+        serialized_message = pickle.dumps(message)
+        await self.connection.send(serialized_message)
+
+    async def receive(self):
+        message = await self.connection.recv()
+        return pickle.loads(message)

federated_learning_framework/decorators.py

@@ -0,0 +1,24 @@
+# federated_learning_framework/decorators.py
+import functools
+
+def federated_learning_decorator(uri):
+    def decorator(func):
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            central_server = kwargs.get('central_server')
+            client = kwargs.get('client')
+            await central_server.run_server()
+            await client.connect_to_central_server(uri)
+            return await func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+def encryption_decorator(context):
+    def decorator(func):
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            client = kwargs.get('client')
+            client.context = context
+            return await func(*args, **kwargs)
+        return wrapper
+    return decorator

federated_learning_framework/encryption.py

@@ -0,0 +1,22 @@
+import tenseal as ts
+
+def create_context():
+    context = ts.context(ts.SCHEME_TYPE.CKKS, poly_modulus_degree=32768, coeff_mod_bit_sizes=[60, 40, 40, 60])
+    context.generate_galois_keys()
+    context.global_scale = 2**40
+    return context
+
+def encrypt_weights(context, model_weights):
+    encrypted_weights = []
+    for weight in model_weights:
+        weight_array = weight.flatten().tolist()
+        encrypted_vector = ts.ckks_vector(context, weight_array)
+        encrypted_weights.append(encrypted_vector.serialize())
+    return encrypted_weights
+
+def decrypt_weights(context, encrypted_weights):
+    decrypted_weights = []
+    for enc_weight in encrypted_weights:
+        enc_vector = ts.ckks_vector_from(context, enc_weight)
+        decrypted_weights.append(enc_vector.decrypt())
+    return decrypted_weights

federated_learning_framework/models/abstract_model.py

@@ -0,0 +1,18 @@
+from abc import ABC, abstractmethod
+
+class AbstractModel(ABC):
+    @abstractmethod
+    def get_weights(self):
+        pass
+
+    @abstractmethod
+    def set_weights(self, weights):
+        pass
+
+    @abstractmethod
+    def train(self, x_train, y_train, epochs=1):
+        pass
+
+    @abstractmethod
+    def predict(self, data):
+        pass

federated_learning_framework/models/pytorch_model.py

@@ -0,0 +1,28 @@
+import torch
+import torch.nn as nn
+from federated_learning_framework.models.abstract_model import AbstractModel
+
+class PyTorchModel(AbstractModel):
+    def __init__(self, model):
+        self.model = model
+
+    def get_weights(self):
+        return [param.data.numpy() for param in self.model.parameters()]
+
+    def set_weights(self, weights):
+        for param, weight in zip(self.model.parameters(), weights):
+            param.data = torch.tensor(weight, dtype=param.data.dtype)
+
+    def train(self, x_train, y_train, epochs=1):
+        criterion = nn.CrossEntropyLoss()
+        optimizer = torch.optim.SGD(self.model.parameters(), lr=0.01)
+        for _ in range(epochs):
+            optimizer.zero_grad()
+            outputs = self.model(x_train)
+            loss = criterion(outputs, y_train)
+            loss.backward()
+            optimizer.step()
+
+    def predict(self, data):
+        with torch.no_grad():
+            return self.model(data).numpy()

federated_learning_framework/models/tensorflow_model.py

@@ -0,0 +1,18 @@
+import tensorflow as tf
+from federated_learning_framework.models.abstract_model import AbstractModel
+
+class TensorFlowModel(AbstractModel):
+    def __init__(self, model):
+        self.model = model
+
+    def get_weights(self):
+        return self.model.get_weights()
+
+    def set_weights(self, weights):
+        self.model.set_weights(weights)
+
+    def train(self, x_train, y_train, epochs=1):
+        self.model.fit(x_train, y_train, epochs=epochs, verbose=0)
+
+    def predict(self, data):
+        return self.model.predict(data)

federated_learning_framework/utils.py

@@ -0,0 +1,4 @@
+import logging
+
+def setup_logging(logfile='federated_learning.log'):
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s:%(message)s', handlers=[logging.FileHandler(logfile), logging.StreamHandler()])

federated_learning_framework-0.0.61.dist-info/LICENSE

@@ -0,0 +1,37 @@
+# Custom License for Federated Learning Framework
+
+This license governs the use of the Federated Learning Framework. By using this framework, you agree to the following terms and conditions:
+
+## Academic Use
+
+Academic use of this framework is permitted free of charge, provided that proper attribution is given. When using this framework in academic works, please include the following citation:
+
+```
+@framework{
+  author = {Mehrdad Javadi},
+  author_email = {mehrdaddjavadi@gamil.com}
+  title = {Federated Learning Framework},
+  year = {2024},
+  url = {https://github.com/mehrdaddjavadi/federated_learning_framework}
+}
+```
+
+## Commercial, Governmental, and Other Non-Academic Use
+
+For commercial, governmental, and other non-academic uses, please contact the author to obtain a usage license. All such uses are subject to approval and may require a licensing fee.
+
+Contact: mehrdaddjavadi@gmail.com or mehrdadjavadi64@gmail.com
+
+
+## Rights
+
+All rights to this framework, including its use and distribution, belong to the author. Unauthorized use, distribution, or modification of this framework is strictly prohibited.
+
+## Disclaimer
+
+This framework is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and no infringement. In no event shall the author be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the framework or the use or other dealings in the framework.
+
+---
+
+Mehrdad javadi
+2024

federated_learning_framework-0.0.61.dist-info/METADATA

@@ -0,0 +1,333 @@
+Metadata-Version: 2.1
+Name: federated-learning-framework
+Version: 0.0.61
+Summary: A modular and extensible framework for federated learning applications.
+Home-page: https://github.com/mehrdaddjavadi/federated_learning_framework
+Author: Mehrdad Javadi
+Author-email: mehrdaddjavadi@gmail.com
+Keywords: federated learning,machine learning,deep learning,active learning,encryption,homomorphic encryption
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: tensorflow
+Requires-Dist: websockets
+Requires-Dist: pytest
+Requires-Dist: tenseal
+
+# Federated Learning Framework
+
+## Overview
+
+Welcome to the Federated Learning Framework, a modular and extensible solution for implementing federated learning across various applications. Harness the power of collective intelligence, ensure data privacy with homomorphic encryption, and apply it to domains like NLP, autonomous vehicles, drones, and more.
+
+## Features
+
+- **Modular and Extensible**: Easily customizable for different machine learning and deep learning applications.
+- **Secure**: Utilizes homomorphic encryption to ensure data privacy.
+- **Active Learning**: Incorporates active learning strategies to improve model performance.
+- **Flexible Communication**: Supports various connection methods including socket programming.
+- **Customizable**: Users can edit and control every part of the framework with various functions.
+
+## Potential Applications
+
+### Healthcare
+
+Federated learning can be used to train models on patient data from multiple hospitals without sharing sensitive information. This approach can improve medical diagnostics and treatment recommendations while preserving patient privacy.
+
+### Autonomous Vehicles
+
+By collecting and learning from data across multiple autonomous vehicles, the framework can help improve the safety and performance of self-driving cars without exposing individual vehicle data.
+
+### Drones
+
+Drones can use federated learning to share and learn from data collected during their operations, enhancing their navigation, object detection, and other capabilities while ensuring data security.
+
+### Natural Language Processing (NLP)
+
+Federated learning can be applied to train NLP models on data from multiple sources, such as user devices, to improve language understanding and generation without compromising user privacy.
+
+### Finance
+
+Financial institutions can use federated learning to develop fraud detection and risk management models by leveraging data from multiple sources while keeping customer data secure.
+
+### Smart Homes and IoT Devices
+
+IoT devices in smart homes can collaboratively learn from user interactions to optimize performance and provide better services without sharing raw data.
+
+## Detailed Component Description
+
+### Central Server
+
+**File:** `central_server.py`
+
+The central server orchestrates the federated learning process by coordinating the communication and aggregation of model weights from various client devices.
+
+**Key Functions:**
+
+- `run_server`: Starts the server to handle client connections.
+- `handle_client`: Manages incoming messages from clients.
+- `transmit_weights`: Broadcasts the aggregated weights to clients.
+- `send_data_to_client`: Sends specific data to a client.
+- `get_data_from_client`: Requests and receives data from a client.
+- `query_active_learning`: Implements active learning strategies to select data for labeling.
+
+### Client Device
+
+**File:** `client_device.py`
+
+Client devices perform local training on their datasets and communicate with the central server.
+
+**Key Functions:**
+
+- `connect_to_central_server`: Connects to the central server.
+- `federated_learning`: Coordinates local training and communication with the server.
+- `receive_weights`: Receives model weights from the central server.
+- `send_weights`: Sends model weights to the central server.
+- `receive_data`: Receives data from the central server.
+
+### Encryption
+
+**File:** `encryption.py`
+
+Provides functions for creating encryption contexts and encrypting/decrypting model weights.
+
+**Key Functions:**
+
+- `create_context`: Sets up the encryption context using TenSEAL.
+- `encrypt_weights`: Encrypts model weights.
+- `decrypt_weights`: Decrypts encrypted model weights.
+
+### Active Learning
+
+**File:** `active_learning.py`
+
+Implements active learning strategies to enhance the training process by selectively querying informative data points.
+
+**Key Functions:**
+
+- `select_informative_samples`: Selects samples for labeling based on uncertainty.
+
+### Connection
+
+**File:** `connection.py`
+
+Manages the connection types and protocols (e.g., WebSocket) for communication between the central server and client devices.
+
+**Key Functions:**
+
+- `run_server`: Starts a WebSocket server.
+- `connect_to_server`: Establishes a WebSocket connection to the server.
+
+### Decorators
+
+**File:** `decorators.py`
+
+Provides decorators for adding federated learning and encryption functionalities to functions.
+
+**Key Functions:**
+
+- `federated_learning_decorator`: Wraps a function to enable federated learning.
+- `encryption_decorator`: Wraps a function to enable homomorphic encryption.
+
+### Utilities
+
+**File:** `utils.py`
+
+Includes utility functions used throughout the framework.
+
+## Installation
+
+Clone the repository:
+
+```sh
+git clone https://github.com/mehrdaddjavadi/federated_learning_framework.git
+```
+
+Navigate to the directory:
+
+```sh
+cd federated_learning_framework
+```
+
+Install the dependencies:
+
+```sh
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Setting Up the Central Server
+
+```python
+import asyncio
+from federated_learning_framework.central_server import CentralServer
+
+async def main():
+    server = CentralServer()
+    await server.run_server()
+
+asyncio.run(main())
+```
+
+### Setting Up the Central Server On Interactive Environment Like Jupyter Notebook
+
+```python
+import nest_asyncio
+import asyncio
+from federated_learning_framework.central_server import CentralServer
+
+nest_asyncio.apply()
+
+async def main():
+    server = CentralServer()
+    await server.run_server()
+
+# If running in an environment with an existing event loop
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Setting Up a Client Device
+
+```python
+import asyncio
+import tensorflow as tf
+from federated_learning_framework.client_device import ClientDevice
+from federated_learning_framework.encryption import create_context
+
+# Define your model
+model = tf.keras.Sequential([
+    tf.keras.layers.Dense(4, activation='relu', input_shape=(3072,)),
+    tf.keras.layers.Dense(10, activation='softmax')
+])
+
+# Create context for encryption
+context = create_context()
+
+# Initialize the client device
+client = ClientDevice(client_id=1, model=model, context=context)
+
+async def main():
+    uri = "ws://localhost:8089"
+    await client.connect_to_central_server(uri)
+    x_train, y_train = ...  # Load your training data
+    await client.federated_learning(uri, x_train, y_train)
+    # Optionally receive data from central server
+    data = await client.receive_data()
+    print(f"Received data: {data}")
+
+asyncio.run(main())
+```
+
+### Sample Execution Script Using Decorators For Interactive Environments Like Colab And Jupyter Notebook
+
+```python
+import asyncio
+import tensorflow as tf
+import numpy as np
+from federated_learning_framework.client_device import ClientDevice
+from federated_learning_framework.central_server import CentralServer
+from federated_learning_framework.encryption import create_context
+from federated_learning_framework.models.tensorflow_model import TensorFlowModel
+
+# Setup logging
+import logging
+logging.basicConfig(level=logging.INFO)
+
+# Define a simple TensorFlow model
+model = tf.keras.Sequential([
+    tf.keras.layers.Dense(4, activation='relu', input_shape=(3072,)),
+    tf.keras.layers.Dense(10, activation='softmax')
+])
+wrapped_model = TensorFlowModel(model)
+
+# Create encryption context
+context = create_context()
+
+# Initialize server and clients
+central_server = CentralServer(context=context)
+client1 = ClientDevice(client_id=1, model=wrapped_model, context=context)
+client2 = ClientDevice(client_id=2, model=wrapped_model, context=context)
+
+# Dummy training data
+x_train = np.random.rand(10, 3072)
+y_train = np.random.randint(0, 10, 10)
+
+async def main():
+    await asyncio.gather(
+        central_server.run_server(),
+        client1.connect_to_central_server("ws://localhost:8089"),
+        client2.connect_to_central_server("ws://localhost:8089"),
+        client1.federated_learning(x_train, y_train),
+        client2.federated_learning(x_train, y_train)
+    )
+
+asyncio.run(main())
+
+```
+
+### Using Decorators
+
+```python
+import asyncio
+import tensorflow as tf
+from federated_learning_framework.decorators import federated_learning_decorator, encryption_decorator
+from federated_learning_framework.client_device import ClientDevice
+from federated_learning_framework.encryption import create_context
+
+# Create context for encryption
+context = create_context()
+
+# Define your model
+model = tf.keras.Sequential([
+    tf.keras.layers.Dense(4, activation='relu', input_shape=(3072,)),
+    tf.keras.layers.Dense(10, activation='softmax')
+])
+
+@federated_learning_decorator(uri="ws://localhost:8089")
+@encryption_decorator(context=context)
+async def main():
+    client = ClientDevice(client_id=1, model=model, context=context)
+    await client.connect_to_central_server('ws://localhost:8089')
+    x_train, y_train = ...  # Load your training data
+    await client.federated_learning('ws://localhost:8089', x_train, y_train)
+
+asyncio.run(main())
+```
+
+## Running Tests
+
+To run the tests, execute the following command in the root directory:
+
+```sh
+python -m unittest discover -s tests
+```
+
+## License
+
+The usage of this library is free for academic work with proper referencing. For business, governmental, and any other types of usage, please contact me directly. All rights are reserved.
+
+**Contact:** mehrdaddjavadi@gmail.com
+
+## Contributing
+
+Feel free to contribute by submitting a pull request or opening an issue.
+
+```
+
+Copy and paste this into your README.md file. This format provides a clear, organized structure and includes all necessary details and instructions for potential users and contributors.
+```

federated_learning_framework-0.0.61.dist-info/RECORD

@@ -0,0 +1,24 @@
+federated_learning_framework/__init__.py,sha256=HvZKThSQYzF5ofyU4UIgaaInB8mR9Y5jeZEd43l1_t0,482
+federated_learning_framework/active_learning.py,sha256=jv6xzbRsHdzieMDwEtTpEn8YL_0M4a3DOawul0X5EnU,269
+federated_learning_framework/central_server.py,sha256=eexr9XoZt0I5hGj1iG3HwX7CmnTX2KAjXfZGMkpRbB8,2620
+federated_learning_framework/client_device.py,sha256=8b5FPXuWJ-PukR4CYzpY9JSVbn-kxtJRq-AhXXAy_rM,2659
+federated_learning_framework/connection.py,sha256=D7zkKkgcFBhUEMcHUOLWZWJEO3jjxxFUrAishBDBT2w,1958
+federated_learning_framework/decorators.py,sha256=gihFUEeIla0osy3319u8sMx0YxAdZqmAfkdRKmJsHXA,825
+federated_learning_framework/encryption.py,sha256=bNarMUqYuyJG52yceGdSyW5jIDyVky2KnX7gqzFdKtY,840
+federated_learning_framework/utils.py,sha256=t4dCUuAqvDach0qZObVoTfaQjXh06v5cpVfLxs_cRQ0,231
+federated_learning_framework/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+federated_learning_framework/models/abstract_model.py,sha256=oNn4auUpt7XqOnfF5l0ebCWn9olPqb5ADwfibIcajQA,357
+federated_learning_framework/models/pytorch_model.py,sha256=kibGM_dzM4uZIcxB3ZCdbv8KPkiKzFT9Vqnu4CLh9fg,988
+federated_learning_framework/models/tensorflow_model.py,sha256=a-ZZbzoYjOL8Pza2KRn4q-TYBm-7OBuYeeOBzTFXuUs,548
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_active_learning.py,sha256=qrnaCkYwdWTu_Jvz17jz0QElogPmKtayKy_qG7P_U08,535
+tests/test_central_server.py,sha256=OOGvSOlKMyMHbrXwDOgdA-QYJMOP7uLCiLpzLBLoM9M,604
+tests/test_client_device.py,sha256=hRLZWUUPCrF-BHK46QtpJBdGjO4WZm5tcoZGQtefKyk,932
+tests/test_connection.py,sha256=E5lFwzvB8FCpjfuePwfc8eQq-CGDJBLW6GmtFB0FldA,921
+tests/test_encryption.py,sha256=PHSRxqS4ltepe7ztOhNQcrfHOYhMMRKqKQJU0Dsa8-o,374
+tests/test_utils.py,sha256=H7Cp9nOf4IOcLeNZKtAUZt-YY3x0c1WiUHAmQKROHWo,272
+federated_learning_framework-0.0.61.dist-info/LICENSE,sha256=Igduf49yy8CINu7sRZg4TvMGy7jOi0xNgmL3e4PRoe0,1646
+federated_learning_framework-0.0.61.dist-info/METADATA,sha256=K-JIgZKigswGbyx97Z4RBXcNDg9A8NrElpG9MAf9b3o,11188
+federated_learning_framework-0.0.61.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+federated_learning_framework-0.0.61.dist-info/top_level.txt,sha256=bnGlrzFER9O24oPGb7hrGhFKBtcrx321yE2CJuwiRMY,35
+federated_learning_framework-0.0.61.dist-info/RECORD,,

federated_learning_framework-0.0.61.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (72.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

federated_learning_framework-0.0.61.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+federated_learning_framework
+tests

tests/test_active_learning.py

@@ -0,0 +1,12 @@
+import numpy as np
+import tensorflow as tf
+from federated_learning_framework.active_learning import query_active_learning
+
+def test_active_learning():
+    model = tf.keras.Sequential([
+        tf.keras.layers.Dense(10, input_shape=(3072,), activation='softmax')
+    ])
+    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+    unlabeled_data = np.random.rand(100, 3072)
+    selected_indices = query_active_learning(model, unlabeled_data, 5)
+    assert len(selected_indices) == 5

tests/test_central_server.py

@@ -0,0 +1,18 @@
+import asyncio
+import pytest
+from federated_learning_framework.central_server import CentralServer
+from federated_learning_framework.encryption import create_context
+
+@pytest.mark.asyncio
+async def test_central_server():
+    context = create_context()
+    server = CentralServer(context=context)
+    server_task = asyncio.create_task(server.run_server())
+
+    await asyncio.sleep(1)  # Give the server some time to start
+
+    # Simulate client connections and other test scenarios here
+
+    server_task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await server_task

tests/test_client_device.py

@@ -0,0 +1,25 @@
+import asyncio
+import pytest
+import tensorflow as tf
+from federated_learning_framework.client_device import ClientDevice
+from federated_learning_framework.encryption import create_context
+from federated_learning_framework.models.tensorflow_model import TensorFlowModel
+
+@pytest.mark.asyncio
+async def test_client_device():
+    context = create_context()
+    model = tf.keras.Sequential([
+        tf.keras.layers.Dense(10, input_shape=(3072,), activation='softmax')
+    ])
+    model = TensorFlowModel(model)
+    client = ClientDevice(client_id=1, model=model, context=context)
+    
+    connect_task = asyncio.create_task(client.connect_to_central_server('ws://localhost:8089'))
+
+    await asyncio.sleep(1)  # Give the client some time to connect
+
+    # Simulate communication and other test scenarios here
+
+    connect_task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await connect_task

tests/test_connection.py

@@ -0,0 +1,28 @@
+import asyncio
+import pytest
+from federated_learning_framework.connection import ConnectionServer, ConnectionClient
+
+@pytest.mark.asyncio
+async def test_connection():
+    async def handle_client(connection, client_id):
+        message = await connection.receive()
+        await connection.send(message)
+
+    server = ConnectionServer('websocket', 'localhost', 8089, handle_client)
+    server_task = asyncio.create_task(server.start())
+
+    await asyncio.sleep(1)  # Give the server some time to start
+
+    client = ConnectionClient('websocket', 'ws://localhost:8089')
+    await client.connect()
+
+    test_message = "test_message"
+    await client.send(test_message)
+    received_message = await client.receive()
+
+    assert received_message == test_message
+
+    await client.connection.close()
+    server_task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await server_task

tests/test_encryption.py

@@ -0,0 +1,9 @@
+import numpy as np
+from federated_learning_framework.encryption import create_context, encrypt_weights, decrypt_weights
+
+def test_encryption():
+    context = create_context()
+    weights = [np.random.rand(10, 10)]
+    encrypted = encrypt_weights(context, weights)
+    decrypted = decrypt_weights(context, encrypted)
+    assert np.allclose(weights[0], decrypted[0])

tests/test_utils.py

@@ -0,0 +1,10 @@
+import logging
+from federated_learning_framework.utils import setup_logging
+
+def test_setup_logging():
+    logger = setup_logging()
+    
+    assert isinstance(logger, logging.Logger)
+    assert logger.level == logging.INFO
+
+    logger.info("Test logging setup")