def show_slot_debug(self):
'''
logger debug to show the slots collected
:return:
'''
dbot_online_logger.debug("----slots----")
for slot in self.slotset:
dbot_online_logger.debug("slots:{}".format(slot.__str__()))
def predict(self, edge_condition):
if not edge_condition:
dbot_online_logger.debug("there are not any edges")
s = self.buy_tv_task.state
return self.state_action_map.get(s)
self.buy_tv_task.trigger(edge_condition)
s = self.buy_tv_task.state
dbot_online_logger.debug("current state is {}".format(s))
return self.state_action_map.get(s)
def is_slots_filled(self, taskname, tracker):
required_slot_names = get_required_slot_names_by_task(taskname)
#required_slot_names = ["inform_"+u for u in required_slot_names]
dbot_online_logger.debug("check task state:")
have_filled_slots = set(tracker.get_filled_slot_names())
dbot_online_logger.debug("|".join(list(have_filled_slots)))
if set(required_slot_names).intersection(have_filled_slots) == set(
required_slot_names):
return True
return False
def date_string(self,date_value):
date = date_value
if date_value in ['today', 'tomorrow', 'the day after tomorrow']:
if date_value == 'today':
date = HelperNER.get_current_date(True)
elif date_value == 'tomorrow':
date = HelperNER.tomorrow()
elif date_value == 'the day after tomorrow':
date = HelperNER.day_after_tomorrow()
dbot_online_logger.debug("the date is converted into " + date)
elif date_value in weekdays:
date = HelperNER.weekday2date(date_value)
dbot_online_logger.debug("the date is converted into (weekday) " + date)
return date
def get_many_days_weather(self,date_str,weathers_d):
target_dates = []
n = 2
maps = {"two": 2, "three": 3, "four": 4, "five": 5}
for time, nums in maps.items():
if time in date_str:
n = nums
for day in range(n):
target_dates.append(HelperNER.next_date(n))
true_weathers = {}
for w in weathers_d:
for i, full_date in enumerate(target_dates):
dbot_online_logger.debug(full_date)
year,month,day = full_date.split('-')
if w.get("day") == day and w.get("month") == month:
true_weather = w.get("description")
true_weathers[full_date] = true_weather
return target_dates,true_weathers
def unit_rule_reader(unit_rule_text):
'''
read a text form of unit rule and convert it into a normal rule object
:param unit_rule_text:
:return: rule object / rule dict
'''
#print(unit_rule_text)
res = unit_rule_text.split(" ")
if len(res) == 3:
slotname, state, content = res
elif len(res) == 2:
slotname, state = res
content = "_"
else:
dbot_online_logger.debug(
"the rule is not valid : {}".format(unit_rule_text))
slotname, state, content = None, None, None
return slotname, state, content
def add_user_confirm(self, q, intent, slots):
"""
add one user type confirm event into the tracker events
:param q: user query/input
:param slots:the list of slot[entity]
:param intent:str
:return:the event
"""
print("add_user_confirm ,intent", intent)
dbot_online_logger.debug("the user say %s" % q)
dbot_online_logger.debug(
"add add_user_confirm ,intent {}".format(intent))
event = Event('user', q, is_message=False)
self.latest_message = q
if slots:
event.set_slotset(slots)
# replace by other format-converter
if intent:
event.set_intent(intent)
self.add_event(event)
return event
def add_user_event(self, q, parsing_result=None, slots=None, intent=None):
"""
add one user type normal query event into the tracker events
:param q: user query/input
:param parsing_result: the rasa nlu parsing result or other equivalent format
:param slots:the list of slot[entity]
:param intent:str
:return:the event
"""
print("add user event ,intent", intent)
dbot_online_logger.debug("the user say %s" % q)
dbot_online_logger.debug("add user event ,intent {}".format(intent))
event = Event('user', q)
self.latest_message = q
if parsing_result:
event.set_parse_data(parsing_result)
event.set_slotset(self.rasa_to_slots(parsing_result))
if slots:
event.set_slotset(slots)
# replace by other format-converter
if intent:
event.set_intent(intent)
self.add_event(event)
return event
def is_match_story_path(self, intents, path):
if len(intents) < len(path):
return False
for intent_experience, intent_expected in zip(intents, path):
if intent_experience not in intent_expected:
return False
dbot_online_logger.debug("intents and path")
dbot_online_logger.debug("|".join(intents))
dbot_online_logger.debug("path--- " + "|".join(path))
return True
def is_finish_a_story_path(self, task, intents=None):
if not intents:
intents = self.intents
paths = read_intent_paths_from_file(any_story.format(task))
finish = False
for path in paths:
if self.is_match_story_path(intents, path):
finish = True
if not finish:
dbot_online_logger.debug("intents and path")
dbot_online_logger.debug("|".join(intents))
for path in paths:
dbot_online_logger.debug("path---" + "|".join(path))
return finish
def how_weather_q(self):
'''
handle the query like :what is the weather like today
:return:
'''
dbot_online_logger.debug("how weather q ")
for s in self.slots:
if s.get_entity_type() == 'weekly_time':
print(s.get_entity_value)
if s.get_entity_type() == 'inform_question_word':
if s.get_entity_value().lower() in ["is","will","are","whether","if","if weather"]:
print("convert to clearify")
return self.is_weather_q()
location = self.find_slot_by_type('location')
date = self.find_slot_by_type('date')
weather_attribute = self.find_slot_by_type('weather_attribute')
lacks = []
if not location:
lacks.append('location')
if not date:
lacks.append('date')
if not weather_attribute:
lacks.append('weather')
if (not location) or (not date) :
rsp = ""
if not location:
dbot_online_logger.debug(" (not location) ")
rsp += 'Which city are you interested in?'
if not date:
dbot_online_logger.debug("(not date) ")
rsp += 'what is the date that you are interested in?'
dbot_online_logger.debug('[!lack info {}]'.format(','.join(lacks)))
else:
true_weather = None
#weathers = self.get_weather_data()
date_string = date.get_entity_value()
ask_many_days =("next" in date_string) and ("day" in date_string)
if date_string in ["today","tomorrow"]or ask_many_days or date_string in weekdays:
if not location:
raise ValueError("not location found")
forecast = self.get_city_weather_forecast(location.get_entity_value())
dbot_online_logger.debug("forecast")
dbot_online_logger.debug(forecast)
weathers_d = self.get_weathers_from_json(forecast)
dbot_online_logger.debug("weathers_d")
dbot_online_logger.debug(weathers_d)
import time
today_date = time.strftime("%d", time.localtime())
today_date = int(today_date)
target_date = today_date
if date.get_entity_value() in ["today","tomorrow"]:
dbot_online_logger.debug("ask today | tomorrow")
if date.get_entity_value() == 'tomorrow':
dbot_online_logger.debug("tomorrow")
target_date = HelperNER.date2day(HelperNER.tomorrow())
target_month = HelperNER.date2month(HelperNER.tomorrow())
elif date.get_entity_value() == 'today':
dbot_online_logger.debug("today")
target_date = HelperNER.date2day(HelperNER.get_current_date(True))
target_month = HelperNER.date2month(HelperNER.get_current_date(True))
weather = self.get_weather_by_month_day(weathers_d, target_month, target_date)
if weather:
true_weather = weather.get("description")
elif date.get_entity_value() in weekdays:
dbot_online_logger.debug("how weather q, ask about weekdays")
target_month,target_date = HelperNER().weekday2date(date.get_entity_value())
weather = self.get_weather_by_month_day(weathers_d,target_month,target_date)
dbot_online_logger.debug(weather)
if weather:
true_weather = weather.get("description")
elif ask_many_days:
dbot_online_logger.debug("how weather q, ask_many_days")
date_str = date.get_entity_value()
target_dates,true_weathers = self.get_many_days_weather(self, date_str, weathers_d)
rsp = "It will be "
for i, target_date in enumerate(target_dates):
true_weather = true_weathers[target_date]
rsp += "{} on {}th".format(true_weather, target_date)
if i == len(target_dates) - 1:
rsp += "."
else:
rsp += ","
return rsp
if true_weather:
dbot_online_logger.debug("---------true weather is found")
rsp = 'The forecast show that it will be {} in {} on {}'.format(true_weather,location.get_entity_value(),date_string)
else:
dbot_online_logger.debug("----------no true weather is found")
rsp = 'sry,cannot find a weather forecast'
return rsp
