import os import sys import shutil import zipfile import multiprocessing import pandas as pd from datetime import datetime,timedelta from lib.data_helpers import data_utils from lib.experiment_specs import study_config from lib.data_helpers import test from lib.data_helpers.builder_utils import BuilderUtils from lib.data_helpers.gaming import Gaming from lib.utilities import serialize class PullEvents(): port_dir = {"PCDashboard": os.path.join("data","external","dropbox","..","PCPort"), "PhoneDashboard":os.path.join("data","external","dropbox","..","PhoneDashboardPort")} #identifying_cols are a list of columns in the dataframe that identify a row. none of them can be empty def __init__(self,source: str, keyword: str, scratch: bool, test: bool, time_cols: list, raw_timezone: str, appcode_col: str, identifying_cols: list, sort_cols: list, drop_cols: list, cat_cols: list, compress_type: str, processing_func = BuilderUtils.default_puller_process, file_reader = None): """ Purpose ------- This class appends the raw data files housed in self.zipped_directory, cleans them a bit with the self.processing func, and saves the merged data file in self.raw_file. Unless self.scratch == True, the puller will only process new raw data files and appends them to the dataframe saved in self.raw_file. The puller documents which files have been processed in the config located in self.config_file_path WARNING: if self.scratch==TRUE, it may take hours or days to reprocess all the data. Call Michael to discuss if this needs to happen. Parameters ---------- source - source the app data source (either PC or PD) keyword - the kind of data coming in (e.g. Snooze, Use etc) scratch - whether or not to start data processing from scratch test - whether or not to test the pulling pipeline (it will reprocess that latest three zipfiles) (I wouldn't play with this) time_cols - list of columns that contain datetimes raw_timezone - the timezone of the raw data appcode_col - the raw column name containing the appcodes identifying_cols - list of columns that should identify a unique row sort_cols - list of columns that describes how the df should be ordered. The df will be sorted from smallest to largest value of the sort_cols drop_cols - list of columns that appear in the raw zipfile or after zipfile processing that should be dropped cat_cols - list of columns that can be converted into the categorical data type compress_type - how the zipfiles are compressed (either "folder", "csv", or "txt") processing_func - the function used to process the raw data (e.g. clean_master dates) file_reader - function that reads in the raw file into memory. only required for file stored in zip folders. """ self.source = source self.keyword = keyword self.scratch = scratch self.pull_test = test self.time_cols = time_cols self.raw_timezone = raw_timezone self.appcode_col = appcode_col self.identifying_cols = identifying_cols self.sort_cols = sort_cols self.drop_cols = drop_cols self.cat_cols = cat_cols self.compress_type = compress_type self.processing_func = processing_func self.file_reader = file_reader self.zipped_directory = os.path.join("data","external", "input", source, f"Raw{self.keyword}Zipped") self.buggy_dir = os.path.join("data","external", "input", source, "BuggyFiles") self.config_file_path = os.path.join("data","external", "input", source, f"{self.source}{self.keyword}Config.csv") self.raw_file = os.path.join("data","external", "input", source, f"Raw{self.keyword}") self.test_file = os.path.join("data","external", "input_test", source, f"Raw{self.keyword}") self.config_user_dict = serialize.open_yaml("config_user.yaml") self.builder_utils = BuilderUtils() self.added_config = self.builder_utils.get_config(self.config_file_path) #dictionary of zipfiles in the raw_file self.new_config = {} def update_data(self): print(f"\n Updating {self.keyword} data! {datetime.now()}") if self.config_user_dict["local"]["test"]==True: df = serialize.soft_df_open(self.test_file) df = self._memory_redux(df) print(df.memory_usage(deep=True) / 1024 ** 2) return df else: self.builder_utils.transport_new_zip_files(PullEvents.port_dir[self.source], self.keyword, self.zipped_directory) new_zip_files = [x for x in os.listdir(self.zipped_directory) if (x.replace(".zip", "") not in self.added_config) & (".zip" in x)] print(f"new zip files {len(new_zip_files)}") # if no new data or scratch run, just load old data if ((self.scratch == False) & (len(new_zip_files) == 0) & (self.pull_test == False)): print("\t No New Data! Loading pickled raw data into memory") if(os.path.getsize(self.raw_file+".pickle") > 0) : df = serialize.soft_df_open(self.raw_file) else: print("Raw file is empty. Reading Backup Compression Zip") df = serialize.read_gz(self.raw_file+".gz") df = self._memory_redux(df) # Archiving Recruitment Data IF Use Data if (self.keyword == "Alternative") or (self.keyword == "Use"): #self._archive_recruitment(df) df = df.loc[df["CreatedDatetimeHour"] >= study_config.surveys["Baseline"]["Start"]-timedelta(1)] return df else: print(f"Length of new zip files {len(new_zip_files)}") df = self.aggregate_data(new_zip_files) self.builder_utils.update_config(self.added_config, self.new_config, self.config_file_path) return df def aggregate_data(self,new_zip_files): old_df, new_zip_files = self._configure_data(new_zip_files) print(f"\t Going to add {len(new_zip_files)} files:") if self.config_user_dict['local']["parallel"] == False: df_dic = self._process_zips(new_zip_files) #if the number of files > # of cores, then multiprocess elif multiprocessing.cpu_count() < len(new_zip_files): df_dic = self._process_zips_mp(new_zip_files) else: print(f"not multiprocessing b/c number of cores {multiprocessing.cpu_count()} < {len(new_zip_files)}") df_dic = self._process_zips(new_zip_files) #get appcodes to keep print("\t get data survey") cl_file = os.path.join(os.path.join("data","external","dropbox_confidential","ContactLists","Used"), study_config.kept_appcode_cl) a_df = pd.read_csv(cl_file) a_df = data_utils.add_A_to_appcode(a_df,"AppCode") appcodes = list(a_df["AppCode"]) print(len(appcodes)) assert len(appcodes) == study_config.number_of_kept_appcodes # combine new with old and keep relevant appcodes if len(df_dic)>0: print("\t adding new data to master") new_df = pd.concat(list(df_dic.values()), sort=True) new_df = new_df.loc[new_df["AppCode"].isin(appcodes)] parent_df = pd.concat([old_df,new_df], sort=True) else: print("\t no new data!") parent_df = old_df # minimal cleaning and save to disk: sort from smallest to largest values of sort_cols print(f"\t Len before duplicate drop {len(parent_df)}") parent_df = parent_df.sort_values(by = self.sort_cols) parent_df = parent_df.drop_duplicates(subset = self.identifying_cols, keep = 'last') print(f"\t Len after duplicate drop {len(parent_df)}") for col in parent_df.columns: if "Unnamed" in col: parent_df = parent_df.drop(columns= [col]) parent_df = parent_df.reset_index(drop=True) print(parent_df.memory_usage(deep=True) / 1024 ** 2) try: os.rename(self.raw_file+".pickle",self.raw_file+"PrevRun.pickle") except: print('could not find old pickle file') try: serialize.save_pickle(parent_df, self.raw_file) except: print("Failed to save pickle!") try: test.save_test_df(parent_df, self.test_file) except: print("Failed to save testfile") # DONT PUT IN TRY BECAUSE IF BACKUP FAILS, WE WANT TO RE PROCESS THE NEW FILES try: os.rename(self.raw_file + ".gz", self.raw_file + "PrevRun.gz") except: print("no old gz file") parent_df.to_csv(self.raw_file + '.gz', index=False, compression='gzip') print(f"\t Done Saving {datetime.now()}") # add new guys to config in memory, now that everything has saved for zip_file, df in df_dic.items(): try: latest_hour = str(df[self.time_cols[0]].max()) earliest_hour = str(df[self.time_cols[0]].min()) except: latest_hour = "NAN" earliest_hour = "NAN" self.new_config[zip_file.replace(".zip", "")] = {"EarliestHour": earliest_hour, "LatestHour": latest_hour, "ZipFile": zip_file} return parent_df """ modifes the reaggregation in the following way: - if self.scatch is True: all zipfiles in data dire are new, and old_df is empty - if self.test is True: reprocess the last three data files, and old_df is reloaded - else: process the new zip files with old df""" def _configure_data(self,new_zip_files): if self.scratch: all_zip_files = [x for x in os.listdir(self.zipped_directory) if ".zip" in x] new_zip_files = sorted(all_zip_files) #continue_ans = input("Warning: Do you want to reprocess all use files? Enter (Y or N) \n ") continue_ans = "Y" if continue_ans == "N": sys.exit() print(f"DELETING ADDED EVENT CONFIG, CAUSING REAGGREGATION OF ALL {self.keyword} ZIPFILES") self.added_config = {} if self.keyword == "Use": print("\t Also Deleting all Granular Gaming Files") for gran_folder in [os.path.join(Gaming.gaming_dir, "FirstLast"), os.path.join(Gaming.gaming_dir, "Granular")]: shutil.rmtree(gran_folder) os.mkdir(gran_folder) old_df = pd.DataFrame() else: if self.pull_test: try: assert len(new_zip_files) == 0 except: print("There are actual new zip files to process! First process these files, then test") sys.exit() print("TEST: Reprocessing 3 files from zipped directory") test_files = os.listdir(self.zipped_directory)[-3:] for zip_file in test_files: del self.added_config[zip_file.replace(".zip", "")] new_zip_files = test_files if not os.path.exists((self.raw_file+".pickle")): old_df = pd.DataFrame() elif os.path.getsize(self.raw_file + ".pickle") > 0: old_df = serialize.soft_df_open(self.raw_file) else: print("Raw file is empty. Reading Backup Compression Zip") old_df = serialize.read_gz(self.raw_file + ".gz") if len(old_df)>1: old_df = self._memory_redux(old_df) # Archiving Recruitment Data IF Use Data if (self.keyword == "Alternative") or (self.keyword == "Use"): #self._archive_recruitment(old_df) old_df = old_df.loc[old_df["CreatedDatetimeHour"] >= study_config.surveys["Baseline"]["Start"]-timedelta(1)] return old_df, new_zip_files def _process_zips_mp(self, new_zip_files: list): # create the pool object for multiprocessing pool = multiprocessing.Pool(processes=study_config.cores) # split the files to add into n lists where n = cores chunks = [new_zip_files[i::study_config.cores] for i in range(study_config.cores)] print(f"Multiprocessing with {study_config.cores} cpus") df_list_of_dics = pool.map(func = self._process_zips, iterable = chunks) pool.close() print("Done Multiprocessing") # flatten the list of dictionaries df_dic = {} for d in df_list_of_dics: for k, v in d.items(): df_dic[k] = v return df_dic def _process_zips(self,new_zip_files): df_dic = {} i = 1 for zip_file in new_zip_files: print(f"processing {zip_file} ({round((i * 100) / len(new_zip_files))}%)", end = "\r") df = self._process_zip(zip_file) if len(df) == 0: continue df_dic[zip_file] = df i = i + 1 return df_dic def _process_zip(self, zip_file): if ".zip" not in zip_file: return pd.DataFrame() # open zipfile if self.compress_type != "folder": df, problem = self._open_zipfile(zip_file) # open json zip folder else: df = self._open_zipfolder(zip_file) problem = "" if len(df) == 0: if problem != "Corrupt": problem = "Empty" print(f"{zip_file} is empty ...archiving in {self.buggy_dir}/{problem}") old_file = os.path.join(self.zipped_directory, zip_file) new_file = os.path.join(self.buggy_dir, problem, zip_file) os.rename(old_file, new_file) return df df.columns = df.columns.str.replace(' ', '') df = df.rename(columns={self.appcode_col: "AppCode"}) df["AppCode"] = df["AppCode"].astype(str).apply(lambda x: "A" + x if x != "nan" and x.isnumeric() else x) df = self.processing_func(df, zip_file, self) df["Zipfile"] = zip_file df = self._memory_redux(df) return df def _open_zipfile(self,zip_file): if self.compress_type == "txt": separator = '\t' elif self.compress_type == "csv": separator = ',' else: separator = "" print("Illegal seperator") sys.exit() try: df = pd.read_csv(os.path.join(self.zipped_directory, zip_file), compression='zip', header=0, sep=separator, quotechar='"') problem = "None" except: print(f"{zip_file} is corrupt. Investigate in archive") df = pd.DataFrame() problem = "Corrupt" return df, problem def _open_zipfolder(self,zip_folder): #print(zip_folder) #print(self.zipped_directory) zip_ref = zipfile.ZipFile(os.path.join(self.zipped_directory, zip_folder)) temp_folder = os.path.join(self.zipped_directory, zip_folder.replace(".zip", "FOLDER")) zip_ref.extractall(path=temp_folder) df_list = [] for file in os.listdir(temp_folder): file_path = os.path.join(temp_folder, file) clean_data = self.file_reader(file_path) df_list.append(clean_data) shutil.rmtree(temp_folder) df = pd.concat(df_list) return df def _open_zipfolders_install(self,zip_folders): """for recovering install data""" for zip_folder in zip_folders: df = self._open_zipfolder(zip_folder) def _memory_redux(self,df): # drop columns that were initially in raw data or processing byproduct for drop_col in self.drop_cols + ["Server","AsOf"]: if drop_col in df.columns.values: df = df.drop(columns = [drop_col]) # make columns categorical for cat_col in self.cat_cols + ["Zipfile"]: if cat_col in df.columns.values: try: df[cat_col] = df[cat_col].astype('category') except: print(f"\t categorizing {cat_col} failed!") return df def _archive_recruitment(self,df): if os.path.exists(self.raw_file + "RecruitmentPhase.pickle"): pass else: r_df_raw = df.loc[df["CreatedDatetimeHour"] < study_config.surveys["Baseline"]["Start"]-timedelta(1)] try: serialize.save_pickle(r_df_raw, self.raw_file + "RecruitmentPhase.pickle") except: r_df_raw.to_csv(self.raw_file + 'RecruitmentPhase.gz', index=False, compression='gzip')