def home(request): """ Landing page """ # complete oauth retrieving token (unless already in session) login_code = request.GET.get('code', '') if not request.session.has_key(ACCESS_TOKEN) and not login_code: return render(request, 'home.html') elif not request.session.has_key(ACCESS_TOKEN) and login_code: client = foursquare.Foursquare(client_id=settings.CLIENT_ID, client_secret=settings.CLIENT_SECRET, redirect_uri=settings.REDIRECT_URI) access_token = client.oauth.get_token(login_code) request.session[ACCESS_TOKEN] = access_token request.session["is_logged_in"] = True client = foursquare.Foursquare(access_token=request.session[ACCESS_TOKEN]) access_token = request.session[ACCESS_TOKEN] user = client.users() user_id = user["user"]["id"] request.session[USER] = user checkins = client.users.checkins() with open(os.path.join(settings.NEW_USER_DIRECTORY, user_id), 'w+') as outfile: json.dump(user, outfile) with open(os.path.join(settings.CHECKINS_DIRECTORY, user_id), 'w+') as outfile: json.dump(checkins, outfile) return redirect('/recommend/')
def search_activity(ciudad, cultural, festivas, ludicas): CLIENT_ID = 'OTXPMRAIY0GHYDTPXELL1EDHFYNVVRFEMQLHUUVXNEYV1DDS' CLIENT_SECRET = '50FCYQPJSHM4CBVXVQFKXVM2AMKAIAEQ3LDZVZZZ44O10MTV' contenidoActivity = {} if str(cultural) == 'Sí': client = foursquare.Foursquare(client_id=CLIENT_ID, client_secret=CLIENT_SECRET) cul = client.venues.search( params={ 'll': GEO[str(ciudad)], 'intent': 'browse', 'radius': '4000', 'query': 'monument' }) k = cul["venues"] for result in k: contenidoActivity[result["name"]] = "C" if str(festivas) == 'Sí': client = foursquare.Foursquare(client_id=CLIENT_ID, client_secret=CLIENT_SECRET) fes = client.venues.search( params={ 'll': GEO[str(ciudad)], 'intent': 'browse', 'radius': '4000', 'query': 'party' }) k = fes["venues"] for result in k: contenidoActivity[result["name"]] = "F" if str(ludicas) == 'Sí': client = foursquare.Foursquare(client_id=CLIENT_ID, client_secret=CLIENT_SECRET) lud = client.venues.search( params={ 'll': GEO[str(ciudad)], 'intent': 'browse', 'radius': '4000', 'query': 'casino' }) k = lud["venues"] for result in k: contenidoActivity[result["name"]] = "L" return contenidoActivity
async def callback(code: str = None, db: Session = Depends(get_db)): if not code: raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST) redirect_uri = 'http://' + os.environ.get("DOMAIN") + '/callback' client = foursquare.Foursquare(client_id=cid, client_secret=cs, redirect_uri=redirect_uri) access_token = client.oauth.get_token(code) client = foursquare.Foursquare(access_token=access_token) user = client.users() user_id = user["user"]["id"] token = create_tokens(db=db, user_id=user_id, at=access_token) return token
def test_basic_auth(self): "Testing basic HTTP authentication." fs = foursquare.Foursquare( foursquare.BasicCredentials(username, password)) test_result = fs.test() self.assertEqual(test_result['response'], 'ok') user = fs.user() self.failUnless('user' in user) # Now try with a bad user/password fs = foursquare.Foursquare( foursquare.BasicCredentials(username, 'passworddontmatter' + password)) self.assertRaises(foursquare.FoursquareRemoteException, lambda: fs.user())
def auth_4sq(client_id, client_secret): # Construct the client object client = foursquare.Foursquare(client_id=client_id, client_secret=client_secret) # Build the authorization url for your app auth_uri = client.oauth.auth_url() return client
def main(): add_table_venue_meta() add_table_venue_photo_4sq() add_table_venue_tips() client = foursquare.Foursquare( config.foursquare_client_id, client_secret=config.foursquare_client_secret) all_plazas = client.venues.search( params={ 'near': 'New York City', 'limit': 50, 'intent': 'browse', 'radius': 5000, 'categoryId': '4bf58dd8d48988d164941735' }) print all_plazas cnt = 0 for v in all_plazas['venues']: time.sleep(10) venue_id = v['id'] print 'progress: %d/%d -> %s' % (cnt, len(all_plazas), v['name']) crawler = VenueMetaCrawler() crawler.grab_meta_data(venue_id) crawler = VenuePhotoCrawlerFoursquare() crawler.grab_photo(venue_id) crawler = VenueTipsCrawler() crawler.grab_tip(venue_id)
def get_status(self): client = foursquare.Foursquare( config.foursquare_client_id, client_secret=config.foursquare_client_secret) all_plazas = client.venues.search( params={ 'near': 'New York City', 'limit': 50, 'intent': 'browse', 'radius': 5000, 'categoryId': '4bf58dd8d48988d164941735' }) queue = Queue.Queue() for i in range(3): t = Job(queue) t.setDaemon(True) t.start() ids = [] for v in all_plazas['venues']: ids.append(v['id']) queue.put(v['id']) queue.join() return "done" """ """ return 'ok'
def fs_rating_dict(location, restaurant): CLIENT_ID = u'OO3LVQ50PEU241GACB3GMFGOQCEMBBGMJKXHFP1IYO2MECOI' CLIENT_SECRET = u'TXQPMS1KMG4DBNFFAA4OBEMEEJG3FW0SNPPGZ0IKGNLQIRE1' client = foursquare.Foursquare(client_id=CLIENT_ID, client_secret=CLIENT_SECRET) rating_dict = {} #get venue id from search venue_info = client.venues.search(params={ 'near': location, 'query': restaurant, 'limit': 1 }) if len(venue_info['venues']) == 0: rating_dict[restaurant] = 0 return rating_dict else: venue_id = venue_info['venues'][0]['id'] if len(venue_info['venues']) == 0: rating_dict[restaurant] = 0 return rating_dict else: venue_id = venue_info['venues'][0]['id'] #get average rating details = client.venues(venue_id) rating = details['venue'].get('rating') if rating == None: rating_dict[restaurant] = 0 else: #divide by 2 to compare to yelp's ratings adjusted_rating = rating / 2 rating_dict[restaurant] = adjusted_rating return rating_dict
def fs_price_tier_dict(location, restaurant): CLIENT_ID = u'OO3LVQ50PEU241GACB3GMFGOQCEMBBGMJKXHFP1IYO2MECOI' CLIENT_SECRET = u'TXQPMS1KMG4DBNFFAA4OBEMEEJG3FW0SNPPGZ0IKGNLQIRE1' client = foursquare.Foursquare(client_id=CLIENT_ID, client_secret=CLIENT_SECRET) price_tier_dict = {} #get venue id from search venue_info = client.venues.search(params={ 'near': location, 'query': restaurant, 'limit': 1 }) if venue_info['venues'] == None: price_tier_dict[restaurant] = 0 else: if len(venue_info['venues']) == 0: price_tier_dict[restaurant] = 0 return price_tier_dict else: venue_id = venue_info['venues'][0]['id'] details = client.venues(venue_id) price = details['venue'].get('price') if price == None: price_tier = 0 price_tier_dict[restaurant] = price_tier else: price_tier = price.get('tier') price_tier_dict[restaurant] = price_tier return price_tier_dict
def get_foursquare_restaurants(zipcode): cid = 'CR35KTWYW2ORWUVSKYRO2DBJQS5IHUGZ0L3AUD1NNEJ1DFVO' csec = '0CJSR410CJYIF3YQBPFBCPAUAXTCJW5JXMJ4ABRDXAKWPZVF' result = [] client = foursquare.Foursquare(client_id=cid, client_secret=csec) auth_uri = client.oauth.auth_url() # ex['groups'][0]['items'][0]['venue']['location'] limit = client.venues.explore(params={ 'query': 'restaurant', 'near': str(zipcode), 'limit': '1', 'offset': '0' })['totalResults'] limit = int(limit) for i in range(0, limit, 50): restaurants = client.venues.explore( params={ 'query': 'restaurant', 'limit': '50', 'offset': str(i), 'near': str(zipcode) })['groups'][0]['items'] for restaurant in restaurants: result.append(foursquare_to_json(restaurant)) return result
def getMenus(self, venues=None): """ Description ----------- A method for returning venue menu query response data. Parameters ---------- venues: list; A list of venue id numbers to query for menu data. """ if venues is None: venues_dict = self.JSON_DATA['VENUES'] client = foursquare.Foursquare( client_id=self.CREDENTIALS['fsid'], client_secret=self.CREDENTIALS['fssecret']) unique_ids = [] menus = {} try: for key in venues_dict: print("Querying menu data for key:", key) for venue in venues_dict[key]['venues']: venue_name = venue['name'] venue_id = venue['id'] if (venue_id in unique_ids): pass else: unique_ids += [venue_id] response = client.venues.menu(venue_id) menus[venue_name] = response except: traceback.print_exc() self.JSON_DATA['MENUS'] = menus print("Menu query operation complete!") return #menus
def handle(self, *args, **options): logger.info("Starting foursquare job") app = SocialApp.objects.filter(provider='foursquare')[0] for bookowner in BookOwner.objects.filter(check_foursquare=True): self.user = bookowner.user self.book = bookowner.book try: token = SocialToken.objects.get(account__user=self.user, app=app) except SocialToken.DoesNotExist: token = None sentry.error("No foursquare token found", exc_info=True, extra={'user': self.user}) if token: self.client = foursquare.Foursquare(access_token=token.token) if self.user and self.book and self.client: checkins = self.get_checkins() self.foursquare_user_id = self.get_foursquare_user_details( ).get('id') for checkin in checkins: self.handle_checkin(checkin)
def get_check_in_info(id): global i dt = date.today() # url = "https://api.foursquare.com/v2/venues/" + id + '?oauth_token=' + FOURSQUARE_ACCESS_TOKEN + '&v=' + dt.strftime('%Y%m%d') client = foursquare.Foursquare(client_id=CLIENT_ID, client_secret=CLIENT_SECRET) data = dict(client.venues(id)) # print url # data = json.load(urllib2.urlopen(url)) checkin = data['venue'] # date_info = checkin['createdAt'] timezoneoffset = checkin['timeZone'] location = checkin['location'] lat = location['lat'] lng = location['lng'] categories = checkin['categories'] categories_name = "" for item in categories: categories_name += item['name'] + '\n' # print user_id, lat, lng, date_info, categories_name temp = str(lat) + '\t' + str(lng) + '\t' + categories_name + '\n' print temp with open("test.txt", "a") as myfile: i += 1 print i myfile.write(categories_name + '\n')
def generate_graph(): CLIENT_ID = "..." CLIENT_SECRET = "..." client = foursquare.Foursquare(client_id=CLIENT_ID, client_secret=CLIENT_SECRET) G = nx.Graph() search = client.venues.explore(params={'near': 'Rome,Italy'}) for group in search['groups']: #creates all the nodes for venue in group['items']: G.add_node(venue["venue"]["id"], id=venue["venue"]["id"], name=venue["venue"]["name"], pos=(venue["venue"]["location"]["lat"], venue["venue"]["location"]["lng"]), country=venue["venue"]["location"]["country"], size=10) #creates the edges between next venues for venue in group['items']: nextVenues = client.venues.nextvenues(venue["venue"]["id"]) for nextvenue in nextVenues["nextVenues"]["items"]: v1 = G.node[venue["venue"]["id"]] if (nextvenue["id"] in G): v2 = G.node[nextvenue["id"]] G.add_edge(v1["id"], v2["id"], distance=venues_distance(v1, v2)) return G
def login(request): """ Login through foursquare """ client = foursquare.Foursquare(client_id=settings.CLIENT_ID, client_secret=settings.CLIENT_SECRET, redirect_uri=settings.REDIRECT_URI) auth_uri = client.oauth.auth_url() return redirect(auth_uri)
def test_oauth(self): if not TEST_OAUTH: return # Authorization dance. oauth_key = raw_input('Enter your foursquare oauth consumer key: ') oauth_secret = raw_input( 'Enter your foursquare oauth consumer secret: ') fs = foursquare.Foursquare( foursquare.OAuthCredentials(oauth_key, oauth_secret)) app_token = fs.request_token() auth_url = fs.authorize(app_token) raw_input( 'Please go the following URL and authorize your app, then press enter: %s\n' % (auth_url, )) # In case we're being piped usernames and passwords and keys and secrets and... time.sleep(15) user_token = fs.access_token(app_token) fs.credentials.set_access_token(user_token) # Now we can test some methods. test_result = fs.test() self.assertEqual(test_result['response'], 'ok') user = fs.user() self.failUnless('user' in user)
def admin_settings(request, plugin): context = RequestContext(request) settings_form = plugin.get_site_settings_form() if request.method == 'POST': if 'submit-settings' in request.POST: settings_form = forms.SiteSettingsForm(request.POST) if settings_form.is_valid(): client_id = settings_form.cleaned_data['client_id'] client_secret = settings_form.cleaned_data['client_secret'] venue_id = settings_form.cleaned_data['venue_id'] client = foursquare.Foursquare(client_id=client_id, client_secret=client_secret) venue = None try: # Search for the venue. Simultaneous validates all three credentials. if venue_id: venue = client.venues(venue_id) except foursquare.FoursquareException, e: messages.error( request, 'Error testing Foursquare connection: %s' % str(e)) else: plugin.save_site_settings_form(settings_form) plugin.save_venue_detail(venue) messages.success(request, 'Settings updated')
def connect_foursquare(): global places conn = sqlite3.connect( '/home/kevin/workspace/FourSquare/foursquare.sqlite') conn.text_factory = str now = datetime.datetime.now() for k in places.keys(): print k client = foursquare.Foursquare( client_id='GJPWWXSBRKXNNZ1EHX2S2K53HW1PD0MORDFCGKPZKX0DVFV1', client_secret='LNXDLIAMJSPXZ3QJ02A4LXIADKEMF0XJWQI5MXXU5NQN5LJD') venues = client.venues.trending( { "ll": places[k], "limit": 50, "radius": 2000 }, multi=False)["venues"] for venue in venues: val = [(venue["location"]["lat"], venue["location"]["lng"], venue["name"], venue["categories"][0]["name"], str(now), venue["hereNow"]["count"], k)] conn.executemany( "INSERT INTO foursquare (lat,long,name,type,datetime,count,city_py) VALUES (?,?,?,?,?,?,?) ", val) conn.commit() conn.close()
def main(): job = Job() client = foursquare.Foursquare( config.foursquare_client_id, client_secret=config.foursquare_client_secret) all_plazas = client.venues.search( params={ 'near': 'New York City', 'limit': 50, 'intent': 'browse', 'radius': 5000, 'categoryId': '4bf58dd8d48988d164941735' }) ids = [] for v in all_plazas['venues']: ids.append(v['id']) t = Thread(target=job.download, args=(ids, )) t.setDaemon(True) t.start() print 'The thread started' second = 0 while (1): second += 1 time.sleep(1) job.report()
def makeFoursquareClient(access_token=None): redirect_uri = generateRedirectUri() return foursquare.Foursquare(client_id = CONFIG['client_id'], client_secret = SECRETS['client_secret'], access_token = access_token, redirect_uri = redirect_uri, version = CONFIG['api_version'])
def get_token(cli_id, cli_sec, session): client_id = cli_id client_secret = cli_sec client = foursquare.Foursquare( client_id=client_id, client_secret=client_secret, redirect_uri='http://127.0.0.1:3000/auth/return') auth_url = client.oauth.auth_url() print 'get access token...' token = '' try: # for those first time get access token ,and for those already have the token will throw an exception html = session.get(auth_url).content authpage = BS(html, 'html.parser') _xsrf = authpage.find('input', {'name': 'fs-request-signature'})['value'] data = {'shouldAuthorize': 'true', 'fs-request-signature': _xsrf} # the stmt will throw a exception when send data resp = session.post(auth_url, data, headers) except requests.exceptions.ConnectionError, e: print 'access_token:' code = str(e).split('?')[1][5:53] access_token = client.oauth.get_token(code) token = access_token print access_token
def __init__(self, user_profile, fs_client_ID=foursquare_API_client_ID, fs_client_secret=foursquare_API_client_secret, intent=fs_intent, limit=fs_limit): """ Initializes the Recommender object instance Parameters ---------- user_profile: dictionary Dictionary with user preferences fs_client_ID: string Foursquare API client ID fs_client_secret: string Foursquare API client password """ # Instantiate Foursquare API wrapper self.fs_client = foursquare.Foursquare(client_id=fs_client_ID, client_secret=fs_client_secret) self.user_profile = user_profile self.intent = intent self.limit = limit self.recommendations = None
def getFoursquareCheckIns(date): """ Gets the check-ins occurred in NY from a starting date. :param date: (Y-m-d). :return: dictionary {(long, lat) : number of check-ins}. """ client = foursquare.Foursquare( client_id='FUG50WOUTS2FHTCUIVFUUXFFTUGGIC1CITI53KBXPAVDFDV0', client_secret='2BLM42NTYGLNAA0J3ECOZSHJVJ0ZBC1S32MWBF24JWDN5PIX') checkins = client.venues.explore( params={ 'near': 'New York, NY', 'afterTimestamp': date, 'time': 'any', 'day': 'any' }) dict = {} for checkin in checkins['groups']: for item in checkin['items']: lat = item['venue']['location']['lat'] lng = item['venue']['location']['lng'] cic = item['venue']['stats']['checkinsCount'] dict[(lng, lat)] = cic return dict
def main(): client = foursquare.Foursquare(client_id=FS_CLIENT_ID, client_secret=FS_CLIENT_SECRET) places = client.venues.search(params={ 'll': '40.7,-74.0', 'limit': '100' })['venues'] for place in places: print place name = place['name'] try: category = place['categories'][0]['shortName'] except IndexError, KeyError: category = None pop = 10 geotag = tweetanalysis.analyzer.GeoTag(place['location']['lat'], place['location']['lng']) addr = ' '.join(place['location']['formattedAddress']) if category: try: models.Venue.Query.get(name=name) print '{} already exists'.format(name) return None except query.QueryResourceDoesNotExist: venue = models.Venue.build(name=name, category=category, pop=pop, geotag=geotag, addr=str(addr)) venue.save() return venue
def __init__(self): self.boba_places = pd.read_csv('./data/boba_final.csv') self.client = foursquare.Foursquare(client_id='key-here', client_secret='key-here') self.test_data = pd.read_csv("./data/Reviews.csv") self.log_model = self.train_model() self.vectorizer = None
def check_consumer_tokens(service, key, secret): """ Checks if the service tokens are ok, facebook not implemeted yet """ if key != '' and secret != '': if service == 'Twitter': auth = tweepy.OAuthHandler(str(key), str(secret)) try: auth.get_authorization_url() return True except: pass if service == 'Foursquare': client = foursquare.Foursquare(str(key), str(secret)) try: client.oauth.auth_url() return True except: pass if service == 'Facebook': return True return False
def get_user_book_client(self, app, profile): user = profile.user book = None token = None client = None try: book = BookOwner.objects.get(user=user).book except BookOwner.DoesNotExist: book = None logger.error( "No BookOwner found for: {} ({})".format(user, user.id) ) try: token = SocialToken.objects.get(account__user=user, app=app) except SocialToken.DoesNotExist: token = None logger.error( "No foursquare token found for: {} ({})".format(user, user.id), ) if token: client = foursquare.Foursquare(access_token=token.token) return user, book, client
def setUp(self): self.apis = [] for lang in ('es', 'fr', 'de', 'it', 'ja', 'th', 'ko', 'ru', 'pt', 'id'): self.apis.append( foursquare.Foursquare(client_id=CLIENT_ID, client_secret=CLIENT_SECRET, lang=lang))
def __init__(self, output_path=DATA_PATH + '/' + CITY + '/foursquare'): super(FourSquareRetriever, self).__init__(output_path) self.key = next(FOURSQUARE_KEYS_ITER) self.output_path = output_path self.dataset_path = self.output_path + '/venues.csv' self.client = foursquare.Foursquare( client_id=self.key['client_id'], client_secret=self.key['client_secret'])
def setUp(self): self.apis = [] for lang in ("es", "fr", "de", "it", "ja", "th", "ko", "ru", "pt", "id"): self.apis.append( foursquare.Foursquare( client_id=CLIENT_ID, client_secret=CLIENT_SECRET, lang=lang ) )