MEDfl 0.1.31__py3-none-any.whl → 0.1.33__py3-none-any.whl

Medfl/NetManager/node.py

@@ -1,178 +1,184 @@
-import pandas as pd
-
-from .net_helper import *
-from .net_manager_queries import *
-from MEDfl.LearningManager.utils import params
-from MEDfl.NetManager.database_connector import DatabaseManager
-
-class Node:
-    """
-    A class representing a node in the network.
-
-    Attributes:
-        name (str): The name of the node.
-        train (int): An integer flag representing whether the node is used for training (1) or testing (0).
-        test_fraction (float, optional): The fraction of data used for testing when train=1. Default is 0.2.
-    """
-
-    def __init__(
-        self, name: str, train: int, test_fraction: float = 0.2, engine=None
-    ):
-        """
-        Initialize a Node instance.
-
-        Parameters:
-            name (str): The name of the node.
-            train (int): An integer flag representing whether the node is used for training (1) or testing (0).
-            test_fraction (float, optional): The fraction of data used for testing when train=1. Default is 0.2.
-        """
-        self.name = name
-        self.train = train
-        self.test_fraction = 1.0 if self.train == 0 else test_fraction
-       
-
-        db_manager = DatabaseManager() ; 
-        db_manager.connect() ; 
-        self.engine = db_manager.get_connection()
-
-    def validate(self):
-        """Validate name, train, test_fraction"""
-        if not isinstance(self.name, str):
-            raise TypeError("name argument must be a string")
-
-        if not isinstance(self.train, int):
-            raise TypeError("train argument must be an int")
-
-        if not isinstance(self.test_fraction, float):
-            raise TypeError("test_fraction argument must be a float")
-
-    def create_node(self, NetId: int):
-        """Create a node in the database.
-        Parameters:
-            NetId (int): The ID of the network to which the node belongs.
-
-        Returns:
-            None
-        """
-        self.engine.execute(
-            text(INSERT_NODE_QUERY.format(self.name, NetId, self.train))
-        )
-
-    def delete_node(self):
-        """Delete the node from the database."""
-        self.engine.execute(text(DELETE_NODE_QUERY.format(self.name)))
-
-    def check_dataset_compatibility(self, data_df):
-        """Check if the dataset is compatible with the master dataset.
-        Parameters:
-            data_df (DataFrame): The dataset to check.
-
-        Returns:
-            None
-        """
-        if master_table_exists() != 1:
-            print("MasterDataset doesn't exist")
-        else:
-            columns = data_df.columns.tolist()
-            
-            # get master_dataset columns
-            result_proxy = self.engine.execute(SELECT_MASTER_COLUMNS_QUERY)
-            master_table_columns = result_proxy.keys()
-
-
-            assert [x == y for x, y in zip(master_table_columns, columns)]
-
-    def update_node(self):
-        """Update the node information (not implemented)."""
-        pass
-
-    def get_dataset(self, column_name: str = None):
-        """Get the dataset for the node based on the given column name.
-        Parameters:
-            column_name (str, optional): The column name to filter the dataset. Default is None.
-
-        Returns:
-            DataFrame: The dataset associated with the node.
-        """
-        NodeId = get_nodeid_from_name(self.name)
-        if column_name is not None:
-            query = text(SELECT_DATASET_BY_COLUMN_QUERY.format(column_name, self.name))
-        else:
-            query = text(SELECT_DATASET_BY_NODE_ID_QUERY.format(NodeId))
-
-        result_proxy = self.engine.execute(query)
-        node_dataset = pd.DataFrame(result_proxy.fetchall(), columns=result_proxy.keys())
-
-        return node_dataset
-
-    def upload_dataset(self, dataset_name: str, path_to_csv: str = params['path_to_test_csv']):
-        """Upload the dataset to the database for the node.
-        Parameters:
-            dataset_name (str): The name of the dataset.
-            path_to_csv (str, optional): Path to the CSV file containing the dataset. Default is the path in params.
-
-        Returns:
-            None
-        """
-        data_df = pd.read_csv(path_to_csv)
-
-        nodeId = get_nodeid_from_name(self.name)
-        columns = data_df.columns.tolist()
-        self.check_dataset_compatibility(data_df)
-
-        data_df = process_eicu(data_df)
-        for index, row in data_df.iterrows():
-            query_1 = "INSERT INTO DataSets(DataSetName,nodeId," + "".join(
-                f"{x}," for x in columns
-            )
-            query_2 = f" VALUES ('{dataset_name}',{nodeId}, " + "".join(
-                f"{is_str(data_df, row, x)}," for x in columns
-            )
-            query = query_1[:-1] + ")" + query_2[:-1] + ")"
-            self.engine.execute(text(query))
-
-    def assign_dataset(self, dataset_name:str):
-        """Assigning existing dataSet to node
-        Parameters:
-            dataset_name (str): The name of the dataset to assign.
-
-        Returns:
-            None
-        """
-
-        nodeId = get_nodeid_from_name(self.name)
-        query = f"UPDATE DataSets SET nodeId = {nodeId} WHERE DataSetName = '{dataset_name}'"
-        self.engine.execute(text(query))
-
-    def unassign_dataset(self, dataset_name:str):
-        """unssigning existing dataSet to node
-        Parameters:
-            dataset_name (str): The name of the dataset to assign.
-
-        Returns:
-            None
-        """
-
-        query = f"UPDATE DataSets SET nodeId = {-1} WHERE DataSetName = '{dataset_name}'"
-        self.engine.execute(text(query))
-
-    def list_alldatasets(self):
-        """List all datasets associated with the node.
-        Returns:
-            DataFrame: A DataFrame containing information about all datasets associated with the node.
-        
-        """
-        return pd.read_sql(
-            text(SELECT_ALL_DATASETS_QUERY.format(self.name)), my_eng
-        )
-
-    @staticmethod
-    def list_allnodes():
-        """List all nodes in the database.
-        Returns:
-            DataFrame: A DataFrame containing information about all nodes in the database.
-        
-        """
-        query = text(SELECT_ALL_NODES_QUERY)
-        res = pd.read_sql(query, my_eng)
-        return res
+import pandas as pd
+
+from .net_helper import *
+from .net_manager_queries import *
+from MEDfl.LearningManager.utils import params
+from MEDfl.NetManager.database_connector import DatabaseManager
+
+from sqlalchemy import text, exc
+
+
+class Node:
+    """
+    A class representing a node in the network.
+
+    Attributes:
+        name (str): The name of the node.
+        train (int): An integer flag representing whether the node is used for training (1) or testing (0).
+        test_fraction (float, optional): The fraction of data used for testing when train=1. Default is 0.2.
+    """
+
+    def __init__(
+        self, name: str, train: int, test_fraction: float = 0.2, engine=None
+    ):
+        """
+        Initialize a Node instance.
+
+        Parameters:
+            name (str): The name of the node.
+            train (int): An integer flag representing whether the node is used for training (1) or testing (0).
+            test_fraction (float, optional): The fraction of data used for testing when train=1. Default is 0.2.
+        """
+        self.name = name
+        self.train = train
+        self.test_fraction = 1.0 if self.train == 0 else test_fraction
+       
+
+        db_manager = DatabaseManager() ; 
+        db_manager.connect() ; 
+        self.engine = db_manager.get_connection()
+
+    def validate(self):
+        """Validate name, train, test_fraction"""
+        if not isinstance(self.name, str):
+            raise TypeError("name argument must be a string")
+
+        if not isinstance(self.train, int):
+            raise TypeError("train argument must be an int")
+
+        if not isinstance(self.test_fraction, float):
+            raise TypeError("test_fraction argument must be a float")
+
+    def create_node(self, NetId: int):
+        """Create a node in the database.
+        Parameters:
+            NetId (int): The ID of the network to which the node belongs.
+
+        Returns:
+            None
+        """
+        self.engine.execute(
+            text(INSERT_NODE_QUERY.format(self.name, NetId, self.train))
+        )
+
+    def delete_node(self):
+        """Delete the node from the database."""
+        self.engine.execute(text(DELETE_NODE_QUERY.format(self.name)))
+
+    def check_dataset_compatibility(self, data_df):
+        """Check if the dataset is compatible with the master dataset.
+        Parameters:
+            data_df (DataFrame): The dataset to check.
+
+        Returns:
+            None
+        """
+        if master_table_exists() != 1:
+            print("MasterDataset doesn't exist")
+        else:
+            columns = data_df.columns.tolist()
+            
+            # get master_dataset columns
+            result_proxy = self.engine.execute(SELECT_MASTER_COLUMNS_QUERY)
+            master_table_columns = result_proxy.keys()
+
+
+            assert [x == y for x, y in zip(master_table_columns, columns)]
+
+    def update_node(self):
+        """Update the node information (not implemented)."""
+        pass
+
+    def get_dataset(self, column_name: str = None):
+        """Get the dataset for the node based on the given column name.
+        Parameters:
+            column_name (str, optional): The column name to filter the dataset. Default is None.
+
+        Returns:
+            DataFrame: The dataset associated with the node.
+        """
+        NodeId = get_nodeid_from_name(self.name)
+        if column_name is not None:
+            query = text(SELECT_DATASET_BY_COLUMN_QUERY.format(column_name, self.name))
+        else:
+            query = text(SELECT_DATASET_BY_NODE_ID_QUERY.format(NodeId))
+
+        result_proxy = self.engine.execute(query)
+        node_dataset = pd.DataFrame(result_proxy.fetchall(), columns=result_proxy.keys())
+
+        return node_dataset
+
+    def upload_dataset(self, dataset_name: str, path_to_csv: str = params['path_to_test_csv']):
+        """Upload the dataset to the database for the node.
+
+        Parameters:
+            dataset_name (str): The name of the dataset.
+            path_to_csv (str, optional): Path to the CSV file containing the dataset. Default is the path in params.
+
+        Returns:
+            None
+        """
+        try:
+            data_df = pd.read_csv(path_to_csv)
+            nodeId = get_nodeid_from_name(self.name)
+            columns = data_df.columns.tolist()
+            self.check_dataset_compatibility(data_df)
+
+            data_df = process_eicu(data_df)
+
+            # Insert data in batches
+            batch_size = 1000  # Adjust as needed
+            for start_idx in range(0, len(data_df), batch_size):
+                batch_data = data_df.iloc[start_idx:start_idx + batch_size]
+                insert_query = f"INSERT INTO Datasets (DataSetName, NodeId, {', '.join(columns)}) VALUES (:dataset_name, :nodeId, {', '.join([':' + col for col in columns])})"
+                data_to_insert = batch_data.to_dict(orient='records')
+                params = [{"dataset_name": dataset_name, "nodeId": nodeId, **row} for row in data_to_insert]
+                self.engine.execute(text(insert_query), params)
+        except exc.SQLAlchemyError as e:
+            print(f"Error uploading dataset: {e}")
+
+    def assign_dataset(self, dataset_name:str):
+        """Assigning existing dataSet to node
+        Parameters:
+            dataset_name (str): The name of the dataset to assign.
+
+        Returns:
+            None
+        """
+
+        nodeId = get_nodeid_from_name(self.name)
+        query = f"UPDATE DataSets SET nodeId = {nodeId} WHERE DataSetName = '{dataset_name}'"
+        self.engine.execute(text(query))
+
+    def unassign_dataset(self, dataset_name:str):
+        """unssigning existing dataSet to node
+        Parameters:
+            dataset_name (str): The name of the dataset to assign.
+
+        Returns:
+            None
+        """
+
+        query = f"UPDATE DataSets SET nodeId = {-1} WHERE DataSetName = '{dataset_name}'"
+        self.engine.execute(text(query))
+
+    def list_alldatasets(self):
+        """List all datasets associated with the node.
+        Returns:
+            DataFrame: A DataFrame containing information about all datasets associated with the node.
+        
+        """
+        return pd.read_sql(
+            text(SELECT_ALL_DATASETS_QUERY.format(self.name)), my_eng
+        )
+
+    @staticmethod
+    def list_allnodes():
+        """List all nodes in the database.
+        Returns:
+            DataFrame: A DataFrame containing information about all nodes in the database.
+        
+        """
+        query = text(SELECT_ALL_NODES_QUERY)
+        res = pd.read_sql(query, my_eng)
+        return res

