def gourmet_response(vars):
try:
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_PROMPT)
response = "It seems you're a gourmet! What meal do you like?"
state_utils.add_acknowledgement_to_response_parts(vars)
return response
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def comment_on_user_experience_and_ask_if_user_wants_to_know_how_to_response(
vars):
uttr_text = state_utils.get_last_human_utterance(vars).get("text", "")
experience_comment, time_detected = common_nlg.compose_experience_comment(
uttr_text)
do_you_want_how_to = tell_how_to(vars, must_continue=time_detected)
state_utils.add_acknowledgement_to_response_parts(vars)
return (
experience_comment +
" During one of my hacks into Minecraft I discovered a secret trick. "
+ do_you_want_how_to)
def tell_about_healthy_gaming_and_ask_what_sport_user_likes_response(vars):
response = (
"You are very sensible person. There are several simple rules which help people stay healthy while "
"playing video games and using computer in general. The first is to give your eyes rest regularly. "
"You can use reminders for that. The second rule is to follow break schedule. And the last rule is "
"to exercise regularly. By the way, what sport do you like?")
state_utils.add_acknowledgement_to_response_parts(vars)
state_utils.set_confidence(vars, confidence=common_nlg.CONF_1)
state_utils.set_can_continue(vars,
continue_flag=common_constants.MUST_CONTINUE)
gaming_memory.mark_current_bot_utterance_as_link_to_other_skill(vars)
return response
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_user_when_he_started_to_play_minecraft_response(
vars, candidate_game_id_is_already_set):
shared_memory_ops.set_current_igdb_game_id_if_game_for_discussion_is_identified(
vars, candidate_game_id_is_already_set)
response = (
"Perfect taste! Minecraft is the best game ever! I dived into the game right after I was created. "
"And what about you? When did you start to play Minecraft?")
human_uttr = state_utils.get_last_human_utterance(vars)
bot_text = state_utils.get_last_bot_utterance(vars).get("text", "")
state_utils.add_acknowledgement_to_response_parts(vars)
flags_set = False
if not if_chat_about_particular_topic(
human_uttr, compiled_pattern=re.compile("minecraft", flags=re.I)):
flags_set, response = common_nlg.maybe_set_confidence_and_continue_based_on_previous_bot_phrase(
vars, bot_text, response)
logger.info(f"flags_set: {flags_set}")
if not flags_set:
state_utils.set_confidence(vars, confidence=common_nlg.CONF_1)
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
return response
def praise_user_achievement_in_minecraft_and_try_to_link_to_harry_potter_response(
vars):
disliked_skills = state_utils.get_disliked_skills(vars)
used_linkto_phrases_ids = shared_memory_ops.get_used_linkto_phrase_ids(
vars)
logger.info(
"(praise_user_achievement_in_minecraft_and_try_to_link_to_harry_potter_response)"
f"LINKTO_RESPONSES_TO_LINKTO_IDS: {shared_memory_ops.LINKTO_RESPONSES_TO_LINKTO_IDS}"
)
book_link_to_id = shared_memory_ops.LINKTO_RESPONSES_TO_LINKTO_IDS[
common_gaming.special_links_to_books["Harry Potter"][0]]
movie_link_to_id = shared_memory_ops.LINKTO_RESPONSES_TO_LINKTO_IDS[
common_gaming.special_links_to_movies["Harry Potter"][0]]
if "movie_skill" not in disliked_skills and movie_link_to_id not in used_linkto_phrases_ids:
response = "Sounds cool! " + common_gaming.special_links_to_movies[
"Harry Potter"][0]
shared_memory_ops.add_used_linkto_to_shared_memory(
vars, common_gaming.special_links_to_movies["Harry Potter"][0])
elif "dff_book_skill" not in disliked_skills and book_link_to_id not in used_linkto_phrases_ids:
response = "Sounds cool! " + common_gaming.special_links_to_books[
"Harry Potter"][0]
shared_memory_ops.add_used_linkto_to_shared_memory(
vars, common_gaming.special_links_to_books["Harry Potter"][0])
else:
response = ""
if response:
state_utils.set_confidence(
vars, confidence=common_nlg.CONF_09_DONT_UNDERSTAND_DONE)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
else:
state_utils.set_confidence(vars, confidence=common_nlg.CONF_0)
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
shared_memory_ops.mark_current_bot_utterance_as_link_to_other_skill(vars)
state_utils.add_acknowledgement_to_response_parts(vars)
return response
def facts_response(vars, topic_config, wikihow_cache, wikipedia_cache):
shared_memory = state_utils.get_shared_memory(vars)
user_uttr = state_utils.get_last_human_utterance(vars)
bot_uttr = state_utils.get_last_bot_utterance(vars)
prev_active_skill = bot_uttr.get("active_skill", "")
if prev_active_skill not in {"dff_wiki_skill", "dff_music_skill"}:
delete_topic_info(vars)
isyes = is_yes(user_uttr) or re.findall(CONTINUE_PATTERN,
user_uttr["text"])
response = ""
cur_mode = shared_memory.get("cur_mode", "smalltalk")
wikipedia_page = shared_memory.get("cur_wikipedia_page", "")
wikihow_page = shared_memory.get("cur_wikihow_page", "")
found_topic = shared_memory.get("special_topic", "")
utt_can_continue = common_constants.CAN_CONTINUE_SCENARIO
utt_conf = CONF_DICT["WIKI_TOPIC"]
first_utt = False
entity_substr = ""
entity_types = []
if not found_topic:
found_topic, first_utt, utt_can_continue, utt_conf = check_switch(
vars, topic_config)
extract_and_save_entity(vars, topic_config, found_topic)
extract_and_save_subtopic(vars, topic_config, found_topic)
extract_and_save_wikipage(vars, True)
if found_topic and cur_mode == "smalltalk":
if "triggers" in topic_config[found_topic]:
triggers = topic_config[found_topic]["triggers"]
entity_substr, entity_types, wikipedia_page, wikihow_page = find_trigger(
vars, triggers)
facts = topic_config[found_topic].get("facts", {})
if facts and not wikihow_page and not wikipedia_page:
entity_substr = facts.get("entity_substr", "")
entity_types = facts.get("entity_types", [])
wikihow_page = facts.get("wikihow_page", "")
wikipedia_page = facts.get("wikipedia_page", "")
logger.info(f"wikipedia_page {wikipedia_page}")
if not wikihow_page:
wikihow_page = shared_memory.get("cur_wikihow_page", "")
if wikihow_page:
if wikihow_page in wikihow_cache:
page_content = wikihow_cache[wikihow_page]
else:
page_content = get_wikihow_content(wikihow_page)
wikihow_page_content_list = preprocess_wikihow_page(page_content)
memory["wikihow_content"] = wikihow_page_content_list
state_utils.save_to_shared_memory(vars,
cur_wikihow_page=wikihow_page)
if not wikipedia_page:
wikipedia_page = shared_memory.get("cur_wikipedia_page", "")
if wikipedia_page:
if wikipedia_page in wikipedia_cache:
page_content = wikipedia_cache[wikipedia_page].get(
"page_content", {})
else:
page_content, _ = get_page_content(wikipedia_page)
if not entity_substr:
entity_substr = wikipedia_page.lower()
titles_info = topic_config[found_topic].get("titles_info", [])
predefined_titles = []
for titles_info_elem in titles_info:
if wikipedia_page in titles_info_elem["pages"]:
predefined_titles = titles_info_elem["titles"]
break
wikipedia_page_content_list = preprocess_wikipedia_page(
entity_substr, entity_types, page_content, predefined_titles)
memory["wikipedia_content"] = wikipedia_page_content_list
state_utils.save_to_shared_memory(
vars, cur_wikipedia_page=wikipedia_page)
logger.info(
f"wikihow_page {wikihow_page} wikipedia_page {wikipedia_page}")
if found_topic:
used_wikihow_nums_dict = shared_memory.get("used_wikihow_nums", {})
used_wikihow_nums = used_wikihow_nums_dict.get(wikihow_page, [])
used_wikipedia_nums_dict = shared_memory.get("used_wikipedia_nums", {})
used_wikipedia_nums = used_wikipedia_nums_dict.get(wikipedia_page, [])
wikihow_page_content_list = memory.get("wikihow_content", [])
wikipedia_page_content_list = memory.get("wikipedia_content", [])
logger.info(
f"response, used_wikihow_nums {used_wikihow_nums} used_wikipedia_nums {used_wikipedia_nums}"
)
logger.info(
f"response, wikipedia_page_content_list {wikipedia_page_content_list[:3]} "
f"wikihow_page_content_list {wikihow_page_content_list[:3]}")
if wikihow_page and wikihow_page_content_list:
for num, fact in enumerate(wikihow_page_content_list):
if num not in used_wikihow_nums:
facts_str = fact.get("facts_str", "")
question = fact.get("question", "")
response = f"{facts_str} {question}".strip().replace(
" ", " ")
used_wikihow_nums.append(num)
used_wikihow_nums_dict[wikihow_page] = used_wikihow_nums
state_utils.save_to_shared_memory(
vars, used_wikihow_nums=used_wikihow_nums_dict)
break
if not response and wikipedia_page and wikipedia_page_content_list:
for num, fact in enumerate(wikipedia_page_content_list):
if num not in used_wikipedia_nums:
facts_str = fact.get("facts_str", "")
question = fact.get("question", "")
response = f"{facts_str} {question}".strip().replace(
" ", " ")
used_wikipedia_nums.append(num)
used_wikipedia_nums_dict[
wikipedia_page] = used_wikipedia_nums
state_utils.save_to_shared_memory(
vars, used_wikipedia_nums=used_wikipedia_nums_dict)
break
cur_mode = "facts"
if len(wikihow_page_content_list) == len(used_wikihow_nums) and len(
wikipedia_page_content_list) == len(used_wikipedia_nums):
cur_mode = "smalltalk"
if len(wikihow_page_content_list) == len(used_wikihow_nums):
state_utils.save_to_shared_memory(vars, cur_wikihow_page="")
memory["wikihow_content"] = []
if len(wikipedia_page_content_list) == len(used_wikipedia_nums):
state_utils.save_to_shared_memory(vars, cur_wikipedia_page="")
memory["wikipedia_content"] = []
answer = answer_users_question(vars, topic_config)
response = f"{answer} {response}".strip().replace(" ", " ")
if not shared_memory.get("special_topic", ""):
found_topic, first_utt, utt_can_continue, utt_conf = check_switch(
vars, topic_config)
state_utils.save_to_shared_memory(vars, special_topic=found_topic)
if response:
state_utils.save_to_shared_memory(vars, cur_mode=cur_mode)
state_utils.set_confidence(vars, confidence=utt_conf)
if isyes or (first_utt and utt_can_continue == "must"):
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
else:
state_utils.set_can_continue(vars, continue_flag=utt_can_continue)
else:
state_utils.set_confidence(vars, confidence=CONF_DICT["UNDEFINED"])
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_NOT_CONTINUE)
state_utils.add_acknowledgement_to_response_parts(vars)
return response
def smalltalk_response(vars, topic_config):
response = ""
first_utt = False
shared_memory = state_utils.get_shared_memory(vars)
bot_uttr = state_utils.get_last_bot_utterance(vars)
prev_active_skill = bot_uttr.get("active_skill", "")
if prev_active_skill not in {"dff_wiki_skill", "dff_music_skill"}:
delete_topic_info(vars)
found_topic = shared_memory.get("special_topic", "")
cur_mode = shared_memory.get("cur_mode", "smalltalk")
isno = is_no(state_utils.get_last_human_utterance(vars))
utt_can_continue = "can"
utt_conf = 0.0
if cur_mode == "facts" and isno:
state_utils.save_to_shared_memory(vars, cur_wikihow_page="")
state_utils.save_to_shared_memory(vars, cur_wikipedia_page="")
memory["wikihow_content"] = []
memory["wikipedia_content"] = []
if not found_topic:
found_topic, first_utt, utt_can_continue, utt_conf = check_switch(
vars, topic_config)
if found_topic:
expected_entities = topic_config[found_topic].get(
"expected_entities", {})
if expected_entities:
state_utils.save_to_shared_memory(
vars, expected_entities=expected_entities)
existing_subtopic_info = shared_memory.get("expected_subtopic_info",
[])
expected_subtopic_info = topic_config[found_topic].get(
"expected_subtopic_info", {})
if expected_subtopic_info and not existing_subtopic_info and first_utt:
state_utils.save_to_shared_memory(
vars, expected_subtopic_info=expected_subtopic_info)
extract_and_save_entity(vars, topic_config, found_topic)
extract_and_save_subtopic(vars, topic_config, found_topic)
available_utterances = shared_memory.get("available_utterances", [])
logger.info(f"subtopics {shared_memory.get('subtopics', [])}")
subtopics_to_delete = 0
add_general_ackn = False
if found_topic:
used_utt_nums_dict = shared_memory.get("used_utt_nums", {})
used_utt_nums = used_utt_nums_dict.get(found_topic, [])
state_utils.save_to_shared_memory(vars, special_topic=found_topic)
subtopics = shared_memory.get("subtopics", [])
if subtopics:
for i in range(len(subtopics) - 1, -1, -1):
cur_subtopic = subtopics[i]
for num, utt_info in enumerate(
topic_config[found_topic]["smalltalk"]):
utt_key = utt_info.get("key", "")
if num not in used_utt_nums and (
not available_utterances or
(available_utterances
and utt_key in available_utterances)):
if utt_info.get(
"subtopic",
"") == cur_subtopic and check_utt_cases(
vars, utt_info):
response, used_utt_nums = make_smalltalk_response(
vars, topic_config, shared_memory, utt_info,
used_utt_nums, num)
if response:
add_general_ackn = utt_info.get(
"add_general_ackn", False)
utt_can_continue = utt_info.get(
"can_continue", "can")
utt_conf = utt_info.get("conf", utt_conf)
break
if response:
used_utt_nums_dict[found_topic] = used_utt_nums
state_utils.save_to_shared_memory(
vars, used_utt_nums=used_utt_nums_dict)
if check_used_subtopic_utt(vars, topic_config,
cur_subtopic):
subtopics_to_delete += 1
break
else:
subtopics_to_delete += 1
if not subtopics or not response:
for num, utt_info in enumerate(
topic_config[found_topic]["smalltalk"]):
utt_key = utt_info.get("key", "")
if (num not in used_utt_nums
and check_utt_cases(vars, utt_info)
and not utt_info.get("subtopic", "")
and (not available_utterances or
(available_utterances
and utt_key in available_utterances))):
response, used_utt_nums = make_smalltalk_response(
vars, topic_config, shared_memory, utt_info,
used_utt_nums, num)
if response:
utt_can_continue = utt_info.get("can_continue", "can")
utt_conf = utt_info.get("conf", utt_conf)
add_general_ackn = utt_info.get(
"add_general_ackn", False)
used_utt_nums_dict[found_topic] = used_utt_nums
state_utils.save_to_shared_memory(
vars, used_utt_nums=used_utt_nums_dict)
break
if subtopics_to_delete:
for i in range(subtopics_to_delete):
subtopics.pop()
state_utils.save_to_shared_memory(vars, subtopics=subtopics)
logger.info(
f"used_utt_nums_dict {used_utt_nums_dict} used_utt_nums {used_utt_nums}"
)
acknowledgement = check_acknowledgements(vars, topic_config)
answer = answer_users_question(vars, topic_config) or acknowledgement
response = f"{answer} {response}".strip().replace(" ", " ")
logger.info(f"response {response}")
if response:
state_utils.save_to_shared_memory(vars, cur_mode="smalltalk")
if utt_conf > 0.0:
state_utils.set_confidence(vars, confidence=utt_conf)
else:
state_utils.set_confidence(vars,
confidence=CONF_DICT["WIKI_TOPIC"])
if first_utt or utt_can_continue == "must":
state_utils.set_can_continue(
vars, continue_flag=common_constants.MUST_CONTINUE)
elif utt_can_continue == "prompt":
state_utils.set_can_continue(
vars, continue_flag=common_constants.CAN_CONTINUE_PROMPT)
else:
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)
if not add_general_ackn:
state_utils.add_acknowledgement_to_response_parts(vars)
return response
def ask_if_user_wants_to_know_how_to_response(vars, must_continue=True):
state_utils.add_acknowledgement_to_response_parts(vars)
return "I know another cool thing. " + tell_how_to(vars, must_continue)
def request_science_topic_response(vars):
try:
# get_unused_topics
science_topics_names = local_utils.get_unused_topics(vars)
if not science_topics_names:
state_utils.set_can_continue(vars, MUST_CONTINUE)
state_utils.set_confidence(vars, confidence=CONF_100)
next_index = state_utils.get_unrepeatable_index_from_rand_seq(
vars,
"nice_chat_acks",
len(NICE_CHAT_ACKS),
True,
)
ack = f"{NICE_CHAT_ACKS[next_index]}"
body = (
"Okay, There are many scientific topics that could be discussed, "
"when I learn something new I will be ready to talk to you about it."
)
return " ".join([ack, body])
science_topics_names = science_topics_names if science_topics_names else list(
science_topics.keys())
current_topic = random.sample(science_topics_names, 1)[0]
local_utils.add_unused_topics(vars, current_topic)
# save is_requested_topic_before
shared_memory = state_utils.get_shared_memory(vars)
is_requested_topic_before = shared_memory.get(
"is_requested_topic_before")
state_utils.save_to_shared_memory(vars,
current_topic=current_topic,
is_requested_topic_before=True)
if is_requested_topic_before:
next_index = state_utils.get_unrepeatable_index_from_rand_seq(
vars,
"nice_chat_acks",
len(NICE_CHAT_ACKS),
True,
)
ack = f"{NICE_CHAT_ACKS[next_index]}"
body = f"So, maybe next? Do you wanna talk about {current_topic}?"
else:
ack = "I think people who are interested in science are special."
body = f"I like to talk about a variety of scientific topics. Do you wanna talk about {current_topic}?"
state_utils.add_acknowledgement_to_response_parts(vars)
if linkto_yes(vars):
state_utils.set_can_continue(vars, MUST_CONTINUE)
state_utils.set_confidence(vars, confidence=CONF_100)
elif if_chat_about_science_topic_pattern(vars):
state_utils.set_can_continue(vars, CAN_CONTINUE_SCENARIO)
state_utils.set_confidence(vars, confidence=CONF_95)
elif is_mentioned_science_pattern(vars):
state_utils.set_can_continue(vars, CAN_CONTINUE_SCENARIO)
state_utils.set_confidence(vars, confidence=CONF_95)
else:
return error_response(vars)
return " ".join([ack, body])
except Exception as exc:
logger.exception(exc)
sentry_sdk.capture_exception(exc)
return error_response(vars)
def comment_on_user_experience_and_ask_if_user_recommends_game_response(vars):
human_uttr = state_utils.get_last_human_utterance(vars)
state_utils.add_acknowledgement_to_response_parts(vars)
return common_nlg.compose_experience_comment(human_uttr.get(
"text", ""))[0] + " " + ask_advice(vars)
def tell_about_what_bot_likes_and_ask_if_user_recommends_game_response(vars):
state_utils.add_acknowledgement_to_response_parts(vars)
return "Your gaming outlook is great! " + ask_advice(vars)
def food_fact_response(vars):
human_utt = state_utils.get_last_human_utterance(vars)
annotations = human_utt["annotations"]
human_utt_text = human_utt["text"].lower()
bot_utt_text = state_utils.get_last_bot_utterance(vars)["text"]
shared_memory = state_utils.get_shared_memory(vars)
used_facts = shared_memory.get("used_facts", [])
fact = ""
facts = []
entity = ""
berry_name = ""
linkto_check = any([linkto in bot_utt_text for linkto in link_to_skill2i_like_to_talk["dff_food_skill"]])
black_list_check = any(list(annotations.get("badlisted_words", {}).values()))
conceptnet_flag, food_item = check_conceptnet(vars)
entities_facts = annotations.get("fact_retrieval", {}).get("topic_facts", [])
for entity_facts in entities_facts:
if entity_facts["entity_type"] in ["food", "fruit", "vegetable", "berry"]:
if entity_facts["facts"]:
facts = entity_facts["facts"][0].get("sentences", [])
entity = entity_facts["entity_substr"]
else:
facts = []
if not facts:
facts = annotations.get("fact_random", [])
if black_list_check:
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
return error_response(vars)
elif conceptnet_flag and all(["shower" not in human_utt_text, " mela" not in human_utt_text]):
if "berry" in bot_utt_text.lower():
berry_names = get_entities(state_utils.get_last_human_utterance(vars), only_named=False, with_labels=False)
if berry_names:
berry_name = berry_names[0]
if all(["berr" not in human_utt_text, len(human_utt_text.split()) == 1, berry_name]):
berry_name += "berry"
fact = get_fact(berry_name, f"fact about {berry_name}")
entity = berry_name
elif berry_name:
if facts and entity:
fact = random.choice([i for i in facts if i not in used_facts])
# facts[0]
elif facts:
for facts_item in facts:
if all(
[
facts_item.get("entity_substr", "xxx") in food_item,
facts_item.get("fact", "") not in used_facts,
]
):
fact = facts_item.get("fact", "")
entity = facts_item.get("entity_substr", "")
break
else:
fact = ""
entity = ""
else:
if all([facts, entity, entity in food_item]):
fact = random.choice([i for i in facts if i not in used_facts])
# facts[0]
elif facts and not entity:
for facts_item in facts:
if all(
[
facts_item.get("entity_substr", "xxx") in food_item,
facts_item.get("fact", "") not in used_facts,
]
):
fact = facts_item.get("fact", "")
entity = facts_item.get("entity_substr", "")
break
else:
fact = ""
entity = ""
else:
fact = ""
entity = ""
acknowledgement = random.choice(FOOD_FACT_ACKNOWLEDGEMENTS).replace("ENTITY", entity.lower())
state_utils.save_to_shared_memory(vars, used_facts=used_facts + [fact])
try:
if bot_persona_fav_food_check(vars) or len(state_utils.get_last_human_utterance(vars)["text"].split()) == 1:
state_utils.set_confidence(vars, confidence=CONF_HIGH)
else:
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
if bool(re.search(DONOTKNOW_LIKE_RE, human_utt_text)):
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
return "Well, as for me, I am a fan of pizza despite I cannot eat as humans."
elif any([dont_want_talk(vars), bool(re.search(NO_WORDS_RE, human_utt_text))]):
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
return error_response(vars)
elif (not fact) and conceptnet_flag:
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
return "Why do you like it?"
elif not fact:
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
return error_response(vars)
elif fact and entity:
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
if len(used_facts):
return f"{fact} Do you want me to tell you more about {entity}?"
else:
response = acknowledgement + f"{fact} Do you want to hear more about {entity}?"
state_utils.add_acknowledgement_to_response_parts(vars)
return response
elif fact:
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
if len(used_facts):
return f"{fact} Do you want me to tell you more about {entity}?"
else:
return f"Okay. {fact} I can share with you one more cool fact. Do you agree?"
elif linkto_check:
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
return "Sorry. I didn't get what kind of food you have mentioned. Could you repeat it please?"
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)
elif linkto_check:
state_utils.set_confidence(vars, confidence=CONF_MIDDLE)
state_utils.set_can_continue(vars, continue_flag=CAN_CONTINUE_SCENARIO)
return "Sorry. I didn't get what kind of food you have mentioned. Could you repeat it please?"
else:
state_utils.set_can_continue(vars, continue_flag=CAN_NOT_CONTINUE)
return error_response(vars)
