def choose_pet_phrase(vars, found_users_pet):
shared_memory = state_utils.get_shared_memory(vars)
used_cats_dogs_phrases_num = shared_memory.get("used_cats_dogs_phrases",
{})
new_used_cats_dog_phrases_num = used_cats_dogs_phrases_num
cand_phrases = CATS_DOGS_PHRASES[found_users_pet]
if used_cats_dogs_phrases_num and found_users_pet in used_cats_dogs_phrases_num:
used_phrases_num = used_cats_dogs_phrases_num[found_users_pet]
if len(used_phrases_num) < len(cand_phrases):
while True:
cand_phrase_num = random.randint(0, len(cand_phrases) - 1)
if cand_phrase_num not in used_phrases_num:
break
else:
cand_phrase_num = random.randint(0, len(cand_phrases) - 1)
if cand_phrase_num not in used_phrases_num:
new_used_cats_dog_phrases_num[found_users_pet].append(
cand_phrase_num)
else:
cand_phrase_num = random.randint(0, len(cand_phrases) - 1)
new_used_cats_dog_phrases_num[found_users_pet] = [cand_phrase_num]
pet_phrase = cand_phrases[cand_phrase_num]
state_utils.save_to_shared_memory(
vars, used_cats_dogs_phrases=new_used_cats_dog_phrases_num)
return pet_phrase
def check_game_name_with_user_response(vars):
logger.info(f"check_game_name_with_user_response")
igdb_game_description, _ = game_info.search_igdb_game_description_by_user_and_bot_phrases(
vars)
if igdb_game_description is not None:
logger.info(
f"(user_wants_to_talk_about_particular_game_request)saving candidate id to shared memory"
)
state_utils.save_to_shared_memory(
vars, candidate_game_id=igdb_game_description["id"])
shared_memory = state_utils.get_shared_memory(vars)
logger.info(
f"(check_game_name_with_user_response)shared_memory: {shared_memory.keys()}"
)
response = f"Would you like to talk about the video game {igdb_game_description['name']}?"
state_utils.set_confidence(vars,
confidence=common_nlg.CONF_092_CAN_CONTINUE)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
else:
response = ""
state_utils.set_confidence(vars, confidence=common_nlg.CONF_0)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
return response
def fast_food_response(vars):
try:
shared_memory = state_utils.get_shared_memory(vars)
used_facts = shared_memory.get("fast_food_facts", [])
unused_facts = [i for i in FAST_FOOD_FACTS if i not in used_facts]
used_questions = shared_memory.get("fast_food_questions", [])
unused_questions = [
i for i in FAST_FOOD_QUESTIONS if i not in used_questions
]
fact = ""
question = ""
if unused_facts:
fact = random.choice(unused_facts)
state_utils.save_to_shared_memory(vars,
fast_food_facts=used_facts +
[fact])
if unused_questions:
question = random.choice(unused_questions)
state_utils.save_to_shared_memory(
vars, fast_food_questions=used_questions + [question])
if fact and question:
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
state_utils.set_can_continue(vars,
continue_flag=CAN_CONTINUE_PROMPT)
return f"I just found out that {fact} {question}"
else:
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
return error_response(vars)
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def retrieve_and_save_name(vars):
user_text = state_utils.get_last_human_utterance(vars)["text"]
shared_memory = state_utils.get_shared_memory(vars)
annotations = state_utils.get_last_human_utterance(vars)["annotations"]
ner = annotations.get("ner", [])
users_pet_breed = shared_memory.get("users_pet_breed", "")
found_name = ""
for entities in ner:
if entities:
for entity in entities:
if entity.get("type", "") == "PER":
found_name = entity["text"]
if not found_name:
fnd = re.findall(
r"(name is |named |called |call him |call her )([a-z]+)\b",
user_text)
if fnd:
found_name = fnd[0][1]
if (found_name and not shared_memory.get("users_pet_name", "")
and found_name
not in {"black", "white", "grey", "brown", "yellow", "cat", "dog"}
and found_name not in users_pet_breed):
state_utils.save_to_shared_memory(vars, users_pet_name=found_name)
return found_name
def what_pets_response(vars):
response = "What pets do you have?"
state_utils.save_to_shared_memory(vars, start=True)
state_utils.set_confidence(vars, confidence=CONF_1)
state_utils.set_can_continue(vars,
continue_flag=common_constants.MUST_CONTINUE)
return response
def mark_current_bot_utterance_as_link_to_other_skill(vars):
current_human_utterance_index = state_utils.get_human_utter_index(vars)
logger.info(
f"Bot utterance after human utterance with index {current_human_utterance_index} "
f"is marked to link to other skill"
)
state_utils.save_to_shared_memory(
vars, index_of_last_human_utterance_after_which_link_from_gaming_was_made=current_human_utterance_index
)
def get_next_sentences_from_summary_and_num_remaining(vars, n_sent=2):
split_summary = get_split_summary(vars)
i = split_summary["current_index"]
split_summary = get_split_summary(vars)
text = " ".join(split_summary["sentences"][i : i + n_sent])
split_summary["current_index"] += n_sent
num_remaining = len(split_summary["sentences"]) - split_summary["current_index"]
state_utils.save_to_shared_memory(vars, curr_summary_sent_index=split_summary["current_index"])
return text, num_remaining
def get_page_info(vars, function_type, where_to_find="current"):
shared_memory = state_utils.get_shared_memory(vars)
curr_pages = shared_memory.get("curr_pages", [])
found_entity_substr_list = shared_memory.get("found_entity_substr", [])
prev_title = shared_memory.get("prev_title", "")
prev_page_title = shared_memory.get("prev_page_title", "")
used_titles = shared_memory.get("used_titles", [])
found_entity_types_list = shared_memory.get("found_entity_types", [])
started = shared_memory.get("start", False)
was_prev_active = if_was_prev_active(vars)
logger.info(f"started {started}")
if function_type == "response" and curr_pages and found_entity_substr_list and found_entity_types_list:
page_content, _ = get_page_content(curr_pages[-1])
all_titles = find_all_titles([], page_content)
wants_more = if_wants_more(vars, all_titles)
logger.info(
f"deleting, function_type {function_type} wants_more {wants_more}")
if not wants_more:
curr_pages.pop()
found_entity_substr_list.pop()
found_entity_types_list.pop()
if not started or not was_prev_active:
curr_pages = []
found_entity_substr_list = []
found_entity_types_list = []
state_utils.save_to_shared_memory(vars, start=False)
new_page = shared_memory.get("new_page", False)
page_content_list = []
main_pages_list = []
if curr_pages:
for page in curr_pages[-2:]:
page_content, main_pages = get_page_content(page)
page_content_list.append(page_content)
main_pages_list.append(main_pages)
else:
found_entity_substr, _, found_entity_types = find_entity(
vars, where_to_find)
curr_page = get_page_title(vars, found_entity_substr)
if curr_page:
curr_pages.append(curr_page)
found_entity_substr_list.append(found_entity_substr)
found_entity_types_list.append(list(found_entity_types))
for page in curr_pages[-2:]:
page_content, main_pages = get_page_content(page)
page_content_list.append(page_content)
main_pages_list.append(main_pages)
return (
found_entity_substr_list,
prev_title,
prev_page_title,
found_entity_types_list,
used_titles,
curr_pages,
page_content_list,
main_pages_list,
new_page,
)
def wikihow_step_response(vars):
shared_memory = state_utils.get_shared_memory(vars)
wikihow_article = shared_memory.get("wikihow_article", "")
prev_wikihow_title = shared_memory.get("prev_wikihow_title", "")
used_wikihow_titles = shared_memory.get("used_wikihow_titles", [])
found_title = ""
facts_str = ""
question = ""
if wikihow_article:
article_content = get_wikihow_content(wikihow_article)
if article_content:
all_page_titles = article_content.keys()
for title in all_page_titles:
if title not in used_wikihow_titles and title != "intro":
found_title = title
break
if prev_wikihow_title:
paragraphs = article_content[prev_wikihow_title]
if paragraphs:
paragraph = paragraphs[0]
sentences = nltk.sent_tokenize(paragraph)
sentences_list = []
cur_len = 0
max_len = 50
for sentence in sentences:
words = nltk.word_tokenize(sentence)
if cur_len + len(words) < max_len:
sentences_list.append(sentence)
cur_len += len(words)
if sentences_list:
facts_str = " ".join(sentences_list)
logger.info(
f"wikihow_step_response, sentences_list {sentences_list} facts_str {facts_str}"
)
if found_title:
question = f"Would you like to know about {found_title.lower()}?"
logger.info(
f"wikihow_step_response found_title {found_title} prev_wikihow_title {prev_wikihow_title}"
)
response = f"{facts_str} {question}"
response = response.strip()
if found_title:
state_utils.save_to_shared_memory(vars, prev_wikihow_title=found_title)
used_wikihow_titles.append(found_title)
state_utils.save_to_shared_memory(
vars, used_wikihow_titles=used_wikihow_titles)
if response:
state_utils.set_confidence(vars, confidence=CONF_DICT["IN_SCENARIO"])
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
else:
state_utils.set_confidence(vars, confidence=CONF_DICT["UNDEFINED"])
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
return response
def my_fav_story_response(vars):
try:
utt = state_utils.get_last_human_utterance(vars)["text"].lower()
shared_memory = state_utils.get_shared_memory(vars)
used_topics = shared_memory.get("used_topics", [])
name = ""
story = ""
question = ""
response = ""
for topic in FAV_STORIES_TOPICS:
if topic in utt:
name = FAV_STORIES_TOPICS.get(topic, "").get("name", "")
story = FAV_STORIES_TOPICS.get(topic, "").get("story", "")
question = FAV_STORIES_TOPICS.get(topic, "").get("question", "")
if name and (topic not in used_topics):
if topic == "weekdays":
response = f"{story} {question}"
else:
response = f"My favorite {topic} is {name}. {story} {question}"
if topic == "book":
state_utils.set_confidence(vars, confidence=CONF_LOW)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
elif topic == "music" and "what kind of music do you like" in utt:
state_utils.set_confidence(vars, confidence=CONF_HIGH)
state_utils.set_can_continue(vars, continue_flag=MUST_CONTINUE)
elif topic == "music":
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
elif (topic == "game") and ("to play with" in utt):
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
return error_response(vars)
else:
state_utils.set_confidence(vars, confidence=CONF_HIGH)
state_utils.set_can_continue(vars, continue_flag=MUST_CONTINUE)
state_utils.save_to_shared_memory(vars, used_topics=used_topics + [topic])
return response
else:
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
return error_response(vars)
if not name and any(
[("my" not in utt) and ("favorite" in utt), re.search(YOUR_FAVORITE_COMPILED_PATTERN, utt)]
):
response = "Oh, I don't have one. What about you?"
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
else:
response = "I've never heard about it. Could you please tell me more about it?"
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
return response
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
state_utils.set_confidence(vars, 0)
return error_response(vars)
def no_science_response(vars):
try:
state_utils.set_confidence(vars, confidence=CONF_100)
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
state_utils.save_to_shared_memory(vars, current_status="")
return "Okay, if I'm always ready to talk about science, the achievements of humanity inspire me. "
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def what_wild_response(vars):
make_my_pets_info(vars)
what_i_like = random.choice(WILD_ANIMALS)
response = f"{what_i_like} What wild animals do you like?"
state_utils.save_to_shared_memory(vars, start=True)
state_utils.save_to_shared_memory(vars, what_wild=True)
state_utils.set_confidence(vars, confidence=CONF_1)
state_utils.set_can_continue(vars,
continue_flag=common_constants.MUST_CONTINUE)
return response
def start_talk_response(vars):
used_titles = []
dialog = vars["agent"]["dialog"]
found_entity_substr, found_entity_id, found_entity_types, found_page_title, _ = continue_after_topic_skill(
dialog)
page_content, _ = get_page_content(found_page_title)
found_entity_substr_list = [found_entity_substr]
found_entity_types_list = [list(found_entity_types)]
curr_pages = [found_page_title]
chosen_title, chosen_page_title = get_title_info(vars, found_entity_substr,
found_entity_types, "",
[], page_content)
titles_q, titles_we_use, all_titles = get_titles(found_entity_substr,
found_entity_types,
page_content)
question = ""
if chosen_title:
question = make_question(chosen_title, titles_q, found_entity_substr,
[])
chosen_title, chosen_page_title = choose_title(vars, all_titles,
titles_we_use, "", [],
curr_pages)
response = question.strip()
if chosen_title:
used_titles.append(chosen_title)
save_wiki_vars(
vars,
found_entity_substr_list,
curr_pages,
chosen_title,
chosen_page_title,
used_titles,
found_entity_types_list,
False,
)
cross_link = state_utils.get_cross_link(vars,
service_name="dff_wiki_skill")
from_skill = cross_link.get("from_service", "")
if from_skill:
state_utils.save_to_shared_memory(vars, interrupted_skill=from_skill)
if response:
state_utils.save_to_shared_memory(vars, start=True)
state_utils.set_confidence(vars,
confidence=CONF_DICT["ENTITY_IN_HISTORY"])
if from_skill:
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
else:
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_PROMPT)
else:
state_utils.set_confidence(vars, confidence=CONF_DICT["UNDEFINED"])
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
return response
def do_you_have_pets_response(vars):
response = random.choice([
"I think that pets are a great source of entertainment. Do you have pets at home?",
"We all know that pets are remarkable for their capacity to love. Do you have pets "
"at home?",
])
state_utils.save_to_shared_memory(vars, asked_have_pets=True)
state_utils.set_confidence(vars, confidence=CONF_1)
state_utils.set_can_continue(vars,
continue_flag=common_constants.MUST_CONTINUE)
return response
def suggest_pet_response(vars):
phrases = [
phrase for pet_phrases in CATS_DOGS_PHRASES.values()
for phrase in pet_phrases
]
response = random.choice(phrases)
state_utils.save_to_shared_memory(vars, start=True)
state_utils.set_confidence(vars, confidence=CONF_2)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
return response
def set_current_igdb_game_id_if_game_for_discussion_is_identified(vars, candidate_game_id_is_already_set):
if candidate_game_id_is_already_set:
set_current_igdb_game_id_from_candidate_game_id(vars)
put_candidate_id_to_igdb_game_ids_user_wanted_to_discuss(vars)
else:
igdb_game_description, _ = search_igdb_game_description_by_user_and_bot_phrases(vars)
if igdb_game_description is not None:
state_utils.save_to_shared_memory(vars, current_igdb_game_id=igdb_game_description["id"])
put_game_id_to_igdb_game_ids_user_wanted_to_discuss(vars, igdb_game_description["id"])
else:
state_utils.save_to_shared_memory(vars, current_igdb_game_id="")
clean_candidate_game_id(vars)
def find_fact(vars, fact_list, pet):
shared_memory = state_utils.get_shared_memory(vars)
used_facts = shared_memory.get("used_facts", {})
used_pet_facts = used_facts.get(pet, [])
fact_dict = {}
for n, elem in enumerate(fact_list[pet]):
fact_dict = elem
if n not in used_pet_facts:
used_pet_facts.append(n)
used_facts[pet] = used_pet_facts
state_utils.save_to_shared_memory(vars, used_facts=used_facts)
break
return fact_dict
def get_not_used_and_save_reaction_to_new_mentioned_person(vars):
shared_memory = state_utils.get_shared_memory(vars)
last_reactions_to_new_person = shared_memory.get(
"last_reactions_to_new_person", [])
reaction = common_utils.get_not_used_template(
used_templates=last_reactions_to_new_person,
all_templates=this_gossip.OPINION_TO_USER_MENTIONING_SOMEONE_NEW)
used_reacts = last_reactions_to_new_person + [reaction]
state_utils.save_to_shared_memory(
vars, last_reactions_to_new_person=used_reacts[-2:])
return reaction
def what_animals_response(vars):
make_my_pets_info(vars, rnd=False)
what_i_like = random.choice(WILD_ANIMALS)
response = f"{what_i_like} What animals do you like?"
state_utils.set_cross_link(vars,
to_service_name="dff_wiki_skill",
from_service_name="dff_animals_skill")
state_utils.save_to_shared_memory(vars, start=True)
state_utils.save_to_shared_memory(vars, what_animals=True)
state_utils.set_confidence(vars, confidence=CONF_1)
state_utils.set_can_continue(vars,
continue_flag=common_constants.MUST_CONTINUE)
return response
def describe_game_to_user_response(vars, ask_if_user_wants_more=True):
text, num_remaining_sentences = gaming_memory.get_next_sentences_from_summary_and_num_remaining(
vars)
if ask_if_user_wants_more:
response = text + ".. Would you like to hear more?"
else:
response = text + " So. Would you like to play this game?"
if num_remaining_sentences == 0:
state_utils.save_to_shared_memory(vars, curr_summary_sent_index=0)
state_utils.set_confidence(vars,
confidence=common_nlg.CONF_092_CAN_CONTINUE)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
return response
def make_response(vars, prev_page_title, page_content, question):
mentions_list = []
mention_pages_list = []
facts_str = ""
if prev_page_title:
paragraphs = find_paragraph(page_content, prev_page_title)
facts_str, mentions_list, mention_pages_list = make_facts_str(
paragraphs)
logger.info(f"facts_str {facts_str} question {question}")
response = f"{facts_str} {question}"
response = response.strip()
state_utils.save_to_shared_memory(vars, mentions=mentions_list)
state_utils.save_to_shared_memory(vars, mention_pages=mention_pages_list)
return response
def extract_and_save_wikipage(vars, save=False):
flag = False
user_uttr = state_utils.get_last_human_utterance(vars)
bot_uttr = state_utils.get_last_bot_utterance(vars)
shared_memory = state_utils.get_shared_memory(vars)
cur_facts = shared_memory.get("cur_facts", {})
for fact in cur_facts:
wikihow_page = fact.get("wikihow_page", "")
condition = fact["cond"]
checked = check_condition(condition, user_uttr, bot_uttr,
shared_memory)
if checked and wikihow_page:
flag = True
if save:
state_utils.save_to_shared_memory(
vars, cur_wikihow_page=wikihow_page)
state_utils.save_to_shared_memory(vars, cur_facts={})
break
wikipedia_page = fact.get("wikipedia_page", "")
condition = fact["cond"]
checked = check_condition(condition, user_uttr, bot_uttr,
shared_memory)
if checked and wikipedia_page:
flag = True
if save:
state_utils.save_to_shared_memory(
vars, cur_wikipedia_page=wikipedia_page)
state_utils.save_to_shared_memory(vars, cur_facts={})
break
return flag
def another_pet_response(vars):
user_uttr = state_utils.get_last_human_utterance(vars)
users_pet = re.findall(r"my (cat|dog)", user_uttr["text"])
if users_pet:
response = f"Very interesting! Could you tell more about your {users_pet[0]}?"
state_utils.set_confidence(vars, confidence=CONF_1)
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
else:
response = "Very interesting! Could you tell more about your pet?"
state_utils.set_confidence(vars, confidence=CONF_2)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
state_utils.save_to_shared_memory(vars, start=True)
return response
def get_not_used_and_save_generic_response(proposed_sf, vars):
logger.info(
f"Getting not yet used generic response for proposed speech function {proposed_sf}..."
)
shared_memory = state_utils.get_shared_memory(vars)
last_responses = shared_memory.get(proposed_sf + "_last_responses", [])
resp = common_utils.get_not_used_template(
used_templates=last_responses,
all_templates=current_templates.
GENERIC_REACTION_TO_USER_SPEECH_FUNCTION[proposed_sf],
)
used_resp = last_responses + [resp]
state_utils.save_to_shared_memory(vars, last_responses=used_resp[-2:])
return resp
def get_not_used_and_save_sentiment_acknowledgement(vars):
sentiment = state_utils.get_human_sentiment(vars)
if is_yes_vars(vars) or is_no_vars(vars):
sentiment = "neutral"
shared_memory = state_utils.get_shared_memory(vars)
last_acknowledgements = shared_memory.get("last_acknowledgements", [])
ack = common_utils.get_not_used_template(
used_templates=last_acknowledgements,
all_templates=GENERAL_ACKNOWLEDGEMENTS[sentiment])
used_acks = last_acknowledgements + [ack]
state_utils.save_to_shared_memory(vars,
last_acknowledgements=used_acks[-2:])
return ack
def make_my_pets_info(vars, rnd=True):
shared_memory = state_utils.get_shared_memory(vars)
my_pets_info = shared_memory.get("my_pets_info", {})
if not my_pets_info:
if rnd:
random.shuffle(WHAT_PETS_I_HAVE)
for pet in ["cat", "dog"]:
for elem in WHAT_PETS_I_HAVE:
if elem["pet"] == pet:
my_pets_info[pet] = {
"name": elem["name"],
"breed": elem["breed"],
"sentence": elem["sentence"]
}
break
state_utils.save_to_shared_memory(vars, my_pets_info=my_pets_info)
def cuisine_fact_response(vars):
cuisine_fact = ""
try:
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
last_utt = state_utils.get_last_human_utterance(vars)
last_utt_lower = last_utt["text"].lower()
conceptnet_flag, food_item = check_conceptnet(vars)
if any([w.pos_ == "ADJ" for w in spacy_nlp(last_utt_lower)]):
for cuisine in list(CUISINES_FACTS.keys()):
if cuisine in last_utt_lower:
cuisine_fact = CUISINES_FACTS.get(cuisine, "")
state_utils.save_to_shared_memory(vars, cuisine=cuisine)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
return cuisine_fact
if not cuisine_fact:
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
response = "You have such a refined taste in food! "
"I haven't tried it yet. What do you recommend to start with?"
state_utils.add_acknowledgement_to_response_parts(vars)
return response
elif conceptnet_flag:
entity_linking = last_utt["annotations"].get("entity_linking", [])
if entity_linking:
_facts = entity_linking[0].get("entity_pages", [])
if _facts:
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
response = f"You're a gourmet! I know about {food_item} that {_facts[0]}"
state_utils.add_acknowledgement_to_response_parts(vars)
return response
else:
return ""
else:
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
return (
"My favorite cuisine is French. I'm just in love "
"with pastry, especially with profiteroles! How about you?"
)
else:
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
return (
"My favorite cuisine is French. I'm just in love "
"with pastry, especially with profiteroles! How about you?"
)
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def ask_about_dog_cat_response(vars):
response = ""
found_users_pet = retrieve_and_save(vars)
if found_users_pet in CATS_DOGS:
repl_pet = replace_pet(found_users_pet)
pet_phrase = choose_pet_phrase(vars, repl_pet)
response = f"{pet_phrase} Do you have a {found_users_pet}?".strip()
state_utils.save_to_shared_memory(vars, start=True)
if response:
state_utils.set_confidence(vars, confidence=CONF_1)
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
else:
state_utils.set_confidence(vars, confidence=0.0)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
return response
def how_about_meal_response(vars):
shared_memory = state_utils.get_shared_memory(vars)
used_meals = shared_memory.get("used_meals", "")
meal = random.choice([i for i in MEALS if i != used_meals])
try:
state_utils.set_confidence(vars, confidence=CONF_HIGH)
state_utils.set_can_continue(vars, continue_flag=MUST_CONTINUE)
# first attempt to suggest a meal
state_utils.save_to_shared_memory(vars, used_meals=meal)
if not used_meals:
return f"I've recently found a couple easy and healthy meals. How about cooking {meal}?"
else:
return f"Okay. Give me one more chance. I recommend {meal}."
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def ask_about_pet_response(vars):
retrieve_and_save(vars)
extract_breed(vars)
shared_memory = state_utils.get_shared_memory(vars)
user_uttr = state_utils.get_last_human_utterance(vars)
found_pet = re.findall(PETS_TEMPLATE, user_uttr["text"])
users_pet = shared_memory.get("users_pet", "")
used_pets_q = shared_memory.get("used_pets_q", [])
found_question = {}
flag = False
for elem in USER_PETS_Q:
if elem["what"] not in used_pets_q:
found_question = elem
found_attr = ""
if found_question and found_question["attr"]:
curr_attr = found_question["attr"]
found_attr = shared_memory.get(curr_attr, "")
found_keywords = False
if found_question and found_question["keywords"]:
keywords = found_question["keywords"]
found_keywords = any(
[keyword in user_uttr["text"] for keyword in keywords])
if not found_attr and not found_keywords:
flag = True
if (found_question.get("what", "") == "breed" and
(users_pet and users_pet not in CATS_DOGS)
or (found_pet and found_pet[0] not in CATS_DOGS)):
flag = False
if flag:
break
what_to_ask = found_question.get("what", "")
if what_to_ask != "name":
retrieve_and_save_name(vars)
prev_what_to_ask = ""
if used_pets_q:
prev_what_to_ask = used_pets_q[-1]
response = make_utt_with_ack(vars, prev_what_to_ask, what_to_ask)
if what_to_ask != "more_info":
used_pets_q.append(what_to_ask)
state_utils.save_to_shared_memory(vars, used_pets_q=used_pets_q)
state_utils.save_to_shared_memory(vars, start=True)
state_utils.set_confidence(vars, confidence=CONF_2)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_SCENARIO)
return response