Medfl/__init__.py

@@ -1,2 +1,3 @@
-from .LearningManager import *
-from .NetManager import *
+from .LearningManager import *
+from .NetManager import *
+from .scripts import *

Medfl/scripts/__init__.py

@@ -0,0 +1,2 @@
+from .base import *
+from .create_db import *

Medfl/scripts/base.py

@@ -0,0 +1,30 @@
+import mysql.connector
+from sqlalchemy import create_engine, text
+from configparser import ConfigParser
+import yaml
+import pkg_resources
+import os
+
+# Get the directory of the current script
+current_directory = os.path.dirname(os.path.abspath(__file__))
+
+# Load configuration from the config file
+config_file_path = os.path.join(current_directory, 'db_config.ini')
+
+config = ConfigParser()
+config.read(config_file_path)
+mysql_config = config['mysql']
+
+
+
+connection_string = (
+    f"mysql+mysqlconnector://{mysql_config['user']}:{mysql_config['password']}@"
+    f"{mysql_config['host']}:{mysql_config['port']}/{mysql_config['database']}"
+)
+
+eng = create_engine(
+    connection_string,
+    execution_options={"autocommit": True},
+)
+
+my_eng = eng.connect()

Medfl/scripts/create_db.py

@@ -0,0 +1,126 @@
+import sys
+import sqlite3
+import pandas as pd
+from configparser import ConfigParser
+import os
+import ast 
+
+from MEDfl.LearningManager.utils import *
+
+
+def main(csv_file_path):
+    try:
+        # Get the directory of the current script
+        current_directory = os.path.dirname(os.path.abspath(__file__))
+
+        # Load configuration from the config file
+        # config_file_path = os.path.join(current_directory, 'sqllite_config.ini')*
+
+        config_file_path = load_db_config()
+
+        # config = ConfigParser()
+        # config.read(config_file_path)
+        # sqlite_config = config['sqllite']
+
+        sqlite_config = config_file_path 
+
+
+        print('Im here !')
+
+        # Connect to SQLite database (it will be created if it doesn't exist)
+        database_path = sqlite_config['database']
+        conn = sqlite3.connect(database_path)
+        cursor = conn.cursor()
+
+        # Drop each table if it exists
+        tables = ['Networks', 'FLsetup', 'Nodes', 'DataSets', 'FLpipeline', 'testResults', 'FedDatasets']
+        for table in tables:
+            cursor.execute(f"DROP TABLE IF EXISTS {table}")
+
+        # Create Networks table
+        cursor.execute(
+            "CREATE TABLE Networks( \
+                         NetId INTEGER PRIMARY KEY AUTOINCREMENT, \
+                         NetName TEXT \
+                         );"
+        )
+
+        # Create FLsetup table
+        cursor.execute("CREATE TABLE FLsetup (\
+        FLsetupId INTEGER PRIMARY KEY AUTOINCREMENT,\
+        name TEXT NOT NULL, \
+        description TEXT NOT NULL,\
+        creation_date TEXT NOT NULL,\
+        NetId INTEGER NOT NULL,\
+        column_name TEXT\
+        )")
+
+        # Create Nodes table
+        cursor.execute("CREATE TABLE Nodes ( \
+         NodeId INTEGER PRIMARY KEY AUTOINCREMENT,\
+         NodeName TEXT,\
+         train BOOLEAN DEFAULT 1,\
+         NetId INTEGER\
+        )")
+
+        data_df = pd.read_csv(csv_file_path)
+        columns = data_df.columns.tolist()
+        column_map = {"object": "TEXT", "int64": "INTEGER", "float64": "REAL"}
+        sub_query = ", ".join(f"{col} {column_map[str(data_df[col].dtype)]}" for col in columns)
+
+        # Create Datasets table by getting columns from the master csv file
+        cursor.execute(
+            f"CREATE TABLE DataSets( \
+                         DataSetId INTEGER PRIMARY KEY AUTOINCREMENT, \
+                         DataSetName TEXT, \
+                         NodeId INTEGER,\
+                         {sub_query}\
+                         )"
+        )
+
+        # Create FLpipeline table
+        cursor.execute("CREATE TABLE FLpipeline(\
+         id INTEGER PRIMARY KEY AUTOINCREMENT,\
+         name TEXT NOT NULL, \
+         description TEXT NOT NULL,\
+         creation_date TEXT NOT NULL,\
+         results TEXT NOT NULL\
+        ) ")
+
+        # Create test results table
+        cursor.execute("CREATE TABLE testResults(\
+         pipelineId INTEGER,\
+         nodename TEXT NOT NULL, \
+         confusionmatrix TEXT,\
+         accuracy REAL,\
+         sensivity REAL,\
+         ppv REAL,\
+         npv REAL,\
+         f1score REAL,\
+         fpr REAL,\
+         tpr REAL, \
+         PRIMARY KEY (pipelineId, nodename)\
+        ) ")
+
+        # Create FederatedDataset table
+        cursor.execute("CREATE TABLE FedDatasets (\
+         FedId INTEGER PRIMARY KEY AUTOINCREMENT,\
+         FLsetupId INTEGER,\
+         FLpipeId INTEGER,\
+         name TEXT NOT NULL\
+        )")
+
+        # Commit and close the cursor
+        conn.commit()
+        cursor.close()
+        conn.close()
+
+    except sqlite3.Error as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python script.py <path_to_csv_file>")
+        sys.exit(1)
+    csv_file_path = sys.argv[1]
+    main(csv_file_path)

