diff --git a/main_package/classes/abstract_importer.py b/main_package/classes/abstract_importer.py new file mode 100644 index 0000000..02e222a --- /dev/null +++ b/main_package/classes/abstract_importer.py @@ -0,0 +1,16 @@ +from abc import ABC, abstractmethod + + +class AbstractImporter(ABC): + + def __init__(self, files_path): + self.files_path = files_path + super().__init__() + + @abstractmethod + def import_trajectories(self, raw_data): + pass + + @abstractmethod + def import_structure(self, raw_data): + pass diff --git a/main_package/classes/importer.py b/main_package/classes/importer.py deleted file mode 100644 index d92c779..0000000 --- a/main_package/classes/importer.py +++ /dev/null @@ -1,128 +0,0 @@ -import os -import glob -import pandas as pd -import numpy as np - - - - -class Importer(): - """ - Fornisce tutti i metodi per importare i dataset contenuti nella directory files_path - in pandas data_frame. - Permette di effettuare operazioni - volte ad ottenere i valori contenuti in tali frame nel formato utile alle computazioni successive. - - :files_path: il path alla cartella contenente i dataset da utilizzare - :df_list: lista contentente tutti i padas_data_frame contenuti nella directory files_path - """ - def __init__(self, files_path): - self.files_path = files_path - self.df_list = [] - - - def import_data_from_csv(self): - """ - Importa tutti i file csv presenti nel path files_path in data_frame distinti. - Aggiunge ogni data_frame alla lista df_list. - Parameters: - void - Returns: - void - """ - try: - read_files = glob.glob(os.path.join(self.files_path, "*.csv")) - for file in read_files: - my_df = pd.read_csv(file) - self.check_types_validity(my_df) - self.df_list.append(my_df) - except ValueError as err: - print(err.args) - - - - def merge_value_columns(self, df): - """ - Effettua il merging di tutte le colonne che contengono i valori delle variabili - in un unica colonna chiamata State. - Parameters: - df: il data_frame su cui effettuare il merging delle colonne - Returns: - void - """ - df['State'] = df[df.columns[2:]].apply(lambda row: ''.join(row.values.astype(str)), axis=1) - - def merge_value_columns_in_all_frames(self): - """ - Richiama il metodo merge_value_columns su tutti i data_frame contenuti nella df_list - Parameters: - void - Returns: - void - - """ - for data_frame in self.df_list: - self.merge_value_columns(data_frame) - - def drop_unneccessary_columns(self, df): - """ - Rimuove le colonne contenenti i valori delle variabili dal data_frame df. - Parameters: - df: il data_frame su cui rimuovere le colonne - Returns: - void - - """ - cols = df.columns.values[2:-1] - df.drop(cols, axis=1, inplace=True) - - def drop_unneccessary_columns_in_all_frames(self): - """ - Richiama il metodo drop_unneccessary_columns su tutti i data_frame contenuti nella df_list - - Parameters: - void - Returns: - void - - """ - for data_frame in self.df_list: - self.drop_unneccessary_columns(data_frame) - - def get_data_frames(self): - """ - Restituisce la lista contenente tutti i data_frames caricati in df_list. - Parameters: - void - Returns: - data_frames list - """ - return self.df_list - - def clear_data_frames(self): - """ - Rimuove tutti i valori contenuti nei data_frames presenti in df_list - Parameters: - void - Returns: - void - """ - for data_frame in self.df_list: - data_frame = data_frame.iloc[0:0] - - - def check_types_validity(self, data_frame): #Solo un esempio di controllo sui valori contenuti nel dataset - """ - Controlla la correttezza dei tipi contenuti nei dati caricati nel data_frame (in questo caso solo che nella seconda colonna siano contenuti dei float) - """ - if data_frame.iloc[:,1].dtype != np.float64: - raise ValueError("The Dataset is Not in the correct format") - - #TODO Integrare i controlli di correttezza sul dataset e capire quali assunzioni vanno fatte - - - - - - - diff --git a/main_package/classes/json_importer.py b/main_package/classes/json_importer.py new file mode 100644 index 0000000..2b435f3 --- /dev/null +++ b/main_package/classes/json_importer.py @@ -0,0 +1,67 @@ +import os +import glob +import pandas as pd +import json +import numpy as np +from abstract_importer import AbstractImporter + + +class JsonImporter(AbstractImporter): + + def __init__(self, files_path): + self.df_samples_list = [] + self.df_structure = pd.DataFrame() + self.df_variables = pd.DataFrame() + super(JsonImporter, self).__init__(files_path) + + def import_data(self): + data = self.read_json_file() + self.import_trajectories(data) + self.import_structure(data) + self.import_variables(data) + + + def import_trajectories(self, raw_data): + self.normalize_trajectories(raw_data, 0, 'samples') + + def import_structure(self, raw_data): + self.df_structure = self.one_level_normalizing(raw_data, 0, 'dyn.str') + + def import_variables(self, raw_data): + self.df_variables = self.one_level_normalizing(raw_data, 0, 'variables') + + def read_json_file(self): + try: + read_files = glob.glob(os.path.join(self.files_path, "*.json")) + for file_name in read_files: + with open(file_name) as f: + data = json.load(f) + return data + except ValueError as err: + print(err.args) + + def one_level_normalizing(self, raw_data, indx, variables_key): + return pd.json_normalize(raw_data[indx][variables_key]) + + def normalize_trajectories(self, raw_data, indx, trajectories_key): + for sample_indx, sample in enumerate(raw_data[indx][trajectories_key]): + self.df_samples_list.append(pd.json_normalize(raw_data[indx][trajectories_key][sample_indx])) + + def clear_data_frames(self): + """ + Rimuove tutti i valori contenuti nei data_frames presenti in df_list + Parameters: + void + Returns: + void + """ + for data_frame in self.df_list: + data_frame = data_frame.iloc[0:0] + + + +ij = JsonImporter("../data") +ij.import_data() +print(ij.df_samples_list[7]) +print(ij.df_structure) +print(ij.df_variables)