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()
