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