def update_reminder_table(self, usr_id, msg_id):
print "In here: "
reminder_dict = {}
try:
reminder_dict = {
'usr_id': usr_id,
'msg_id': msg_id,
'msg_text': self.message_text,
'year': self.year,
'month': self.month,
'date': self.day,
'hh': self.hour,
'mm': self.min,
'sent': "F",
'crt_ts': str(datetime.now()),
'upd_ts': str(datetime.now())
}
print reminder_dict
except Exception as e:
print str(e)
postgres = PostgresHelper()
print "Updating table: ", reminder_dict
postgres.postgres_insert_dictionary_list(
table_name=config_dict['REMINDER_TABLE'],
dict_list=[reminder_dict])
def profile_exists(self, usr_id):
postgres = PostgresHelper()
results = postgres.postgres_select(table_name=config_dict['USR_TABLE'], condition=" WHERE usr_id=%s",
parameters=[usr_id], return_dict=True)
print results
if results is not None and len(results) > 0:
return True
return False
def get_usr_timezone(self, usr_id):
postgres = PostgresHelper()
results = postgres.postgres_select(table_name=config_dict['USR_TABLE'], condition=" WHERE usr_id=%s",
parameters=[usr_id], req_column_list=['timezone'], return_dict=True)
print "results" , results
try:
return results[0]['timezone']
except:
print "Could not fetch timezone"
return 0
def get_ids_from_log(self):
postgres = PostgresHelper()
cmd = 'SELECT distinct A.usr_id from {} A ' \
'left outer join {} B ' \
'on A.usr_id = B.usr_id ' \
'where B.usr_id is NULL'.format(config_dict['LOG_TABLE'], config_dict['USR_TABLE'])
usr_ids = postgres.postgres_executor(cmd, return_dict=True)
for dd in usr_ids:
self.usr_ids_to_fetch.add(dd['usr_id'])
def insert_in_log_table(self):
postgres = PostgresHelper()
curr_max = postgres.postgres_select_max_from(
table_name=config_dict['LOG_TABLE'], column_name="msg_id")
self.message_id = curr_max + 1
insertion_dict = [{
'usr_id': self.usr_id,
'msg_id': self.message_id,
'msg_text': self.message_text,
'msg_typ': self.message_type,
'cr_ts': str(datetime.datetime.now())
}]
postgres.postgres_insert_dictionary_list(
dict_list=insertion_dict, table_name=config_dict['LOG_TABLE'])
postgres.con.close()
def get_response_message(self):
if self.message_type in {'A', 'T', 'C', 'I', 'B', 'G', 'N'}:
return random.choice(response_dict[self.message_type])
elif self.message_type == "R":
reminder.is_reminder(self.message_text)
userTableManager = UserTableManager()
#self.usr_id = "urjit"
offset = float(userTableManager.get_usr_timezone(self.usr_id))
print "offset, ", offset
print "Got usr timezone"
reminder.extract_date_time(offset=offset)
print "Updating now"
reminder.update_reminder_table(usr_id=self.usr_id,
msg_id=self.message_id)
print "Done updating"
return random.choice(response_dict['A'])
elif self.message_type == "K":
if self.normalized_message in known_qa_dict:
return known_qa_dict[self.normalized_message]
else:
return known_qa_dict[self.message_text]
elif self.message_type == 'L':
postgres = PostgresHelper()
answers = postgres.postgres_select(
table_name=config_dict['MAIN_TABLE'],
req_column_list=['msg_text'],
return_dict=True,
distinct=True)
postgres.con.close()
return_message = ""
i = 0
print answers
for ans in answers:
i += 1
return_message += str(i)
return_message += ". "
return_message += ans['msg_text']
return_message += "\n"
return return_message
else:
return random.choice(response_dict[self.A])
def remember(self):
postgres = PostgresHelper()
self.tag_pos()
print "Nouns:", self.nouns
print "Verbs", self.verbs
self.construct_remember_dict_list()
postgres.postgres_insert_dictionary_list(
table_name=config_dict['MAIN_TABLE'],
dict_list=self.insert_dict_list)
log.debug("remembered")
postgres.con.close()
try:
return self.get_response_message()
except Exception as err:
print "error in fetching response message in remember()"
return "Alright, I'll remember that!"
def seek(self):
postgres = PostgresHelper()
self.tag_pos()
print "Nouns:", self.nouns
print "Verbs", self.verbs
if len(self.nouns) == 0:
print "Sorry, I cannot understand"
return "Sorry, I cannot understand"
condition = "WHERE noun in ({}) AND usr_id = '{}'".format(
','.join('%s' for n in self.nouns), self.usr_id)
answers = postgres.postgres_select(
table_name=config_dict['MAIN_TABLE'],
req_column_list='*',
return_dict=True,
condition=condition,
parameters=self.nouns)
postgres.con.close()
print answers
print ""
if len(answers) > 0:
bestMatcher = BestMatcher(answers, self.message_text)
best_match_dict = bestMatcher.find_best_match()
if bestMatcher.confident == 0:
best_match_msg = ("I'm not very "
"sure but I think this is what you are "
"looking for: " +
best_match_dict['msg_text'])
return best_match_msg
else:
best_match_msg = best_match_dict['msg_text']
return self.rephrase_answer(best_match_msg)
return "I'm sorry, I don't know the answer to that."
def update_profiles(self):
postgres = PostgresHelper()
print "Printing profiles:", self.profiles_to_insert
postgres.postgres_insert_dictionary_list(table_name=config_dict['USR_TABLE'], dict_list=self.profiles_to_insert)
#msg.identify_rule_based()
msg.identify_message_type()
msg.insert_in_log_table(msg.message_text, "I")
if msg.message_type in {'T', 'I', 'C', 'K', 'B', 'G', 'N'}:
try:
response_message_text = msg.get_response_message()
except LookupError, e:
print "Lookup Error", str(e)
response_message_text = msg.remember()
elif msg.message_type == 'Q':
response_message_text = msg.seek()
elif msg.message_type == "L":
postgres = PostgresHelper()
answers = postgres.postgres_select(
table_name=config_dict['MAIN_TABLE'],
req_column_list=['msg_text'],
return_dict=True,
distinct=True)
postgres.con.close()
return_message = ""
i = 0
print answers
for ans in answers:
i += 1
return_message += str(i)
return_message += ". "
return_message += ans['msg_text']