ActionExecuted(ACTION_LISTEN_NAME), ] tracker = get_tracker(events) assert tracker.last_executed_action_has("another") is False @pytest.mark.parametrize( "events, expected_extracted_slots", [ ([], {}), ([ActionExecuted("my_form")], {}), ( [ActionExecuted("my_form"), SlotSet("my_slot", "some_value")], { "my_slot": "some_value" }, ), ( [ ActionExecuted("my_form"), SlotSet("my_slot", "some_value"), SlotSet("some_other", "some_value2"), ], { "my_slot": "some_value", "some_other": "some_value2" }, ),
def run(self, dispatcher, tracker, domain): style = tracker.get_slot('style') beer_already_rec = tracker.get_slot('beer') beer = get_beer(style, excl=beer_already_rec) dispatcher.utter_message("You might like this beer: {}!".format(beer)) return [SlotSet("beer", beer)]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: # score=tracker.get_slot("hello_flag") # score=1 return [SlotSet("hello_flag", "1")]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: print(tracker.get_latest_entity_values("item")) # answer = choice(['success', 'failure']) # Wait for ROS respone return [SlotSet("bring_status", "success")]
def run(self, dispatcher, tracker, domain): return [ SlotSet("main", None), SlotSet("duration", None), SlotSet("satisfied", None) ]
def run(self, dispatcher, tracker, domain): start_time = time.time() # Read email to_user = tracker.get_slot('email') # Check if the email address is entered i.e. whether the user wants the results to be sent over email if (to_user != "unknown"): # Setup email response from_user = '******' password = '******' subject = 'Foodie has found you the restaurants' msg = MIMEMultipart() msg['From'] = from_user msg['TO'] = to_user msg['Subject'] = subject # Read the search results response = tracker.get_slot('emailmsg') #formatting the body of the email rest_name = [] rest_address = [] rest_rating = [] rest_budget = [] for res in response[::2]: rest_name.append(res.split(' in ')[0]) rest_address.append( res.split(' in ')[1].split(' has a rating of ')[0]) rest_rating.append( res.split(' in ')[1].split(' has a rating of ')[1][:-1]) for budget in response[1::2]: rest_budget.append(budget[:-1]) txt = "" for idx in range(len(response) // 2): txt = txt + '<b>Restaurant Name:</b> ' + rest_name[idx] + '<br>' txt = txt + '<b>Restaurant locality address:</b> ' + rest_address[ idx] + '<br>' txt = txt + '<b>Budget:</b> ' + rest_budget[idx] + '<br>' txt = txt + '<b>Zomato user rating:</b> ' + rest_rating[ idx] + '<br>' txt = txt + '<br>' html = """\ <html> <body> <p>Greetings from Foodie!,<br> <h3>Here are the top rated restaurants as per your criteria:</h3> <br>""" html = html + txt html = html + """ <br><b><i>Itadakimasu,</b></i><br><b>Foodie Team</b> </p> </body> </html> """ msg.attach(MIMEText(html, 'html')) text = msg.as_string() # Create a secure SSL context try: context = ssl.create_default_context() with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server: server.login(from_user, password) server.sendmail(from_user, to_user, text) server.close() # Inform the user dispatcher.utter_message( "The details have been emailed to you, you should receive it shortly. Bon Appetit!" ) except: dispatcher.utter_message( "Sorry, we are having some problem in sending email to you. Please try after some time" ) print("--- email sending %s seconds ---" % (time.time() - start_time)) return [SlotSet('email', to_user)]
async def unisec_validate_slots( self, dispatcher: "CollectingDispatcher", tracker: "Tracker", domain: Dict[Text, Any], ) -> List[EventType]: # print("unisec validated slot called") slot_dict = [] validator = UnisecValidator.getInstance() #reset local slot listSlot = self.required_validation_slot() self.validated_slots = {} for i in listSlot: self.validated_slots[i] = None self.validated_slots[i + "_validated"] = None for slot in self.validated_slots: if tracker.get_slot(slot) != None and slot[-10:] != '_validated': try: validate_func = getattr(validator, "validate_" + slot) origin = tracker.get_slot(slot) validation_output = [] if isinstance(origin, str): try: validation_output = validate_func(' '.join( tracker.get_slot(slot).split('_'))) except: validation_output = validate_func( tracker.get_slot(slot)) if validation_output is None: print( "vukihai: something went wrong with validation function: " + "validate_" + slot) validation_output = (1, tracker.get_slot(slot), tracker.get_slot(slot)) # if validation_output[0] < 0.5: # validation_output = (1,None,None) self.validated_slots[slot] = validation_output[1] self.validated_slots[ slot + "_validated"] = validation_output[2] slot_dict.append(SlotSet(slot, validation_output[1])) slot_dict.append( SlotSet(slot + "_validated", validation_output[2])) else: validation_output = [] for i in origin: try: validation_output.append( validate_func(' '.join(i.split('_')))) except: validation_output.append(validate_func(i)) # if validation_output[-1][0] < 0.5: # validation_output[-1] = (1,None,None) self.validated_slots[slot] = [] self.validated_slots[slot + "_validated"] = [] for i in validation_output: self.validated_slots[slot].append(i[1]) self.validated_slots[slot + "_validated"].append( i[2]) slot_dict.append( SlotSet(slot, self.validated_slots[slot])) slot_dict.append( SlotSet(slot + "_validated", self.validated_slots[slot + "_validated"])) if self.validated_slots[slot] != None: UnisecLogger.log(UnisecLogger.ENTITY_EXTRACTED, slot, self.validated_slots[slot], tracker.latest_message.get('text')) except: print('vukihai: validate function not found: ' + "validate_" + slot) # print("vukihai slot validate event") print(slot_dict) return slot_dict
def run(self, dispatcher, tracker, domain): config = {"user_key": "d7d2afaf2f19d43708fb09bbe480d6b0"} zomato = zomatopy.initialize_app(config) loc = tracker.get_slot('location') cuisine = tracker.get_slot('cuisine') price = tracker.get_slot('price') global response global cnt #find budget boundary minBudget, maxBudget = getMinMaxBudget(price) location_detail = zomato.get_location(loc, 1) d1 = json.loads(location_detail) lat = d1["location_suggestions"][0]["latitude"] lon = d1["location_suggestions"][0]["longitude"] cuisines_dict = { 'bakery': 5, 'american': 1, 'mexican': 73, 'chinese': 25, 'cafe': 30, 'italian': 55, 'biryani': 7, 'north indian': 50, 'south indian': 85 } results = zomato.restaurant_search("", lat, lon, str(cuisines_dict.get(cuisine)), 50) json_results = json.loads(results) #filter by budget temp_dict = {} final_dict = {} cnt = json_results['results_found'] if json_results['results_found'] == 0: response = "no results" else: i = 0 for restaurant in json_results['restaurants']: temp_dict = [ restaurant['restaurant']["user_rating"] ["aggregate_rating"], restaurant['restaurant']['name'], restaurant['restaurant']['location']['address'], restaurant['restaurant']['average_cost_for_two'] ] if (temp_dict[3] >= minBudget) and (temp_dict[3] <= maxBudget): final_dict[i] = temp_dict i = i + 1 #sort by rating sorted_dict = {} for k, v in sorted(final_dict.items(), key=lambda item: item[1][0], reverse=True): sorted_dict[k] = v #prepare top 5 response response = "" if len(sorted_dict) == 0: response = "no results" else: i = 0 for k, v in sorted_dict.items(): i = i + 1 response = response + "Found " + v[1] + " in " + v[ 2] + " where price for two people is Rs." + str( v[3]) + " and rating is " + str(v[0]) + "..." + "\n" if (i == 5): break dispatcher.utter_message("-----" + response) return [SlotSet('location', loc)]
def run(self, dispatcher, tracker, domain) -> List[EventType]: return [SlotSet("producto_desconocido", tracker.latest_message.get("text"))]
def run(self, dispatcher, tracker, domain): MailID = tracker.get_slot('mail_id') sendmail(MailID, response) return [SlotSet('mail_id', MailID)]
def run(self, dispatcher, tracker, domain): #Extract the list of tier 1 and 2 cities from wikipage url = "https://en.wikipedia.org/wiki/Classification_of_Indian_cities" r = requests.get(url, verify=False) soup = BeautifulSoup(r.text, "html.parser") #Parse the content to extract names cities = list( map(lambda x: x.text.lower(), soup.find('table', class_='wikitable').find_all('a'))) #Get the list of common synonym names for the cities in tier 1 and 2 city_synonym = [] #Extract the common city synonyms from this page r = requests.get( 'https://www.scoopwhoop.com/news/whats-in-a-name/#.45rdcz1m2', verify=False) synonym_list = BeautifulSoup(r.text, 'html.parser').find( 'div', class_='article-body').find_all('h2') #extract Synonym list for city in synonym_list: if re.search(r'^[0-9]{1,2}.+', city.text.strip()): city_synonym.append(city.text.strip().split()[1].lower()) city_synonym.append(city.text.strip().split()[-1].lower()) #Few other city synonyms as gathered from the internet city_synonym_2 = [ 'allahabad', 'atal-nagar', 'bangalore', 'baroda', 'bejawada ', 'belagavi ', 'belgaum', 'benares', 'bengaluru', 'bijapur', 'bombay', 'calcutta ', 'calicut', 'cannanore', 'cawnpore ', 'chennai', 'cochin', 'gauhati', 'gulbarga ', 'gurgaon', 'gurugram ', 'guwahati ', 'hubballi ', 'hubli ', 'indhur', 'indore', 'jabalpur ', 'jajesmow ', 'jajmau', 'jubbulpore ', 'kalaburagi ', 'kannur', 'kanpur', 'kochi ', 'kolkata', 'kollam', 'kozhikode', 'kudanthai', 'kumbakonam ', 'madras', 'mangalore', 'mangaluru', 'mumbai', 'bombay', 'mysore', 'mysore', 'mysuru', 'nellore', 'panaji', 'panjim', 'pondicherry', 'poona ', 'prayagraj', 'puducherry ', 'pune', 'quilon', 'raipur', 'shimla', 'simhapuri', 'simla ', 'thiruvananthapuram', 'thrissur ', 'tindivanam ', 'tinnevelly ', 'tinthirivanam ', 'tiruchirapalli', 'tirunelveli', 'tiruvallikeni ', 'trichinopoly', 'trichur', 'triplicane ', 'trivandrum ', 'vadodara ', 'varanasi ', 'vatakara ', 'vijayapura ', 'vijayawada ', 'visakhapatnam ', 'waltair' ] #List of all valid cities in India for verification. Parse from this page url1 = "https://en.wikipedia.org/wiki/List_of_cities_in_India_by_population" r1 = requests.get(url1, verify=False) soup1 = BeautifulSoup(r1.text, "html.parser") #Extract list of all cities in India all_cities_list = [] temp_city = list( map(lambda x: x.text.lower(), soup1.find('table', class_='wikitable').find_all('a'))) for city in temp_city: if not re.search(r'^.[0-9]{1,2}.+', city): all_cities_list.append(city) #get the location from user slot loc = tracker.get_slot('location') #Check for pincodes. Not supported for now if (loc.lower().isdigit()): dispatcher.utter_message( "Sorry I am naive I dont understand pincodes and digits for now. Please try some actual place!!" ) return [SlotSet('location', None), SlotSet("location_ok", False)] #Check for invalid city elif not (loc.lower() in all_cities_list or loc.lower() in city_synonym or loc.lower() in city_synonym_2 or loc.lower() in cities): dispatcher.utter_message("Sorry did'nt find any such location " + loc + " Can you please tell again?") return [SlotSet('location', None), SlotSet("location_ok", False)] #Check for valid city but no servicable by Zomato elif not (loc.lower() in city_synonym or loc.lower() in city_synonym_2 or loc.lower() in cities): dispatcher.utter_message("We do not operate in " + loc + " yet. Please try some other city.") return [SlotSet('location', None), SlotSet("location_ok", False)] #If valid city and servicable return true else: return [SlotSet('location', loc), SlotSet('location_ok', True)]
async def run( self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: "DomainDict", ) -> List[Dict[Text, Any]]: """ Executes this action. Args: dispatcher: the dispatcher tracker: the tracker domain: the domain Returns: list of slots """ slot_names_since_last_user_utterance: List[str] = [] for event in reversed(tracker.events): event_type = event["event"] if event_type == "slot": slot_names_since_last_user_utterance.append(event["name"]) elif event_type == "user": break object_name_or_type = (tracker.get_slot(SLOT_OBJECT_NAME_OR_TYPE) if SLOT_OBJECT_NAME_OR_TYPE in slot_names_since_last_user_utterance else None) # found_object_names = ( # tracker.get_slot(SLOT_FOUND_OBJECT_NAMES) # if SLOT_FOUND_OBJECT_NAMES in slot_names_since_last_user_utterance # else None # ) # object_activity_provided = ( # tracker.get_slot(SLOT_OBJECT_ACTIVITY_PROVIDED) # if SLOT_OBJECT_ACTIVITY_PROVIDED # in slot_names_since_last_user_utterance # else None # ) # If no parameters were set, then quit if not any([object_name_or_type]): # return [FollowupAction(name=question_answer_action.ACTION_NAME)] # return [] # return [AllSlotsReset()] return [] found_objects_by_name: List[Object] = [] found_objects_by_type: List[Object] = [] found_objects_by_things_provided: List[Object] = [] # TODO: Prioritize finding things that were talked about recently (i.e. in 'found_objects') for object in self.objects: # Find objects by name if object_name_or_type.casefold() == object.name.casefold(): found_objects_by_name.append(object) # Find objects by type if object_name_or_type in [ type.name.casefold() for type in object.types ]: found_objects_by_type.append(object) # Find objects by things provided if object_name_or_type in [ thing.name.casefold() for thing in object.things_provided ]: found_objects_by_things_provided.append(object) found_objects = (found_objects_by_name or found_objects_by_type or found_objects_by_things_provided) return [ SlotSet( key=SLOT_FOUND_OBJECT_NAMES, value=[object.name for object in found_objects] if len(found_objects) > 0 else None, ), ]
def run(self, dispatcher, tracker, domain): dbhost = tracker.get_slot('dbhost') dbdriver = tracker.get_slot('dbdriver') dbdialect = tracker.get_slot('dbdialect') dbusername = tracker.get_slot('dbusername') dbpassword = tracker.get_slot('dbpassword') dbname = tracker.get_slot('dbname') try: entities = "" engine = create_engine( str(dbdriver) + '+' + str(dbdialect) + '://' + str(dbusername) + ':' + str(dbpassword) + '@' + str(dbhost) + '/' + str(dbname)) inspector = reflection.Inspector.from_engine(engine) tables_names = (inspector.get_table_names()) column_names = [] for table in tables_names: cols = inspector.get_columns(table) for col in cols: column_names.append(col['name']) path1 = "data/lookup" if path.exists(path1) == True: try: shutil.rmtree(path1) except Error as er: path1.rmdir() os.makedirs(path1) else: os.makedirs(path1) domain = 'domain.yml' stream = open(domain, 'r') data = yaml.load(stream) for table in tables_names: path2 = path1 + "/" + table os.makedirs(path2) tb = path2 + "/" + table + "s.txt" t = open(tb, 'a+') t.write(table) t.close() hello = path2 + "/columns" os.makedirs(hello) cols = inspector.get_columns(table) for col in cols: # data['entities'].append(col['name']) # data['slots'][col['name']]={'type':'unfeaturized'} with open('domain.yml', 'w') as fp: fp.write(yaml.dump(data)) with engine.connect() as con: rs = con.execute('SELECT {0} FROM {1}'.format( col['name'], table)) resultset = [dict(row) for row in rs] yo = hello + "/" + col['name'] os.makedirs(yo) fl = yo + "/" + col['name'] cl = fl + "synonyms.txt" clmn = open(cl, 'a') clmn.write(col['name']) clmn.close() filename = fl + ".txt" with open(filename, 'a+') as file: for dic in resultset: b = (str)(dic[col['name']]) + "\n" file.write(b) file.close() writer = open('data/nlu.md', 'a+') r = "\t- lookup/" + table + "/columns/" + col[ 'name'] + "/" + col['name'] + ".txt" writer.write("\n## synonym:" + col['name'] + "\n\t" + r) def occurences(searched_word): L = [] with open("data/nlu.md", newline='') as file: result = file.read() words = word_tokenize(result) for index, word in enumerate(words, 0): if word == searched_word: L.append(index) return L l = occurences("table") lcol = occurences("column") with open("data/nlu.md", newline='') as file1: result = file1.read() words = word_tokenize(result) for i in l: x = randint(0, (len(tables_names) - 1)) syn = list() for synset in wordnet.synsets(tables_names[x]): for lemma in synset.lemmas(): syn.append(lemma.name()) syn.append(tables_names[x]) syn.append(tables_names[x]) syn.append(tables_names[x]) for j in syn: k = randint(0, (len(syn) - 1)) if words[i - 3] == '[': words[i - 3] = words[i - 3] + str(syn[k]) else: words[i - 3] = str(syn[k]) if words[i + 1] != ')': words[i] = "table" words[i + 1] = ":" words[i + 2] = tables_names[x] else: words[i] = "table:" + tables_names[x] for j in lcol: x = randint(0, (len(column_names) - 1)) synC = list() for synset in wordnet.synsets(column_names[x]): for lemma in synset.lemmas(): synC.append(lemma.name()) synC.append(column_names[x]) synC.append(column_names[x]) synC.append(column_names[x]) for a in synC: b = randint(0, (len(synC) - 1)) if words[j - 3] == '[': words[j - 3] = '[' + str(synC[b]) else: words[j - 3] = str(synC[b]) if words[j + 1] != ')': words[j] = "column" words[j + 1] = ":" words[j + 2] = column_names[x] else: words[j] = "column:" + column_names[x] for j in range(len(words)): if (words[j] == '-'): words[j - 1] = str(words[j - 1]) + '\n' if (words[j] == '#' and words[j - 1] == '#'): words[j - 2] = str(words[j - 2]) + '\n' writer = open('data/nlu.md', 'w') for m in range(len(words) - 1): if words[m] == '[' or words[m + 1] == ']' or words[ m + 1] == '(' or words[m] == '(' or words[ m + 1] == ')' or words[m] == 'intent' or words[ m + 1] == ')\n' or ( words[m] == '#' and words[m + 1] == '#' ) or words[m] == ':' or words[m + 1] == ":": writer.write(words[m]) else: writer.write(words[m] + ' ') writer.write(words[len(words) - 1]) except Error as e: print("Error while connecting to database", e) return [ SlotSet("tableNames", list(tables_names)), SlotSet("columnNames", list(column_names)) ]
def run(self, dispatcher, tracker, domain): config = {"user_key": "20c9c0971cf659fba29b5b9f78015f8d"} zomato = zomatopy.initialize_app(config) loc = tracker.get_slot('location') if loc is None: dispatcher.utter_message(template="utter_ask_location") return [] print("locations is: " + str(loc)) cuisine = tracker.get_slot('cuisine') if cuisine is None: dispatcher.utter_message(template="utter_ask_cuisine") return [SlotSet('location', loc)] print("cuisine is: " + str(cuisine)) price = tracker.get_slot('price') if price is None: dispatcher.utter_message(template="utter_ask_price_range") return [SlotSet('location', loc), SlotSet('cuisine', cuisine)] print("price range is: " + str(price)) people = tracker.get_slot('people') print("people is: " + str(people)) dispatcher.utter_message("Getting the restaurant details...\n\n") location_detail = zomato.get_location(loc, 1) d1 = json.loads(location_detail) lat = d1["location_suggestions"][0]["latitude"] lon = d1["location_suggestions"][0]["longitude"] cuisines_dict = { 'american': 1, 'chinese': 25, 'mexican': 73, 'italian': 55, 'north indian': 50, 'south indian': 85 } flag = 0 list_results = list() if price == '<=300': cheaper_restaurants = [] for val in range(0, 100, 20): results = zomato.restaurant_search_iteratively( loc, lat, lon, str(cuisines_dict.get(cuisine)), start=val, sort="price", order="asc") d = json.loads(results) cheaper_restaurants.extend(d['restaurants']) cheaper_restaurants = sorted( cheaper_restaurants, key=lambda restaurant: restaurant['restaurant']['user_rating'][ 'aggregate_rating'], reverse=True) list_results = [ self.get_restaurant_params(restaurant) for restaurant in cheaper_restaurants[:10] ] else: for val in range(0, 100, 20): results = zomato.restaurant_search_iteratively( loc, lat, lon, str(cuisines_dict.get(cuisine)), start=val, sort="rating", order="desc") d = json.loads(results) for restaurant in d['restaurants']: # Assuming average cost for single person is 75% of average cost of two person cost_for_two = restaurant['restaurant'][ 'average_cost_for_two'] if price == '300-700' and cost_for_two >= 300 and cost_for_two <= 700 and len( list_results) <= 10: print(self.get_restaurant_params(restaurant)) list_results.append( self.get_restaurant_params(restaurant)) if price == '>=700' and cost_for_two >= 700 and len( list_results) <= 10: print(self.get_restaurant_params(restaurant)) list_results.append( self.get_restaurant_params(restaurant)) if len(list_results) > 9: flag = 1 break if flag == 1: break print("list of results - {}".format(list_results)) dispatcher.utter_message("Showing you top rated restaurants:\n\ \n----------------------------------------------------\n") if len(list_results) > 0: final_strn_to_dispatch = "" for i, val in enumerate(list_results[:5]): print("Dispatching...." + str(val)) str1 = "{index}. {restaurant_name} in {restaurant_address} has been rated {rating}\ \nAverage Cost for two person is Rs. {avg_cost_2}\ \n----------------------------------------------------\n".format( index=i + 1, restaurant_name=val['Restaurant Name'], restaurant_address=val['Restaurant locality address'], rating=val['Zomato User Rating'], avg_cost_2=val['Average budget for two people']) final_strn_to_dispatch += str1 dispatcher.utter_message(final_strn_to_dispatch) f = open('restaurants.txt', "w") f.write(json.dumps(list_results)) else: dispatcher.utter_message("No results found..") return [SlotSet('location', loc)]
def run(self, dispatcher, tracker, domain): start_time = time.time() print("i am inside action_check_city") #dispatcher.utter_message("i am inside action_check_city") # Tier 1 and 2 cities listed in wikipedia: https://en.wikipedia.org/wiki/Classification_of_Indian_cities city_list = [ 'Ahmedabad', 'Bangalore', 'Chennai', 'Delhi', 'Hyderabad', 'Kolkata', 'Mumbai', 'Pune', 'Jaipur', 'Coimbatore', 'Agra', 'Ajmer', 'Aligarh', 'Amravati', 'Amritsar', 'Asansol', 'Aurangabad', 'Bareilly', 'Belgaum', 'Bhavnagar', 'Bhiwandi', 'Bhopal', 'Bhubaneswar', 'Bikaner', 'Bilaspur', 'Bokaro Steel City', 'Chandigarh', 'Cuttack', 'Dehradun', 'Dhanbad', 'Bhilai', 'Durgapur', 'Dindigul', 'Erode', 'Faridabad', 'Firozabad', 'Ghaziabad', 'Gorakhpur', 'Gulbarga', 'Guntur', 'Gwalior', 'Gurgaon', 'Guwahati', 'Hamirpur', 'Hubli-Dharwad', 'Indore', 'Jabalpur', 'Jalandhar', 'Jammu', 'Jamnagar', 'Jamshedpur', 'Jhansi', 'Jodhpur', 'Kakinada', 'Kannur', 'Kanpur', 'Karnal', 'Kochi', 'Kolhapur', 'Kollam', 'Kozhikode', 'Kurnool', 'Ludhiana', 'Lucknow', 'Madurai', 'Malappuram', 'Mathura', 'Mangalore', 'Meerut', 'Moradabad', 'Mysore', 'Nagpur', 'Nanded', 'Nashik', 'Nellore', 'Noida', 'Patna', 'Pondicherry', 'Purulia', 'Prayagraj', 'Raipur', 'Rajkot', 'Rajahmundry', 'Ranchi', 'Rourkela', 'Salem', 'Sangli', 'Shimla', 'Siliguri', 'Solapur', 'Srinagar', 'Surat', 'Thanjavur', 'Thiruvananthapuram', 'Thrissur', 'Trichy', 'Tirunelveli', 'Ujjain', 'Bijapur', 'Vadodara', 'Varanasi', 'Vijayawada', 'Visakhapatnam', 'Vellore', 'Warangal' ] cities = {} # Get the soundex code of each city and create a dictionary for city in city_list: cities.update({get_soundex(city): city}) # Considering the alternate colloquial names of the cities # Source: general knowledge and https://www.scoopwhoop.com/news/whats-in-a-name/#.45rdcz1m2 # Only those names are considered which generate different Soundex codes than the original city name cities_alt = { get_soundex('Bendakaluru'): 'Bangalore', get_soundex('Madras'): 'Chennai', get_soundex('New Delhi'): 'Delhi', get_soundex('Calcutta'): 'Kolkata', get_soundex('Bombay'): 'Mumbai', get_soundex('Belagavi'): 'Belgaum', get_soundex('Bokaro'): 'Bokaro Steel City', get_soundex('Hubli'): 'Hubli-Dharwad', get_soundex('Dharwad'): 'Hubli-Dharwad', get_soundex('Cawnpore'): 'Kanpur', get_soundex('Cochin'): 'Kochi', get_soundex('Calicut'): 'Kozhikode', get_soundex('Puducherry'): 'Pondicherry', get_soundex('Tanjore'): 'Thanjavur', get_soundex('Trivandrum'): 'Thiruvananthapuram', get_soundex('Trichinapoly'): 'Trichy', get_soundex('Tiruchirappalli'): 'Trichy', get_soundex('Baroda'): 'Vadodara', get_soundex('Banares'): 'Varanasi', get_soundex('Vizag'): 'Visakhapatnam', get_soundex('Vasai'): 'Mumbai', get_soundex('Virar'): 'Mumbai', get_soundex('Vasai-Virar City'): 'Mumbai' } # Get the user selected location loc = tracker.get_slot('location') # Check if the user selected city is in the list if get_soundex(loc) in cities.keys(): # Yes, get the correct city name city = cities[get_soundex(loc)] # else check if the name entered is the alternate name of the city elif get_soundex(loc) in cities_alt.keys(): # Yes, hence map it to the correct city name city = cities_alt[get_soundex(loc)] else: # City is not in the list city = 'unlisted' # Output pre-defined message if the city is not in the list if city == 'unlisted': dispatcher.utter_message( "Sorry, we don’t operate in this city. Please specify some other location" ) city_id = 'unlisted' return [SlotSet('location', city_id), UserUtteranceReverted()] # Zomato has a ID for each city. We need that to search for restaurants else: config = {"user_key": "f9c893da39750138e222b042c8070293"} zomato = zomatopy.initialize_app(config) location_detail = zomato.get_location(city, 1) d = json.loads(location_detail) city_id = d["location_suggestions"][0]["city_id"] print("--- %s seconds ---" % (time.time() - start_time)) return [SlotSet('location', city_id)]
def run(self, dispatcher, tracker, domain) -> List[EventType]: dispatcher.utter_message(template="utter_welcome_avatar") dispatcher.utter_message(template="utter_welcome_saludo") dispatcher.utter_message(template="utter_welcome_angel") dispatcher.utter_message(template="utter_welcome_continuar") return [SlotSet("conversacion_iniciada", False)]
def run(self, dispatcher, tracker, domain): print("i am inside action_check_price") # Default value of price range is mid range price_range = "2" # Get price range for two from the user price = tracker.get_slot('price') price = price.lower() print(price) # Price slot will either have values 1,2,3 (indicating low. mid and high range) or will have a string. For example: # 'less than 500', 'more than 300', '<300', etc. So logic should detect both these types and determine the price range accordingly # Upper limit words for the price range price_low = [ 'maximum', 'max', 'less than', 'lesser than', 'cheaper than' 'not more than', 'within', 'not above', '<=', '<' ] # Lower limit words for the price range price_hi = [ 'minimum', 'min', 'more than', 'higher than', 'not less than', 'not lesser than', 'not below', '>=', '>' ] # Remove the word Rupee or similar words if present as it is not needed rupee = ['rs.', 'rs', 'rupees.', 'rupee.', 'rupees', 'rupee'] for r in rupee: if r in price: price = price.replace(r, '') # Consider a special case where user specifies the price range himself # User could say "Find me restaurants between Rs.300 and Rs.500" # Check if there are two numbers present in the string if len(re.findall(r'\d+', price)) == 2: # Consider the upper limit as the price (e.g.: in Rs.300 and Rs.500, it will select 500) price = sorted(re.findall(r'\d+', price))[1] # If it is a pure number, then it is either the price range option (1, 2 or 3), or directly holds the amount if re.search(r'^[\s]*\d+[\s]*$', price): # Remove white spaces if any price = price.strip(" ") # Check if the user has chosen using the dropdown i.e. if the slot 'price' already has the value 1, 2 or 3 if float(price) in range(1, 4): # If yes, then correct price range is mentioned price_range = price # Check if the user has directly input the price range, then assign the proper value to the slot 'price' accordingly elif float(price) < 300: # It is in low price range price_range = "1" elif (float(price) >= 300) and (float(price) <= 700): # It is in mid price range price_range = "2" elif float(price) > 700: # It is in high price range price_range = "3" else: # Price is not mentioned # Choose default i.e. mid range price_range = "2" # It is not a pure number. It means it contains a string. Extract the price (which will be a number) and determine the price range else: # At first, three special cases are considered: # User could say "Find me restaurants below Rs. 500" or he could say "Find me restaurants not below Rs. 500" # First case is finding a cheaper restaurant and second case is finding an expensive restaurant if ('below' in price) and ('not' not in price): price = price.replace('below', 'less than') # User could say "Find me restaurants above Rs. 500" or he could say "Find me restaurants not above Rs. 500" # First case is finding an expensive restaurant and second case is finding a cheaper restaurant if ('above' in price) and ('not' not in price): price = price.replace('above', 'more than') # User could say "Find me restaurants priced = 500" # '=' can be considered as user wants to consider restaurant budget below that amount if ('=' in price) and ('>=' not in price) and ('<=' not in price): price = price.replace('=', 'less than') # If the user has provided the upper limit for the price range # (for example "within Rs.400", "cheaper than Rs.500", etc) for p in price_low: if p in price: # Extract the amount amount = float(re.findall(r'\d+', price)[0]) if amount < 300: # It is in low price range price_range = "1" elif (amount >= 300) and (amount <= 700): # It is in mid price range price_range = "2" elif amount > 700: # It is in high price range price_range = "3" else: # Choose default i.e. mid range price_range = "2" break # If the user has provided the lower limit for the price range # (for example "minimum Rs.400", "more than Rs.500", etc) for p in price_hi: if p in price: # Extract the amount amount = float(re.findall(r'\d+', price)[0]) if 700 < amount: # It is in high price range price_range = "3" elif (700 >= amount) and (300 <= amount): # It is in mid price range price_range = "2" elif 300 > amount: # It is in low price range price_range = "1" else: # Choose default i.e. mid range price_range = "2" break print(price_range) return [SlotSet('price', price_range)]
def run(self, dispatcher, tracker, domain) -> List[EventType]: dispatcher.utter_message(template="utter_comencemos") dispatcher.utter_message(template="utter_informar_privacidad") dispatcher.utter_message(template="utter_pedir_nombre") return [SlotSet("shown_privacy", True), SlotSet("conversacion_iniciada", True)]
def deactivate(self) -> List[EventType]: """Return `Form` event with `None` as name to deactivate the form and reset the requested slot""" logger.debug(f"Deactivating the form '{self.name()}'") return [Form(None), SlotSet(REQUESTED_SLOT, None)]
def run(self, dispatcher, tracker, domain): response_message = "" email_message = "" search_validity = "valid" budget = tracker.get_slot("budget") location = tracker.get_slot("location") cuisine = tracker.get_slot("cuisine") if not location: search_validity = "invalid" else: """ retrieve location details """ response = api_zomato.get_location(location) location_details = {} if response is not None: response_json = json.loads(response) if response_json["status"] == "success": """ fetch location details and store 'city_id' """ location_details = response_json["location_suggestions"][0] city_id = location_details["city_id"] city_name = location_details["city_name"] """ Validate if the location details is of the requested location """ if location.lower() == city_name.lower(): """ fetch all cuisines available in the location """ response_cuisine = api_zomato.get_cuisines(city_id) supported_cuisines_names = [ "American", "Chinese", "Italian", "Mexican", "North Indian", "South Indian", ] """ filter only supported cuisines """ filtered_cuisine = { key: value for key, value in response_cuisine.items() if value in supported_cuisines_names } if cuisine is not None: cuisine_list = [ key for key, value in filtered_cuisine.items() if str(value).lower() == cuisine.lower() ] else: cuisine_list = [ key for key, value in filtered_cuisine.items() ] restaurants_found = self.search_restaurant( location, location_details, cuisine_list) if len(restaurants_found) > 0: restaurant_filtered_budget = self.filter_restaurant_by_budget( budget, restaurants_found) number_of_records = 10 if len(restaurant_filtered_budget) < 10: number_of_records = len( restaurant_filtered_budget) for indx in range(0, number_of_records): restaurant = restaurant_filtered_budget[indx] if indx < 5: response_message = (response_message + "\n " + str(indx + 1) + ". " + restaurant["name"] + " in " + restaurant["address"] + " has been rated " + restaurant["rating"] + " out of 5" + "\n") email_message = ( email_message + "\n " + str(indx + 1) + ". " + restaurant["name"] + " in " + restaurant["address"] + " has been rated " + restaurant["rating"] + " out of 5. " + "Average cost for 2 : " + str(restaurant["avg_cost_for_2"]) + "\n") else: search_validity = "invalid" else: search_validity = "invalid" else: search_validity = "invalid" else: search_validity = "invalid" if search_validity == "valid": dispatcher.utter_message(response_message) return [ SlotSet("search_validity", search_validity), SlotSet("email_message", email_message) ]
def run(self, dispatcher, tracker, domain): config={ "user_key":"63163217253a26f16084d1dfb85e0f02"} zomato = zomatopy.initialize_app(config) loc = tracker.get_slot('location') cuisine = tracker.get_slot('cuisine') price = tracker.get_slot('price') location_detail=zomato.get_location(loc, 1) d1 = json.loads(location_detail) lat=d1["location_suggestions"][0]["latitude"] lon=d1["location_suggestions"][0]["longitude"] city_id=d1["location_suggestions"][0]["city_id"] cuisines_dict={'american': 1, 'andhra': 2, 'asian': 3, 'arabian': 4, 'bakery': 5, 'afghani': 6,'biryani': 7, 'bengali': 10, 'chettinad': 18, 'burmese': 22, 'chinese': 25, 'raw meats': 27,'cafe': 30, 'continental': 35, 'european': 38, 'fast food': 40, 'french': 45, 'goan': 47,'gujarati': 48, 'hyderabadi': 49, 'north indian': 50, 'italian': 55, 'japanese': 60, 'kerala': 62,'konkan': 63, 'kashmiri': 65, 'lebanese': 66, 'korean': 67, 'malaysian': 69, 'mediterranean': 70,'malwani': 71, 'mangalorean': 72, 'mexican': 73, 'mongolian': 74, 'mughlai': 75, 'pizza': 82,'seafood': 83, 'south indian': 85, 'portuguese': 87, 'rajasthani': 88, 'spanish': 89, 'street food': 90,'tibetan': 93, 'thai': 95, 'vietnamese': 99, 'desserts': 100, 'maharashtrian': 102, 'indonesian': 114,'nepalese': 117, 'singaporean': 119, 'cantonese': 121, 'australian': 131, 'belgian': 132, 'british': 133,'german': 134, 'middle eastern': 137, 'pakistani': 139, 'iranian': 140, 'steak': 141, 'turkish': 142,'healthy food': 143, 'egyptian': 146, 'moroccan': 147, 'indian': 148, 'tex-mex': 150,'greek': 156,'lucknowi': 157, 'brazilian': 159, 'coffee and tea': 161, 'peruvian': 162, 'tea': 163, 'juices': 164,'assamese': 165, 'burger': 168, 'armenian': 175, 'sushi': 177, 'kebab': 178, 'grill': 181, 'patisserie': 183,'deli': 192, 'bbq': 193, 'brasserie': 195, 'pan asian': 209, 'swiss': 213, 'israeli': 218, 'bar food': 227,'north eastern': 231, 'ice cream': 233, 'bubble tea': 247, 'drinks only': 268, 'oriya': 269, 'beverages': 270,'finger food': 271, 'fusion': 274, 'oriental': 278, 'parsi': 290, 'awadhi': 292, 'modern european': 294,'fish and chips': 298, 'sandwich': 304, 'vegetarian': 308, 'satay': 312, 'asian fusion': 401, 'falafel': 571,'eastern european': 651, 'crepes': 881, 'modern australian': 969, 'chili': 971, 'south american': 972,'yum cha': 978, 'dumplings': 985, 'panini': 989, 'sindhi': 993, 'charcoal chicken': 994, 'salad': 998,'roast chicken': 1005, 'bihari': 1013, 'cuisine varies': 1014, 'mithai': 1015, 'modern indian': 1018,'hot pot': 1022, 'rolls': 1023, 'wraps': 1024, 'fried chicken': 1025, 'bohri': 1032, 'vegan': 1034,'cafe food': 1039, 'coffee': 1040, 'paan': 1048} list1 = [0, 20, 40, 60, 80] d = [] for i in list1: results = zomato.restaurant_search("", lat, lon, str(cuisines_dict.get(cuisine)), limit=i) d1 = json.loads(results) d.extend(d1['restaurants']) response = [] if len(d) == 0: response = [] else: for restaurant in d: if str(price) == 'lesser than 300': if restaurant['restaurant']['average_cost_for_two'] <300: response.append([restaurant['restaurant']['name'],restaurant['restaurant']['location']['address'],restaurant['restaurant']['average_cost_for_two'],float(restaurant['restaurant']['user_rating']['aggregate_rating'])]) else: response elif str(price) == 'between 300 to 700': if 300 <= restaurant['restaurant']['average_cost_for_two'] <700: response.append([restaurant['restaurant']['name'],restaurant['restaurant']['location']['address'],restaurant['restaurant']['average_cost_for_two'],float(restaurant['restaurant']['user_rating']['aggregate_rating'])]) else: response else: if restaurant['restaurant']['average_cost_for_two'] >=700: response.append([restaurant['restaurant']['name'],restaurant['restaurant']['location']['address'],restaurant['restaurant']['average_cost_for_two'],float(restaurant['restaurant']['user_rating']['aggregate_rating'])]) else: response if len(response) == 0: dispatcher.utter_message("Sorry, we couldn't find any restaurant in given budget/location/cuisine.") else: response = sorted(response, key=operator.itemgetter(3), reverse=True) top5 = response[:5] response_display = 'Showing you top 5 results in your budget range :' +"\n" + "\n" j = 0 for i in top5: j = j + 1 response_display = response_display + str(j) + ". " + i[0] + ' in ' + i[1] + ' has been rated ' + str(i[3]) + "\n" + "\n" dispatcher.utter_message("-----"+str(response_display)) response_email = "Hi," + "\n" + "\n" 'Here is the list of the restaurants you requested - ' + "\n" top10 = response[:10] k = 0 for i in top10: k = k + 1 response_email = response_email + str(k) + ". " + i[0] + ' in ' + i[1] + ' has been rated - ' + str(i[3]) + ' and has average price for two people - Rs.' + str(i[2]) +"\n" + "\n" response_email = response_email + "Thanks," + "\n" + "Restaurant Chatbot" return [SlotSet('search_results',response_display),SlotSet('email_results',response_email )]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: return [SlotSet("airport", None)]
def run(self, dispatcher, tracker, domain): print("Reseting main slot") return [SlotSet("main", None), SlotSet("satisfied", None)]
async def run(self, dispatcher, tracker, domain): return [SlotSet("test", self.some_common_feature())]
def run(self, dispatcher, tracker, domain): return [SlotSet("dietary", None), SlotSet("satisfied", None)]
@pytest.mark.parametrize( "slots,expected_slots", [ ( { SLOT_MENTION: None, SLOT_ATTRIBUTE: None, SLOT_OBJECT_TYPE: "restaurant", SLOT_LISTED_OBJECTS: None, SLOT_LAST_OBJECT: None, SLOT_LAST_OBJECT_TYPE: None, }, [ SlotSet(SLOT_MENTION, None), SlotSet(SLOT_ATTRIBUTE, None), SlotSet(SLOT_OBJECT_TYPE, "restaurant"), SlotSet(SLOT_LAST_OBJECT, None), SlotSet(SLOT_LAST_OBJECT_TYPE, "restaurant"), SlotSet(SLOT_LISTED_OBJECTS, [3, 2, 1]), ], ), ( { SLOT_MENTION: None, SLOT_ATTRIBUTE: None, SLOT_OBJECT_TYPE: "restaurant", SLOT_LISTED_OBJECTS: None, SLOT_LAST_OBJECT: None, SLOT_LAST_OBJECT_TYPE: "restaurant",
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: score = tracker.get_slot("scope_counter") score = score + 1 return [SlotSet("scope_counter", score)]
async def run(self, dispatcher, tracker, domain): start_time = time.time() #print("i am inside action_search_restaurants") # My API Key of Zomato config = {"user_key": "f9c893da39750138e222b042c8070293"} zomato = zomatopy.initialize_app(config) # Price range determination price = tracker.get_slot('price') print(price) # Get the user selected cuisine # Slot 'cuisine' would have been updated in the ActionCheckCuisine() with correct cuisine name cuisine = tracker.get_slot('cuisine') print(cuisine) # Get the user selected location # Slot 'location' would have been updated in the ActionCheckCity() with correct city ID as per Zomato API city_id = tracker.get_slot('location') print(city_id) # Check if slots are correctly filled or not # If location slot is not filled, ask for city name if city_id == None: print("no city entered 1") # As per https://rasa.com/docs/action-server/sdk-dispatcher/ dispatcher.utter_message(template="utter_ask_location") return [FollowupAction("action_listen")] # Slot is filled but action was not carried out elif get_last_action(tracker.events, "action_check_city") == False: print("no city entered 2") return [FollowupAction("action_check_city")] # If cuisine slot is not filled, ask for cuisine if cuisine == None: print("no cuisine entered 1") dispatcher.utter_message(template="utter_ask_cuisine") return [FollowupAction("action_listen")] # Slot is filled but action was not carried out elif get_last_action(tracker.events, "action_check_cuisine") == False: print("no cuisine entered 2") return [FollowupAction("action_check_cuisine")] # If price slot is not filled, ask for price range if price == None: print("no price entered 1") dispatcher.utter_message(template="utter_ask_price_range") return [FollowupAction("action_listen")] # Slot is filled but action was not carried out elif get_last_action(tracker.events, "action_check_price") == False: print("no price entered 2") return [FollowupAction("action_check_price")] # Cuisines code (used by zomato) # Source: https://developers.zomato.com/documentation?lang=tr#/ cuisines_dict = { 'american': 1, 'chinese': 25, 'mexican': 73, 'italian': 55, 'north indian': 50, 'south indian': 85 } # Prepare the response response = [] initialResponse = "" # As long as there is a valid location specified if (city_id != 'unlisted'): # get_location gets the lat-long coordinates of 'loc' #location_detail = zomato.get_location(loc, 1) # Store retrieved data as a dict #d = json.loads(location_detail) #city_id = d["location_suggestions"][0]["city_id"] # Fetch results # If cuisine is specified, then use that to search restaurants if (cuisine != 'unlisted'): count = 0 #Zomato api only lets us fetch 100 records, after that it starts returning blank json for offset in range(0, 100, 20): #results = zomato.restaurant_search_by_city(city_id, str(cuisines_dict[cuisine]), offset) loop = asyncio.get_event_loop() if loop.is_running() == False: results = asyncio.run( zomato.restaurant_search_by_city_async( city_id, str(cuisines_dict[cuisine]), offset)) else: results = await zomato.restaurant_search_by_city_async( city_id, str(cuisines_dict[cuisine]), offset) d1 = json.loads(results) if offset == 0: maxData = d1['results_found'] if (count >= 10) or (offset > maxData): break # If no results match with the user mentioned criteria if maxData == 0: initialResponse = "No restaurants found matching your criteria" dispatcher.utter_message(initialResponse) else: initialResponse = "Here are the top rated restaurants as per your criteria:" + "\n" for restaurant in d1['restaurants']: if count >= 10: break # Getting Top 10 restaurants for the lower price range if ((float(price) == 1) and (restaurant['restaurant'] ['average_cost_for_two'] < 300) and (cuisine.title() in restaurant['restaurant']['cuisines'])): response.append( str(restaurant['restaurant']['name']) + " in " + str(restaurant['restaurant'] ['location']['address']) + " has a rating of " + str(restaurant['restaurant']['user_rating'] ['aggregate_rating']) + ".") response.append("The average price of Rs." + str(restaurant['restaurant'] ['average_cost_for_two']) + " for two persons" + "\n") count = count + 1 # Getting Top 10 restaurants for the mid price range elif ((float(price) == 2) and (restaurant['restaurant'] ['average_cost_for_two'] >= 300) and (restaurant['restaurant'] ['average_cost_for_two'] <= 700) and (cuisine.title() in restaurant['restaurant']['cuisines'])): response.append( str(restaurant['restaurant']['name']) + " in " + str(restaurant['restaurant'] ['location']['address']) + " has a rating of " + str(restaurant['restaurant']['user_rating'] ['aggregate_rating']) + "\n") response.append("The average price of Rs." + str(restaurant['restaurant'] ['average_cost_for_two']) + " for two persons" + "\n") count = count + 1 # Getting Top 10 restaurants for the higher price range elif ((float(price) == 3) and (restaurant['restaurant'] ['average_cost_for_two'] > 700) and (cuisine.title() in restaurant['restaurant']['cuisines'])): response.append( str(restaurant['restaurant']['name']) + " in " + str(restaurant['restaurant'] ['location']['address']) + " has a rating of " + str(restaurant['restaurant']['user_rating'] ['aggregate_rating']) + "\n") response.append("The average price of Rs." + str(restaurant['restaurant'] ['average_cost_for_two']) + " for two persons" + "\n") count = count + 1 # Cuisine is not specified, hence search for all cuisine types else: count = 0 #print("inside else cuisine") for offset in range(0, 100, 20): #results = zomato.restaurant_search_by_city(city_id, "", offset) loop = asyncio.get_event_loop() if loop.is_running() == False: results = asyncio.run( zomato.restaurant_search_by_city_async( city_id, '', offset)) else: results = await zomato.restaurant_search_by_city_async( city_id, '', offset) d1 = json.loads(results) if (count >= 10) or (offset > d1['results_found']): break # If no results match with the user mentioned criteria if d1['results_found'] == 0: initialResponse = "No restaurants found matching your criteria" dispatcher.utter_message(initialResponse) else: initialResponse = "Here are the top rated restaurants as per your criteria:" + "\n" for restaurant in d1['restaurants']: if count >= 10: break # Getting Top 10 restaurants for the lower price range if ((float(price) == 1) and (restaurant['restaurant'] ['average_cost_for_two'] < 300)): response.append( str(restaurant['restaurant']['name']) + " in " + str(restaurant['restaurant'] ['location']['address']) + " has a rating of " + str(restaurant['restaurant']['user_rating'] ['aggregate_rating']) + ".") response.append("The average price of Rs." + str(restaurant['restaurant'] ['average_cost_for_two']) + " for two persons" + "\n") count = count + 1 # Getting Top 10 restaurants for the mid price range elif ((float(price) == 2) and (restaurant['restaurant'] ['average_cost_for_two'] >= 300) and (restaurant['restaurant'] ['average_cost_for_two'] <= 700)): response.append( str(restaurant['restaurant']['name']) + " in " + str(restaurant['restaurant'] ['location']['address']) + " has a rating of " + str(restaurant['restaurant']['user_rating'] ['aggregate_rating']) + "\n") response.append("The average price of Rs." + str(restaurant['restaurant'] ['average_cost_for_two']) + " for two persons" + "\n") count = count + 1 # Getting Top 10 restaurants for the higher price range elif ((float(price) == 3) and (restaurant['restaurant'] ['average_cost_for_two'] > 700)): response.append( str(restaurant['restaurant']['name']) + " in " + str(restaurant['restaurant'] ['location']['address']) + " has a rating of " + str(restaurant['restaurant']['user_rating'] ['aggregate_rating']) + "\n") response.append("The average price of Rs." + str(restaurant['restaurant'] ['average_cost_for_two']) + " for two persons" + "\n") count = count + 1 # If no results obtained if (count == 0): initialResponse = "Sorry, No results found for your criteria. Please type modified criteria?" dispatcher.utter_message(initialResponse) return [Restarted()] # Display the results else: dispatcher.utter_message(initialResponse) for res in response[::2][:5]: dispatcher.utter_message(res) # If no valid location is given else: response = "Sorry, we don’t operate in this city. Please specify some other location" dispatcher.utter_message(response) print(offset) print("--- %s seconds ---" % (time.time() - start_time)) return [SlotSet('emailmsg', response)]
def run(self, dispatcher, tracker, domain): loc = tracker.get_slot('location') cuisine = tracker.get_slot('cuisine') price = tracker.get_slot('price') print(price) location_detail = zomato.get_location(loc, 1) d1 = json.loads(location_detail) lat = d1["location_suggestions"][0]["latitude"] lon = d1["location_suggestions"][0]["longitude"] cuisines_dict = { 'mexican': 5, 'chinese': 25, 'american': 30, 'italian': 55, 'north indian': 50, 'south indian': 85 } results = zomato.restaurant_search("", lat, lon, str(cuisines_dict.get(cuisine)), 10) d = json.loads(results) def list_sort(list): list.sort(key=lambda x: x[3]) return list def Reverse(lst): return [ele for ele in reversed(lst)] global email_data global reverse_list response = "" if d['results_found'] == 0: response = "no results" else: email_data.clear() if price == 'Lesser than Rs. 300': for i, restaurant in enumerate(d['restaurants']): averageCostFor2 = restaurant['restaurant'][ 'average_cost_for_two'] if averageCostFor2 <= 300: name = restaurant['restaurant']['name'] address = restaurant['restaurant']['location'][ 'address'] # averageCostFor2 = restaurant['restaurant']['average_cost_for_two'] userrating = restaurant['restaurant']['user_rating'][ 'aggregate_rating'] temp_list = [ name, address, averageCostFor2, userrating ] email_data.append(temp_list) # if len(email_data) == 6: # break elif price == 'Rs. 300 to 700': for i, restaurant in enumerate(d['restaurants']): averageCostFor2 = restaurant['restaurant'][ 'average_cost_for_two'] if averageCostFor2 >= 300 and averageCostFor2 <= 700: name = restaurant['restaurant']['name'] address = restaurant['restaurant']['location'][ 'address'] # averageCostFor2 = restaurant['restaurant']['average_cost_for_two'] userrating = restaurant['restaurant']['user_rating'][ 'aggregate_rating'] temp_list = [ name, address, averageCostFor2, userrating ] email_data.append(temp_list) # if len(email_data) == 6: # break elif price == 'More than 700': for i, restaurant in enumerate(d['restaurants']): averageCostFor2 = restaurant['restaurant'][ 'average_cost_for_two'] if averageCostFor2 >= 700: name = restaurant['restaurant']['name'] address = restaurant['restaurant']['location'][ 'address'] # averageCostFor2 = restaurant['restaurant']['average_cost_for_two'] userrating = restaurant['restaurant']['user_rating'][ 'aggregate_rating'] temp_list = [ name, address, averageCostFor2, userrating ] email_data.append(temp_list) # if len(email_data) == 6: # break sorted_value = list_sort(email_data) print(sorted_value) reverse_list = Reverse(sorted_value) def Enquiry(lis1): if not lis1: return 1 else: return 0 search_validity = "invalid" if Enquiry(sorted_value) == 0: for i, x in enumerate(reverse_list): response = "NAME : " + str(x[0]) + " ADDRESS : " + str( x[1]) + " USER RATING : " + str(x[3]) #search_validity = "valid" #print(search_validity) dispatcher.utter_message(response) if i == 4: break return [SlotSet('search_validity_ok', True)] else: search_validity = "invalid" print(search_validity) dispatcher.utter_message("Sorry no result found ") return [SlotSet("search_validity", search_validity)]
def run(self, dispatcher, tracker, domain) -> List[EventType]: problem = tracker.latest_message.get("text") return [SlotSet("problem_description", problem)]