def yelpSearch(term, location): yelp_api = YelpAPI (application.config['YELP_API_KEY']) result = yelp_api.search_query(term=term,location=location) response = jsonify(result) response.headers.add('Access-Control-Allow-Origin', application.config['ALLOWED_DOMAIN']) return response
def return_restaurant(location_name): api_key = "###############" yelp_api = YelpAPI(api_key) # pprint(yelp_api.search_query(term='restaurant', location=location_name, sort_by='rating', limit=5)) results = yelp_api.search_query(term='restaurant', location=location_name, limit=5)['businesses'] print('connected') all_restaurant = [] for i in range(5): name = '' display_phone = '' price = '' rating = '' url = '' if 'name' in results[i]: name = results[i]['name'] if 'display_phone' in results[i]: display_phone = results[i]['display_phone'] if 'price' in results[i]: price = results[i]['price'] if 'rating' in results[i]: rating = results[i]['rating'] if 'url' in results[i]: url = results[i]['url'] temp_restaurant = Restaurant_info(name, display_phone, price, rating, url) # all_restaurant.append({'name':name, 'display_phone':display_phone,'price':price,'rating':rating,'url':url}) all_restaurant.append(temp_restaurant) return all_restaurant
def interact_form(): s = """<!DOCTYPE html> <html> <body> <form action='/problem4form' method='POST'> <h1>Look for the best restaurants in your area!</h1> ENTER CITY HERE:<br> <input type="text" name="restaurants" value=""> <br> <input type="submit" value="Submit"> </form> </body> </html>""" # Yelp api yelp_api = YelpAPI(yelp_info.client_id, yelp_info.client_secret) #list for the results restaurant_name = "" if request.method == 'POST': loc = request.form['restaurants'] yelp = yelp_api.search_query(term='restaurant', location=loc, sort_by='rating', limit=3, radius=40000) for restaurant in yelp["businesses"]: restaurant_name = restaurant_name + ", " + restaurant['name'] return s + '<br><br>' + "<h1>Try out these restaurants!</h1>" + restaurant_name[ 2:] else: return s
def get_info_from_api(consumer_key, consumer_secret, token, token_secret, district, categories): yelp_api = YelpAPI(consumer_key, consumer_secret, token, token_secret) dictRest = {} offset = [0] for j in district: for category in categories: for k in offset: search_results = yelp_api.search_query(term=category, location=j, offset=k, limit=20) list_Business = search_results["businesses"] if len(list_Business) <> 0: for i in list_Business: if i["location"].has_key("coordinate") and i.has_key( "categories"): busi_id = i["id"] if busi_id not in dictRest.keys(): busi_info = {} busi_info["name"] = i["name"] busi_info["categories"] = i["categories"] busi_info["rating"] = i["rating"] busi_info["url"] = i["url"] busi_info["longitude"] = i["location"][ "coordinate"]["longitude"] busi_info["latitude"] = i["location"][ "coordinate"]["latitude"] dictRest[busi_id] = busi_info return dictRest
def yelp_search(coords=(-122.4392, 37.7474)): yelp_api = YelpAPI(client_id, client_secret) search_results = yelp_api.search_query(categories='tacos', longitude=coords[0], latitude=coords[1], limit=10) return search_results
def post(self, request): yelp_api = YelpAPI('4eeWvgRSP72tOmZaghWTvQ', 'K88plDw1UnwjACzBophf6Du578c', 'uKfMmBjcu1_JXCj5aS1o9foFOB8VpN4q', 'DRi5uRtvXpyXSRUxhf_8SaQ52LI') search_results = yelp_api.business_query(request.DATA.get('name')) return Response({'results': search_results.get('reviews')})
def __init__(self): self.business_match = mongodb.db.business_match self.business_details = mongodb.db.business_details self.business_reviews = mongodb.db.business_reviews self.yelp_req = mongodb.db.yelp_request self.yelp_api = YelpAPI(app.config['YELP_API_KEY']) self.response = None
def food(jenni, input): if not hasattr(jenni.config, 'yelp_api_credentials'): return yelp_api = YelpAPI(jenni.config.yelp_api_credentials['consumer_key'], jenni.config.yelp_api_credentials['consumer_secret'], jenni.config.yelp_api_credentials['token'], jenni.config.yelp_api_credentials['token_secret']) location = input.group(2) if not location: jenni.say("Please enter a location.") return done = False max_offset = 5 try: while not done: offset = random.randint(0, max_offset) response = yelp_api.search_query(category_filter="restaurants", location=location, limit=20, offset=offset) if len(response['businesses']) > 0: done = True jenni.say("How about, " + response['businesses'][random.randint(0, len(response['businesses']) - 1)]['name'] + "?") else: max_offset = offset - 1 except YelpAPI.YelpAPIError: jenni.say("Invalid location!")
def process_search(request): form = request.GET # print(form) # googlemaps display googlemaps_url = f"https://www.google.com/maps/embed/v1/search?key={googlemap_key}&q={form['food_type']}+in+{form['location']}" request.session['search_url'] = googlemaps_url # print(googlemaps_url) # yelpapi call yelp_api = YelpAPI(yelp_key) businesses = yelp_api.search_query(term=form['food_type'], location=form['location'], sort_by='rating', limit=5)['businesses'] # shape the response (name, image_url, url) # pprint.pprint(businesses) restaurant = {} result = [] for business in businesses: for k, v in business.items(): if k == "name" or k == "image_url" or k == "url": restaurant[k] = v result.append(restaurant) restaurant = {} request.session['top_restaurants'] = result context = {'googlemaps_url': googlemaps_url, 'top_restaurants': result} return render(request, 'roundtable/partials/rests_map.html', context)
def get_info_from_api(consumer_key, consumer_secret, token, token_secret, district, categories): yelp_api = YelpAPI(consumer_key, consumer_secret, token, token_secret) dictRest = {} offset = [0] for j in district: for category in categories: for k in offset: search_results=yelp_api.search_query(term = category,location = j,offset = k,limit = 20) list_Business=search_results["businesses"] if len(list_Business) <> 0: for i in list_Business: if i["location"].has_key("coordinate") and i.has_key("categories"): busi_id=i["id"] if busi_id not in dictRest.keys(): busi_info = {} busi_info["name"] = i["name"] busi_info["categories"] = i["categories"] busi_info["rating"] = i["rating"] busi_info["url"] = i["url"] busi_info["longitude"] = i["location"]["coordinate"]["longitude"] busi_info["latitude"] = i["location"]["coordinate"]["latitude"] dictRest[busi_id] = busi_info return dictRest
def get_restaurants_seach(): location = request.args.get('location') longitude = request.args.get('longitude') latitude = request.args.get('latitude') categories = request.args.get('categories') price = request.args.get('price') sort_by = request.args.get('sort_by') yelp_res = YelpAPI(API_KEY).search_query(location=location, longitude=longitude, latitude=latitude, categories=categories, price=price, sort_by=sort_by, limit=5) yelp_list = yelp_res["businesses"] biz_list = [] user_id = session['user_id'] user = crud.get_user_by_id(user_id) for idx in range(len(yelp_list)): yelp_id = yelp_list[idx]["id"] res = crud.get_restaurant_by_id(yelp_id) group_name = None if 'group_name' in request.cookies: group_name = request.cookies["group_name"] like = crud.get_like(user, res, group_name) biz = YelpAPI(API_KEY).business_query(id=yelp_id) biz_res = restaurant_from_yelp(biz, like, like_count=0) biz_list.append(biz_res) return jsonify({"businesses": biz_list})
def nearby_yelp(latitude, longitude): #from https://github.com/gfairchild/yelpapi #doc: http://www.yelp.com/developers/documentation/v2/search_api #Sort mode: 0=Best matched (default), 1=Distance, 2=Highest Rated yconsumer_key = '6IZDGF5Bck3MP6zU0lFgLQ' yconsumer_secret = 'dZR4dJJpYUAETKH82yzv2nkXitM' ytoken = 'YtSoZfbmiWxfLg87GGoLUsC_wcx8wUtO' ytoken_secret = 'z9pDq7T0Pa_CwfQOMmF1XM4dhhQ' max_yelp_radius = 10000 print YelpAPI(yconsumer_key, yconsumer_secret, ytoken, ytoken_secret) yelp_api = YelpAPI(yconsumer_key, yconsumer_secret, ytoken, ytoken_secret) llvar = str(latitude) + ',' + str(longitude) search_results = yelp_api.search_query(ll=llvar, limit=20, sort=0, radius_filter=rdist) #Make certain the farthest away places are still within your radius for i in search_results.get('businesses'): if i.get('distance') > max_yelp_radius: index = search_results.get('businesses').index(i) #find the index of it del search_results.get('businesses')[index] return search_results
class YelpScraper: """ Right now it's basically a wrapper for YelpAPI object. Example y = YelpScraper('API KEY') res = y.get_pois(34.140940, -118.127974, 5000) # Search near Pasadena biz_id = res['businesses'][0]['id'] y.get_poi_features(biz_id) """ def __init__(self, api_key): self.yelp = YelpAPI(api_key) def get_pois(self, latitude, longitude, radius): """ Search Yelp for points of interest near the given latitude and longitude. https://www.yelp.com/developers/documentation/v3/business_search :param latitude: Decimal latitude. :param longitude: Decimal latitude. :param radius: Search radius in *meters*. """ return self.yelp.search_query(latitude=latitude, longitude=longitude, radius=radius) def get_poi_features(self, yelpid): """ Get details about a specific point of interest, given its Yelp ID. """ return self.yelp.business_query(yelpid)
def yelpSearch(store, city="Edmonton" ): #Search the store name on Yelp to find its classifications #my specific key yelp_api = YelpAPI( "BkeVvBepP5xWd8hfOi_Pud4wx3d1NWAx7XV_oopCygqKDNuJyE1MBr5TqGhNlBf1KM-cVcz05YsyTGkAkeVq73yTbwbER51fVxc9Qq4vGBhwtCQkjZvPP9LBkvNDXHYx" ) #search yelp for the resturant op = yelp_api.search_query(term=store, location=city, sort_by='rating', limit=5) title1 = '' title2 = '' title = [] #find the descriptors of the buisness try: title1 = op['businesses'][0]['categories'][0]['title'] except IndexError: print('Retailer not Recognized') try: title2 = op['businesses'][0]['categories'][1]['title'] except IndexError: pass title.append(title1) title.append(title2) return title
def food(jenni, input): if not hasattr(jenni.config, 'yelp_api_credentials'): return yelp_api = YelpAPI(jenni.config.yelp_api_credentials['consumer_key'], jenni.config.yelp_api_credentials['consumer_secret'], jenni.config.yelp_api_credentials['token'], jenni.config.yelp_api_credentials['token_secret']) location = input.group(2) if not location: jenni.say("Please enter a location.") return done = False max_offset = 5 try: while not done: offset = random.randint(0, max_offset) response = yelp_api.search_query(category_filter="restaurants", location=location, limit=20, offset=offset) if len(response['businesses']) > 0: done = True jenni.say("How about, " + response['businesses'][random.randint( 0, len(response['businesses']) - 1)]['name'] + "?") else: max_offset = offset - 1 except YelpAPI.YelpAPIError: jenni.say("Invalid location!")
def main(): consumer_key = "z5lwUGdh0deaEbvRhUwCKw" consumer_secret = "Tq7QBqhKIKyNBlOEGYzJK0UrLHc" token = "QwkD6OQ_h3zslXmnTyoitk5vZqhSt8pv" token_secret = "95Oyv0QdB_v6ghyi87oe8AtPkBo" yelp_api = YelpAPI(consumer_key, consumer_secret, token, token_secret) args = {"term": "food", "location": "San Fransciso"} response = yelp_api.search_query(term = "food", location="Menlo Park") params = {"oauth_consumer_key": consumer_key, "oauth_token": token, "oauth_signature_method": "HMAC-SHA1", "oauth_signature": token_secret, "oauth_timestamp": int(time.time()), "oauth_nonce": uuid.uuid4() } #url = "https://api.yelp.com/v2/search?term=food&location=San+Francisco" #response = requests.get(url, params=params) rand = random.randint(0,len(response['businesses'])) while rand < 4: if response['businesses'][rand]['rating'] >= 4: break else: rand = random.randint(0,len(response['businesses'])) rec_rest = {'restaurant': response['businesses'][rand]['name'], 'rating': response['businesses'][rand]['rating']} for i in range(len(response['businesses'])): if response['businesses'][i]['rating'] >= 4: print({'restaurant': response['businesses'][i]['name'], 'rating': response['businesses'][i]['rating']}) else: pass print('\n',rec_rest,sep='')
def min_query(self, term, limit=5, category='', radius=None, location='washington, dc', sort=0, offset=0): '''A minimal query that returns a simple dictionary with the following key values. The values returned include name, phone, display phone, location, categories, yelp rating, yelp review count, a rating image url, yelp url, and yelp mobile url To simplify/minimize location, we return the neighborhood if available, else we return the city.''' # create YelpAPI object yelp_query = YelpAPI(self.consumer_key, self.consumer_secret, self.token, self.token_secret) response = yelp_query.search_query(term=term, category_filter=category, limit=limit, radius_filter=radius, location=location, sort=sort, offset=offset) print response min_response = [] for entry in response['businesses']: if 'neighborhoods' in entry['location'].keys(): location = entry['location']['neighborhoods'][0] elif 'city' in entry['location']: location = entry['location']['city'] else: location = 'No neighborhood or city listed :(' categories = '' if 'categories' in entry.keys(): for value in entry['categories'][:-1]: categories = categories + value[0] + ', ' categories = categories + entry['categories'][-1][0] key_list = ['name', 'phone', 'display_phone', 'rating', 'review_count', 'rating_img_url', 'url', 'mobile_url'] for key in key_list: if key not in entry.keys(): entry[key] = 'None' tmp_dict = {'name':entry['name'], 'phone':entry['phone'], 'display_phone':entry['display_phone'], 'location':location, 'categories':categories, 'rating':entry['rating'], 'review_count':entry['review_count'], 'rating_img_url':entry['rating_img_url'], 'url':entry['url'], 'mobile_url':entry['mobile_url']} min_response.append(tmp_dict) return min_response
def filter_by_category(user_cuisine): # f = open('sample.json', 'w') # for category in processed_rest_data: # if "restaurants" in restaurant["parents"]: # f = open('sample.json', 'r') # contents = f.read() # return json.loads(contents) # for cuisine in cuisines: # # params = get_search_parameters(cuisine) # print cuisine yelp_api = YelpAPI(CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET) try: print "trying %s....." % user_cuisine results = yelp_api.search_query(category_filter=user_cuisine, location="San Francisco, CA", limit=20) # results_string = json.dumps(results, indent=4) # f.write(results_string+'\n') # load_restaurants(results) print "%s worked!" % user_cuisine return results except Exception, e: print user_cuisine, 'failed' print "error msg is:\n\n %s" % e
def get_data(address): """Get data for restaurants in campus area using Yelp""" # Arguments for search query search_term = 'restaurant*' campus_location = address spending_limits = '1, 2, 3' num_businesses = 50 # Get and store data from the Yelp API yelp_api = YelpAPI( 'Ew6EOoXyDZ2J5fGCqV4eRc7zhwDfwVmttmBpOI4AgIG4KIpgKFwZA9Bavy5rK6AonwB-nVXy4oBb1SU7' '-2Xp9xqKMxXpG7NYr4vDs6VkDpN4ITSH8Gn0PfNWxfxVW3Yx') results = yelp_api.search_query(term=search_term, location=campus_location, price=spending_limits, limit=num_businesses) # Retrieve necessary information and store biz_dict = {} for business in results['businesses']: biz_dict[business['name']] = { 'rating': business['rating'], 'popularity': business['review_count'], 'price': business['price'], 'distance': business['distance'], 'url': business['url'] } return biz_dict
def get_yelp(points): """ Returns a list of dictionaries that contains name, address, and weighted rating of top restaurants along a route. Arguments --------- points is a list of dictionaries with keys being the time stamp and the values being the coordinates in a tuple Returns ------- list of dictionaries with restaurant name, address, and weighted rating Removes duplicates, sorts by weighted rating """ secret = open('app/yelp_key.txt', 'r') ykey = secret.read() secret.close() yelp_api = YelpAPI(ykey) response = [] for key, value in points.items(): response.append( yelp_api.search_query(term='restaurants', latitude=value[0], longitude=value[1], sort_by='rating', limit=5)) time.sleep(.1) # sleep .1 seconds to avoid yelp api limits initial = [] for i in range(len(response)): for j in range(5): rating = response[i]['businesses'][j]['rating'] review_count = response[i]['businesses'][j]['review_count'] #Weighted formula, we set 50 as a moderate amount of reviews weighted = round( float(rating) + 5 * float(1 - math.pow(math.e, -review_count / MODERATE_NUMBER_OF_REVIEWS)), 3) if response[i]['businesses'][j]['location'][ 'address1'] and not response[i]['businesses'][j][ 'is_closed']: name = response[i]['businesses'][j]['name'] address = response[i]['businesses'][j]['location'][ 'address1'] + ", " + response[i]['businesses'][j][ 'location']['city'] + ", " + response[i]['businesses'][ j]['location']['state'] + " " + response[i][ 'businesses'][j]['location']['zip_code'] initial.append({ 'name': name, 'address': address, 'rating': weighted }) #removes duplicates result = [ dict(tupleized) for tupleized in set( tuple(name.items()) for name in initial) ] #sorts by weighted average result2 = sorted(result, key=lambda k: k['rating'], reverse=True) return (result2)
def get_categories_from_name_and_address(name, address): yelp_api = YelpAPI(MY_API_KEY) alias = get_alias_from_name_and_address(name, address) if alias == "": return [] else: result = yelp_api.business_query(id=alias) return [c['alias'] for c in result['categories']]
def __init__(self): api_key = get_secret('YELP', 'api_key') self.api = YelpAPI(api_key) events_connector = ConnectorEvent.query.filter( ConnectorEvent.connector_type == ExtractEvents.TYPE, ConnectorEvent.connector_event_id == ExtractEvents.ID).first() self.events = events_connector.data
def moreSearchResults(): if len(resObjs) < 9: for objectNameMaker in range(5, 10): #should prob put into a function resObjs.append('r' + str(objectNameMaker)) resObjs[objectNameMaker] = restaurant() yelp_api = YelpAPI(api_key) yelpJson = yelp_api.search_query(term = form.query, location = form.location, distance = form.distance, price = form.price, limit = 10) initObjs(yelpJson, 10) return render_template('moreResults.html', resObjs = resObjs)
def businesses(city): CLIENT_ID = configKeys.ci CLIENT_SECRET = configKeys.cs api = YelpAPI(CLIENT_ID, CLIENT_SECRET) res = api.search_query(location=city, sort_by='rating', categories="arts", limit=30) return res["businesses"]
def __init__(self): self.BASE_URL = 'https://www.yelp.com/' # auth = Oauth1Authenticator(consumer_key=YOUR_CONSUMER_KEY,consumer_secret=YOUR_CONSUMER_SECRET,token=YOUR_TOKEN,token_secret=YOUR_TOKEN_SECRET) # auth = Oauth1Authenticator(consumer_key='pvImIXD6_9XDcw5TEBWdEw',consumer_secret='fBbKhobgly9fsjqnlsTNA5SyQI4',token='Nj9xR2XNdp0yQzf6eJysd9AJkj-FFW4M',token_secret='u5YhqlY6ptEoleexrhQZmqM5vg8') # client = Client(auth) self.yelp = YelpAPI('pvImIXD6_9XDcw5TEBWdEw', 'fBbKhobgly9fsjqnlsTNA5SyQI4', 'Nj9xR2XNdp0yQzf6eJysd9AJkj-FFW4M', 'u5YhqlY6ptEoleexrhQZmqM5vg8')
def get_alias_from_name_and_address(name, address): yelp_api = YelpAPI(MY_API_KEY) result = yelp_api.search_query(term=name, location=address, sort_by='best_match', limit=1) try: return result['businesses'][0]['alias'] except IndexError: return ""
def __init__(self,params): self.BASE_URL = 'https://www.yelp.com/' self.yelp = YelpAPI('pvImIXD6_9XDcw5TEBWdEw','fBbKhobgly9fsjqnlsTNA5SyQI4','Nj9xR2XNdp0yQzf6eJysd9AJkj-FFW4M','u5YhqlY6ptEoleexrhQZmqM5vg8') self.crawl_id = 0 self.crawler_record = None self.site = None self.session = requests.Session() self.params = params self.keyword = params['term']+ ' '+params['location'] self.count = 0
def process(id): yp = YelpAPI( 'zmd9y3Q30Zj7Ekoh8sokT1bmzw4hWXNfzpjbnjSV5GXhX6v6gKslsx7T645Dm4rBMCv-x5ZKAM_0l7-FlFJS76ev43IWXnDcwyoOwIRVZh2SGyLne_jzL3-LHAbGXHYx' ) response = yp.reviews_query(id) textArray = [] for item in response['reviews']: textArray.append(item['text']) return str(sentiment.getSentiment(textArray))
def yelpJSON(label): label = label.encode('utf-8') yelp_api = YelpAPI(application.config['YELP_API_KEY']) result = yelp_api.business_query(label) reviews = yelp_api.reviews_query(label) result['review_list'] = reviews response = jsonify(result) response.headers.add('Access-Control-Allow-Origin', application.config['ALLOWED_DOMAIN']) return response
def getDetailsFromAdress(adress): #adress = adress + " stockholm" yelp_api = YelpAPI( "MrRGPpo52MhH9Rhd2mYhqVTHUTolmcqQ1ekyXhAdh15ckOCdKeEPqgMvvOCBQM149OD5CpXMlg32NRseNdbtARSn_wErkvnAaLUXwZ0EBm4uhJXucT1ULSSrX9vwXXYx" ) response = yelp_api.search_query(location=adress, radius=2000, limit=1) # print(response) latitude = response['region']['center']['latitude'] longitude = response['region']['center']['longitude'] pointsOfInterestsNearby = response['total'] return (latitude, longitude, pointsOfInterestsNearby)
def getYelpData(phoneNums): """ This function takes in a list of phone numbers and looks them up in Yelp Fusion using yelpapi. It then returns 2 dictionaries of the business' information and three pertinent user reviews of the business. param: phoneNums = List of phone numbers return: phoneDict = Dictionary mapping a phone number to a list. list[0] = the business' rating list[1] = the business' review count list[2] = the business' url return: reviewDict = Dictionary mapping a phone number to a list of reviews (up to 3 reviews available, chosen by Yelp algorithm) list[0] = the review's rating list[1] = the review's text list[2] = the review's time of creation (IN PACIFIC TIME) """ yelp_api = YelpAPI(APIKEY) phoneDict = dict() reviewDict = dict() #lineNum = 1 for phoneNum in phoneNums: #print(lineNum) response = yelp_api.phone_search_query(phone=str(phoneNum)) #print(phoneNum) #pprint(response) #lineNum = lineNum + 1 # If the phone number is listed in Yelp, store rating, review_count, url in # array mapped to phone number. Then, use the business-id field from # response to store 3 reviews in a separate list. Return both at end. if response['total'] != 0: business = response['businesses'][0] phoneDict[phoneNum] = [ business['rating'], business['review_count'], business['url'] ] # Get reviews using company id and store in reviewDict companyID = str(business['id']) reviewResponse = yelp_api.reviews_query(id=companyID) reviewList = reviewResponse['reviews'] # Put a list of review information in reviewDict (mapped to phone number) for review in reviewList: reviewDict[phoneNum] = [ review['rating'], review['text'], review['time_created'] ] return phoneDict, reviewDict
def full_query(self, term, limit=5, category='', radius=None, location='washington, dc', sort=0): '''A full query that passes back the full JSON response from Yelp. For more information on seacch and response values see http://www.yelp.com/developers/documentation/v2/search_api''' # create YelpAPI object yelp_query = YelpAPI(self.consumer_key, self.consumer_secret, self.token, self.token_secret) category='' limit=5 radius=None offset = 0 response = yelp_query.search_query(term=term, category_filter=category, limit=limit, radius_filter=radius, location=location, sort=sort, offset=offset) return response
def parseYelpData(places, heading="tel"): """ This function takes in a list of businesses and looks them up by phone number in Yelp Fusion using yelpapi. It adds data about Yelp average rating of the business, the number of Yelp reviews, and the company's Yelp link to the dictionary of the business. The function then returns the updated list of businesses. param: places list of businesses that have been scraped by the GoogleParser param: heading default to "tel", signifying the heading for the phone number data field of each business return: updated list of businesses, with these data fields added to each business: 'yelp_rating', 'yelp_review_count', 'yelp_url','is_listed_yelp','is_claimed_yelp' """ yelp_api = YelpAPI(APIKEY) for place in places: phoneNum = changeFormatTel(place[heading]) if phoneNum == "": place['yelp_rating'] = "" place['yelp_review_count'] = "" place['yelp_url'] = "" place['is_listed_yelp'] = "0" place['is_claimed_yelp'] = "0" continue response = yelp_api.phone_search_query(phone=str(phoneNum)) # If the phone number is listed in Yelp, add Yelp rating, review_count, and # yelpUrl to the dictionary of the business. if response['total'] != 0: business = response['businesses'][0] place['yelp_rating'] = strip(str(business['rating'])) place['yelp_review_count'] = strip(str(business['review_count'])) place['yelp_url'] = strip(str(business['url'])) companyID = strip(str(business['id'])) claimResponse = yelp_api.business_query(id=companyID) place['is_listed_yelp'] = "1" if claimResponse['is_claimed'] == True: place['is_claimed_yelp'] = "1" else: place['is_claimed_yelp'] = "0" else: place['yelp_rating'] = "" place['yelp_review_count'] = "" place['yelp_url'] = "" place['is_listed_yelp'] = "0" place['is_claimed_yelp'] = "0" # to avoid Yelp's error messages of too many queries per second time.sleep(1) return places
def get_yelp_data(params): api_key = 'm2Fz_n7pVC_-u3GTRpW392W_IpIWLL1e7ACybtxbOIulWzuhQ1U-mSWuCmNPZepBpWAzSq6kKmL9HF-rqMGYARNXy1y1016FU6_jEEFVHtivYJQlmpNxaHdBNnrdXXYx' yelp_api = YelpAPI(api_key, timeout_s=3.0) try: search_results = yelp_api.search_query(term=params['term'], location=params['location'], limit=params['limit'], offset=params['offset']) except: print('Exception') return None return search_results
def moreResults(): yelp_api = YelpAPI(api_key) #ipAddress = "152.3.43.40" #for testing locally ipAddress = getIP() locCoor = getLoc(ipAddress) if len(resObjs) < 9: for objectNameMaker in range(5, 10): #should prob put into a function resObjs.append('r' + str(objectNameMaker)) resObjs[objectNameMaker] = restaurant() NUM_REST = 10 yelpJson = yelp_api.search_query(latitude = locCoor['lat'], longitude = locCoor['lon'], limit = 10) initObjs(yelpJson, 10) return render_template('moreResults.html', resObjs = resObjs)
def test_uses_timeout(self, has_timeout, faker, mock_request, random_dict): url = faker.uri() mock_call = mock_request.get(url, json=random_dict) timeout_s = faker.random_int(1, 60) if has_timeout else None yelp = YelpAPI(faker.pystr(), timeout_s=timeout_s) assert 0 == mock_call.call_count resp = yelp._query(url) assert resp == random_dict assert 1 == mock_call.call_count assert timeout_s == mock_call.last_request.timeout
def api(): yelp_api = YelpAPI( "92b7FDwkewHE9-5Ii9ig1hrlYWRtuzGWzaCTSRialTUvjhx7IpvJvRI2KP2T71WiWxlc8eu4ASfYfdiQbPXAkKQvaQyIypoI9j9DXeqecgrgw78PM2CXiJe_JKrsW3Yx" ) # args="?" # search_results = yelp_api.search_query(args) #print("10") response = yelp_api.phone_search_query(phone='+17189966288') # # print(response) # print("\n\n\n\n\n\n") # print (response['businesses'][0]['name']) return render_template('api.html', business=response)
class Yelp(): def __init__(self): self.BASE_URL = 'https://www.yelp.com/' # auth = Oauth1Authenticator(consumer_key=YOUR_CONSUMER_KEY,consumer_secret=YOUR_CONSUMER_SECRET,token=YOUR_TOKEN,token_secret=YOUR_TOKEN_SECRET) # auth = Oauth1Authenticator(consumer_key='pvImIXD6_9XDcw5TEBWdEw',consumer_secret='fBbKhobgly9fsjqnlsTNA5SyQI4',token='Nj9xR2XNdp0yQzf6eJysd9AJkj-FFW4M',token_secret='u5YhqlY6ptEoleexrhQZmqM5vg8') # client = Client(auth) self.yelp = YelpAPI('pvImIXD6_9XDcw5TEBWdEw','fBbKhobgly9fsjqnlsTNA5SyQI4','Nj9xR2XNdp0yQzf6eJysd9AJkj-FFW4M','u5YhqlY6ptEoleexrhQZmqM5vg8') def getWebsite(self,url): response = requests.get(url) soup = BeautifulSoup(response.text) try: web = soup.find('div',{'class':'biz-website'}).find('a').text return web except: return url def search(self,params): #response = client.search('San Francisco', **params) #print response.businesses response = self.yelp.search_query(term=params['term'],location=params['location'],limit=1) print self.getWebsite(response['businesses'][0]['url'])
def __init__(self): self.BASE_URL = 'https://www.yelp.com/' # auth = Oauth1Authenticator(consumer_key=YOUR_CONSUMER_KEY,consumer_secret=YOUR_CONSUMER_SECRET,token=YOUR_TOKEN,token_secret=YOUR_TOKEN_SECRET) # auth = Oauth1Authenticator(consumer_key='pvImIXD6_9XDcw5TEBWdEw',consumer_secret='fBbKhobgly9fsjqnlsTNA5SyQI4',token='Nj9xR2XNdp0yQzf6eJysd9AJkj-FFW4M',token_secret='u5YhqlY6ptEoleexrhQZmqM5vg8') # client = Client(auth) self.yelp = YelpAPI('pvImIXD6_9XDcw5TEBWdEw','fBbKhobgly9fsjqnlsTNA5SyQI4','Nj9xR2XNdp0yQzf6eJysd9AJkj-FFW4M','u5YhqlY6ptEoleexrhQZmqM5vg8')
def callYelp(location,term,limit): yelp_api = YelpAPI(CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET) response = yelp_api.search_query(term=term, location=location, sort=0, limit=limit) context_list = [] for r in response['businesses']: single = {} single['term'] = term single['name'] = r['name'] single['address'] =r['location']['display_address'] single['link'] = r['url'] single['lat'] = r['location']['coordinate']['latitude'] single['lon'] = r['location']['coordinate']['longitude'] if r['is_closed'] == "False": single['close'] = "CLOSE" else: single['close'] = "OPEN" context_list.append(single) return context_list
class Yelp(object): def __init__(self, longitude, latitude): self.client = YelpAPI(CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET) self.longitude = str(longitude) self.latitude = str(latitude) print(self.latitude, self.longitude) def get_locations(self): return self.client.search_query( ll=self.latitude + ',' + self.longitude, limit=5)
def YelpGain(self): from yelpapi import YelpAPI MY_CONSUMER_KEY = 'dae5HXBIXTb0ChnDZkzB3w' MY_CONSUMER_SECRET = 'qanTfPX5tMyh2hUFOMv-GgHgEUQ' MY_ACCESS_TOKEN = '60i6KZ_lUoOMuqZKb1yUsQ4EuRZweqS5' MY_ACCESS_SECRET = '0__YQm18_g2jUsMcbu6THu3edpA' yelp_api = YelpAPI(consumer_key=MY_CONSUMER_KEY, consumer_secret=MY_CONSUMER_SECRET, token=MY_ACCESS_TOKEN, token_secret=MY_ACCESS_SECRET) yelpResult = {} index = 1 response = yelp_api.search_query(term=info['yelp'], location='college station, tx', sort=2, limit=5) for business in response['businesses']: result = {} result['name'] = str(business['name']) result['id'] = str(business['id']) result['rating'] = str(business['rating'])+ "(" + str(business['review_count'])+'reviews' + ")" result['address'] = ', '.join(business['location']['display_address']) yelpResult[index] = result index = index + 1 return yelpResult
# Scrapes a whole city from Yelp. import argparse, csv, collections, geojson, ConfigParser, time from yelpapi import YelpAPI from shapely import geometry import util parser = argparse.ArgumentParser() parser.add_argument('--neighborhoods_file', default='data/sffind_neighborhoods.json') parser.add_argument('--config_file', default='config.txt') parser.add_argument('--output_file', default='yelp_results.json') args = parser.parse_args() config = ConfigParser.ConfigParser() config.read('config.txt') yelp_api = YelpAPI(config.get('yelp', 'consumer_key'), config.get('yelp', 'consumer_secret'), config.get('yelp', 'token'), config.get('yelp', 'token_secret')) # results = yelp_api.search_query(term='coffee', location='Noe Valley, San Francisco, CA') # https://www.yelp.com/developers/documentation/v2/search_api num_results_so_far = 0 while True: results = yelp_api.search_query(category_filter='coffee', location='San Francisco, CA', offset=num_results_so_far) print results['total'] for business in results['businesses']: if business['is_closed']: print "Not including, permanently closed: %s" % business['name'] continue print business['name'] print business['location']['coordinate']
from yelpapi import YelpAPI from yelp_authentication import CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET yelp_api = YelpAPI(CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET) # Example search by bounding box and category. See # http://www.yelp.com/developers/documentation/v2/all_category_list # for an official list of Yelp categories. The bounding box definition # comes from # http://isithackday.com/geoplanet-explorer/index.php?woeid=12587707. print('***** 5 bike rentals in San Francisco county *****') response = yelp_api.search_query(category_filter='bikerentals', bounds='37.678799,-123.125740|37.832371,-122.356979', limit=5) for business in response['businesses']: print('{}\n\tYelp ID: {}\n\trating: {} ({} reviews)\n\taddress: {}'.format(business['name'], business['id'], business['rating'], business['review_count'], business['location']['display_address']))
import time client = MongoClient('localhost', 27017) db = client.yelp_maryland yelp_results_collection = db.yelp_results argparser = argparse.ArgumentParser(description='Example Yelp queries using yelpapi. Visit https://www.yelp.com/developers/manage_api_keys to get the necessary API keys.') argparser.add_argument('--consumer_key', type=str, help='Yelp v2.0 API consumer key') argparser.add_argument('--consumer_secret', type=str, help='Yelp v2.0 API consumer secret') argparser.add_argument('--token', type=str, help='Yelp v2.0 API token') argparser.add_argument('--token_secret', type=str, help='Yelp v2.0 API token secret') args = argparser.parse_args() args.consumer_key = "R5P_xyFZ-bwmmv8wf8opCQ" args.consumer_secret = "YIDTvnHGL7ca0t9GlxEgCYtnQbo" args.token = "gMilIig9VdyrSVnrqZBoTkFnARB4WQol" args.token_secret = "AlieRCAbn28ppTXt_dteyDHdRDk" yelp_api = YelpAPI(args.consumer_key, args.consumer_secret, args.token, args.token_secret) #attrs=BusinessParking.garage,BusinessParking.lot,BusinessParking.validated #sortby=review_count yelp_results_collection.remove() #response = yelp_api.search_query(term='alcohol', location='Montgomery County, MD', sort=2, limit=20, offset=0) #response2 = yelp_api.search_query(term='alcohol', location='Montgomery County, MD', sort=2, limit=20, offset=20) #response_code = yelp_results_collection.insert(response) #response_code2 = yelp_results_collection.insert(response2) BaseLat = 38.9 BaseLon = -77.4 lat_intervals = [float(i) / 10 for i in xrange(5)]
from yelpapi import YelpAPI from yelp_authentication import CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET yelp_api = YelpAPI(CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET) # Example business query. Look at # http://www.yelp.com/developers/documentation/v2/business for more # information. print("***** selected reviews for Amy's on 6th St. *****") business = yelp_api.business_query(id='amys-ice-creams-austin-3') for review in business['reviews']: print('rating: {}\nexcerpt: {}\n'.format(review['rating'], review['excerpt']))
from yelpapi import YelpAPI import pandas as pd consumer_key = 'PnHvincoddn76xfpm3LhLg' consumer_secret = 'PGmBEyjY0dKu1jzYkJr2Mxe2SCs' token = 'Xo8UWIL1CdyTxn-cX-XYbxsAXQOpgfYz' token_secret = '1J60nMB-wGTsLyNOyGkY9EZfMFM' yelp_api = YelpAPI(consumer_key,consumer_secret,token,token_secret) #search_results = yelp_api.search_query() columns = ['bars','restaurants','laundry','pizza','hospitals','coffee','boutique','clothing','education','arts'] #zip_code = ['10453','10458','10451','10454','10463','10466','10461','11212','11209','11204','11234','11223','11201','11203','11207','11211','11220','11206','10026','10001','10029','10010','10012','10004','10002','10021','10023','10031','11361','11354','11365','11412','11101','11374','11691','11004','11414','11368','10301','10314'] zip_code = [10001, 10002, 10003, 10004, 10005, 10006, 10007, 10009, 10010, 10011, 10012, 10013, 10014, 10016, 10017, 10018, 10019, 10020, 10021, 10022, 10023, 10024, 10025, 10026, 10027, 10028, 10029, 10030, 10031, 10032, 10033, 10034, 10035, 10036, 10037, 10038, 10039, 10040, 10044, 10065, 10069, 10075, 10103, 10110, 10111, 10112, 10115, 10119, 10128, 10152, 10153, 10154, 10162, 10165, 10167, 10168, 10169, 10170, 10171, 10172, 10173, 10174, 10177, 10199, 10271, 10278, 10279, 10280, 10282, 10301, 10302, 10303, 10304, 10305, 10306, 10307, 10308, 10309, 10310, 10311, 10312, 10314, 10451, 10452, 10453, 10454, 10455, 10456, 10457, 10458, 10459, 10460, 10461, 10462, 10463, 10464, 10465, 10466, 10467, 10468, 10469, 10470, 10471, 10472, 10473, 10474, 10475, 11004, 11005, 11101, 11102, 11103, 11104, 11105, 11106, 11109, 11201, 11203, 11204, 11205, 11206, 11207, 11208, 11209, 11210, 11211, 11212, 11213, 11214, 11215, 11216, 11217, 11218, 11219, 11220, 11221, 11222, 11223, 11224, 11225, 11226, 11228, 11229, 11230, 11231, 11232, 11233, 11234, 11235, 11236, 11237, 11238, 11239, 11351, 11354, 11355, 11356, 11357, 11358, 11359, 11360, 11361, 11362, 11363, 11364, 11365, 11366, 11367, 11368, 11369, 11370, 11371, 11372, 11373, 11374, 11375, 11377, 11378, 11379, 11385, 11411, 11412, 11413, 11414, 11415, 11416, 11417, 11418, 11419, 11420, 11421, 11422, 11423, 11424, 11425, 11426, 11427, 11428, 11429, 11430, 11432, 11433, 11434, 11435, 11436, 11451, 11691, 11692, 11693, 11694, 11697] d = {} for i in columns: count = d.setdefault(i, {}) for j in zip_code: count = d[i].setdefault(j, 0) business_results = yelp_api.search_query(term = i,location = j, radius_filter = 1000) rating = 0 num = 0 for k in business_results['businesses']: try: if k['review_count']>500: rating += (k['rating']/float(5))*3 + 2 else: rating += (k['rating']/float(5))*3 + (k['review_count']/float(500))*2 #print k['name'],k['rating'],k['review_count'],k['location']['postal_code'],k['location']['neighborhoods'] except: continue rating = rating/float(20) print i,j
""" Example call: ./examples.py "[API Key]" """ from yelpapi import YelpAPI import argparse from pprint import pprint argparser = argparse.ArgumentParser(description='Example Yelp queries using yelpapi. ' 'Visit https://www.yelp.com/developers/v3/manage_app to get the ' 'necessary API keys.') argparser.add_argument('api_key', type=str, help='Yelp Fusion API Key') args = argparser.parse_args() yelp_api = YelpAPI(args.api_key) """ Example search by location text and term. Search API: https://www.yelp.com/developers/documentation/v3/business_search """ print('***** 5 best rated ice cream places in Austin, TX *****\n{}\n'.format("yelp_api.search_query(term='ice cream', " "location='austin, tx', sort_by='rating', " "limit=5)")) response = yelp_api.search_query(term='ice cream', location='austin, tx', sort_by='rating', limit=5) pprint(response) print('\n-------------------------------------------------------------------------\n') """
from yelpapi import YelpAPI import pysolr import json import collections import dictlitestore yelp_api =YelpAPI('a5oBT4RnnHpt6rtHQWsGYg','61UpHpxNDVJfpACumIIJNIR2nJ8','-PlfjeTyjnMSGP67pQbopdxJ-lXE70Bn','ewGlo-jkCt0LpNYphzr2SxaEtCY') neighborhoods = ['Ang Mo Kio','Arab Street','Bedok North', 'Bishan', 'Boat Quay', 'Boon Keng', 'Boon Lay','Bras Brasah','Bugis','Bukit Timah','Changi','Chinatown','Choa Chu Kang','City Hall','Clarke Quay','Clementi','Dhoby Ghaut','Eunos','Farrer Park','Geylang','Harbourfront','Holland Village','Hougang','Kallang','Katong','Lavender','Macpherson','Marine Parade','Newton','Novena','Orchard','Pasir Ris','Raffles Place','Serangoon','Somerset','Tampines','Thomson','Toa Payoh','Woodlands','Yio Chu Kang','Yishun'] #neighborhoods = ['Lavender','Macpherson','Marine Parade','Newton','Novena','Orchard','Pasir Ris','Raffles Place','Serangoon','Somerset','Tampines','Thomson','Toa Payoh','Woodlands','Yio Chu Kang','Yishun'] #solr = pysolr.Solr('http://localhost:8983/solr/', timeout=10) row = 0 print len(neighborhoods) #resultsDict = [] with dictlitestore.DictLiteStore('sports.db', 'sportslistings') as bucket: #results = yelp_api.search_query(location='singapore', category_filter='shopping') #print results['businesses'][0] #print len(results['businesses']) #bucket.store(results['businesses'][0]) for location in neighborhoods: search_results = yelp_api.search_query(location=location, category_filter='active', cc='SG') #print type(search_results) #print json.dumps(search_results['businesses']) print location print "-------------------------------------------------------" totalResults = search_results['total'] for x in range (0, min(50, totalResults/20)):
# Answer to Challenge 1: Change your search in some way described in the API # documentation (e.g., use a category filter) # # I've changed this to print ice cream places in Seattle using the category # filter. I used the term "icecream" which I found documented on this page in # the API documentation: # # https://www.yelp.com/developers/documentation/v2/all_category_list from yelpapi import YelpAPI from yelp_authentication import CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET yelp_api = YelpAPI(CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET) # Example search by location text and term. Take a look at # http://www.yelp.com/developers/documentation/v2/search_api for # the various options available. print('***** 5 best rated ice cream places in Seattle, WA *****') response = yelp_api.search_query(category_filter='icecream', location='seattle, wa', sort=2, limit=5) print('region center (lat,long): {},{}\n'.format(response['region']['center']['latitude'], response['region']['center']['longitude'])) for business in response['businesses']: print('{}\n\tYelp ID: {}\n\trating: {} ({} reviews)\n\taddress: {}'.format(business['name'], business['id'], business['rating'], business['review_count'], business['location']['display_address']))
def main(): yelp_api = YelpAPI(login_data['yelp_consumer_key'], login_data['yelp_consumer_secret'], login_data['yelp_token'], login_data['yelp_token_secret']) zip_codes = [row.zip_code for row in session.query(ZipCode).all()] current_month = datetime.date.today().month current_rows = session.query(YelpAPIDb).filter(extract('month', YelpAPIDb.date_created) == current_month).all() current_rows = [row.as_dict() for row in current_rows] existing_zip_codes = [row['zip_code'] for row in current_rows] remaining_zip_codes = [zip_code for zip_code in zip_codes if zip_code not in existing_zip_codes] category_list = ["cafes", "newamerican", "indpak", "italian", "japanese", "thai"] for i, zip_code in enumerate(remaining_zip_codes): zip_code_results = [] for category in category_list: offset = 0 total_count = 21 results_per_query_limit = 20 business_counter = 1 remaining_count = 1 LOGGER.info("Extracting {} restaurants from zip code {} ({} out of {})".format(category, zip_code, i, len(remaining_zip_codes))) while remaining_count > 0: try: search_results = yelp_api.search_query(location=zip_code, category_filter=category, sort=0, limit=20, offset=offset) total_count = search_results['total'] except YelpAPI.YelpAPIError as e: print e break if search_results['total'] == 0: session.merge(YelpAPIDb(zip_code=zip_code, date_created=datetime.date.today(), avg_rating=None, business_count=0)) session.commit() break for business in search_results['businesses']: if is_business_valid(business, zip_code): print "{} out of {} businesses".format(business_counter, total_count) zip_code_results.append({"zip_code": zip_code, "rating": business['rating'], "review_count": business["review_count"]}) business_counter += 1 remaining_count = total_count - business_counter offset += results_per_query_limit if zip_code_results: total_review_count = sum([business['review_count'] for business in zip_code_results]) zip_code_avg_rating = sum( [business['rating'] * business['review_count'] for business in zip_code_results]) / total_review_count row = YelpAPIDb(zip_code=zip_code, date_created=datetime.date.today(), avg_rating=zip_code_avg_rating, business_count=len(zip_code_results)) session.merge(row) session.commit() else: session.merge( YelpAPIDb(zip_code=zip_code, date_created=datetime.date.today(), avg_rating=None, business_count=0)) session.commit() session.close()
# Answer to Challenge 6: What is the highest rated falafel place in Seattle? from yelpapi import YelpAPI from yelp_authentication import CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET yelp_api = YelpAPI(CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET) # Example search by location text and term. Take a look at # http://www.yelp.com/developers/documentation/v2/search_api for # the various options available. response = yelp_api.search_query(term='falafel', location='seattle, wa', sort=2, limit=1) for business in response['businesses']: print('{}\n\trating: {} ({} reviews)'.format(business['name'], business['rating'], business['review_count']))
from yelpapi import YelpAPI yelp_api =YelpAPI('a5oBT4RnnHpt6rtHQWsGYg','61UpHpxNDVJfpACumIIJNIR2nJ8','-PlfjeTyjnMSGP67pQbopdxJ-lXE70Bn','ewGlo-jkCt0LpNYphzr2SxaEtCY') neighborhoods = ['Alexandra', 'Ang Mo Kio', 'Ann Siang Hill', 'Arab Street', 'Bayfront', 'Bedok North', 'Bedok Reservoir', 'Bedok South', 'Bencoolen', 'Bishan', 'Boat Quay', 'Boon Keng', 'Boon Lay','Bras Brasah','Buangkok','Bugis','Bukit Batok','Bukit Panjang','Bukit Timah','Changi','Chinatown','Choa Chu Kang','City Hall','Clarke Quay','Clementi','Dempsey Hill','Dhoby Ghaut','Dover','Duxton Hill','Eunos','Farrer Park','Geylang','Ghim Moh','Harbourfront','Holland Hill','Holland Village','Hougang','Joo Chiat','Jurong','Jurong Island','Kallang','Katong','Kembangan','Kent Ridge','Keppel','Labrador Park','Lavender','Lim Chu Kang','Little India','Macpherson','Mandai','Marine Parade','Mount Sophia','Mountbatten','Newton','Novena','Orchard','Outram','Pasir Panjang','Pasir Ris','Paya Lebar','Potong Pasir','Pulau Ubin','Punggol','Queenstown','Raffles Place','Redhill','River Valley','Robertson Quay','Seletar','Sembawang','Sengkang','Sentosa','SerangoonSerangoon Gardens','Siglap','Simei','Sixth Avenue','Somerset','Tampines','Tanglin','Tanglin Halt','Tanjong Pagar','Tanjong Rhu','Telok Blangah','Telok Kurau','Thomson','Tiong Bahru','Toa Payoh','Tuas','Ubi','Ulu Pandan','Upper Bukit Timah','Wessex Estate','West Coast','Woodlands','Yio Chu Kang','Yishun','one-north'] resultsDict = [] for location in neighborhoods: search_results = yelp_api.search_query(location=location, category_filter='food') totalResults = search_results['total'] for x in range (0, min(50, totalResults/20)): offsetValue = (str)(x*20) print "Query", x results = yelp_api.search_query(location=location, category_filter='food', offset=offsetValue) resultsDict.append(results)
# Answer to Challenge 9: Make an interactive version that prompts users for # input. # # This is an interactive version of challenge_8.py from yelpapi import YelpAPI from yelp_authentication import CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET yelp_api = YelpAPI(CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET) # Example search by location text and term. Take a look at # http://www.yelp.com/developers/documentation/v2/search_api for # the various options available. search_term = input("What do you want to search for: ") response = yelp_api.search_query(term=search_term, location='seattle, wa', sort=2, limit=20) counter = 0 for business in response['businesses']: if business['review_count'] >= 100: counter = counter + 1 print("of the 20 highest rated restaurants in seattle, {} have 100 or fewer reviews".format(counter))
def business_row(business): return [ business['location']['address'][0], business['location']['city'], business['categories'][0][0], business['rating'], business['url'] ] # Pulled the list from the neighborhoods shapefile at # http://www.nyc.gov/html/dcp/html/bytes/applbyte.shtml#other # Used http://dbfconv.com to convert the dbf (the data part of a shapefile) into a csv neighborhoods = [ "Wakefield, Bronx", "Co-op City, Bronx", "Eastchester, Bronx", "Fieldston, Bronx", "Riverdale, Bronx", "Kingsbridge, Bronx", "Marble Hill, Manhattan", "Woodlawn, Bronx", "Norwood, Bronx", "Williamsbridge, Bronx", "Baychester, Bronx", "Pelham Parkway, Bronx", "City Island, Bronx", "Bedford Park, Bronx", "University Heights, Bronx", "Morris Heights, Bronx", "Fordham, Bronx", "East Tremont, Bronx", "West Farms, Bronx", "High Bridge, Bronx", "Melrose, Bronx", "Mott Haven, Bronx", "Port Morris, Bronx", "Longwood, Bronx", "Hunts Point, Bronx", "Morrisania, Bronx", "Soundview, Bronx", "Clason Point, Bronx", "Throgs Neck, Bronx", "Country Club, Bronx", "Parkchester, Bronx", "Westchester Square, Bronx", "Van Nest, Bronx", "Morris Park, Bronx", "Belmont, Bronx", "Spuyten Duyvil, Bronx", "North Riverdale, Bronx", "Pelham Bay, Bronx", "Schuylerville, Bronx", "Edgewater Park, Bronx", "Castle Hill, Bronx", "Olinville, Bronx", "Pelham Gardens, Bronx", "Concourse, Bronx", "Unionport, Bronx", "Edenwald, Bronx", "Bay Ridge, Brooklyn", "Bensonhurst, Brooklyn", "Sunset Park, Brooklyn", "Greenpoint, Brooklyn", "Gravesend, Brooklyn", "Brighton Beach, Brooklyn", "Sheepshead Bay, Brooklyn", "Manhattan Terrace, Brooklyn", "Flatbush, Brooklyn", "Crown Heights, Brooklyn", "East Flatbush, Brooklyn", "Kensington, Brooklyn", "Windsor Terrace, Brooklyn", "Prospect Heights, Brooklyn", "Brownsville, Brooklyn", "Williamsburg, Brooklyn", "Bushwick, Brooklyn", "Bedford Stuyvesant, Brooklyn", "Brooklyn Heights, Brooklyn", "Cobble Hill, Brooklyn", "Carroll Gardens, Brooklyn", "Red Hook, Brooklyn", "Gowanus, Brooklyn", "Fort Greene, Brooklyn", "Park Slope, Brooklyn", "Cypress Hills, Brooklyn", "East New York, Brooklyn", "Starrett City, Brooklyn", "Canarsie, Brooklyn", "Flatlands, Brooklyn", "Mill Island, Brooklyn", "Manhattan Beach, Brooklyn", "Coney Island, Brooklyn", "Bath Beach, Brooklyn", "Borough Park, Brooklyn", "Dyker Heights, Brooklyn", "Gerritsen Beach, Brooklyn", "Marine Park, Brooklyn", "Clinton Hill, Brooklyn", "Sea Gate, Brooklyn", "Downtown, Brooklyn", "Boerum Hill, Brooklyn", "Prospect Lefferts Gardens, Brooklyn", "Ocean Hill, Brooklyn", "City Line, Brooklyn", "Bergen Beach, Brooklyn", "Midwood, Brooklyn", "Prospect Park South, Brooklyn", "Georgetown, Brooklyn", "Spring Creek, Brooklyn", "East Williamsburg, Brooklyn", "North Side, Brooklyn", "South Side, Brooklyn", "Navy Yard, Brooklyn", "Ocean Parkway, Brooklyn", "Fort Hamilton, Brooklyn", "Chinatown, Manhattan", "Washington Heights, Manhattan", "Inwood, Manhattan", "Hamilton Heights, Manhattan", "Manhattanville, Manhattan", "Central Harlem, Manhattan", "East Harlem, Manhattan", "Upper East Side, Manhattan", "Yorkville, Manhattan", "Lenox Hill, Manhattan", "Roosevelt Island, Manhattan", "Upper West Side, Manhattan", "Lincoln Square, Manhattan", "Clinton, Manhattan", "Midtown, Manhattan", "Murray Hill, Manhattan", "Chelsea, Manhattan", "Greenwich Village, Manhattan", "East Village, Manhattan", "Lower East Side, Manhattan", "Tribeca, Manhattan", "Little Italy, Manhattan", "Soho, Manhattan", "West Village, Manhattan", "Manhattan Valley, Manhattan", "Morningside Heights, Manhattan", "Gramercy, Manhattan", "Battery Park City, Manhattan", "Financial District, Manhattan", "Astoria, Queens", "Woodside, Queens", "Jackson Heights, Queens", "Elmhurst, Queens", "Howard Beach, Queens", "South Corona, Queens", "Forest Hills, Queens", "Kew Gardens, Queens", "Richmond Hill, Queens", "Downtown Flushing, Queens", "Long Island City, Queens", "Sunnyside, Queens", "East Elmhurst, Queens", "Maspeth, Queens", "Ridgewood, Queens", "Glendale, Queens", "Rego Park, Queens", "Woodhaven, Queens", "Ozone Park, Queens", "South Ozone Park, Queens", "College Point, Queens", "Whitestone, Queens", "Bayside, Queens", "Auburndale, Queens", "Little Neck, Queens", "Douglaston, Queens", "Glen Oaks, Queens", "Bellerose, Queens", "Kew Gardens Hills, Queens", "Fresh Meadows, Queens", "Briarwood, Queens", "Jamaica Center, Queens", "Oakland Gardens, Queens", "Queens Village, Queens", "Hollis, Queens", "South Jamaica, Queens", "St. Albans, Queens", "Rochdale, Queens", "Springfield Gardens, Queens", "Cambria Heights, Queens", "Rosedale, Queens", "Far Rockaway, Queens", "Broad Channel, Queens", "Breezy Point, Queens", "Steinway, Queens", "Beechhurst, Queens", "Bay Terrace, Queens", "Edgemere, Queens", "Arverne, Queens", "Seaside, Queens", "Neponsit, Queens", "Murray Hill, Queens", "Floral Park, Queens", "Holliswood, Queens", "Jamaica Estates, Queens", "Queensboro Hill, Queens", "Hillcrest, Queens", "Ravenswood, Queens", "Lindenwood, Queens", "Laurelton, Queens", "Lefrak City, Queens", "Belle Harbor, Queens", "Rockaway Park, Queens", "Somerville, Queens", "Brookville, Queens", "Bellaire, Queens", "North Corona, Queens", "Forest Hills Gardens, Queens", "St. George, Staten Island", "New Brighton, Staten Island", "Stapleton, Staten Island", "Rosebank, Staten Island", "West Brighton, Staten Island", "Grymes Hill, Staten Island", "Todt Hill, Staten Island", "South Beach, Staten Island", "Port Richmond, Staten Island", "Mariner's Harbor, Staten Island", "Port Ivory, Staten Island", "Castleton Corners, Staten Island", "New Springville, Staten Island", "Travis, Staten Island", "New Dorp, Staten Island", "Oakwood, Staten Island", "Great Kills, Staten Island", "Eltingville, Staten Island", "Annadale, Staten Island", "Woodrow, Staten Island", "Tottenville, Staten Island", "Tompkinsville, Staten Island", "Silver Lake, Staten Island", "Sunnyside, Staten Island", "Ditmas Park, Brooklyn", "Wingate, Brooklyn", "Rugby, Brooklyn", "Park Hill, Staten Island", "Westerleigh, Staten Island", "Graniteville, Staten Island", "Arlington, Staten Island", "Arrochar, Staten Island", "Grasmere, Staten Island", "Old Town, Staten Island", "Dongan Hills, Staten Island", "Midland Beach, Staten Island", "Grant City, Staten Island", "New Dorp Beach, Staten Island", "Bay Terrace, Staten Island", "Huguenot, Staten Island", "Pleasant Plains, Staten Island", "Butler Manor, Staten Island", "Charleston, Staten Island", "Rossville, Staten Island", "Arden Heights, Staten Island", "Greenridge, Staten Island", "Heartland Village, Staten Island", "Chelsea, Staten Island", "Bloomfield, Staten Island", "Bulls Head, Staten Island", "Carnegie Hill, Manhattan", "Noho, Manhattan", "Civic Center, Manhattan", "Midtown South, Manhattan", "Richmond Town, Staten Island", "Shore Acres, Staten Island", "Clifton, Staten Island", "Concord, Staten Island", "Emerson Hill, Staten Island", "Randall Manor, Staten Island", "Howland Hook, Staten Island", "Elm Park, Staten Island", "Remsen Village, Brooklyn", "New Lots, Brooklyn", "Paerdegat Basin, Brooklyn", "Mill Basin, Brooklyn", "Jamaica Hills, Queens", "Utopia, Queens", "Pomonok, Queens", "Astoria Heights, Queens", "Claremont Village, Bronx", "Concourse Village, Bronx", "Mount Eden, Bronx", "Mount Hope, Bronx", "Sutton Place, Manhattan", "Hunters Point, Queens", "Turtle Bay, Manhattan", "Tudor City, Manhattan", "Stuyvesant Town, Manhattan", "Flatiron, Manhattan", "Sunnyside Gardens, Queens", "Blissville, Queens", "Fulton Ferry, Brooklyn", "Vinegar Hill, Brooklyn", "Weeksville, Brooklyn", "Broadway Junction, Brooklyn", "Dumbo, Brooklyn", "Manor Heights, Staten Island", "Willowbrook, Staten Island", "Sandy Ground, Staten Island", "Egbertville, Staten Island", "Roxbury, Queens", "Homecrest, Brooklyn", "Middle Village, Queens", "Prince's Bay, Staten Island", "Lighthouse Hill, Staten Island", "Richmond Valley, Staten Island", "Malba, Queens", "Highland Park, Brooklyn", "Madison, Brooklyn" ] # You'll have to put your own keys here - # register at http://www.yelp.com/developers/ yelp_api = YelpAPI(CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET) with open('lunch-morningside-heights-yelp.csv', 'wb') as csvfile: business_writer = unicodecsv.writer(csvfile) business_writer.writerow(["Name", "Address", "City", "Category", "Rating", "URL"]) for neighborhood in ["Morningside Heights"]: # Pause for a second so Yelp doesn't get unhappy with us time.sleep(1) print "Processing %s" % neighborhood response = yelp_api.search_query(term='lunch', location='%s, New York' % neighborhood, limit=20) for business in response['businesses']: # When we call business_row, maybe some are missing categories or addresses etc # If that happens, let's just ignore the error and keep on trucking
from yelpapi import YelpAPI import argparse from pprint import pprint import json from sets import Set yelp_api = YelpAPI('HT2dPycSfSpTHWsyqt95wQ', 'uBi1MMxW4HbJn7sumEie9oLK3Jw', '2sgcGgH_Gs9UlKVQfY8uqte0lhjSpE8z', '2tItNfdQoaHzpqqh1WGJmaG85F0') with open('location_all_latlngs.txt') as data_file: location_latlngs = json.load(data_file) with open('location_counts.txt') as data_file: location_counts = json.load(data_file) full_data = [] urls = Set() business_keys = ["url", "rating", "review_count", "name", "location"] for i in range(51, len(location_counts)): #0-50 already done. #for i in range(4, 5): for index, ll in enumerate(location_latlngs.get(location_counts[i][0], [])): pass if index <= 20: #keep under 20 try: response = yelp_api.search_query(term='scuba diving', ll=ll) #full_data.append(response) for i in range(0, len(response['businesses'])): if str(response['businesses'][i]['url']) not in urls: business = response['businesses'][i] business = { keep_key: response['businesses'][i][keep_key] for keep_key in business_keys } # unwanted = set(business.keys()) - set(business_keys) # for unwanted_key in unwanted: del business[unwanted_key]
#!/usr/bin/env python ''' Simple script that access the yelp API and finds the 400 `best' restaurants within a bounding lat/long box. The queried responses are saved to a file for parsing. API keys stored in keys or just write yours in at the preemble ''' from yelpapi import YelpAPI import pickle import keys consumer_key = keys.consumer_key consumer_secret = keys.consumer_secret token = keys.token token_secret = keys.token_secret yelp_api = YelpAPI(consumer_key, consumer_secret, token, token_secret) """ Example search by location text and term. Take a look at http://www.yelp.com/developers/documentation/v2/search_api for the various options available. """ # response = yelp_api.search_query(term='restaurants', location='idaho falls, ID', sort=1, offset=20) # print('region center (lat,long): %f,%f\n' % (response['region']['center']['latitude'], response['region']['center']['longitude'])) # for business in response['businesses']: # print('%s\n\tYelp ID: %s\n\trating: %g (%d reviews)\n\taddress: %s' % (business['name'], business['id'], business['rating'], # business['review_count'], ', '.join(business['location']['display_address']))) # # response = []
# Scrapes a whole city from Yelp. import argparse, csv, collections, ConfigParser, time, json from yelpapi import YelpAPI parser = argparse.ArgumentParser() parser.add_argument('--neighborhoods_file', default='data/sffind_neighborhoods.json') parser.add_argument('--config_file', default='config.txt') parser.add_argument('--output_file', default='yelp_results.json') parser.add_argument('--limit', help='stop after N businesses, for testing', type=int) args = parser.parse_args() config = ConfigParser.ConfigParser() config.read('config.txt') yelp_api = YelpAPI(config.get('yelp', 'consumer_key'), config.get('yelp', 'consumer_secret'), config.get('yelp', 'token'), config.get('yelp', 'token_secret')) # https://www.yelp.com/developers/documentation/v2/search_api all_businesses = [] num_results_so_far = 0 # bounds=sw_latitude,sw_longitude|ne_latitude,ne_longitude # bounds = '37.70,-122.5|37.76,-122.35' # lower half of SF # bounds = '37.76,-122.5|37.82,-122.35' # upper half of SF bounds = '37.70,-122.55|37.82,-122.35' # all SF, rough handmade query. while True: try: # results = yelp_api.search_query(category_filter='coffee', # location='San Francisco, CA', offset=num_results_so_far) results = yelp_api.search_query(category_filter='coffee', bounds=bounds, offset=num_results_so_far)
from yelpapi import YelpAPI from yelp_authentication import CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET yelp_api = YelpAPI(CONSUMER_KEY, CONSUMER_SECRET, TOKEN, TOKEN_SECRET) # Example search by location text and term. Take a look at # http://www.yelp.com/developers/documentation/v2/search_api for # the various options available. print('***** 5 best rated ice cream places in Austin, TX *****') response = yelp_api.search_query(term='ice cream', location='austin, tx', sort=2, limit=5) print('region center (lat,long): {},{}\n'.format(response['region']['center']['latitude'], response['region']['center']['longitude'])) for business in response['businesses']: print('{}\n\tYelp ID: {}\n\trating: {} ({} reviews)\n\taddress: {}'.format(business['name'], business['id'], business['rating'], business['review_count'], business['location']['display_address']))