class AreaEvents(): def __init__(self, oltp_uri, stagedb_uri): self._db = DatabaseHelper(oltp_uri) self._dw = DatabaseHelper(stagedb_uri) def etl(self): try: df = self.__extract() transformed_df = self.__transform(df) self.__load(transformed_df) print('data loaded successfully') except Exception as e: print('error occured !!' + str(e)) def __extract(self): return self._db.extract_table_to_pandas("musicbrainz.l_area_event", columns="id, entity0, entity1") def __transform(self, df): df["area_id"] = df["entity0"] df["event_id"] = df["entity1"] df = df.drop('entity0', 1) df = df.drop('entity1', 1) return df.sort_values(by=['id'], ascending=True) def __load(self, transformed_df): self._dw.load_df_into_dwh(transformed_df, "dim.area_events", "public")
class Genders(): def __init__(self, oltp_uri, stagedb_uri): self._db = DatabaseHelper(oltp_uri) self._dw = DatabaseHelper(stagedb_uri) def etl(self): try: df = self.__extract() transformed_df = self.__transform(df) self.__load(transformed_df) print('data loaded successfully') except Exception as e: print('error occured !!' + str(e)) def __extract(self): return self._db.extract_table_to_pandas( "musicbrainz.gender", columns="id, name, parent, child_order") def __transform(self, df): top_row = pd.DataFrame({ 'id': [0], 'name': ['Unknown'], 'parent': [None], 'child_order': [0] }) df = pd.concat([top_row, df]).reset_index( drop=True) #Trick to add row to the line of base data framw return df.sort_values(by=['id'], ascending=True) def __load(self, transformed_df): self._dw.load_df_into_dwh(transformed_df, "dim.genders", "public")
def __init__(self): self.facialAnalyzer = FacialAnalyzer() self.audioAnalysisStatus = False self.dbh = DatabaseHelper().getInstance() lh = LoggerHelper().getInstance() self.logger = lh.createLoggerWorker("Analysis Manager", "DEBUG", 2) self.logger.info("Analysis Manager Instantiated")
def __init__(self, import_name): super(FlaskServer, self).__init__(import_name) bt = BackgroundTaskManager() bt.begin() self.secret_key = os.urandom(24) self.route("/")(self.login_page) self.route("/register/")(self.register_page) self.route("/login-user/", methods=['POST'])(self.login_user) self.route('/logout/')(self.logout) self.route('/menu_page/', methods=['GET','POST'])(self.menu_page) self.route('/menu/')(self.menu) self.route("/res/")(self.result_page) self.route("/graphs/")(self.graph_page) self.route("/lingraph/")(self.lingraph_page) self.route("/configf/", methods=['POST'])(self.config_func) self.route("/config/")(self.config_page) self.route("/info/")(self.info_page) self.route('/register_user/', methods=['POST'])(self.register_user) self.route("/notifications")(self.updateNotifications) self.route('/pref_func/', methods=['POST'])(self.pref_func) self.route("/textpreferences")(self.getPreferences) self.dbh = DatabaseHelper().getInstance() # Check if these directories exist if(os.path.isdir("recordings_audio") == False): os.makedirs("recordings_audio") if(os.path.isdir("recordings_video") == False): os.makedirs("recordings_video") if(os.path.isdir("logfiles") == False): os.makedirs("logfiles") lh = LoggerHelper().getInstance() self.flasklogger = lh.createLoggerWorker("flaskserver","DEBUG",2) self.flasklogger.info("Flask Server Instantiated") self.loggedUsers = []#Users who have already logged in today self.registeredUsers = []#Users who have registered for the first time
class Places(): def __init__(self, oltp_uri, stagedb_uri): self._db = DatabaseHelper(oltp_uri) self._dw = DatabaseHelper(stagedb_uri) def etl(self): try: df = self.__extract() transformed_df = self.__transform(df) self.__load(transformed_df) print('data loaded successfully') except Exception as e: print('error occured !!' + str(e)) def __extract(self): return self._db.extract_table_to_pandas( "musicbrainz.place", columns="id, gid, name, type, area, ended") def __transform(self, df): df = df[df["gid"] != None] df['type'] = df.type.fillna(0) df['area'] = df.type.fillna(0) df["is_active"] = df["ended"] df = df.drop('gid', 1) return df.sort_values(by=['id'], ascending=True) def __load(self, transformed_df): self._dw.load_df_into_dwh(transformed_df, "dim.places", "public") def __create_index(self): self._dw.run_command( "CREATE INDEX index_name ON table_name (column_name);")
class Artists(): def __init__(self, oltp_uri, stagedb_uri): self._db = DatabaseHelper(oltp_uri) self._dw = DatabaseHelper(stagedb_uri) def etl(self): try: df = self.__extract() transformed_df = self.__transform(df) self.__load(transformed_df) print('data loaded successfully') except Exception as e: print('error occured !!' + str(e)) def __extract(self): return self._db.extract_table_to_pandas("musicbrainz.artist", columns="id, gid, name, sort_name, type, area, gender, ended") def __transform(self, df): df = df[df["gid"] != None] df['type'] = df.type.fillna(0) df['area'] = df.type.fillna(0) df['gender'] = df.type.fillna(0) df["is_active"] = df.ended.apply(lambda x : not(x)) df = df.drop('ended', 1) return df.sort_values(by=['id'], ascending=True) def __load(self, transformed_df): self._dw.load_df_into_dwh(transformed_df, "dim.artists", "public")
def get_recommend_by_movie(movieid, algo='euclidean'): db = DatabaseHelper(password='******') if algo == 'euclidean': return {str(movieid): db.get_recommend_by_movie_euclidean(movieid)} elif algo == 'pearson': return {str(movieid): db.get_recommend_by_movie_pearson(movieid)} else: return None
def __init__(self): self.movies = OrderedDict() self.reviews = defaultdict(dict) db = DatabaseHelper(password='******') self.movies = db.get_all_movies() self.reviews = db.get_all_reviews() # Change this to the number of movies in dataset self.num_of_movie = 3952
def get_recommend_by_user(userid, algo='euclidean'): db = DatabaseHelper(password='******') if algo == 'euclidean': return {str(userid): db.get_recommend_by_user_euclidean(userid)} elif algo == 'pearson': return {str(userid): db.get_recommend_by_user_pearson(userid)} elif algo == 'svd': return {str(userid): db.get_recommend_by_user_svd(userid)} else: return None
def wrap(*args,**kwargs): if 'user' in flask.session: flask.flash("You need to log out first") dbh = DatabaseHelper.getInstance() nm = NotificationManager.getInstance(flask.session['sessionID']) return flask.render_template('menu.html', message=nm.getUserNotifications(), days=json.dumps(dbh.getTakenDays(flask.session['sessionID']))) else: return f(*args,**kwargs)
def wrap(*args,**kwargs): nm = NotificationManager.getInstance(flask.session['sessionID']) dbh = DatabaseHelper.getInstance() acc,filename,wpm,var,mFreq,brTime,avgAmp = dbh.return_audiorecordings(flask.session['sessionID']) if len(filename) == 0: if not nm.newStartGiven: nm.addNotification("Hi " + flask.session['user'] + ', and welcome to PAPA! It seems to be your first time using this app. Please click the help button to get started.', "help", "PAPA Team") nm.newStartGiven = True return f(*args,**kwargs)
class LinkTypes(): def __init__(self, oltp_uri, stagedb_uri): self._db = DatabaseHelper(oltp_uri) self._dw = DatabaseHelper(stagedb_uri) def etl(self): try: df = self.__extract() transformed_df = self.__transform(df) self.__load(transformed_df) print('data loaded successfully') except Exception as e: print('error occured !!' + str(e)) def __extract(self): return self._db.extract_table_to_pandas( "musicbrainz.link_type", columns="id, parent, name, child_order") def __transform(self, df): return df.sort_values(by=['id'], ascending=True) def __load(self, transformed_df): self._dw.load_df_into_dwh(transformed_df, "dim.link_types", "public")
def __init__(self, import_name): super(AudioRec, self).__init__(import_name) self.route("/audiorec/")(self.audiorec) self.route("/select")(self.selectArticlePage) self.route("/loading-results/")(self.loadScreen) self.route("/selectfunc", methods=['GET','POST'])(self.text_choice_func) self.fi = STTFileImporter() self.am = AnalysisManager() self.dbh = DatabaseHelper().getInstance() self.tipSelector = FileImporter() lh = LoggerHelper().getInstance() self.recordinglogger = lh.createLoggerWorker("recording","DEBUG",2) self.recordinglogger.info("Audio Rec Instantiated")
def getOrdering(self, userID): listFilled = [] dbh = DatabaseHelper.getInstance() prefs = dbh.return_text_pref(userID) for i in prefs: if i != "NULL" and i != '': listFilled.append(i) for i in os.listdir('files/daily-articles/'): if i not in listFilled and i != 'ArticleSites.txt' and i != ".DS_Store": listFilled.append(i) return listFilled
def insertAnalyzeData(self): try: peakspermin = (self.peaks / self.duration) * 60 self.logger.debug("PeaksPerMin = {}") troughspermin = (self.troughs / self.duration) * 60 self.logger.debug("troughspermin") blinkspermin = (self.blinks / self.duration) * 60 self.logger.debug("blinkspermin") self.dbh = DatabaseHelper.getInstance() self.dbh.insert_videorecordings(self.userId, self.blinks, self.peaks, self.troughs, blinkspermin, peakspermin, troughspermin, self.duration, self.filename, self.case) self.logger.info("Data has been inserted into the Database") self.resetValues() return True except: self.logger.error("Insert Analyze Failed") return False
def beginAnalysisThread(self, user, userId, dbh, filename, case): try: self.case = case self.filename = filename + ".avi" self.dbh = DatabaseHelper.getInstance() self.username = user self.userId = userId self.VIDEOPATH = str(os.getcwd() + "\\recordings_video\\" + self.username + "\\" + self.filename) self.out = cv2.VideoWriter(self.VIDEOPATH, self.fourcc, 20.0, (320, 240)) self.logger.info("Video Created at:{0}".format(self.VIDEOPATH)) self.logger.info( "Analysis Thread has Begun(user:{0}, userId:{1},filename:{2})". format(self.username, self.userId, self.filename)) self.Thread = threading.Thread(target=self.analyzeVideoRecording, args=(case, filename, user, userId)) self.Thread.start() return True except Exception as e: self.logger.error("Tried to Begin Thread:{0}".format(e)) return False
def wrap(*args,**kwargs): nm = NotificationManager.getInstance(flask.session['sessionID']) dbh = DatabaseHelper.getInstance() acc,filename,wpm,var,mFreq,brTime,avgAmp = dbh.return_audiorecordings(flask.session['sessionID']) ch_acc,ch_wpm,ch_var,ch_mFreq,ch_breath,ch_avgAmp,ch_blink,ch_jvib = dbh.return_config(flask.session['sessionID']) filename,total_blinks,total_peaks,total_troughs,blinkspermin,peakspermin,troughspermin,video_duration = dbh.return_videoRecordings(flask.session['sessionID']) try: if len(acc) >5: avg_acc = (sum(acc) - acc[-1])/(len(acc) - 1) avg_wpm = (sum(wpm) - wpm[-1])/(len(wpm) - 1) avg_var = (sum(var) - var[-1])/(len(var) - 1) avg_mFreq = (sum(mFreq) - mFreq[-1])/(len(mFreq) - 1) avg_brTime = (sum(brTime) - brTime[-1])/(len(brTime) - 1) avg_avgAmp = (sum(avgAmp) - avgAmp[-1])/(len(avgAmp) - 1) avg_blinkspermin = (sum(blinkspermin) - blinkspermin[-1])/(len(blinkspermin) - 1) avg_peakspermin = (sum(peakspermin) - peakspermin[-1])/(len(peakspermin) - 1) if (((acc[-1]/avg_acc)-100) <= -ch_acc) or (((wpm[-1]/avg_wpm)-100) <= -ch_wpm) or (((var[-1]/avg_var)-100) <= -ch_var) or (((brTime[-1]/avg_brTime)-100) <= ch_breath) or (((avg_avgAmp[-1]/avg_avgAmp)-100) <= -ch_avgAmp) or (((mFreq[-1]/avg_mFreq)-100) <= -ch_mFreq or (((blinkspermin[-1]/avg_blinkspermin)-100) <= -ch_blink) or (((peakspermin[-1]/avg_peakspermin)-100) <= ch_jvib)): nm.addNotification('We have noticed some changes in your results, your doctor has been notified, but you may wish to book an appointment',"deterioration","Analysis Team") nm.sendDoctorNotifications("Hello", "*****@*****.**") return flask.render_template('menu.html', message=nm.getUserNotifications(), days=json.dumps(dbh.getTakenDays(flask.session['sessionID']))) except: return flask.render_template('menu.html', message=nm.getUserNotifications(), days=json.dumps(dbh.getTakenDays(flask.session['sessionID']))) return f(*args,**kwargs)
class AnalysisManager(): def __init__(self): self.facialAnalyzer = FacialAnalyzer() self.audioAnalysisStatus = False self.dbh = DatabaseHelper().getInstance() lh = LoggerHelper().getInstance() self.logger = lh.createLoggerWorker("Analysis Manager", "DEBUG", 2) self.logger.info("Analysis Manager Instantiated") # This function generates a date time stamp and uses that as a filename def generateFilename(self, username): time = datetime.datetime.now() self.username = username self.filename = time.strftime("%d-%m-%y_%H-%M-%S") return self.filename # Root function for Audio Analysis on the Thread def performAudioAnalysis(self, userID, expectedStr): try: ac = AccuracyChecker() ac.record("recordings_audio/" + self.username + '/' + self.filename + ".wav") accuracy, wpm = ac.performAnalysis(expectedStr) afa = AudioFeatureAnalyzer("recordings_audio/" + self.username + '/' + self.filename + ".wav") variance = afa.calcFrequencyVariance() mFrequency = afa.calcModalFrequency() breathTime = afa.calcTimeSpentBreathing() avgAmp = afa.calcAverageAmplitude() self.logger.info("userID is {}".format(userID)) aS = AnalysisSingletonSwitch.getInstance(userID) while not aS.userChecked: self.logger.debug('waiting for recognzizer') time.sleep(5) self.logger.info("userID is {}".format(userID)) aS = AnalysisSingletonSwitch.getInstance(userID) if aS.isUser: self.dbh.insert_audiorecordings(userID, accuracy, self.filename, wpm, variance, mFrequency, breathTime, avgAmp, "INSERT") self.logger.debug('Inserted Audio') count = 0 while not aS.facialFinished: if count == 6: break self.logger.debug('waiting for face analyzer') time.sleep(5) count += 1 aS = AnalysisSingletonSwitch.getInstance(userID) nm = NotificationManager.getInstance(userID) nm.addNotification("Your results are ready for display", "results", "Analysis Team") self.logger.debug('Added Notification') aS.removeInstance(userID) else: nm = NotificationManager.getInstance(userID) nm.addNotification( "We're sorry but we couldn't recognize you from your recording, please try again later.", "info", "Analysis Team") except Exception as e: self.logger.error('Error: {}'.format(e)) # This function runs the audio and facial analysis threads def startAnalysis(self, userID, expectedStr): fr = FacialRecognizer() fr.beginUserRecognizerThread(self.username, userID) self.thread = threading.Timer(interval=5, function=self.performAudioAnalysis, args=(userID, expectedStr)) self.thread.start() # Runs the face analyzer module # args: username, userid, dbh,filename self.facialAnalyzer.beginAnalysisThread(self.username, userID, self.dbh, self.filename, 'insert') return
def update_u2m_euclidean(model): result = euclidean.getRecomDict_User(model) db = DatabaseHelper(password='******') db.save_knn_euclidean_recommend_result(result, type='user') print('End training U2M euclidean')
def update_m2m_pearson(model): result = pearson.getRecomDict_Movie(model) db = DatabaseHelper(password='******') db.save_knn_pearson_recommend_result(result, type='movie') print('End training M2M pearson')
class FlaskServer(AudioRec): def __init__(self, import_name): super(FlaskServer, self).__init__(import_name) bt = BackgroundTaskManager() bt.begin() self.secret_key = os.urandom(24) self.route("/")(self.login_page) self.route("/register/")(self.register_page) self.route("/login-user/", methods=['POST'])(self.login_user) self.route('/logout/')(self.logout) self.route('/menu_page/', methods=['GET','POST'])(self.menu_page) self.route('/menu/')(self.menu) self.route("/res/")(self.result_page) self.route("/graphs/")(self.graph_page) self.route("/lingraph/")(self.lingraph_page) self.route("/configf/", methods=['POST'])(self.config_func) self.route("/config/")(self.config_page) self.route("/info/")(self.info_page) self.route('/register_user/', methods=['POST'])(self.register_user) self.route("/notifications")(self.updateNotifications) self.route('/pref_func/', methods=['POST'])(self.pref_func) self.route("/textpreferences")(self.getPreferences) self.dbh = DatabaseHelper().getInstance() # Check if these directories exist if(os.path.isdir("recordings_audio") == False): os.makedirs("recordings_audio") if(os.path.isdir("recordings_video") == False): os.makedirs("recordings_video") if(os.path.isdir("logfiles") == False): os.makedirs("logfiles") lh = LoggerHelper().getInstance() self.flasklogger = lh.createLoggerWorker("flaskserver","DEBUG",2) self.flasklogger.info("Flask Server Instantiated") self.loggedUsers = []#Users who have already logged in today self.registeredUsers = []#Users who have registered for the first time # This function returns the login page @already_loggedin def login_page(self): try: self.flasklogger.debug("logged in") return flask.render_template('login.html') except Exception as e: self.flasklogger.error("Login Page Failed: Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) # This function returns the register page @already_loggedin def register_page(self): try: return flask.render_template('register.html') except Exception as e: self.flasklogger.error("Register Page Failed:Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) # This function takes username and password and checks the database to log in the user @already_loggedin def login_user(self): try: user = flask.request.form['username'] password = flask.request.form['password'] if len(user) and len(password) == 0: flask.flash("Please input your username and password correctly") return flask.render_template("login.html") check = self.dbh.checkUserCredentials("Login",user,password) if(check == 'Invalid'): flask.flash("Invalid Credentials, Try Again") return flask.render_template('login.html') else: PATH = 'recordings_audio/' + user if not os.path.exists(PATH): os.makedirs(PATH) PATH = 'recordings_video/' + user if not os.path.exists(PATH): os.makedirs(PATH) flask.flash("You have successfully logged in") # Add session ID flask.session['sessionID'] = check flask.session['user'] = user if user not in self.loggedUsers: self.loggedUsers.append(user) return flask.render_template('prescreen.html', user_id = flask.session['sessionID'], username = flask.session['user']) else:#Only show the prescreening on their first login of the day return flask.redirect('/menu/') except Exception as e: self.flasklogger.error("Login User Function Failed:Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) # This function logs a user out @login_required def logout(self): try: NotificationManager.removeInstance(flask.session['sessionID']) flask.session.clear() flask.flash("You have been logged out!") return flask.redirect(flask.url_for('login_page')) except Exception as e: self.flasklogger.error("Logout Failed:Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) # This function returns the menu page and activates a notification @login_required @notify_deterioration def menu(self): try: nm = NotificationManager.getInstance(flask.session['sessionID']) return flask.render_template('menu.html', message=nm.getUserNotifications(), days=json.dumps(self.dbh.getTakenDays(flask.session['sessionID']))) except Exception as e: self.flasklogger.error("Menu Page Failed:Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) # This function inserts prescreening answers and puts it into the database # and then send a message to the client to redirect to the menu page @test_firstLogin def menu_page(self): try: if flask.request.method == "POST": mood = flask.request.form['q1'] food = flask.request.form['q2'] medication = flask.request.form['q3'] userId = flask.session['sessionID'] self.dbh.insert_prescreening(mood,medication,food,userId,"Insert") return flask.jsonify("Data Inserted") except Exception as e: self.flasklogger.error("Pre Menu Page(Data Insert) Failed:Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) # This function pulls recording data from the Database, creates a JSON string and then sends it through the Graph Page-Client Side @login_required def result_page(self): try: self.tip = self.tipSelector.loadFile() #import audio data from db and convert to a json string accuracy_percentage,filename,wpm,variance,mFreq,brTime,avgAmp = self.dbh.return_audiorecordings(flask.session['sessionID']) filenamestripwav = [] for val in filename: filenamestripwav.append(val.strip('.wav')) ser_accp = pd.Series(accuracy_percentage, index = [filenamestripwav], name = "accuracy") ser_wpm = pd.Series(wpm, index = [filenamestripwav], name = "words") ser_var = pd.Series(variance, index = [filenamestripwav], name = "variance") ser_mFreq = pd.Series(mFreq, index = [filenamestripwav], name = "modalFrequency") ser_brTime = pd.Series(brTime, index = [filenamestripwav], name = "brTime") ser_avgAmp = pd.Series(avgAmp, index = [filenamestripwav], name = "avgAmp") # Turn Series into a DataFrame and convert it to json using pandas frame = pd.concat([ser_accp,ser_wpm,ser_var,ser_mFreq,ser_brTime,ser_avgAmp], axis = 1) frame.to_json('static\json\graphdata.json') file = open('static\json\graphdata.json','r') self.jsonstring = file.read() #import video data and export as json filename, total_blinks, total_peaks, total_troughs, blinkspermin, peakspermin, troughspermin, video_duration = self.dbh.return_videoRecordings(flask.session['sessionID']) filenamestripavi = [] for val in filename: filenamestripavi.append(val.strip('.avi')) f_total_blinks = pd.Series(total_blinks, index = [filenamestripavi], name = "total blinks") f_total_peaks = pd.Series(total_peaks, index = [filenamestripavi], name = "total peaks") f_total_troughs = pd.Series(total_troughs, index = [filenamestripavi], name = "total troughs") f_blinkspermin = pd.Series(blinkspermin, index = [filenamestripavi], name = "blinkspermin") f_peakspermin = pd.Series(peakspermin, index = [filenamestripavi], name = "peakspermin") f_troughspermin = pd.Series(troughspermin, index = [filenamestripavi], name = "troughs per min") f_video_duration = pd.Series(video_duration, index = [filenamestripavi], name = "video duration") # Turn Series into a DataFrame and convert it to json using pandas frame2 = pd.concat([f_total_blinks,f_total_peaks,f_total_troughs,f_blinkspermin,f_peakspermin,f_troughspermin,f_video_duration], axis = 1) frame2.to_json('static\json\graphdata2.json') file2 = open('static\json\graphdata2.json','r') self.videojsonstring = file2.read() ch_acc,ch_wpm,ch_var,ch_mFreq,ch_breath,ch_avgAmp,ch_blink,ch_jvib = self.dbh.return_config(flask.session['sessionID']) self.flasklogger.debug("{0},{1},{2},{3},{4},{5},{6},{7}".format(ch_acc,ch_wpm,ch_var,ch_mFreq,ch_breath,ch_avgAmp,ch_blink,ch_jvib)) mood,medication,food = self.dbh.return_prescreen(flask.session['sessionID']) self.flasklogger.debug("{0},{1},{2}".format(mood,medication,food)) return flask.render_template('result.html', jsonstring = self.jsonstring, videojsonstring = self.videojsonstring, ch_acc = ch_acc, ch_wpm = ch_wpm, ch_var = ch_var, ch_breath = ch_breath, ch_blink = ch_blink, ch_jvib = ch_jvib, mood = mood,medication = medication, food = food, value = self.tip) except Exception as e: self.flasklogger.error("Result Page Failed:Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) # This function pulls the results json file and creates a radar graph @login_required def graph_page(self): try: ch_acc,ch_wpm,ch_var,ch_mFreq,ch_breath,ch_avgAmp,ch_blink,ch_jvib = self.dbh.return_config(flask.session['sessionID']) return flask.render_template('graphs.html', jsonstring = self.jsonstring, videojsonstring = self.videojsonstring, ch_mFreq = ch_mFreq, ch_avgAmp = ch_avgAmp) except Exception as e: self.flasklogger.error("Graph page Failed:Exception:{0}".format(e)) return flask.render_template('wrong.html') # This functions pulls the results from json file and creates line graphs @login_required def lingraph_page(self): try: return flask.render_template('lingraph.html', jsonstring = self.jsonstring, videojsonstring = self.videojsonstring) except Exception as e: self.flasklogger.error("Line Graph Failed:Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) @login_required def info_page(self): try: return flask.render_template('info.html') except Exception as e: self.flasklogger.error("Info Page Failed:Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) # This function pulls the configuration page @login_required def config_page(self): try: return flask.render_template('config.html') except Exception as e: self.flasklogger.error("Configuration Page Failed:Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) # This function takes the config page form, inserts into the database and creates a notification preference def config_func(self): try: userId = flask.session['sessionID'] time = flask.request.form['time'] ch_acc = flask.request.form['ch_acc'] ch_wpm = flask.request.form['ch_wpm'] ch_freq = flask.request.form['ch_freq'] ch_mod_freq = flask.request.form['ch_mod_freq'] ch_avg_amp = flask.request.form['ch_avg_amp'] ch_breath = flask.request.form['ch_breath'] ch_blink = flask.request.form['ch_blink'] ch_jvib = flask.request.form['ch_jvib'] self.dbh.insert_config(userId,time,ch_acc,ch_wpm,ch_freq,ch_mod_freq,ch_breath,ch_avg_amp,ch_blink,ch_jvib,"save") nm = NotificationManager.getInstance(flask.session['sessionID']) nm.addNotification("Your changes have been saved.", "config", "SYSTEM") return flask.render_template("menu.html",message = nm.getUserNotifications(), days=json.dumps(self.dbh.getTakenDays(flask.session['sessionID']))) except Exception as e: self.flasklogger.error("Configuration Function Failed:Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) # This function registers a user into the database @already_loggedin def register_user(self): try: user = flask.request.form['username'] password = flask.request.form['password'] sex = flask.request.form['sex'] age = flask.request.form['age'] diagnosed = flask.request.form['diagnosed'] if len(user) == 0 or len(password) == 0: flask.flash("Please input your username and password correctly") return flask.render_template("register.html") check = self.dbh.checkUserCredentials("Register",user,password) if( check == 'Valid'): self.registeredUsers.append(user) self.dbh.insert_users(user,password,sex,age,diagnosed,"Register") PATH = 'recordings_audio/' + user if not os.path.exists(PATH): os.makedirs(PATH) self.dbh.insert_config(user,1,10,10,10,10,10,10,10,10,'First Use') flask.flash("You have successfully registered") return flask.render_template('login.html') else: flask.flash("Invalid Credentials, Try again") return flask.render_template('register.html') except Exception as e: self.flasklogger.error("Register User Function Failed:Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) # This function updates the notification instance def updateNotifications(self): try: nm = NotificationManager.getInstance(flask.session['sessionID']) self.flasklogger.debug("CurrList:{}".format(self.registeredUsers)) return nm.getUserNotifications() except Exception as e: self.flasklogger.error("Update Notification Function:Exception:{0}".format(e)) return flask.render_template('wrong.html', error = "{}".format(e)) # This function returns the text preferences page @login_required def getPreferences(self): try: return flask.render_template("textpreferences.html") except Exception as e: self.flasklogger.error("Text Preferences Page Failed To return:{0}".format(e)) return flask.render_template('wrong.html',error="{}".format(e)) # This function takes the users preferences of articles and stores them into the Database def pref_func(self): try: userID = flask.session['sessionID'] pref1 = flask.request.form.get('irishindependent') pref2 = flask.request.form.get('irishtimes') pref3 = flask.request.form.get('rte') pref4 = flask.request.form.get('rtesport') pref5 = flask.request.form.get('guardian') pref6 = flask.request.form.get('skysports') self.dbh.insert_text_pref(userID, dict(p1=('irishindependent' if pref1 == 'true' else "NULL"))['p1'], dict(p2=('irishtimes' if pref2 == 'true' else "NULL"))['p2'], dict(p3=('rte' if pref3 == 'true' else "NULL"))['p3'], dict(p4=('rtesport' if pref4 == 'true' else "NULL"))['p4'], dict(p5=('guardian' if pref5 == 'true' else "NULL"))['p5'], dict(p6=('skysports' if pref6 == 'true' else "NULL"))['p6'], "INSERT") nm = NotificationManager.getInstance(flask.session['sessionID']) nm.addNotification("Your changes have been saved", "preferences", "System") return flask.redirect('/menu') except Exception as e: self.flasklogger.error("Preferences function failed:{0}".format(e)) return flask.render_template('wrong.html',error="{}".format(e))
def __init__(self, oltp_uri, stagedb_uri): self._db = DatabaseHelper(oltp_uri) self._dw = DatabaseHelper(stagedb_uri)
class Events(): def __init__(self, oltp_uri, stagedb_uri): self._db = DatabaseHelper(oltp_uri) self._dw = DatabaseHelper(stagedb_uri) def etl(self): try: df = self.__extract() transformed_df = self.__transform(df) return self.__load(transformed_df) print('data loaded successfully') except Exception as e: print('error occured !!' + str(e)) def __extract(self): return self._db.extract_table_to_pandas( "musicbrainz.event", columns= "id, gid, begin_date_year, begin_date_month, begin_date_day, end_date_year, end_date_month, end_date_day, time, type, cancelled, ended" ) def __transform(self, df): df = df[df["gid"] != None] df['begin_date_year'] = df.begin_date_year.fillna(0) df['end_date_year'] = df.end_date_year.fillna(0) df['begin_date_month'] = df.begin_date_month.fillna(0) df['end_date_month'] = df.end_date_month.fillna(0) df = df[df["begin_date_year"] != 0] df = df[df["end_date_year"] != 0] df = df[df["begin_date_month"] != 0] df = df[df["end_date_month"] != 0] df['begin_date_day'] = df.begin_date_day.fillna(1) df['end_date_day'] = df.end_date_day.fillna(1) df['begin_date_tmp'] = df['begin_date_year'].astype('int64').astype( str) + '/' + df['begin_date_month'].astype('int64').astype( str) + '/' + df['begin_date_day'].astype('int64').astype(str) df['begin_date'] = df['begin_date_tmp'].apply(lambda x: parse(x)) df['begin_date_id'] = df['begin_date'].apply( lambda x: x.strftime('%Y%m%d')) df['end_date_tmp'] = df['end_date_year'].astype('int64').astype( str) + '/' + df['end_date_month'].astype('int64').astype( str) + '/' + df['end_date_day'].astype('int64').astype(str) df['end_date'] = df['end_date_tmp'].apply(lambda x: parse(x)) df['end_date_id'] = df['end_date'].apply( lambda x: x.strftime('%Y%m%d')) df['duration'] = df['end_date'] - df['begin_date'] #).dt.days df = df.drop('begin_date_year', 1) df = df.drop('begin_date_month', 1) df = df.drop('begin_date_day', 1) df = df.drop('begin_date_tmp', 1) df = df.drop('begin_date', 1) df = df.drop('end_date_year', 1) df = df.drop('end_date_month', 1) df = df.drop('end_date_day', 1) df = df.drop('end_date_tmp', 1) df = df.drop('end_date', 1) df.begin_date_id = df.begin_date_id.astype('int64') df.end_date_id = df.end_date_id.astype('int64') return df.sort_values(by=['id'], ascending=True) def __load(self, transformed_df): self._dw.load_df_into_dwh(transformed_df, "dim.events", "public")
psr.genHypothesis() except Exception as e: logger.error("Failed to generate hypothesis".format(e)) self.fail("Failed generating hypothesis") class FacialAnalyzerTestCases(unittest2.TestCase): def test_analysis_thread(self): try: facialAnalyzer.beginAnalysisThread("test_img_no_delete", 1010, dbh, "testfilename", "TEST") except Exception as e: logger.error("Facial Analyzer Thread Failed".format(e)) self.fail("Facial Analyzer Thread Failed") if __name__ == '__main__': lh = LoggerHelper().getInstance() logger = lh.createLoggerWorker("unittest", "DEBUG", 2) dbh = DatabaseHelper().getInstance() facialAnalyzer = FacialAnalyzer() ac = AccuracyChecker() afa = AudioFeatureAnalyzer("UnittestAudio\\TestCase.wav") sfi = STTFileImporter() fi = FileImporter() formatter = STTFormatter() psr = pocketSphinxRecognizer( "pocketsphinx-data\\en-US\\acoustic-model", 'pocketsphinx-data\\en-US\\language-model.lm.bin', 'pocketsphinx-data\\en-US\\pronounciation-dictionary.dict') unittest2.main()