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
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 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 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!")
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 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 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
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 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 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!")
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 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 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 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 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 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 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 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 ""
class YelpClient(): def __init__(self): self.yelp = YelpAPI(API_KEY) def get_tag_set(self): return random.sample(prefs, pref_size) def get_random_location(self): lat = DC["lat"] + random.uniform(-loc_dev * 2, loc_dev * 2) long = DC["long"] + random.uniform(-loc_dev * 2, loc_dev * 2) return (lat, long) def get_venues(self, lat, long, categories): venues = self.yelp.search_query(location='DC', latitude=lat, longitude=long, categories=categories, limit=50, open_now=True) return venues def generate_venue_set(self): lat, long = self.get_random_location() tags = self.get_tag_set() categories = ','.join(tags) # print(categories) venue_set = self.get_venues(lat, long, categories)["businesses"] # print(venue_set) venues = [] for v in venue_set: categories = [c['alias'] for c in v["categories"]] address = str(v["location"]["address1"]) + " " + str(v["location"]["city"]) + ", " + \ str(v["location"]["state"]) + " " + \ str(v["location"]["zip_code"]) venue = { "yelp_id": v["id"], "name": v["name"], "coordinates": [v["coordinates"]["latitude"], v["coordinates"]["longitude"]], "address": address, "categories": categories, "image": v["image_url"] } venues.append(venue) return venues
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 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
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 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 startPage(): yelp_api = YelpAPI(api_key) #ipAddress = "23.121.182.143" #for testing locally #using duke IP bc duke gardens bug ipAddress = getIP() #for deployment locCoor = getLoc(ipAddress) yelpJson = yelp_api.search_query(latitude = locCoor['lat'], longitude = locCoor['lon'], limit = NUM_REST) initObjs(yelpJson, 5) if request.method == 'POST': #this block is only entered when the form is submitted #read in form values form.query = request.form.get('query') form.location = request.form.get('location') form.distance = request.form.get('distance') form.price = str(int(request.form.get('price'))) #search with form values yelpJson = yelp_api.search_query(term = form.query, location = form.location, distance = form.distance, price = form.price, limit = NUM_REST) if checkResults(yelpJson)==-1: #if the search is too specific return '<h1> Your search did not return enough restaurants to display, please try again</h1><a href = "/" class = "w3-xlarge w3-button ">Clear Search</a>' initObjs(yelpJson, 5) #render page after search using values from form return render_template('finalPage.html', ipA = ipAddress, term = form.query, mapR = form.distance, latitude = yelpJson['region']['center']['latitude'], longitude = yelpJson['region']['center']['longitude'], r0=resObjs[0], r1=resObjs[1], r2=resObjs[2], r3 = resObjs[3], r4=resObjs[4]) #render page before search with defaults and ip location return render_template('firstPage.html', ipA = ipAddress, latitude = locCoor['lat'], longitude = locCoor['lon'], r0=resObjs[0], r1=resObjs[1], r2=resObjs[2], r3 = resObjs[3], r4=resObjs[4])
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 list(self, request): yelp_api = YelpAPI(api_key) search_location = self.request.query_params.get("location", None) search_total = yelp_api.search_query(location=search_location, categories='parking, All', sort_by='rating', limit=0) if search_total["total"] <= 50: offset_amt = 0 elif 50 < search_total["total"] <= 1000: offset_amt = (search_total["total"] - 50) else: offset_amt = 950 search_results = yelp_api.search_query(location=search_location, categories='parking, All', sort_by='rating', limit=50, offset=offset_amt) return Response(search_results["businesses"])
def search_yelp(): client_id = yelp_crediatials.client_id api_key = yelp_crediatials.api_key yelp_api = YelpAPI(api_key) term = 'Mexican restaurant bar' location = 'Boston, MA' search_limit = 50 response = yelp_api.search_query(term=term, location=location, limit=search_limit) print(response) '''
def scrape_healthy_restaurants(): city_list = [] for tup in top_cities_data(): city_list.append(tup[0]) yelp_api = YelpAPI(API_KEY) healthy_restuarants_dict = {} #get restaurants with key word "healthy in each city for city in city_list: search_results = yelp_api.search_query(term = 'healthy', location = city) healthy_restuarants_dict[city] = search_results["total"] return(healthy_restuarants_dict)
def get(self, request, *args, **kwargs): yelp_api = YelpAPI(settings.YELP_API_KEY) search_results = yelp_api.search_query(**self.request.GET) term = request.GET.get('term') longitude = float(request.GET.get('longitude')) latitude = float(request.GET.get('latitude')) results_count = search_results['total'] map_models.Search.objects.create(term=term, position=Point(longitude, latitude), results_count=results_count) return JsonResponse(search_results)
async def async_deep_query(terms, location, offset=0, limit=20, radius=40000, output='yelper.csv', pages=-1): """Define the application entrypoint.""" # Prepare the Yelp client. yelp_api = YelpAPI(os.environ['YELP_API_KEY']) params = { 'term': terms, 'location': location, 'offset': offset, 'limit': limit, 'radius': radius, } # Prepare the CSV file. fieldnames = dataclasses.asdict(YelpBusiness('fake')).keys() with open(output, 'w') as csvfile: writer = csv.DictWriter(csvfile, fieldnames=fieldnames) writer.writeheader() # Search Yelp. while True: search_results = yelp_api.search_query(**params) # Check whether we need to process further or not. if not search_results: break if not search_results['businesses']: break if (params['offset'] / params['limit']) >= pages > 0: break # Process the results. tasks = [ deep_entry_parsing(business, params['offset'] + i) for i, business in enumerate(search_results['businesses']) ] page_results = await asyncio.gather(*tasks) # Write the entries to the file and flush. for entry in page_results: writer.writerow(dataclasses.asdict(entry)) csvfile.flush() # Update the offset before looping again. params['offset'] += params['limit']
def random_zips(list_of_zips, n_zips, key): # Initializing the Yelp API using key provided yelp = YelpAPI(key) # Casting the data type of the DataFrame into strings list_of_zips = [str(i) for i in list_of_zips] # Creating a Series from the inputted list of zip codes zip_list = pd.Series(list_of_zips) # Creating an empty list of the number of businesses in a zip code zip_bus_list = [] for zipcode in zip_list: # Using exceptions in case Yelp APIs limitations are met try: # Using the Yelp API search query to retrieve 1 business per zip code search = yelp.search_query(location=zipcode, limit=1) # Appending to the list search['total'], which is the total number # of businesses in a zip code (this metadata is available with each inidividual # business search call) zip_bus_list.append(search['total']) except: pass # Converting the list of businesses into a Series, and then into a DataFrame # that includes the zip code and number of businesses zip_bus_list_series = pd.Series(zip_bus_list) df_business = pd.concat([zip_list, zip_bus_list_series], axis=1) # Renaming the appended columns to 'zipcode' and 'n_business' df_business = df_business.rename(columns={0: 'zipcode', 1: 'n_business'}) # Only choosing zip codes that have between 50 and 1000 businesses df_avail = df_business[(df_business['n_business'] < 1000) & (df_business['n_business'] > 50)] # Setting a random seed for reproducibility np.random.seed(42) # Choosing n_zips specified amount of # random zipcodes from the available list if (n_zips > df_avail.shape[0]): print('You specified more zipcodes than are available in your list') n_zips = df_avail.shape[0] zip_list = np.random.choice(df_avail['zipcode'], n_zips, replace=False) return zip_list.tolist()
def main(): try: yelp_api = YelpAPI(myapi.api_key(), timeout_s=3.0) search_results = yelp_api.search_query(location='77042', radius='8000') except: print("error: ", sys.exc_info()[0]) blist = json.loads(json.dumps(search_results)) for business in blist["businesses"]: print(business["name"].encode('ascii', 'ignore')) print(business["url"].encode('ascii', 'ignore')) print(business["phone"].encode('ascii', 'ignore'))
def get_results(term, location): yelp_api = YelpAPI(os.environ["YELP_API_KEY"]) results = yelp_api.search_query(term=term, location=location, limit=50, sort_by="review_count", radius=8000) businesses = results["businesses"] distance_business = [] for business in businesses: if business["distance"] < 8000: distance_business.append(business) return distance_business
def search_yelp(self, youcook_search_query): yelp_api = YelpAPI(self.api_key) term = youcook_search_query location = 'Boston' search_limit = 5 response = yelp_api.search_query(term=term, location=location, limit=search_limit, sort_by="rating", open_now=True, price="1") # randomly select of the restaurants for diversity random_int = random.randint(0, search_limit - 1) rand_response = response["businesses"][random_int] return rand_response["url"] # return url of the restaurant
def getYelpData(): count = 0 # File containing restaurant names: RestaurantNames.txt input_file = open("RestaurantNames.txt", "r") out_file = open("yelp_data_final.txt", "w") data = input_file.read() json_data = json.loads(data) yelp_api = YelpAPI( 't3EnvPrJD5QFX9byrhYDronkMOjI17LzpSvePzEIRd-NS1FzIK_ayRigJn_iH8qLFI40RRmOXw56V38qcB-JBYdKImFYCg4F8eSmiAQEaOTLfkcNOAz3zxTuWQjBXHYx' ) restaurant_data_yelp = [] for each_data in json_data: each_data = json_data[each_data] res_data = each_data search_results = yelp_api.search_query(term=each_data["name"], location='Chicago, IL') #search_results=json.loads(input_file2.read()) #json.dump(search_results,out_file) search_results['businesses'][1] for each_result in search_results['businesses']: score1 = fuzz.partial_ratio( each_result['location']['display_address'], each_data["street_address"]) score2 = fuzz.partial_ratio(each_result['name'], each_data["name"]) if score1 > 90 and score2 > 90: if 'id' in each_result: res_data['yelp_id'] = each_result['id'] if 'rating' in each_result: res_data['rating'] = each_result['rating'] if 'review_count' in each_result: res_data['review_count'] = each_result['review_count'] if 'url' in each_result: res_data['url'] = each_result['url'] if 'categories' in each_result: res_data['category'] = each_result['categories'] if 'display_phone' in each_result: res_data['phone_number'] = each_result['display_phone'] res_data['lat'] = each_result['coordinates']['latitude'] res_data['lon'] = each_result['coordinates']['longitude'] restaurant_data_yelp.append(res_data) print("processed:", count) count = count + 1 json.dump(restaurant_data_yelp, out_file, sort_keys=True, indent=4, separators=(',', ': '))
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
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
# argparser.add_argument('token_secret', type=str, help='Yelp v2.0 API token secret') # args = argparser.parse_args() consumer_key = 'cdKLIdRVUr7vnYnsTWbiIA' consumer_secret = 'gujwKmCVeIRDxB1QiWHCK4FPKiQ' token = 'npddkfvdPPcQP9JtroXIeo6GaWqPIlWR' token_secret = 'R9TFAp59AbjY8qtBVs0lwlwww3w' 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 *****\n%s\n' % "yelp_api.search_query(term='ice cream', location='austin, tx', sort=2, limit=5)") response = yelp_api.search_query(term='ice cream', location='austin, tx', sort=2, limit=5) 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']))) print('\n-------------------------------------------------------------------------\n') """ 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 *****\n%s\n' % "yelp_api.search_query(category_filter='bikerentals', bounds='37.678799,-123.125740|37.832371,-122.356979', limit=5)") 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('%s\n\tYelp ID: %s\n\trating: %g (%d reviews)\n\taddress: %s' % (business['name'], business['id'], business['rating'],
'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') """ Example search by centroid and category. all Yelp categories: https://www.yelp.com/developers/documentation/v3/all_category_list centroid: https://www.flickr.com/places/info/2487956 """ print('***** 5 bike rentals in San Francisco *****\n{}\n'.format("yelp_api.search_query(categories='bikerentals', " "longitude=-122.4392, latitude=37.7474, limit=5)")) response = yelp_api.search_query(categories='bikerentals', longitude=-122.4392, latitude=37.7474, limit=5) pprint(response) print('\n-------------------------------------------------------------------------\n')
# 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']))
# 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']))
# 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))
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']))
from yelpapi import YelpAPI import json yelp_api = YelpAPI('a5oBT4RnnHpt6rtHQWsGYg', '61UpHpxNDVJfpACumIIJNIR2nJ8', '-PlfjeTyjnMSGP67pQbopdxJ-lXE70Bn', 'ewGlo-jkCt0LpNYphzr2SxaEtCY') search_results = yelp_api.search_query(location='singapore') print json.dumps(search_results)
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']))
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()
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] full_data.append(business) urls.add(str(response['businesses'][i]['url'])) except: pass with open('yelp_full_data.txt', 'w') as outfile: json.dump(full_data, outfile) with open('yelp_urls.txt', 'w') as outfile:
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)
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 try: business_writer.writerow(business_row(business)) except: print "Failed!" pass
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 #count = d.setdefault()
#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)] lon_intervals = [float(i) / 10 for i in xrange(7)] for lat in lat_intervals: for lon in lon_intervals: bounds = str(BaseLat + lat) + ',' + str(BaseLon + lon) + '|' + str(BaseLat + lat + 0.1) + ',' + str(BaseLon + lon + 0.1) print bounds response = yelp_api.search_query(term='alcohol', bounds=bounds, sort=2, limit=20, offset=0) response2 = yelp_api.search_query(term='alcohol', bounds=bounds, sort=2, limit=20, offset=20) if response['businesses'] != []: response_code = yelp_results_collection.insert(response['businesses']) if response2['businesses'] != []: response_code2 = yelp_results_collection.insert(response2['businesses']) time.sleep(10) Lats2 = yelp_results_collection.aggregate([{'$project': {'name' : '$id', 'longitude': '$location.coordinate.longitude', 'latitude': '$location.coordinate.latitude', 'rating' : '$rating'}}]) f = open('./yelp_rating.csv', 'w') csv_file = csv.writer(f) writer = csv.DictWriter(f, fieldnames = ['_id','name','latitude','longitude','rating'])
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 = [] for offset in range(0,400,20): tmp = yelp_api.search_query(term='restaurants', bounds='43.446888,-112.097128|43.542030,-111.931131', sort=0, offset=offset,radius_filter=8000) response.append(tmp) print(tmp) pickle.dump(response, open('restaurants.p','wb'))
#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)): offsetValue = (str)(x*20) #print("Query", x) results = yelp_api.search_query(location=location, category_filter='active', offset=offsetValue, cc='SG') row=0 for r in results: results['businesses'][row]['identifier'] = results['businesses'][row]['id'] del results['businesses'][row]['id']
sort_mode = 2 # initialize an api object yelp_api = YelpAPI(consumer_key, consumer_secret, token, token_secret) # write output to file with open(output_file, 'w+b') as fh: writer = csv.writer(fh) # look here for the terms you can use for searching and their meaning # http://www.yelp.com/developers/documentation/v2/search_api#searchMSL for offset in search_offsets: print "At offset: %d" % offset search_results = yelp_api.search_query( location = search_location, term = search_term, offset = offset, sort = sort_mode ) for biz in search_results.get('businesses'): name = biz.get('name') rating = biz.get('rating') # address is always returned as a list; get first element address = biz.get('location').get('address')[0] zip_code = biz.get('location').get('postal_code') # geocode addresses geo_results = Geocoder.geocode('%s, %s' % (address, zip_code))
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) except Exception as e: print "Error sending request, writing file and quitting." print e break print "This many so far: %d, this many total: %d" % (num_results_so_far, results['total']) for business in results['businesses']: if business['is_closed']: print "Not including, permanently closed: %s" % business['name'] continue try: all_businesses.append({'name': business['name'], 'latitude': business['location']['coordinate']['latitude'], 'longitude': business['location']['coordinate']['longitude'], })
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'] num_results_so_far += len(results['businesses']) if num_results_so_far >= results['total']: break time.sleep(3) # results = yelp_api.search_query(category_filter='coffee', # location='Noe Valley, San Francisco, CA', offset = 20) #