def __import(self): client = Client(self.__auth) params = { 'term': 'food', 'limit': 20, } file = os.path.join(os.path.dirname(os.path.realpath(__file__)), "city_names.txt") with open(file) as f: lines = f.readlines() states = StateSeeder() submissionList = [] for city in lines: print "Searching for " + city locationParam = city.strip() + ", USA" results = client.search(locationParam, **params) state = states.lookupState( results.businesses[0].location.state_code) mapped = map( lambda (item): self.__buildRestaurant(city.strip(), state, item), results.businesses) submissionList.append(mapped) for item in submissionList: self.__insertRestaurantsForCity(item) print "DONE"
def yelp_search(): # read API keys if "consumer_key" in os.environ: auth = Oauth1Authenticator( consumer_key=os.environ['consumer_key'], consumer_secret=os.environ['consumer_secret'], token=os.environ['token'], token_secret=os.environ['token_secret']) else: with open('config_secret.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) client = Client(auth) params = {'term': request.args.get('category', 'food'), 'lang': 'en'} response = client.search('South Bend, IN', **params) businesses = response.businesses results = { b.name: { "business_url": b.url, "image_url": b.image_url, "snippet": b.snippet_text, "location": { "latitude": b.location.coordinate.latitude, "longitude": b.location.coordinate.longitude, }, } for b in businesses } return jsonify(**results)
def _scrape_yelp(query): client = Client(settings.YELP_AUTH) results = client.search('Phoenix', term=query).businesses reviews = list( map(lambda x: client.get_business(x.id).business.reviews[0].excerpt, results)) return reviews
def get_businesses(location, term): auth = Oauth1Authenticator(consumer_key=os.environ['CONSUMER_KEY'], consumer_secret=os.environ['CONSUMER_SECRET'], token=os.environ['TOKEN'], token_secret=os.environ['TOKEN_SECRET']) client = Client(auth) params = {'term': term, 'lang': 'en', 'limit': 3} response = client.search(location, **params) businesses = [] # for business in response.businesses: # # print(business.name, business.rating, business.phone) # businesses.append(business.name) # return businesses # businesses = get_businesses('Danville', 'golf') # print(businesses) # question: what if i want to print out a list of each business as a dictionary for business in response.businesses: print(business.name, business.rating, business.phone) businesses.append({ "name": business.name, "rating": business.rating, "phone": business.phone }) return businesses
def grab_restaurants(city, offset): """grabs business information for the input city args: city (str): the input city offset (int): input value to change the search window for the city returns: 20 restaurants based on the search window for a given city """ # set up api call with given keys # I followed Yelp's advice to store api information in a json file for privacy with io.open('config_secret.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) # set parameters to search for restuarants in a given offset window params = { 'term': 'restaurant', 'offset': offset } return client.search(city, **params)
def yelpsearchapi_by_location(loc): DEFAULT_LOCATION = loc CREDENTIALS_PATH = 'static/credentials.json' RADIUS_FILTER_METERS = 1000 NEAREST_SORT_OPTION = 1 LIMIT = 5 # read api keys credentials with io.open(CREDENTIALS_PATH) as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) # enter parameters params = { 'category_filter': 'bars', 'radius_filter': RADIUS_FILTER_METERS, 'sort': NEAREST_SORT_OPTION, 'limit': LIMIT } if loc: response = client.search(loc, **params) else: response = client.search(DEFAULT_LOCATION, **params) return response
def getRestaurants(latitude, longitude): client = Client(auth) params = {'term': 'food', 'lang': 'en', 'radius_filter': 10000} response = client.search_by_coordinates(latitude, longitude, **params) return response.businesses
def get_businesses (location, term, limit): auth = Oauth1Authenticator( consumer_key=os.environ['CONSUMER_KEY'], consumer_secret=os.environ['CONSUMER_SECRET'], token=os.environ['TOKEN'], token_secret=os.environ.get('TOKEN_SECRET') ) client = Client(auth) params = { 'term': term, 'lang': 'en', 'limit': limit } response = client.search(location, **params) # create an empty list named businesses businesses = [] # add things to it. for business in response.businesses: businesses.append({"name": business.name, "address": business.location.display_address, "rating": business.rating, 'phone': business.display_phone}) return businesses
def search_yelp(input): out = [] with io.open('config_secret.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) params = { 'term' : input } client = Client(auth) response = client.search('Atlanta', **params) print json.dumps(response, default=lambda o: o.__dict__, indent=2) for a in response.businesses: if a.image_url is None: a.image_url = 'http://http.cat/404.jpg' try: nav_link = ','.join([str(a.location.coordinate.latitude), str(a.location.coordinate.longitude)]) except AttributeError: # print json.dumps(a, default=lambda o: o.__dict__, indent=2) nav_link = '' out.append([a.name, a.image_url.replace("ms.jpg", "l.jpg"), a.url, a.rating, a.phone, nav_link]) if (len(out) == 0): out.append('No results found') return out
def search_yelp(secret_file, location, search_parameters): # Extract Yelp Data through the API import io import json from yelp.client import Client from yelp.oauth1_authenticator import Oauth1Authenticator # read API keys with io.open(secret_file) as cred: # Auth in file not shared on github creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) # There are three ways to query the Search API: search, search_by_bounding_box, and # search_by_coordinates. For each of these methods, additional parameters are optional. # The full list of parameters can be found on the Search API Documentation. # https://github.com/Yelp/yelp-python # search_by_bounding_box takes a southwest latitude/longitude and a northeast # latitude/longitude as the location boundary response = client.search_by_bounding_box( location['sw_latitude'], location['sw_longitude'], location['ne_latitude'], location['ne_longitude'], **search_parameters ) return response
def Yelp(command, yelp_authkeys): lowerCom = command.lower() searchType = re.findall(r'yelp (.*?) in', lowerCom, re.DOTALL) searchKey="" for t in searchType: searchKey+=t searchType=searchKey params = { 'term' : searchType } keyword = 'in ' before_key, keyword, after_key = lowerCom.partition(keyword) location = after_key auth = Oauth1Authenticator( consumer_key = yelp_authkeys["CONSUMER_KEY"], consumer_secret= yelp_authkeys["CONSUMER_SECRET"], token = yelp_authkeys["TOKEN"], token_secret = yelp_authkeys["TOKEN_SECRET"] ) client = Client(auth) response = client.search(location, **params) out ="" for x in range(0,3): out += str(x+1) + ". " + str(response.businesses[x].name) + "\n Address: " + str(response.businesses[x].location.display_address).strip('[]').replace("'","").replace(",","") + "\n Ratings: " + str(response.businesses[x].rating) + " with " + str(response.businesses[x].review_count) + " Reviews \n Phone: " + str(response.businesses[x].display_phone) + "\n" return(out)
def get_businesses(location, term): auth = Oauth1Authenticator( consumer_key=environ['CONSUMER_KEY'], consumer_secret=environ['CONSUMER_SECRET'], token=environ['TOKEN'], token_secret=environ['TOKEN_SECRET'] ) client = Client(auth) params = { 'term': term, 'lang': 'en', 'limit': 5 } response = client.search(location, **params) businesses = [] for business in response.businesses: # print(business.name, business.rating, business.phone) businesses.append({"name": business.name, "rating": business.rating, "phone": business.phone, "address": business.location.address }) return businesses
def main(): # read API keys with io.open('config_secret.json') as cred: creds = json.load(cred) session = Oauth1Authenticator(**creds) client = Client(session) locations = [(40.744, -73.985)] api_calls = [] neighborhood_counter = Counter() for lat,lon in locations: params = get_search_parameters(lat,lon) results = client.search_by_coordinates(lat, lon, **params) #Be a good internet citizen and rate-limit yourself for b in results.businesses: # business fields: 'categories', 'deals', 'display_phone', 'distance', 'eat24_url', 'gift_certificates', 'id', 'image_url', 'is_claimed', 'is_closed', 'location', 'menu_date_updated', 'menu_provider', 'mobile_url', 'name', 'phone', 'rating', 'rating_img_url', 'rating_img_url_large', 'rating_img_url_small', 'reservation_url', 'review_count', 'reviews', 'snippet_image_url', 'snippet_text', 'url' print b.name print "Street address: %s"%b.location.cross_streets print "Neighborhoods: %s"%b.location.neighborhoods print b.location.coordinate.latitude, b.location.coordinate.longitude neighborhood_counter.update(b.location.neighborhoods) # 'address', 'city', 'coordinate', 'country_code', 'cross_streets', 'display_address', 'geo_accuracy', 'neighborhoods', 'postal_code', 'state_code' print neighborhood_counter
def get_random_bar_coords(lat, lon, radius): mpm = 1609.34 # meters per mile config = json.load(open('conf.json', 'rb')) auth = Oauth1Authenticator( consumer_key=config['yelp']['consumer_key'], consumer_secret=config['yelp']['consumer_secret'], token=config['yelp']['token'], token_secret=config['yelp']['token_secret'] ) client = Client(auth) param_offset = lambda x: { 'term': 'bars, All', 'lang': 'en', 'sort': 2, # 2: only the top rated in the area 'radius_filter': int(radius * mpm), 'offset': x } bus_list = [] for offset in [0, 20]: response = client.search_by_coordinates(lat, lon, **param_offset(offset)) bus_list.extend(response.businesses) bar = random.choice(bus_list) while bar.name in ["Peter's Pub", "Hemingway's Cafe"]: # Can we just bar = random.choice(bus_list) return bar.location.coordinate.latitude, bar.location.coordinate.longitude
def call_yelp(midlat,midlong,radius): auth = Oauth1Authenticator( consumer_key='Qas4yX9C4dXU-rd6ABmPEA', consumer_secret='5Rtb9Gm5KuwRHSevprdb450E37M', token='xBq8GLMxtSbffTWPPXx7au7EUd2ed3MO', token_secret='Nee0b14NkDO9uSX5cVsS7c4j6GQ' ) print radius client = Client(auth) params = { 'term':'24 hour', 'sort':'0', 'radius_filter': str(radius) # 3 mi radius } #ex: response = client.search_by_coordinates(40.758895,-73.985131, **params) response = client.search_by_coordinates(float(midlat),float(midlong), **params) f = open('output_yelp.txt','w+') for i in range(0,len(response.businesses)): #f.write(response.businesses[i].name) #f.write(",") f.write('%f' % response.businesses[i].location.coordinate.latitude) f.write(",") f.write('%f' % response.businesses[i].location.coordinate.longitude) f.write("\n") f.close()
def get_yelp_info(yelp_id): origin = request.headers.get('Origin') referer = request.headers.get('Referer') if origin is None or referer is None: return abort(404) allowed_url = AllowedUrl.query(AllowedUrl.origin == origin, AllowedUrl.referer == referer).get() if allowed_url is None: return abort(404) yelp_key = Yelp.query().get() if yelp_key is None: return abort(404) auth = Oauth1Authenticator(consumer_key=yelp_key.consumer_key, consumer_secret=yelp_key.consumer_secret, token=yelp_key.token, token_secret=yelp_key.token_secret) client = Client(auth) result = client.get_business(yelp_id).business response = {} response['url'] = result.url response['image_url'] = result.image_url response['rating_img_url'] = result.rating_img_url return jsonify(response)
def call_yelp(midlat,midlong,radius): auth = Oauth1Authenticator( consumer_key='Qas4yX9C4dXU-rd6ABmPEA', consumer_secret='5Rtb9Gm5KuwRHSevprdb450E37M', token='xBq8GLMxtSbffTWPPXx7au7EUd2ed3MO', token_secret='Nee0b14NkDO9uSX5cVsS7c4j6GQ' ) print radius client = Client(auth) params = { 'term':'24 hour', 'sort':'0', 'radius_filter': str(radius) # 3 mi radius } #ex: response = client.search_by_coordinates(40.758895,-73.985131, **params) response = client.search_by_coordinates(float(midlat),float(midlong), **params) f = open('output_yelp.txt','w+') for i in range(0,len(response.businesses)): f.write(response.businesses[i].name) f.write(",") f.write('%f' % response.businesses[i].location.coordinate.latitude) f.write(",") f.write('%f' % response.businesses[i].location.coordinate.longitude) f.write("\n") f.close()
def get_businesses(address): auth = Oauth1Authenticator( consumer_key=os.environ['YELP_CONSUMER_KEY'], consumer_secret=os.environ['YELP_CONSUMER_SECRET'], token=os.environ['YELP_TOKEN'], token_secret=os.environ['YELP_TOKEN_SECRET']) client = Client(auth) params = {'term': "food", 'lang': 'en', 'limit': '3'} response = client.search(address, **params) businesses = [] for business in response.businesses: # print(business.name, business.rating, business.phone) businesses.append({ "name": business.name, "rating": business.rating, "phone": business.phone, "image": business.image_url, "stars": business.rating_img_url }) #return("The top 3 recommended resturants for {}, are: {}, {}, and {}".format(address, businesses[0]['name'], #businesses[1]['name'], businesses[2]['name'])) return businesses
def get_businesses(location, searchterm): auth = Oauth1Authenticator( consumer_key=os.environ['CONSUMER_KEY'], consumer_secret=os.environ['CONSUMER_SECRET'], token=os.environ['TOKEN'], token_secret=os.environ['TOKEN_SECRET'], ) client = Client(auth) params = {'term': searchterm, 'lang': 'en', 'limit': 3, 'sort': 2} # page_size = 3 response = client.search(location, **params) businesses = [] for business in response.businesses: #print(business.name, business.rating, business.phone) businesses.append({ "name": business.name, "rating": business.rating, "phone": business.phone }) return businesses #businesses = get_businesses('Melbourne', 'food') #print(businesses)
def main(): parser = argparse.ArgumentParser() parser.add_argument("output_filename", help="do not include extension (always .json)") args = parser.parse_args() # read API keys with io.open('config_secret.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) params = {'term': 'food', 'sort': '2'} response = client.search('Richmond', **params) compactJson = [] formats = ("id", "name", "rating") for bus in response.businesses: compacted = {} for format in formats: compacted[format] = getattr(bus, format) compacted["latitude"] = bus.location.coordinate.latitude compacted["longitude"] = bus.location.coordinate.longitude compactJson.append(compacted) jsonDump = json.dumps(compactJson, ensure_ascii=False, sort_keys=True, indent=4) with open(args.output_filename + ".json", "w") as f: f.write(jsonDump)
def __init__(self, data): #authorization with io.open('config_secret2.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) self.client = Client(auth) self.data = data self.food_per_business = data['food_per_business']
def fetch(location='San Francisco', category='private tutors', start=0, pages=1000): client = Client(auth) results = [] i = start while i < pages: businesses = client.search(location, term=category, offset=i).businesses results.append(businesses) print(i) if (len(businesses) < 20): break i += 20 dicts_to_output = [{ 'Source': 'Yelp', 'Position': '', 'Phone': biz.display_phone, 'Yelp_ID': biz.id, 'Yelp_URL': biz.url, 'Business_Name': biz.name, 'Website': '', 'Email': '', 'Individual?': '', 'First_Name': '', 'Last_Name': '', 'Has_booking_on_website?': '', 'Address': biz.location.address, 'City': biz.location.city, 'State': biz.location.state_code, 'Zip_Code': biz.location.postal_code, 'Yelp_Top_Category': biz.categories[0].alias if biz.categories else '', 'Yelp_Review_Count': biz.review_count, 'Yelp_Rating': biz.rating } for biz in [item for sublist in results for item in sublist]] return dicts_to_output
def group_recommend(request, event_id): try: event = Group.objects.get(id=event_id) except ObjectDoesNotExist: raise Http404 context = {} # if the request user has no relation with the event, redirect to homepage if not (request.user == event.user or event.members.filter(user=request.user).exists()): return redirect('/linterest/') # create a new chatroom associated with event if not already exist try: chatroom = GroupChatRoom.objects.get(group=event) except ObjectDoesNotExist: # create a new chatroom w.r.t. the event if not already exist chatroom = GroupChatRoom(group=event) members = event.members.all(); chatroom.users.add(Profile.objects.get(user=event.user)) for member in members: chatroom.users.add(member) chatroom.save() context["event_id"] = event_id context["user"] = request.user context["type"] = "group" with io.open('yelp_secret.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) params = { 'term': event.type, 'lang': 'en', 'limit': 10, } print('prepare to search') try: response = client.search(event.city, **params) except: defaultCoordinate = [40.44, -79.99] context['latitude'] = defaultCoordinate[0] context['longitude'] = defaultCoordinate[1] context['error_message'] = 'Recommendations are unavailable in the given location' return render(request, 'recommend.html', context) print('search successfully') context['latitude'] = response.region.center.latitude context['longitude'] = response.region.center.longitude context['businesses'] = response.businesses return render(request, 'recommend.html', context)
def fetchCoffeeBusinesses(self): with io.open(self.yelp_auth_path) as auth_file: creds = json.load(auth_file) auth = Oauth1Authenticator(**creds) client = Client(auth) params = {'term': 'coffee', 'lang': 'en'} coffee_shops = client.search('San Francisco', **params) return coffee_shops.businesses
def __init__(self, yelp_config): self.auth = Oauth1Authenticator( consumer_key=yelp_config['consumer_key'], consumer_secret=yelp_config['consumer_secret'], token=yelp_config['token'], token_secret=yelp_config['token_secret']) self.client = Client(self.auth) self.reader = csv.DictReader self.outfile = open('data/yelp/businesses.csv', "w+") self.db = []
def post_detail(request, photo_id): try: # get Flickr Post details post = FlickrPost.objects.get(pk=photo_id) context_dict['valid_post'] = True h = html.parser.HTMLParser() if not post.latitude or not post.longitude: photo = __get_flickr_post_info(photo_id) post.latitude = float(photo['location']['latitude']) post.longitude = float(photo['location']['longitude']) post.description = h.unescape(photo['description']['_content']) post.save() context_dict['post'] = post # get Yelp reviews for that location yelp = YelpClient.objects.get(pk=1) auth = Oauth1Authenticator( consumer_key=yelp.consumer_key, consumer_secret=yelp.consumer_secret, token=yelp.token, token_secret=yelp.token_secret ) client = Client(auth) # get location that most closely matches the geolocation best_business = None alt_businesses = list() yelp_api_error = False try: response = client.search_by_coordinates(post.latitude, post.longitude) if response.businesses: best_business = response.businesses[0] if len(response.businesses) > 5: alt_businesses = response.businesses[1:6] elif len(response.businesses) > 1: alt_businesses = response.businesses[1:] except: yelp_api_error = True context_dict['yelp_api_error'] = yelp_api_error context_dict['best_business'] = best_business context_dict['alt_businesses'] = alt_businesses except FlickrPost.DoesNotExist: context_dict['valid_post'] = False return render(request, 'entree/post_detail.html', context_dict)
def Add_nodes(city_name='San_Francisco', buss_type='Restaurants', number=100): # Ussing the Yelp library for Yelp authentification and requesting info auth = Oauth1Authenticator(consumer_key="", consumer_secret="", token="", token_secret="") client = Client(auth) buss_types = make_sure('buss_types') assert buss_type in buss_types.keys() locations = find_locations(city_name, number) if os.path.isfile('Data/{}_Data.json'.format(city_name)) == False: with open('Data/{}_Data.json'.format(city_name), 'w') as f: geojson.dump({"type": "FeatureCollection", "features": []}, f) with open('Data/{}_Data.json'.format(city_name)) as f: data = json.load(f) IDs = [] added = 0 nodes_added = [] for feature in [ feature for feature in data['features'] if feature['geometry']['type'] == 'point' ]: IDs.append(feature['properties']['name']) for lat, long in locations: places = client.search_by_coordinates(lat, long, buss_type) for business in places.businesses: if business.name not in IDs: IDs.append(business.name) node = Node(business.name, business.location.coordinate.latitude, business.location.coordinate.longitude, business.rating, buss_type, business.categories, business.image_url, city_name, comp_time=buss_types[buss_type]['durations']) data['features'].append(node.geo_interface()) nodes_added.append(node) added += 1 with open('Data/{}_Data.json'.format(city_name), 'w') as f: geojson.dump(data, f) return '{} nodes added'.format(added)
def getRestaurants(latitude, longitude): client = Client(auth) params = { 'term': 'food', 'lang': 'en', 'radius_filter': 10000 } response = client.search_by_coordinates(latitude, longitude, **params) return response.businesses
def __init__(self): self.name = "yelp" creds = self.loadCredentials() # Authenticate Yelp auth = Oauth1Authenticator(consumer_key=creds["consumer_key"], consumer_secret=creds["consumer_secret"], token=creds["token"], token_secret=creds["token_secret"]) self.yelpClient = Client(auth) self.mongoClient = MongoClient(creds["mongodb"])
def api_callee(event, context): # read API keys with io.open('config_secret.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) params = { 'term': event['item'], 'lang': 'en', 'limit': 5 } #print event['item'] #print event['location'] response = client.search(event['location'], **params) #print response placesYelp = "" #print response.businesses[0] if response.businesses == None: placesYelp = 'jankiap50_error_yelp' elif len(response.businesses) == 0: placesYelp = 'jankiap50' else: placesYelp = str(response.businesses[0].name) +'@'+ \ str(response.businesses[0].mobile_url.partition("?")[0]) +'@' + \ str(response.businesses[0].image_url) +'@' + \ str(response.businesses[0].rating) +'@' + \ str(response.businesses[0].display_phone)+'@' + \ str(response.businesses[1].name)+'@' + \ str(response.businesses[1].mobile_url.partition("?")[0])+'@' + \ str(response.businesses[1].image_url) +'@' + \ str(response.businesses[1].rating)+'@' + \ str(response.businesses[1].display_phone)+'@' + \ str(response.businesses[2].name)+'@' + \ str(response.businesses[2].mobile_url.partition("?")[0])+'@'+ \ str(response.businesses[2].image_url) +'@' + \ str(response.businesses[2].rating)+'@' + \ str(response.businesses[2].display_phone)+'@' + \ str(response.businesses[3].name)+'@' + \ str(response.businesses[3].mobile_url.partition("?")[0])+'@' + \ str(response.businesses[3].image_url) +'@' + \ str(response.businesses[3].rating)+'@' + \ str(response.businesses[3].display_phone)+'@' + \ str(response.businesses[4].name)+'@' + \ str(response.businesses[4].mobile_url.partition("?")[0])+'@'+ \ str(response.businesses[4].image_url) +'@' + \ str(response.businesses[4].rating)+'@' + \ str(response.businesses[4].display_phone)+'@' #return response.businesses[0].name, response.businesses[0].url.partition("?")[0], response.businesses[0].rating, response.businesses[0].display_phone #print str(placesYelp) result=placesYelp.encode('ascii', 'ignore') return result
def search_food(address): auth = Oauth1Authenticator(consumer_key=os.environ['CONSUMER_KEY'], consumer_secret=os.environ['CONSUMER_SECRET'], token=os.environ['TOKEN'], token_secret=os.environ['TOKEN_SECRET']) client = Client(auth) FORECASTIO_API_KEY = os.environ['FORECASTIO_API_KEY'] # print("What term are you looking for?") # term_input=raw_input() # print("And around what address are you looking at?") # area=raw_input() # print("Looking for {} in {}".format(term_input, area)) params = {'term': 'bar', 'radius_filter': 1200, 'lang': 'en'} response = client.search(address, **params) businesses_list = [] for business in response.businesses: if business.rating >= 3.5: businesses_list.append({ "name": business.name, "rating": business.rating, "phone": business.phone }) # Select a random number from the list of businesses rannum = randint(0, len(businesses_list) - 1) # print("Cool! Beep boop beep beep boop....") # print("calculating...") # print("calculating...") # print("calculating...") # print("Out of {} businesses I am choosing number {}".format(len(businesses_list),rannum)) # Caclulate weather at random selected resturant # def get_address(buisnessname): # location = geolocator.geocode(buisnessname) # print(location) # Select a random business from the business list, using the random int generated above return "Check out {}! \n Phone number is {}".format( businesses_list[rannum].get('name'), businesses_list[rannum].get('phone'))
def fetchCoffeeBusinesses(self): with io.open(self.yelp_auth_path) as auth_file: creds = json.load(auth_file) auth = Oauth1Authenticator(**creds) client = Client(auth) params = { 'term': 'coffee', 'lang': 'en' } coffee_shops = client.search('San Francisco', **params) return coffee_shops.businesses
def getResults(entityDict): auth = Oauth1Authenticator(consumer_key="GnqVNHo3kMwUkjHtcKTAiQ", consumer_secret="pAAALBgFrBrnfV4wUm4Q-gnRQK0", token="X1adQAiL7lfMu4x0DFLypmDXMJTeR45_", token_secret="6ol3E34GGqZm-rBF-M8U9HsSt7M") client = Client(auth) LOCATION = entityDict['location'] CUISINE = entityDict['cuisine'] COST = entityDict['cost'] RATING = entityDict['rating'] DATETIME = entityDict['datetime'] if (DATETIME): HOUR = DATETIME.split('T')[1][0:2] else: HOUR = "" CUISINE = CUISINE if CUISINE else "" COST = COST if COST else "" RATING = float(RATING) if RATING else 0.0 params = { 'term': COST + ' ' + CUISINE + ' ' + 'restaurants' + ' which remain open at ' + HOUR, 'sort': "0", 'limit': '3' } if (LOCATION == None): return {} response = client.search(LOCATION, **params) d = {} count = 1 for i in range(0, len(response.businesses)): if (response.businesses[i].rating >= RATING): d[count] = {} d[count]["name"] = response.businesses[i].name d[count]["url"] = response.businesses[i].url d[count]["address"] = response.businesses[i].location.address d[count]["rating"] = response.businesses[i].rating d[count]["reviews"] = response.businesses[i].review_count count += 1 return d
def get_total_ratings(x): # authenticate the api auth = Oauth1Authenticator( consumer_key='d8eoj4KNoPqOqE_RN9871Q', consumer_secret='pGVDNEGSaH8Kv-WZ8ba5v02IjCo', token='S-SfyVte5G0nCkTmbydWRtxlheNXCEnG', token_secret='Y_UViE9LthLQqW7_ht8U8V_F6aE' ) client = Client(auth) # return the total number of ratings for a restaurant total_ratings = client.get_business(x) total_ratings = total_ratings.business.review_count return total_ratings
def get(self): args = parser.parse_args() auth = Oauth1Authenticator(consumer_key=consumer_key, consumer_secret=consumer_secret, token=yelp_token, token_secret=yelp_token_secret) client = Client(auth) response = client.search(**args) res = [[ b.name, b.location.coordinate.latitude, b.location.coordinate.longitude, b.rating ] for b in response.businesses] res = sorted(res, key=lambda x: x[-1], reverse=True) return json.dumps(res)
def get_results(params): # read API keys with open('config_secret.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) request = client.search_by_coordinates("http://api.yelp.com/v2/search",params=params) #Transforms the JSON API response into a Python dictionary data = request.json() client.close() return data
def Add_nodes(city_name = 'San_Francisco', buss_type = 'Restaurants' , number = 100): # Ussing the Yelp library for Yelp authentification and requesting info auth = Oauth1Authenticator( consumer_key="", consumer_secret="", token="", token_secret="" ) client = Client(auth) buss_types = make_sure('buss_types') assert buss_type in buss_types.keys() locations = find_locations(city_name,number) if os.path.isfile('Data/{}_Data.json'.format(city_name)) == False: with open('Data/{}_Data.json'.format(city_name),'w') as f: geojson.dump({"type": "FeatureCollection","features": []}, f) with open('Data/{}_Data.json'.format(city_name)) as f: data = json.load(f) IDs = [] added = 0 nodes_added = [] for feature in [feature for feature in data['features'] if feature['geometry']['type'] == 'point']: IDs.append(feature['properties']['name']) for lat,long in locations: places = client.search_by_coordinates(lat, long, buss_type) for business in places.businesses: if business.name not in IDs: IDs.append(business.name) node = Node(business.name, business.location.coordinate.latitude, business.location.coordinate.longitude, business.rating, buss_type, business.categories, business.image_url, city_name, comp_time = buss_types[buss_type]['durations']) data['features'].append(node.geo_interface()) nodes_added.append(node) added += 1 with open('Data/{}_Data.json'.format(city_name), 'w') as f: geojson.dump(data, f) return '{} nodes added'.format(added)
def yelp_search(): client = Client(auth) page_size = 20 page = 0 count = 0 max_page_count = 1 # Can take a max value of 50 search_term = "Parks" city = "New York City" print("Page: " + str(page + 1) + "\n") resp = client.search(term=search_term, location=city, limit=page_size, offset=page * page_size) count = count + len(resp.businesses) for j in resp.businesses: website_link = make_post_requests(j.url) if website_link != '0': print("Link found.\n") links.append([website_link]) else: print("Website link not found.\n") while resp and page < max_page_count - 1: page = page + 1 if page % 7 == 0: print("\nSleeping for 10 minutes") sleep(600) print("Page: " + str(page + 1)) resp = client.search(term=search_term, location=city, limit=page_size, offset=page * page_size) count = count + len(resp.businesses) for j in resp.businesses: website_link = make_post_requests(j.url) if website_link != '0': print("Link found.\n") links.append([website_link]) else: print("Website link not found.\n") path = search_term + '.csv' with open(path, 'w') as outfile: writer = csv.writer(outfile) for row in links: writer.writerow(row)
class yelper: def __init__(self): with io.open('config_secret.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) self.client = Client(auth) def resturant_search(self, query): try: params = { 'term':'food' } response = self.client.search(query,**params) except Exception as e: print(e) return None data = [0]*5 for resturant in response.businesses: data[int(resturant.rating)-1] += 1 """ data[business.id] = {"coordinates": (business.location.coordinate.latitude, business.location.coordinate.longitude)} print(business.categories) print() """ return data
def search_yelp(nouns): auth = Oauth1Authenticator( consumer_key=environ.get('YELP_CONSUMER_KEY'), consumer_secret=environ.get('YELP_CONSUMER_SECRET'), token=environ.get('YELP_TOKEN'), token_secret=environ.get('YELP_TOKEN_SECRET') ) terms = reduce(lambda prev, curr: prev + ' ' + curr, nouns, ''), print terms client = Client(auth) return client.search('New York, NY', **{ 'term': nouns[0], 'limit': 3, 'category_filter': 'restaurants' });
def get(location, term): print('in yelp_api.get, with term: ', term) params = { 'location': location, 'term': term, } auth = Oauth1Authenticator(**settings.YELP_CONFIG) client = Client(auth) response = client.search(**params) total_results = response.total businesses = [business for business in response.businesses] average_rating = sum([business.rating for business in businesses])/len(businesses) return { 'total': total_results, 'selected_businesses_count': len(businesses), 'average_rating': average_rating, }
class YelpService(object): def __init__(self): auth = Oauth1Authenticator( consumer_key="uz2Sv5gO6dwlnjRv3BqzwA", consumer_secret="VhgG3IucBO_eTheOlWzrVuuVjbU", token="bN1HD9FSDGqUWjzxbIkho_N1muVe0xcA", token_secret="hEdALK5D2gCI9-H3GwGKAw1jEYo" ) self.client = Client(auth) self._business_cache = {} def get_location(self, yelp_id): """ Get the location of a yelp business """ business = self._get_business(yelp_id) return business.location.coordinate def get_name(self, yelp_id): """ Get the name of a location """ business = self._get_business(yelp_id) return business.name def get_url(self, yelp_id): """ Get the url to the yelp side of a business """ business = self._get_business(yelp_id) return business.url def _get_business(self, yelp_id): if yelp_id in self._business_cache: return self._business_cache[yelp_id] else: response = self.client.get_business(yelp_id) self._business_cache[yelp_id] = response.business return response.business def search(self, query, location): response = self.client.search(location=location, term=query) return response.businesses
def __init__(self): auth = Oauth1Authenticator( consumer_key= 'NqKErS1dFKKwfxlc5KpB0Q', consumer_secret= 'BzO_xc7Jge-B5YeysLuLi-WkiHE', token= '72CDWmpOaC8LEVgjY1bZVQgyX4v3v8fx', token_secret='yLfQC1-Vr_B5mpuqKtidnK_gnbo' ) self.client = Client(auth)
def __init__(self): ''' Load Oauth keys ''' _path_ = os.path.abspath(os.path.dirname(sys.argv[0])) _path_ = '/'.join([_path_,'web_app/api_adapter/config_secret.json']) cred = io.open(_path_) cred = json.load(cred) auth = Oauth1Authenticator(**cred) self.client = Client(auth)
def get_businesses_from_yelp(location_string): """ Search Yelp through API for knitting/yarn, save results to objects location_string: the user location string :return: list of YelpBusiness objects for input city """ # read API keys with io.open('yelp_config_secret.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) yelp_knitting_category_alias = 'knittingsupplies' params = { 'category_filter': yelp_knitting_category_alias } yelp_results = client.search(location_string, **params) list_of_biz = [] for business in yelp_results.businesses: biz_name = business.name biz_addr = business.location.display_address biz_city = business.location.city biz_lat = business.location.coordinate.latitude biz_long = business.location.coordinate.longitude biz_url = business.url biz_closed = business.is_closed # exclude businesses that are closed if biz_closed == False: new_biz = YelpBusiness(biz_name=biz_name, biz_addr=biz_addr[0], biz_city=biz_city, biz_lat=biz_lat, biz_long=biz_long, biz_url=biz_url) list_of_biz.append(new_biz) return list_of_biz
def yelp(loc, c, paramsA, paramsB): print "YELP" auth = Oauth1Authenticator( consumer_key="Q7OyV59ytZdO-zuAo3Rl0g", consumer_secret="xNOuCM0FhUthxpA8RFiQgEPtFaM", token="EE_wX2qYssWNzSLL65gFCg9ciTbf1sEL", token_secret="gHEEbPgA66UVFAC3bmmehi6kY3I" ) client = Client(auth) print "YELPC" print c if(c == 1 or c == '1'): print 1111111111111111111111111111111111111111 # params1 = { # 'sort': '2', # #'sort': '1', # 'term': 'food', # 'lang': 'en', # #'radius_filter': '10' # } # print "YELP1" response = client.search(loc, **paramsA) elif(c == 2 or c == '2'): print 222222222222222222222222222222222222222 # params2 = { # 'sort': '2', # #'sort': '1', # 'term': 'fun', # 'lang': 'en', # #'radius_filter': '10' # } response = client.search(loc, **paramsB) #print mainlist print "YELPM" for i in range(10): mainlist.append(response.businesses[i].name) ratinglist.append(response.businesses[i].rating) citylist.append(response.businesses[i].location.city) print mainlist
def __init__(self): auth = Oauth1Authenticator( consumer_key="uz2Sv5gO6dwlnjRv3BqzwA", consumer_secret="VhgG3IucBO_eTheOlWzrVuuVjbU", token="bN1HD9FSDGqUWjzxbIkho_N1muVe0xcA", token_secret="hEdALK5D2gCI9-H3GwGKAw1jEYo" ) self.client = Client(auth) self._business_cache = {}
def yelp(self, words): print("yelp") auth = Oauth1Authenticator( consumer_key=cf.get("yelp", "ConsumerKey"), consumer_secret=cf.get("yelp", "ConsumerSecret"), token=cf.get("yelp", "Token"), token_secret=cf.get("yelp", "TokenSecret"), ) client = Client(auth) if "around me" or "near me" in words: print("yelp") params = {"term": "food"} response = client.search("Lawrence", **params) text = ( "Some of the restaurants are " + response.businesses[0].name + " and " + response.businesses[1].name ) print(text) return text
def yelp_search_resturants_general(self, city, state, radius): cityState = city + ',' + state auth = Oauth1Authenticator( consumer_key= 'bM0VPHWh91R0g46amxYbnA', consumer_secret='l-p2JF_V2BZSsNWGPRT7QywfoGE', token='rD8K96AXRAxiwI_R_mQwwdMUwb65Ctt_', token_secret= 'ugp2wQ8Pb4tcV0Qc8pc23MlkvLw' ) client = Client(auth) print "My client is authenticated" + str(client) params = { 'term': 'restaurants', 'radius_filter': str(int(radius) * 1609), 'sort': '0', 'limit':'20' } data = client.search(cityState, **params) return data
def yelp_search_attractions(self, city, state, radius): cityState = city + ',' + state #Authentication keys for yelp auth = Oauth1Authenticator( consumer_key= 'bM0VPHWh91R0g46amxYbnA', consumer_secret='l-p2JF_V2BZSsNWGPRT7QywfoGE', token='rD8K96AXRAxiwI_R_mQwwdMUwb65Ctt_', token_secret= 'ugp2wQ8Pb4tcV0Qc8pc23MlkvLw' ) client = Client(auth) params = { 'category_filter': 'landmarks,museums,beaches', 'radius_filter': str(int(radius) * 1609), 'sort': '0', 'limit': '20' } data = client.search(cityState, **params) return data
class YelpClient(object): def __init__(self): auth = Oauth1Authenticator( consumer_key= 'NqKErS1dFKKwfxlc5KpB0Q', consumer_secret= 'BzO_xc7Jge-B5YeysLuLi-WkiHE', token= '72CDWmpOaC8LEVgjY1bZVQgyX4v3v8fx', token_secret='yLfQC1-Vr_B5mpuqKtidnK_gnbo' ) self.client = Client(auth) def search(self,params): return self.client.get_business(params)
def get_restaurants(city, offset): """ Returns API response from Yelp API call to get restaurants for a city, with the results offset. Note that Yelp only returns 20 results each time, which is why we need to offset if we want the next Nth results. """ # Read Yelp API keys with io.open('config_secret.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) # Set term as restaurant to get restaurants for results # Need to pass in offset, so Yelp knows how much to offset by params = { 'term': 'restaurant', 'offset': offset } return client.search(city, **params)
def findScheduleOptions(self): self.options_list = [] #Create a pair of activities for each of the combinations of one result from yelp and one from eventful for an_event in self.eventful_results: event_activity = Activity(an_event, "eventful") lat = an_event['latitude'] # lng = an_event['longitude'] # dining_activities = [] auth = Oauth1Authenticator(consumer_key = "mvC1SY7wAUx_RPlVhG-fIw",consumer_secret = "vkqWVoowxsWkUu7KU0t2Pj3qY1k",token = "syYEIdwvGt-uLGdgVmu9ZsQfE98CROe4", token_secret = "AQLQnKJA7VYw4XlVIMK7hYzSwDo") # client = Client(auth) # print("yelp params", self.yelp_params) yelp_results = client.search_by_coordinates(lat, lng, **self.yelp_params) print(len(yelp_results.businesses)) for j in range(len(yelp_results.businesses)): #print(location.businesses[j]) #print(self.yelp_results.businesses[j]) dining = Activity(yelp_results.businesses[j], "yelp") dining_activities.append(dining) self.options_list.append(EventAndDiningPair(event_activity, dining_activities))
def getresponse(term,lat,lon): #term, location coords R = 6371 radius = 2 filename = 'config_secret.json' with io.open('/Users/thiyagesh/Desktop/yelp/drf-demo/drf_demo/model_less/config_secret.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) params = { 'term': term, 'lang': 'fr' } result = [] lat = float(lat) lon = float(lon) x1 = lon - math.degrees((radius*math.cos(math.radians(lat)))/R) x2 = lon + math.degrees((radius*math.cos(math.radians(lat)))/R) y1 = lat + math.degrees(radius/R) y2 = lat - math.degrees(radius/R) print "Original:",lat,lon print "Next:",lat-0.001,lon+0.001 response = client.search_by_bounding_box( lat+0.01, lon-0.01, lat-0.01, lon+0.01, **params ) #response = client.search_by_coordinates(lat, long, **params) for i in response.businesses: result.append(i.name) if len(result) != 0: return result else: return None
def get_yelp(city, job): res = [] with open('yelp.json') as cred: creds = load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) results = client.search(city, **{ 'term': job, 'lang': 'fr', 'sort': 2 }).businesses for result in results: res.append({ "name": result.name, "rating": result.rating, "longitude": result.location.coordinate.longitude, "latitude": result.location.coordinate.latitude, "street": result.location.address }) return res
class API_adapter(object): def __init__(self): ''' Load Oauth keys ''' _path_ = os.path.abspath(os.path.dirname(sys.argv[0])) _path_ = '/'.join([_path_,'web_app/api_adapter/config_secret.json']) cred = io.open(_path_) cred = json.load(cred) auth = Oauth1Authenticator(**cred) self.client = Client(auth) def get_restaurant(self, location, category_filter=None): params = { 'term': 'food', 'location': location, 'cc' : 'US' } if category_filter: params['category_filter'] = category_filter restaurant = self.client.search(**params) return restaurant.businesses
# cell 1 - crtea Yelp client based on your keys from yelp.client import Client from yelp.oauth1_authenticator import Oauth1Authenticator auth = Oauth1Authenticator( consumer_key="[your customer kwy]", consumer_secret="[your customer secret]", token="[your token]", token_secret="[your token secret]" ) client = Client(auth) # cell 2 - TYR1: try to find whether Yelp search is based on key words in current business content params = { 'term': 'Pokemon' } response = client.search('Seattle', **params) ct = 0 for biz in response.businesses: print biz.name print biz.id print biz.image_url print biz.categories print biz.rating print biz.reviews
import json from yelp.client import Client from yelp.oauth1_authenticator import Oauth1Authenticator # read API keys with open('config_secret.json') as cred: creds = json.load(cred) auth = Oauth1Authenticator(**creds) client = Client(auth) #terms= ['KFC'] #for term in terms: params = { 'terms': 'parks, all', 'lang': 'en', 'sort': '1', 'radius_filter':'40000', } response = client.search('San Francisco', **params) bizlist=response.businesses for biz in bizlist: print biz.url