alembic/env.py

@@ -1,61 +1,61 @@
-from logging.config import fileConfig
-import logging
-from sqlalchemy import engine_from_config, create_engine
-from sqlalchemy import pool
-import sys
-import os
-from alembic import context
-
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from scripts.base import my_eng
-
-# this is the Alembic Config object, which provides
-# access to the values within the .ini file in use.
-config = context.config
-
-# Interpret the config file for Python logging.
-# This line sets up loggers basically.
-fileConfig(config.config_file_name)
-
-# add your model's MetaData object here
-# for 'autogenerate' support
-# from myapp import mymodel
-# target_metadata = mymodel.Base.metadata
-target_metadata = None
-
-# other values from the config, defined by the needs of env.py,
-# can be acquired:
-# my_important_option = config.get_main_option("my_important_option")
-# ... etc.
-def configure_logger(name):
-    # This is the standard logging configuration
-    logging.config.fileConfig(
-        'alembic_logging.ini',  # Path to your logging configuration file
-        defaults={
-            'logfilename': 'alembic.log',  # Log file name
-        },
-        disable_existing_loggers=False,
-    )
-
-    return logging.getLogger(name)
-
-
-
-def run_migrations_offline():
-    """Run migrations in 'offline' mode."""
-    pass
-
-def run_migrations_online():
-    """Run migrations in 'online' mode."""
-    pass
-
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    run_migrations_online()
-
-
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    run_migrations_online()
+from logging.config import fileConfig
+import logging
+from sqlalchemy import engine_from_config, create_engine
+from sqlalchemy import pool
+import sys
+import os
+from alembic import context
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from scripts.base import my_eng
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = None
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+def configure_logger(name):
+    # This is the standard logging configuration
+    logging.config.fileConfig(
+        'alembic_logging.ini',  # Path to your logging configuration file
+        defaults={
+            'logfilename': 'alembic.log',  # Log file name
+        },
+        disable_existing_loggers=False,
+    )
+
+    return logging.getLogger(name)
+
+
+
+def run_migrations_offline():
+    """Run migrations in 'offline' mode."""
+    pass
+
+def run_migrations_online():
+    """Run migrations in 'online' mode."""
+    pass
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()