def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
returned = [SlotSet("object", None), SlotSet("next_action", None)]
user, room = get_current_user_room(tracker)
current_room = tracker.get_slot("current_room")
value = tracker.get_slot("object")
# Check if it is a treasure or monster in the room
if isinstance(value, str) and not value.isnumeric():
if value.lower() == "monster":
if len(room.found_monsters) > 0:
current_monster = room.found_monsters[0]
room.monsters -= 1
dispatcher.utter_message(text="You reach a " +
current_monster +
". What do you do?")
returned.append(SlotSet("current_monster",
current_monster))
else:
dispatcher.utter_message(
text="You don't see any monster here.")
return returned
elif value.lower() == "treasure":
if len(room.found_treasures) > 0:
current_treasure = room.found_treasures.pop(0)
room.treasures -= 1
user.weapons.append(current_treasure)
dispatcher.utter_message(
text="<speak><emphasis level='strong'>You now have the "
+ current_treasure +
".</emphasis><break time='0.1'/> What do you want to do?</speak>"
)
returned.append(SlotSet("weapons", user.weapons))
else:
dispatcher.utter_message(
text="You don't see any treasure here.")
return returned
elif value.lower() == "next":
value = room.next[-1] if len(room.next) > 0 else 0
elif value.lower() == "previous":
value = room.previous
if value is None:
dispatcher.utter_message(text="This is the first room!")
return returned
else:
dispatcher.utter_message(
text="You can't go here, what do you want to do?")
return returned
new_room = None
reachable_rooms = []
reachable_rooms = room.next
if room.previous is not None:
reachable_rooms.append(room.previous)
new_room = get_room(user, reachable_rooms, value)
if not new_room:
dispatcher.utter_message(
text="You cannot reach this room from here.")
return returned
if str(value) == str(user.n_rooms):
dispatcher.utter_message(
text=
"<speak><emphasis level ='moderate'>You have reached the final room! <prosody pitch='high'>You win!!</prosody></emphasis></speak>"
)
return [Restarted()]
else:
dispatcher.utter_message(text="Welcome to room number " +
str(value) + ", what do you want to do?")
returned.append(SlotSet("current_room", value))
return returned
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
# dispatcher.utter_message(text="Hello World!")
print(tracker.get_slot('num'))
# dispatcher.utter_template('utter_your_num', tracker, number=details[str(tracker.get_slot('NAME')).lower()])
return []
def submit(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
"""Once required slots are filled, print buttons for found facilities"""
location = tracker.get_slot('location')
facility_type = tracker.get_slot('facility_type')
results = _find_facilities(location, facility_type)
button_name = _resolve_name(FACILITY_TYPES, facility_type)
if len(results) == 0:
dispatcher.utter_message(
"Sorry, we could not find a {} in {}.".format(
button_name, location.title()))
return []
buttons = []
# limit number of results to 3 for clear presentation purposes
for r in results[:3]:
if facility_type == FACILITY_TYPES["hospital"]["resource"]:
facility_id = r.get("provider_id")
name = r["hospital_name"]
elif facility_type == FACILITY_TYPES["nursing_home"]["resource"]:
facility_id = r["federal_provider_number"]
name = r["provider_name"]
else:
facility_id = r["provider_number"]
name = r["provider_name"]
payload = "/inform{\"facility_id\":\"" + facility_id + "\"}"
buttons.append({
"title": "{}".format(name.title()),
"payload": payload
})
if len(buttons) == 1:
message = "Here is a {} near you:".format(button_name)
else:
if button_name == "home health agency":
button_name = "home health agencie"
message = "Here are {} {}s near you:".format(
len(buttons), button_name)
# TODO: update rasa core version for configurable `button_type`
dispatcher.utter_button_message(message, buttons)
return []
# This is a simple example for a custom action which utters "Hello World!"
# class ActionHelloWorld(Action):
#
# def name(self) -> Text:
# return "action_hello_world"
#
# def run(self, dispatcher: CollectingDispatcher,
# tracker: Tracker,
# domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
#
# dispatcher.utter_message(text="Hello World!")
#
# return []
def test_validate():
# noinspection PyAbstractClass
class CustomFormAction(FormAction):
def name(self):
return "some_form"
@staticmethod
def required_slots(_tracker):
return ["some_slot", "some_other_slot"]
form = CustomFormAction()
tracker = Tracker(
"default",
{"requested_slot": "some_slot"},
{
"entities": [
{"entity": "some_slot", "value": "some_value"},
{"entity": "some_other_slot", "value": "some_other_value"},
]
},
[],
False,
None,
{},
"action_listen",
)
events = form.validate(CollectingDispatcher(), tracker, {})
# check that validation succeed
assert events == [
SlotSet("some_other_slot", "some_other_value"),
SlotSet("some_slot", "some_value"),
] or events == [
SlotSet("some_slot", "some_value"),
SlotSet("some_other_slot", "some_other_value"),
]
tracker = Tracker(
"default",
{"requested_slot": "some_slot"},
{"entities": [{"entity": "some_other_slot", "value": "some_other_value"}]},
[],
False,
None,
{},
"action_listen",
)
events = form.validate(CollectingDispatcher(), tracker, {})
# check that validation succeed because other slot was extracted
assert events == [SlotSet("some_other_slot", "some_other_value")]
tracker = Tracker(
"default",
{"requested_slot": "some_slot"},
{"entities": []},
[],
False,
None,
{},
"action_listen",
)
with pytest.raises(Exception) as execinfo:
form.validate(CollectingDispatcher(), tracker, {})
# check that validation failed gracefully
assert execinfo.type == ActionExecutionRejection
assert "Failed to extract slot some_slot with action some_form" in str(
execinfo.value
)
def test_validate_if_required():
# noinspection PyAbstractClass
class CustomFormAction(FormAction):
def name(self):
return "some_form"
@staticmethod
def required_slots(_tracker):
return ["some_slot", "some_other_slot"]
form = CustomFormAction()
tracker = Tracker(
"default",
{"requested_slot": "some_slot"},
{
"entities": [
{"entity": "some_slot", "value": "some_value"},
{"entity": "some_other_slot", "value": "some_other_value"},
]
},
[],
False,
None,
{"name": "some_form", "validate": True, "rejected": False},
"action_listen",
)
events = form._validate_if_required(CollectingDispatcher(), tracker, {})
# check that validation was performed
assert events == [
SlotSet("some_other_slot", "some_other_value"),
SlotSet("some_slot", "some_value"),
] or events == [
SlotSet("some_slot", "some_value"),
SlotSet("some_other_slot", "some_other_value"),
]
tracker = Tracker(
"default",
{"requested_slot": "some_slot"},
{
"entities": [
{"entity": "some_slot", "value": "some_value"},
{"entity": "some_other_slot", "value": "some_other_value"},
]
},
[],
False,
None,
{"name": "some_form", "validate": False, "rejected": False},
"action_listen",
)
events = form._validate_if_required(CollectingDispatcher(), tracker, {})
# check that validation was skipped because 'validate': False
assert events == []
tracker = Tracker(
"default",
{"requested_slot": "some_slot"},
{
"entities": [
{"entity": "some_slot", "value": "some_value"},
{"entity": "some_other_slot", "value": "some_other_value"},
]
},
[],
False,
None,
{"name": "some_form", "validate": True, "rejected": False},
"some_form",
)
events = form._validate_if_required(CollectingDispatcher(), tracker, {})
# check that validation was skipped
# because previous action is not action_listen
assert events == []
def submit(
self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> List[Dict]:
#read pickle file
df, _ = check_and_reload_data()
if tracker.get_slot('time') is None:
date_query = datetime.today().date()
print(date_query)
out_data = df[df['date'].dt.date == date_query]
# print('DATAFRAME')
# print(out_data.head())
if len(out_data) > 0:
if tracker.get_slot('metric') == 'confirmed':
dispatcher.utter_message(
"Total confirmed cases are {} out of which {} are added today"
.format(
list(out_data['totalconfirmed'])[0],
list(out_data['dailyconfirmed'])[0]))
elif tracker.get_slot('metric') == 'recovered':
dispatcher.utter_message(
"Total recovered cases are {} out of which {} are added today"
.format(
list(out_data['totalrecovered'])[0],
list(out_data['dailyrecovered'])[0]))
elif tracker.get_slot("metric") == "deceased":
dispatcher.utter_message(
"Total deceased cases are {} out of which {} are added today"
.format(
list(out_data['totaldeceased'])[0],
list(out_data['dailydeceased'])[0]))
else:
dispatcher.utter_message(
"Total active cases are {} out of which {} are added today"
.format(
list(out_data['totalactive'])[0],
list(out_data['dailyactive'])[0]))
else:
dispatcher.utter_message(
"I am having trouble getting you the data. I am still in learning phase."
)
return [AllSlotsReset()]
else:
all_entities = tracker.latest_message.get("entities", [])
time_entity = [
e for e in all_entities if e.get("entity") == "time"
]
# print(time_entity)
additional_info = time_entity[0]['additional_info']
print(additional_info)
# dispatcher.utter_message("Additional Info")
if additional_info['type'] == 'interval':
from_time = parser.isoparse(additional_info['from']['value'])
to_time = parser.isoparse(additional_info['to']['value'])
grain = additional_info['from']['grain']
if grain == "day":
out_data = df[(df['date'].dt.date > from_time.date())
& (df['date'].dt.date <= to_time.date())][
'daily' +
tracker.get_slot('metric')].sum()
elif grain == 'month':
out_data = df[(df['date'].dt.month > from_time.month)
& (df['date'].dt.month <= to_time.month)][
'daily' +
tracker.get_slot('metric')].sum()
elif grain == 'week':
out_data = df[
(df['date'].dt.week > int(from_time.strftime('%V')))
& (df['date'].dt.week <= int(to_time.strftime('%V')))][
'daily' + tracker.get_slot('metric')].sum()
elif grain == 'year':
out_data = df[(df['date'].dt.year > from_time.year)
& (df['date'].dt.year <= to_time.year)][
'daily' +
tracker.get_slot('metric')].sum()
else:
dispatcher.utter_message(
"I have date wise data only. I wish I could have second wise feed :("
)
return [AllSlotsReset()]
if tracker.get_slot('metric') == 'confirmed':
dispatcher.utter_message(
"In {} total confirmed cases are {}".format(
tracker.get_slot("time"), out_data))
elif tracker.get_slot('metric') == 'recovered':
dispatcher.utter_message(
"In {} total recovered cases are {}".format(
tracker.get_slot("time"), out_data))
elif tracker.get_slot("metric") == "deceased":
dispatcher.utter_message(
"In {} total deceased cases are {}".format(
tracker.get_slot("time"), out_data))
else:
dispatcher.utter_message(
"In {} total active cases are {}".format(
tracker.get_slot("time"), out_data))
else:
from_time = parser.isoparse(additional_info['value'])
# from_time = parser.isoparse(additional_info['value'])
# to_time = parser.isoparse(additional_info['to']['value'])
if additional_info['grain'] == 'day':
out_data = df[df['date'].dt.date == from_time.date()][
'daily' + tracker.get_slot('metric')].sum()
elif additional_info['grain'] == 'month':
out_data = df[df['date'].dt.month == from_time.month][
'daily' + tracker.get_slot('metric')].sum()
elif additional_info['grain'] == 'week':
out_data = df[df['date'].dt.week == int(
from_time.strftime('%V'))][
'daily' + tracker.get_slot('metric')].sum()
elif additional_info['grain'] == 'year':
out_data = df[df['date'].dt.year == from_time.year][
'daily' + tracker.get_slot('metric')].sum()
else:
dispatcher.utter_message(
"I wish I could have that granular data :(")
return [AllSlotsReset()]
time_print = format_time_by_grain(from_time,
additional_info['grain'])
if tracker.get_slot('metric') == 'confirmed':
dispatcher.utter_message(
"{}: total confirmed cases are {}".format(
time_print, out_data))
elif tracker.get_slot('metric') == 'recovered':
dispatcher.utter_message(
"{}:total recovered cases are {}".format(
time_print, out_data))
elif tracker.get_slot("metric") == "deceased":
dispatcher.utter_message(
"{}: total deceased cases are {}".format(
time_print, out_data))
else:
dispatcher.utter_message(
"{}: total active cases are {}".format(
time_print, out_data))
return [AllSlotsReset()]
# print(tracker.slots)
# print(tracker.latest_message)
# dispatcher.utter_message("Here is your number")
dispatcher.utter_message(
"Overall Numbers till now. Total:{}, Active:{}, Deaths: {}, Recovered: {}:"
.format(df['dailyconfirmed'].sum(), df['dailyactive'].sum(),
df['dailydeceased'].sum(), df['dailyrecovered'].sum()))
return []
def test_extract_trigger_slots():
"""Test extraction of a slot value from trigger intent
"""
# noinspection PyAbstractClass
class CustomFormAction(FormAction):
def name(self):
return "some_form"
@staticmethod
def required_slots(_tracker):
return ["some_slot"]
def slot_mappings(self):
return {
"some_slot": self.from_trigger_intent(
intent="trigger_intent", value="some_value"
)
}
form = CustomFormAction()
tracker = Tracker(
"default",
{},
{"intent": {"name": "trigger_intent", "confidence": 1.0}},
[],
False,
None,
{},
"action_listen",
)
slot_values = form.extract_other_slots(CollectingDispatcher(), tracker, {})
# check that the value was extracted for correct intent
assert slot_values == {"some_slot": "some_value"}
tracker = Tracker(
"default",
{},
{"intent": {"name": "other_intent", "confidence": 1.0}},
[],
False,
None,
{},
"action_listen",
)
slot_values = form.extract_other_slots(CollectingDispatcher(), tracker, {})
# check that the value was not extracted for incorrect intent
assert slot_values == {}
# tracker with active form
tracker = Tracker(
"default",
{},
{"intent": {"name": "trigger_intent", "confidence": 1.0}},
[],
False,
None,
{"name": "some_form", "validate": True, "rejected": False},
"action_listen",
)
slot_values = form.extract_other_slots(CollectingDispatcher(), tracker, {})
# check that the value was not extracted for correct intent
assert slot_values == {}
def required_slots(tracker: Tracker) -> List[Text]:
last(tracker)
latest_entities = tracker.latest_message['entities']
if latest_entities:
for entity in latest_entities:
if entity['entity'] == 'qualification':
# print('fees q,c latest_message')
if (tracker.get_slot('course')):
ACode('qc')
return ["qualification", "course"]
elif (tracker.get_slot('field')):
ACode('qf')
return ["qualification", "field"]
else:
ACode('qf')
return ["qualification", "field"]
elif entity['entity'] == 'degree':
#print('fees degree latest_message')
if entity['value'] == 'msc' or entity['value'] == 'bsc':
#print('with sc')
ACode('dc')
return ['degree', 'course']
else:
ACode('d')
return ["degree"]
elif entity['entity'] == 'field':
ACode('qf')
# print('fees q,c latest_message')
return ["qualification", "field"]
elif entity['entity'] == 'course':
ACode('qc')
# print('fees q,c latest_message')
return ["qualification", "course"]
elif all_entites2:
if all_entites2[-1] == "degree":
#print("fees with degree called last entity")
if tracker.get_slot(
all_entites2[-1]) == 'bsc' or tracker.get_slot(
all_entites2[-1]) == 'msc':
ACode('dc')
return ['degree', 'course']
else:
ACode('d')
return ["degree"]
elif (all_entites2[-1] == "qualification"):
if (tracker.get_slot('course')):
ACode('qc')
return ["qualification", "course"]
elif (tracker.get_slot('field')):
ACode('qf')
return ["qualification", "field"]
else:
ACode('qf')
return ["qualification", "field"]
elif (all_entites2[-1] == "field"):
ACode('qf')
#print("fees with q,c called")
return ["qualification", "field"]
elif (all_entites2[-1] == "course"):
ACode('qc')
#print("fees with q,c called")
return ["qualification", "course"]
else:
ACode('d')
#print("fees with q,c called")
return ["degree"]
elif all_entites2:
if all_entites2[-1] == "degree":
#print("fees with degree called last entity")
if tracker.get_slot(
all_entites2[-1]) == 'bsc' or tracker.get_slot(
all_entites2[-1]) == 'msc':
ACode('dc')
return ['degree', 'course']
else:
ACode('d')
return ["degree"]
elif (all_entites2[-1] == "course"):
ACode('qc')
#print("fees with q,c called")
return ["qualification", "course"]
elif (all_entites2[-1] == "field"):
ACode('qf')
return ["qualification", "field"]
elif (all_entites2[-1] == "qualification"):
if (tracker.get_slot('course')):
ACode('qc')
return ["qualification", "course"]
elif (tracker.get_slot('field')):
ACode('qf')
return ["qualification", "field"]
else:
ACode('qf')
return ["qualification", "field"]
else:
ACode('d')
#print("fees with q,c called")
return ["degree"]
def submit(
self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> List[Dict]:
if (AdmissionCodes[-1] == 'qf'):
field = tracker.get_slot('field')
qualification = tracker.get_slot('qualification')
if (field == 'pharmacy' and qualification == 'undergraduate'):
dispatcher.utter_template('utter_adm_pharmacy_undergraduate',
tracker)
elif ((field == 'physio' and qualification == 'undergraduate') or
(field == 'nursing' and qualification == 'undergraduate')):
dispatcher.utter_template(
'utter_adm_nursing/physio_undergraduate', tracker)
elif (field == 'engineering' and qualification == 'undergraduate'):
dispatcher.utter_template(
'utter_adm_engineering_undergraduate', tracker)
elif (field == 'management' and qualification == 'undergraduate'):
dispatcher.utter_template('utter_adm_bba_undergraduate',
tracker)
elif (field == 'computer applications'
and qualification == 'undergraduate'):
dispatcher.utter_template(
'utter_adm_computeraplication_undergraduate', tracker)
else:
dispatcher.utter_template('utter_other_field', tracker)
elif (AdmissionCodes[-1] == 'qc'):
course = tracker.get_slot('course')
qualification = tracker.get_slot('qualification')
if ((course == "ce" or course == "it" or course == "cs" or course
== 'me' or course == 'ci' or course == 'ee' or course == 'ec')
and qualification == 'undergraduate'):
dispatcher.utter_template(
'utter_adm_engineering_undergraduate', tracker)
elif (course == 'GNM' and qualification == 'undergraduate'):
dispatcher.utter_template(
'utter_adm_nursing/physio_undergraduate', tracker)
else:
dispatcher.utter_template('utter_other_field', tracker)
elif (AdmissionCodes[-1] == 'dc'):
course = tracker.get_slot('course')
degree = tracker.get_slot('degree')
if (degree == 'bsc' and course == 'it'):
dispatcher.utter_template('utter_adm_bscit_undergraduate',
tracker)
else:
dispatcher.utter_template('utter_other_field', tracker)
elif (AdmissionCodes[-1] == 'd'):
degree = tracker.get_slot('degree')
if (degree == 'bpharm'):
dispatcher.utter_template('utter_adm_pharmacy_undergraduate',
tracker)
elif (degree == 'btech'):
dispatcher.utter_template(
'utter_adm_engineering_undergraduate', tracker)
elif (degree == 'bpt'):
dispatcher.utter_template(
'utter_adm_nursing/physio_undergraduate', tracker)
elif (degree == 'bba'):
dispatcher.utter_template('utter_adm_bba_undergraduate',
tracker)
elif (degree == 'bca'):
dispatcher.utter_template(
'utter_adm_computeraplication_undergraduate', tracker)
else:
dispatcher.utter_template('utter_other_field', tracker)
return []
def submit(
self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> List[Dict]:
print("programCode: ", programCodes[-1])
if programCodes[-1] == 'qf':
if tracker.get_slot('field') == "commerce":
m = ""
m = available_programs_qf(coursesRoot,
tracker.get_slot('qualification'),
"computer applications")
m = m + available_programs_qf(
coursesRoot, tracker.get_slot('qualification'),
"management")
dispatcher.utter_message(m)
elif tracker.get_slot('field') == "medical":
m = ""
m = available_programs_qf(coursesRoot,
tracker.get_slot('qualification'),
"nursing")
m = m + available_programs_qf(
coursesRoot, tracker.get_slot('qualification'), "physio")
m = m + available_programs_qf(
coursesRoot, tracker.get_slot('qualification'), "pharmacy")
m = m + available_programs_qf(
coursesRoot, tracker.get_slot('qualification'),
"paramedical sciences")
dispatcher.utter_message(m)
else:
m = ""
m = available_programs_qf(coursesRoot,
tracker.get_slot('qualification'),
tracker.get_slot('field'))
dispatcher.utter_message(m)
elif programCodes[-1] == 'd':
m = ""
m = available_programs_d(coursesRoot, tracker.get_slot('degree'))
dispatcher.utter_message(m)
return []
def required_slots(tracker: Tracker) -> List[Text]:
last(tracker)
latest_entities = tracker.latest_message['entities']
if latest_entities:
for entity in latest_entities:
if entity['entity'] == "field":
f = tracker.get_slot('field')
if f == "engineering":
lCode('f')
return ['course', 'field']
elif f == "pharmacy" or f == "physio":
lCode('f')
return ['field']
else:
if all_entites3:
if all_entites3[-1] == "field":
f = tracker.get_slot('field')
if f == "engineering":
lCode('f')
return ['course', 'field']
elif f == "pharmacy" or f == "physio":
lCode('f')
return ['field']
else:
lCode('f')
return ['field']
elif all_entites3[-1] == "course":
lCode('c')
return ['course']
else:
lCode('f')
return ['field']
elif entity['entity'] == "course":
lCode('c')
return ['course']
elif all_entites3:
if all_entites3[-1] == "field":
f = tracker.get_slot('field')
if f == "engineering":
lCode('f')
return ['course', 'field']
elif f == "pharmacy" or f == "physio":
lCode('f')
return ['field']
else:
lCode('f')
return ['field']
elif all_entites3[-1] == "course":
lCode('c')
return ['course']
else:
lCode('f')
return ['field']
else:
lCode('f')
return ['field']
elif all_entites3:
if all_entites3[-1] == "field":
f = tracker.get_slot('field')
if f == "engineering":
lCode('f')
return ['course', 'field']
elif f == "pharmacy" or f == "physio":
lCode('f')
return ['field']
else:
lCode('f')
return ['field']
elif all_entites3[-1] == "course":
lCode('c')
return ['course']
else:
lCode('f')
return ['field']
else:
lCode('f')
return ['field']
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
slot_dict = tracker.current_slot_values()
for slot_entry in slot_dict:
dispatcher.utter_message(str(slot_entry))
dispatcher.utter_message(str(slot_dict[slot_entry]))
return []
def run(self, dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
# user_name = tracker.get_slot("user_name")
crime_date = tracker.get_slot("crime_date")
crime_time = tracker.get_slot("crime_time")
# report_date = tracker.get_slot("report_date")
# report_time = tracker.get_slot("report_time")
crime_location = tracker.get_slot("crime_location")
suspected_people = tracker.get_slot("suspected_people")
sname = tracker.get_slot("sname")
cname = tracker.get_slot("cname")
crime_type = tracker.get_slot("crime_type")
stolen_things = tracker.get_slot("stolen_things")
stolen_amount = tracker.get_slot("stolen_amount")
injury_occured = tracker.get_slot("injury_occured")
people_with = tracker.get_slot("people_with")
vehicle_type = tracker.get_slot("vehicle_type")
number_people_died = tracker.get_slot("number_people_died")
person_location = tracker.get_slot("person_location")
kidnapper_call = tracker.get_slot("kidnapper_call")
if kidnapper_call == None:
kidnapper_call = "No contact"
call_details = tracker.get_slot("call_details")
robbery_details = tracker.get_slot("robbery_details")
accident_details = tracker.get_slot("accident_details")
"""
msg = "Data [{}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}] is to be sent to the database...!!!".format(
crime_date, crime_time, crime_location, suspected_people, stolen_things
, stolen_amount, sname, cname, crime_type, injury_occured, people_with, vehicle_type
, number_people_died, person_location, kidnapper_call, call_details, robbery_details, accident_details)
"""
msg = "Required data has been captured..."
dispatcher.utter_message(text=msg)
return []
def required_slots(tracker: Tracker) -> List[Text]:
if tracker.get_slot("object"):
return []
else:
return ["direction"]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
current_question = tracker.get_slot('question_id')
dispatcher.utter_message(text=self.__choose_answer(current_question))
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
search = Talk.search()
time_slot = tracker.get_slot('time')
day_slot = tracker.get_slot('day')
if time_slot and day_slot:
if day_slot.lower() == 'hoy' or day_slot.lower() == 'mañana':
weekday = datetime.today().weekday()
if day_slot.lower() == 'mañana':
weekday += 1
if weekday == 5:
day = 'Sabado'
elif weekday == '6':
day = 'Domingo'
else:
dispatcher.utter_message(
"Solo tengo registradas charlas el Sábado y Domingo\n")
return []
else:
day = unidecode.unidecode(day_slot).lower()
if day != 'sabado' and day != 'domingo':
dispatcher.utter_message(
"Solo tengo registradas charlas el Sábado y Domingo\n")
return []
if ':' in time_slot:
time_parts = time_slot.split(':')
hour = int(time_parts[0])
minute = int(time_parts[1])
else:
hour = int(time_slot)
minute = 0
if day == 'sabado':
date = datetime(year=2019,
month=10,
day=5,
hour=hour,
minute=minute)
else:
date = datetime(year=2019,
month=10,
day=6,
hour=hour,
minute=minute)
query = search.sort('start').\
query('term', day=day).\
query('range', start={'gte': date})
if query.count() == 0:
dispatcher.utter_message(
"No he encontrado ninguna charla el dia {} a las {}\n".
format(day, time_slot))
else:
message = "He encontrado las siguientes charlas el dia {} a las {}:\n".format(
day, time_slot)
message += range_query_to_message(query)
dispatcher.utter_message(message)
return [SlotSet('time', None), SlotSet('day', None)]
elif time_slot and not day_slot:
dispatcher.utter_message("¿Qué día, Sábado o Domingo?\n")
elif day_slot and not time_slot:
dispatcher.utter_message("¿A qué hora?\n")
else:
dispatcher.utter_message(
"He entendido que buscas una charla, pero no he encontrado día ni hora\n"
)
return []
def __user_needs_evaluation(self, tracker: Tracker) -> bool:
return tracker.get_slot('score_questions') > CUTOFF_POINT
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
search = Talk.search()
talk_slot = tracker.get_slot('talk')
if talk_slot:
query = search.sort('start').query('match', title=talk_slot)
if query.count() > 0:
talks = []
for t in query:
talks.append(t.title + " el " + t.day + " a las " +
t.start.strftime('%H:%M') + " en " + t.place)
dispatcher.utter_message(
"Las charlas que he encontrado son:\n{}".format(
'\n'.join(talks)))
else:
dispatcher.utter_message(
"No he encontrado ninguna charla sobre ese tema. ¿Puedes reformular la pregunta?"
)
return [SlotSet('talk', None)]
speaker = tracker.get_slot('speaker')
if speaker:
query = search.sort('start').query('match', speakers=speaker)
if query.count() > 0:
# TODO Replace this ugly code by an Elastic Aggregation. Make speakers field a keyword as well
talksBySpeaker = defaultdict(list)
for t in query:
t.speakers.sort()
for s in t.speakers:
if speaker.lower() in s.lower():
talksBySpeaker[s].append(t)
if len(talksBySpeaker) == 1:
talks = []
for t in list(talksBySpeaker.values())[0]:
talks.append(t.title + " el " + t.day + " a las " +
t.start.strftime('%H:%M') + " en " +
t.place)
dispatcher.utter_message(
"Las charlas que he encontrado de {} son:\n{}".format(
speaker, '\n'.join(talks)))
else:
found_speakers = talksBySpeaker.keys()
message = "¿A qué '{}' te refieres?. He encontrado {}:\n{}".\
format(speaker, len(talksBySpeaker), '\n'.join(found_speakers))
dispatcher.utter_message(message)
return [SlotSet("found_speakers", list(found_speakers))]
else:
query = search.sort('start').query('match', title=speaker)
if query.count() == 0:
dispatcher.utter_message(
"No he encontrado ninguna charla de {}".format(
speaker))
else:
talks = []
for t in query:
talks.append(t.title + " el " + t.day + " a las " +
t.start.strftime('%H:%M') + " en " +
t.place)
dispatcher.utter_message(
"Las charlas que he encontrado de {} son:\n{}".format(
speaker, '\n'.join(talks)))
return [SlotSet("speaker", None)]
else:
tokens = tokenize(tracker.latest_message.get('text'))
candidates = search_talks_database(tokens)
if len(candidates) > 0:
shoulds = []
for candidate in candidates:
shoulds.append(Q('match_phrase', title=candidate))
q = Q('bool', should=shoulds)
query = search.sort('start').query(q)
if query.count() == 0:
dispatcher.utter_message(
"No he podido encontrar ninguna charla, lo siento".
format(speaker))
else:
talks = []
for t in query:
talks.append(t.title + " el " + t.day + " a las " +
t.start.strftime('%H:%M') + " en " +
t.place)
dispatcher.utter_message(
"Las posibles charlas relevantes que he encontrado son:\n{}"
.format('\n'.join(talks)))
else:
dispatcher.utter_message(
"No he encontrado ninguna charla. ¿Puedes reformular la pregunta?"
)
return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
job_workplaces = tracker.get_slot("1_activity") + tracker.get_slot(
"2_outside") + tracker.get_slot("3_workingtime") + (
"4_environment") + ("5_company")
job_softskills = tracker.get_slot("6_skills") + tracker.get_slot(
"7_personally") + tracker.get_slot(
"8_problems_dealing") + tracker.get_slot("9_public")
# List of strings
# Append a list as new line to an old csv file
dispatcher.utter_message(
template="utter_slots_values",
activity=tracker.get_slot("1_activity"),
outside=tracker.get_slot("2_outside"),
workingtime=tracker.get_slot("3_workingtime"),
environment=tracker.get_slot("4_environment"),
company=tracker.get_slot("5_company"),
skills=tracker.get_slot("6_skills"),
personally=tracker.get_slot("7_personally"),
problems_dealing=tracker.get_slot("8_problems_dealing"),
public=tracker.get_slot("9_public"),
min_salary=tracker.get_slot("10_min_salary"),
wish_salary=tracker.get_slot("11_wish_salary"))
return []
def submit(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
dispatcher.utter_message(text="Parameters Submitted")
self.error_query = tracker.get_slot("error_action")
print(f"slot value: {self.error_query}")
return []
def test_extract_other_slots_no_intent():
"""Test extraction of other not requested slots values
from entities with the same names
"""
# noinspection PyAbstractClass
class CustomFormAction(FormAction):
def name(self):
return "some_form"
@staticmethod
def required_slots(_tracker):
return ["some_slot", "some_other_slot"]
form = CustomFormAction()
tracker = Tracker(
"default",
{"requested_slot": "some_slot"},
{"entities": [{"entity": "some_slot", "value": "some_value"}]},
[],
False,
None,
{},
"action_listen",
)
slot_values = form.extract_other_slots(CollectingDispatcher(), tracker, {})
# check that the value was not extracted for requested slot
assert slot_values == {}
tracker = Tracker(
"default",
{"requested_slot": "some_slot"},
{"entities": [{"entity": "some_other_slot", "value": "some_other_value"}]},
[],
False,
None,
{},
"action_listen",
)
slot_values = form.extract_other_slots(CollectingDispatcher(), tracker, {})
# check that the value was extracted for non requested slot
assert slot_values == {"some_other_slot": "some_other_value"}
tracker = Tracker(
"default",
{"requested_slot": "some_slot"},
{
"entities": [
{"entity": "some_slot", "value": "some_value"},
{"entity": "some_other_slot", "value": "some_other_value"},
]
},
[],
False,
None,
{},
"action_listen",
)
slot_values = form.extract_other_slots(CollectingDispatcher(), tracker, {})
# check that the value was extracted only for non requested slot
assert slot_values == {"some_other_slot": "some_other_value"}
def submit(
self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> List[Dict]:
"""Define what the form has to do
after all required slots are filled"""
age = float(tracker.get_slot('AGE'))
print(age)
bp = float(tracker.get_slot('BloodPressure'))
print(bp)
al = float(tracker.get_slot('Albumin'))
print(al)
pcc = float(tracker.get_slot('PusCellClumps'))
print(pcc)
bgr = float(tracker.get_slot('BloodGlucoseRandom'))
print(bgr)
bu = float(tracker.get_slot('BloodUrea'))
print(bu)
sod = float(tracker.get_slot('Sodium'))
print(sod)
pot = float(tracker.get_slot('Potassium'))
print(pot)
hemo = float(tracker.get_slot('Hemoglobin'))
print(hemo)
rbcc = float(tracker.get_slot('RedBloodCellCount'))
print(rbcc)
dm = float(tracker.get_slot('DiabetesMellitus'))
print(dm)
appet = float(tracker.get_slot('Appetite'))
print(appet)
# final_features = pd.DataFrame(
# {'age': [age / 80], 'bp': [bp / 10], 'al': [al / 5], 'pcc': [pcc],
# 'bgr': [bgr / 146], 'bu': [bu / 418], 'sod': [sod / 164], 'pot': [pot / 130.1],
# 'hemo': [hemo / 21.7], 'rbcc': [rbcc / 12.8], 'dm': [dm], 'appet': [appet]})
# print('After '+final_features)
# model = pickle.load(open('model.pkl', 'rb'))
# print('after model')
# prediction = model.predict(final_features)
# print('after prediction')
request = {
'age': age,
'bp': bp,
'al': al,
'pcc': pcc,
'bgr': bgr,
'bu': bu,
'sod': sod,
'pot': pot,
'hemo': hemo,
'rbcc': rbcc,
'dm': dm,
'appet': appet
}
register_url = 'http://127.0.0.1:5000/' + "predict"
r = requests.get(register_url, params=request)
print(r.content)
pred = r.content.decode("utf-8")
print("after string :" + pred)
pred = float(pred)
print('after float:' + str(pred))
print(pred)
print(type(pred))
# print('after pred :'+r.content)
# pred=int(r.content)
if pred > 0.75:
print('in if loop if part')
result_prediction = 'Don\'t worry you have ' + str(
(1 - pred) * 100
) + '% precentage to have chronicle kidney disease. We have 99.06% confident for say that !! '
print('in if loop if part')
elif (pred > 0.5):
print('in if loop else part')
result_prediction = 'You are in some denger zone. You have ' + str(
(1 - pred) * 100
) + '% percentae to have chronicle kidney disease. We have 99.06% confident for say that !! Care full'
print('in if loop else part')
else:
result_prediction = 'You are in very danger zone.You have ' + str(
(1 - pred) * 100
) + '% percentae to have chronicle kidney disease. We have 99.06% confident for say that !! Meet your doctor as soon as possible'
# utter submit template
print(result_prediction)
dispatcher.utter_message(responses="utter_submit",
text=result_prediction.format())
return [SlotSet("result", result_prediction)]
def test_validate_trigger_slots():
"""Test validation results of from_trigger_intent slot mappings
"""
# noinspection PyAbstractClass
class CustomFormAction(FormAction):
def name(self):
return "some_form"
@staticmethod
def required_slots(_tracker):
return ["some_slot"]
def slot_mappings(self):
return {
"some_slot": self.from_trigger_intent(
intent="trigger_intent", value="some_value"
)
}
form = CustomFormAction()
tracker = Tracker(
"default",
{},
{"intent": {"name": "trigger_intent", "confidence": 1.0}},
[],
False,
None,
{},
"action_listen",
)
slot_values = form.validate(CollectingDispatcher(), tracker, {})
# check that the value was extracted on form activation
assert slot_values == [
{"event": "slot", "timestamp": None, "name": "some_slot", "value": "some_value"}
]
tracker = Tracker(
"default",
{},
{"intent": {"name": "trigger_intent", "confidence": 1.0}},
[],
False,
None,
{
"name": "some_form",
"validate": True,
"rejected": False,
"trigger_message": {
"intent": {"name": "trigger_intent", "confidence": 1.0}
},
},
"action_listen",
)
slot_values = form.validate(CollectingDispatcher(), tracker, {})
# check that the value was not extracted after form activation
assert slot_values == []
tracker = Tracker(
"default",
{"requested_slot": "some_other_slot"},
{
"intent": {"name": "some_other_intent", "confidence": 1.0},
"entities": [{"entity": "some_other_slot", "value": "some_other_value"}],
},
[],
False,
None,
{
"name": "some_form",
"validate": True,
"rejected": False,
"trigger_message": {
"intent": {"name": "trigger_intent", "confidence": 1.0}
},
},
"action_listen",
)
slot_values = form.validate(CollectingDispatcher(), tracker, {})
# check that validation failed gracefully
assert slot_values == [
{
"event": "slot",
"timestamp": None,
"name": "some_other_slot",
"value": "some_other_value",
}
]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
logger.debug("---- [ActionCheckMuscle] ----")
# Get slot value
body = tracker.get_slot('body')
muscle = tracker.get_slot('muscle')
intent = tracker.latest_message['intent'].get('name')
logger.debug("b:{}, m:{}".format(body, muscle))
try:
# Need muscle suggestion
if body != None and (intent == 'negative'
or tracker.get_slot('deny') != None
or tracker.get_slot('suggest') != None):
rnd = random.choice(list(bodyMap[body.lower()]))
dispatcher.utter_message(template='utter_random_muscle',
variable=rnd)
dispatcher.utter_message(template='utter_ask_facility')
return [
SlotSet('muscle', muscleMap[rnd][0]),
SlotSet('deny', None),
SlotSet('suggest', None),
FollowupAction('action_listen')
]
# Need to know what muscles in body.
elif intent == 'query':
if muscle != None:
return [FollowupAction('action_check_equipment')]
dispatcher.utter_template('utter_query_muscle',
tracker,
body=body)
dispatcher.utter_message(" - {}".format(bodyMap[body.lower()]))
return []
# Ask muscle directly.
elif body == None and any(
tracker.get_latest_entity_values('muscle')):
print(tracker.latest_message)
body = tracker.latest_message['entities'][0].get('role')
dispatcher.utter_message(template='utter_ask_facility')
return [
SlotSet('body', body),
SlotSet('deny', None),
SlotSet('suggest', None)
]
# Vaildate muscle
if any(
tracker.get_latest_entity_values(
'muscle', entity_role=str(body).lower())):
dispatcher.utter_message(template='utter_ask_facility')
return [SlotSet('deny', None), SlotSet('suggest', None)]
# Vaildate muscle fail
dispatcher.utter_template('utter_wrong_muscle', tracker)
return [SlotSet('muscle', None)]
except:
dispatcher.utter_template('utter_system_wrong')
return [AllSlotsReset(), FollowupAction('action_restart')]
def _has_211(tracker: Tracker) -> bool:
province = tracker.get_slot(PROVINCE_SLOT)
return province in PROVINCES_WITH_211
def get_carry_over_slots(self, tracker: Tracker) -> List[Dict[Text, Any]]:
actions = super().get_carry_over_slots(tracker)
carry_over_slots = ("first_name", "last_name", "destination", "reason")
for slot in carry_over_slots:
actions.append(SlotSet(slot, tracker.get_slot(slot)))
return actions
def validate(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
#def validate(self, dispatcher, tracker, domain):
# type: (CollectingDispatcher, Tracker, Dict[Text, Any]) -> List[Dict]
""""Validate extracted requested slot else raise an error"""
slot_values = self.extract_other_slots(dispatcher, tracker, domain)
# extract requested slot
slot_to_fill = tracker.get_slot(REQUESTED_SLOT)
if slot_to_fill:
slot_values.update(
self.extract_requested_slot(dispatcher, tracker, domain))
if not slot_values:
# reject form action execution
# if some slot was requested but nothing was extracted
# it will allow other policies to predict another action
raise ActionExecutionRejection(
self.name(), "Failed to validate slot {0} "
"with action {1}"
"".format(slot_to_fill, self.name()))
for slot, value in slot_values.items():
if slot == 'dept':
if value.lower() not in self.dept_db():
dispatcher.utter_template('utter_incorrect_dept', tracker)
slot_values[slot] = None
# validation failed, set this slot to None
elif slot == 'time':
dept = tracker.get_slot('dept')
if value[11:19] == "00:00:00":
dispatcher.utter_template("utter_incorrect_time", tracker)
slot_values[slot] = None
else:
flag = 0
file = pd.read_csv('DocAvail.csv')
date = value[0:10]
time_slot = value[11:19]
date_time = datetime.datetime.strptime(date, "%Y-%m-%d")
weekday = datetime.datetime.strftime(date_time, "%A")
Dept = file[file['Department'].str.lower() ==
dept].reset_index().drop('index', axis=1)[[
'Physician name', weekday
]]
print(Dept)
for i in range(len(Dept)):
avail_time = Dept.ix[i, weekday].split('-')
low = int(avail_time[0].split(':')[0])
high = int(avail_time[1].split(':')[0])
time_slot_int = int(value[11:19].split(':')[0])
if time_slot_int > low and time_slot_int < high:
flag = 1
break
if flag == 1:
pass
else:
dispatcher.utter_template("utter_incorrect_time",
tracker)
slot_values[slot] = None
return [SlotSet(slot, value) for slot, value in slot_values.items()]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
"""
Trả về generic template san pham cuoi va ask them vao gio hang/thanh toan
:param dispatcher:
:param tracker:
:param domain:
:return:
"""
# debug('\n_________act_shoe_new_shoe_________')
print('_____' + self.name())
prefix_name = tracker.get_slot(Entities.prefix_name)
customer_name = tracker.get_slot(Entities.customer_name)
messenger_id = tracker.current_state()["sender_id"]
bot_position = tracker.get_slot(Entities.bot_position)
shoe_id = tracker.get_slot(Entities.shoe_id)
shoe_model = tracker.get_slot(Entities.shoe_model)
shoe_size = tracker.get_slot(Entities.shoe_size)
color_id = tracker.get_slot(Entities.color_id)
color_name = tracker.get_slot(Entities.shoe_color)
coupon_id = tracker.get_slot(Entities.coupon_id)
coupon_code = tracker.get_slot(Entities.coupon_code)
# get_final_shoe(shoe_id int, shoe_size int, color_id int)
# query = 'call get_final_shoe({}, {}, {})'.format(shoe_id, shoe_size, color_id)
query = f'''
select
mainapp_shoe.id as shoe_id,
mainapp_shoe.shoeName,
mainapp_shoe.shoeModel,
mainapp_shoe.shoeThumbnail,
mainapp_shoe.image_static,
mainapp_detailshoe.id as detailShoe_id,
mainapp_detailshoe.newPrice,
mainapp_detailshoe.quantityAvailable,
mainapp_detailshoe.size,
mainapp_color.id as color_id,
mainapp_color.colorName
from mainapp_shoe
inner join mainapp_detailshoe
on (mainapp_shoe.id = mainapp_detailshoe.shoe_id)
inner join mainapp_color
on (mainapp_detailshoe.color_id = mainapp_color.id)
where
mainapp_shoe.id = {shoe_id} and
mainapp_detailshoe.size = {shoe_size} and
mainapp_color.id = {color_id};
'''
shoes, detail_shoes, colors = SqlUtils.get_result(
query, Shoe, DetailShoe, Color)
if len(detail_shoes) == 0:
err_code = ErrorCode.ERR_IN_ACT_SHOW_FINAL_CHOICE
err_message = f'Xin lỗi {prefix_name}{customer_name}, hệ thống đã xảy ra lỗi. error code={err_code}'
dispatcher.utter_message(text=err_message)
return []
elif detail_shoes[0].quantityAvailable < 1:
text = 'Xin lỗi {}, đôi {} size {} màu {} hết hàng rồi ạ' \
.format(prefix_name, shoe_model, shoe_size, color_name)
dispatcher.utter_message(text=text)
return []
else:
text = '{} thêm món này vào giỏ hàng giúp {} nhé'.format(
bot_position, prefix_name)
dispatcher.utter_message(text=text)
horizontal_template_elements = []
for index in range(len(shoes)):
shoe = shoes[index]
detail_shoe = detail_shoes[index]
detail_shoe: DetailShoe
buttons = [
PostBackButton(
title='Thêm vào giỏ hàng' + shoe.shoeModel,
str_send_to_webhook='ok luôn. thêm vào giỏ hàng'),
# UrlButton(
# title='Mua luôn đôi này',
# url_access=MyWebUrl.get_buy_now_url(messenger_id=messenger_id,
# detail_shoe_id=detail_shoe.detailShoe_id)
# ),
]
element = HorizontalTemplateElement(
image_url=shoe.image_static,
title=shoe.shoeName,
subtitle=f'màu: {color_name}, size: {shoe_size}\n ' +
price_format(detail_shoe.newPrice),
default_action=HorizontalTemplateElement.DefaultAction(
MyWebUrl.get_detail_shoe_url(shoe.shoe_id)),
list_buttons=buttons,
)
horizontal_template_elements.append(element)
horizontal_template = HorizontalTemplate(
horizontal_template_elements)
dispatcher.utter_message(
json_message=horizontal_template.to_json_message())
# xem tiep
quick_reply_elements = [
QuickReplyElement(QuickReplyElement.TEXT, 'Xem thêm giày',
'Xem đôi giày khác'),
]
text = 'Hành động khác:'
# if not coupon_id:
# text = '{} có muốn lấy mã giảm giá không ạ?'.format(prefix_name)
# quick_reply_elements.append(
# QuickReplyElement(QuickReplyElement.TEXT, 'Lấy mã giảm giá', 'cho tôi xem mã giảm giá'),
# )
quick_replies = QuickReplies(
text_before_template=text,
list_quick_reply_elements=quick_reply_elements)
dispatcher.utter_message(
json_message=quick_replies.to_json_message())
# print('*****************************************************')
# print(horizontal_template.to_json_message())
# print('*****************************************************')
# pprint(quick_replies.to_json_message())
return []
def run(self, dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[EventType]:
slots = {}
if tracker.get_slot('date') is None and tracker.get_slot('time') is None:
any_date, good_date = False, False
for entity in tracker.latest_message['entities']:
if entity['entity'] == 'dates':
any_date = True
date_intervals = entity['value']
for e_date in date_intervals:
overlaps = is_good_date(self.appointments, e_date, all_options=True)
if overlaps and not good_date:
# If specified interval is longer then a day, suggest narrowing it...
if is_multiple_days(overlaps):
cands = sorted([d['start_date'] for d in overlaps])
cands_s = f'{get_date_text(cands[0])} és {get_date_text(cands[1])}'
dispatcher.utter_message(
text=f"A legközelebbi két nap amikor ráérek a kért időszakban {cands_s} lesz.")
return []
else:
good_date = overlaps[0]['start_date'].date()
break
elif entity['entity'] == 'times' and tracker.get_slot('possible_dates') is not None:
for date in tracker.get_slot('possible_dates'):
for appointment in self.appointments:
if date in appointment['start_date'].strftime("%Y-%m-%d"):
good_date = datetime.strptime(date, "%Y-%m-%d").date()
any_date = True
break
# Checking the value of any_date and good_date variables, and with that give back the right sentence
if not any_date:
dispatcher.utter_message(text="Okés. Mikor lenne jó?")
return []
if not good_date:
dispatcher.utter_message(text="Sajnos nem érek rá akkor... Máskor esetleg?")
return [FollowupAction("followup_action_recommend_date")]
if good_date:
slots['date'] = SlotSet('date', good_date.strftime('%Y-%m-%d'))
if tracker.get_slot("date") or slots:
if tracker.get_slot('date'):
possible_date = datetime.strptime(tracker.get_slot('date'), '%Y-%m-%d').date()
else:
possible_date = good_date
any_time, good_time = False, False
for entity in tracker.latest_message['entities']:
if entity['entity'] == 'times':
any_time = True
time_intervals = entity['value']
time_intervals = [{'start_date': datetime.combine(possible_date,
datetime.strptime(ti['start_date'],
'%H:%M').time()),
'end_date': datetime.combine(possible_date,
datetime.strptime(ti['end_date'], '%H:%M').time())}
for ti in time_intervals]
for e_time in time_intervals:
overlap = is_good_date(self.appointments, e_time)
if overlap and not good_time:
# If specified interval is longer then an hour, suggest narrowing it...
if (overlap['end_date'] - overlap['start_date']).seconds > 3600:
dispatcher.utter_message(
text=f"{get_time_text(overlap['start_date'])} és {get_time_text(overlap['end_date'])} között ráérek. Mikor legyen pontosan?")
return []
else:
good_time = overlap['start_date'].time()
break
if not any_time and not slots:
dispatcher.utter_message(text="Nem értettem, ne haragudj. Hány órakor találkozzunk?")
return []
if not good_time and not slots:
dispatcher.utter_message(text=f"Sajnos nem érek rá ekkor... Egy másik időpont esetleg?")
return [FollowupAction("followup_action_recommend_date")]
if good_time:
slots['time'] = SlotSet('time', good_time.strftime('%H:%M'))
if slots:
if 'time' in list(slots.keys()):
if 'date' in list(slots.keys()):
date = good_date
else:
date = datetime.strptime(tracker.get_slot('date'), '%Y-%m-%d')
dispatcher.utter_message(template="utter_submit",
date=get_date_text(date),
time=get_time_text(datetime.combine(datetime.min.date(), good_time),
add_suffix=True))
elif 'date' in list(slots.keys()):
dispatcher.utter_message(text=f"Ráérek {get_date_text(good_date)}. Mikor lenne jó aznap?")
return list(slots.values())
else:
return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
dia = tracker.get_slot('dia')
horas = tracker.get_slot('horas')
duracion = tracker.get_slot('duracion')
if duracion != "None" and "hora" in duracion:
switcher = {
"una hora": "60",
"dos horas": "120",
"tres horas": "180",
"cuatro horas": "240",
"1 hora": "60",
"2 horas": "120",
"3 horas": "180",
"4 horas": "240"
}
duracion = switcher.get(duracion)
if duracion != "None" and "minuto" in duracion:
switcher = {
"un": "1",
"dos": "2",
"tres": "3",
"cuatro": "4",
"cinco": "5",
"seis": "6",
"siete": "7",
"ocho": "8",
"nueve": "9"
}
duracion = duracion.replace(" minutos", "")
duracion = duracion.replace(" minuto", "")
duracion = switcher.get(duracion, duracion)
horas = horas.replace("h",
"") # para cuando toma por ejemplo: a las 11h
if horas != "None" and len(horas) > 2 and not ":" in horas:
switcher = {
"ocho": "08:00",
"nueve": "09:00",
"una": "13:00",
"dos": "14:00",
"tres": "15:00",
"cuatro": "16:00",
"cinco": "17:00",
"seis": "18:00"
}
horas = switcher.get(horas)
if horas != "None" and len(horas) < 2 and not ":" in horas:
switcher = {
"1": "13:00",
"2": "14:00",
"3": "15:00",
"4": "16:00",
"5": "17:00",
"6": "18:00",
"7": "19:00",
"8": "20:00",
"9": "21:00"
}
horas = switcher.get(horas)
if ":" in horas:
switcher = {
"01": "13",
"02": "14",
"03": "15",
"04": "16",
"05": "17",
"06": "18"
}
hora = horas[:2]
horas = str(switcher.get(hora, hora)) + horas[2:]
else:
if horas != "None":
horas = horas + ":00"
dispatcher.utter_message(text='!c_evento:' +
tracker.get_slot('evento') + '_dia:' + dia +
'_horario:' + horas + '_duracion:' + duracion)
return [
SlotSet('evento', "None"),
SlotSet('dia', "hoy"),
SlotSet('horas', "None"),
SlotSet('duracion', "None")
]
