def getCert(self, id, cfg, token, verifier): oauthKey = cfg[OAUTH_CONSUMER_KEY] params = { 'oauth_nonce': generate_nonce(), 'oauth_token': token, 'oauth_verifier': verifier, 'oauth_timestamp': generate_timestamp(), 'oauth_signature_method': 'RSA-SHA1', 'oauth_consumer_key': oauthKey, 'oauth_version': '1.0' } consumer = Consumer(oauthKey, '') rsa_sha1 = SignatureMethod_RSA_SHA1( privateKeyFile=cfg[PRIVATE_KEY_FILE_TAG]) client = OA4MPClient(consumer=consumer) client.set_signature_method(rsa_sha1) response, content = client.request(cfg[SERVICE_URI_TAG] + '/token', parameters=params) tokens = content.split('&') access_token = urllib.unquote(tokens[0].split('=')[1]) params = { 'oauth_nonce': generate_nonce(), 'oauth_token': access_token, 'oauth_timestamp': generate_timestamp(), 'oauth_signature_method': 'RSA-SHA1', 'oauth_consumer_key': oauthKey, 'oauth_version': '1.0' } # we now have the token and the secret. consumer = Consumer(oauthKey, '') rsa_sha1 = SignatureMethod_RSA_SHA1( privateKeyFile=cfg[PRIVATE_KEY_FILE_TAG]) client = OA4MPClient(consumer=consumer) client.set_signature_method(rsa_sha1) response, content = client.request(cfg[SERVICE_URI_TAG] + '/getcert', parameters=params) tokens = content.split('\n') username = urllib.unquote(tokens[0].split('=')[1]) tokens = tokens[1:] certs = '\n'.join(tokens) fileStore = FileStore(cfg) asset = fileStore.get(id) asset[USERNAME_KEY] = username asset[CERTS_KEY] = certs fileStore.put(id, asset) return username, certs
def do(config): key = config['consumer_key'] sec = config['consumer_sec'] consumer = oauth.Consumer(key, sec) c = oauth.Client(consumer) params = dict( oauth_signature_method='HMAC-SHA1', oauth_nonce=oauth.generate_nonce(), oauth_timestamp=oauth.generate_timestamp()) req = oauth.Request.from_consumer_and_token( consumer=consumer, http_method='POST', http_url=REQUEST_TOKEN_URL, parameters=params, is_form_encoded=True) req.sign_request(oauth.SignatureMethod_HMAC_SHA1(), consumer, None) res = c.request(REQUEST_TOKEN_URL, method='POST', headers=req.to_header()) r = urlparse.parse_qs(res[1]) print r rt = oauth.Token(r['oauth_token'][0], r['oauth_token_secret'][0]) print AUTHORIZE_URL + '?oauth_token=' + urllib.quote(rt.key) v = raw_input("PIN: ") params = dict( oauth_signature_method='HMAC-SHA1', oauth_nonce=oauth.generate_nonce(), oauth_timestamp=oauth.generate_timestamp(), oauth_token=rt.key, oauth_token_secret=rt.secret, oauth_verifier=v) req = oauth.Request.from_consumer_and_token( consumer=consumer, token=rt, http_method='POST', http_url=ACCESS_TOKEN_URL, parameters=params, is_form_encoded=True) req.sign_request(oauth.SignatureMethod_HMAC_SHA1(), consumer, rt) res = c.request(ACCESS_TOKEN_URL, method='POST', headers=req.to_header()) r = urlparse.parse_qs(res[1]) print " key: '%s'" % r['oauth_token'][0] print " sec: '%s'" % r['oauth_token_secret'][0]
def request(self, uri, method="POST", body=None, headers=None): params = { 'oauth_consumer_key': self.consumer.key, 'oauth_signature_method': self.method.name, 'oauth_token':self.token.key, 'oauth_timestamp':oauth2.generate_timestamp(), 'oauth_nonce':oauth2.generate_nonce(), 'oauth_version':'1.0' } echo_request = EchoRequest(method="GET", url=self.auth_service_provider, parameters=params ) signature=echo_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), self.consumer, self.token) if not headers: headers={} headers.update(echo_request.to_header(self.realm, self.auth_service_provider)) register_openers() datagen, heads = multipart_encode(body) headers.update(heads) req = urllib2.Request(uri, datagen, headers) response = urllib2.urlopen(req) return response
def get_matches_from_team_id(team_id): params = { 'oauth_version': "1.0", 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': str(int(time.time())), 'file': 'matchesarchive', 'teamID': team_id, } req = oauth.Request(method="GET", url=url_content, parameters=params) req.sign_request(signature_method, consumer,token) with contextlib.closing(urllib2.urlopen(req.to_url(), timeout=10)) as x: # send the request responseData = x.read() #return responseData root = ET.fromstring(responseData) matches = [] for child in root.findall('Team'): for res in child.findall('MatchList'): for match in res.findall('Match'): id = match.find('MatchID').text type = match.find('MatchType').text #status = match.find('Status').text date = match.find('MatchDate').text matches.append({"match_id":int(id),"match_type":int(type),#"match_status":status, "match_date":date}) return matches
def api_request(list_of_tweets): """Takes a list of up to 100 tweet ids and returns tweet details, including retweet count. Tweets in original list must be strings.""" #Create api searcher: url1 = 'https://api.twitter.com/1.1/statuses/lookup.json' params = { "oauth_version": "1.0", "oauth_nonce": oauth2.generate_nonce(), "oauth_timestamp": int(time.time()) } consumer = oauth2.Consumer(key=consumer_key, secret=consumer_secret) token = oauth2.Token(key=access_token_key, secret=access_token_secret) params["oauth_consumer_key"] = consumer.key params["oauth_token"] = token.key tweets_as_strings = ','.join(list_of_tweets) url = url1 params['id'] = tweets_as_strings params['map'] = 'true' req = oauth2.Request(method="GET", url=url, parameters=params) signature_method = oauth2.SignatureMethod_HMAC_SHA1() req.sign_request(signature_method, consumer, token) headers = req.to_header() url = req.to_url() response = urllib2.Request(url) tweets = urllib2.urlopen(response) return json.load(tweets)
def get_users_by_screen_name(screen_names): #18k per 15 mins url1 = "https://api.twitter.com/1.1/users/lookup.json" params = { "oauth_version": "1.0", "oauth_nonce": oauth2.generate_nonce(), "oauth_timestamp": int(time.time()) } params["oauth_consumer_key"] = consumer.key params["oauth_token"] = token.key # Convert list to csv screen_names = ','.join(screen_names) params["screen_name"] = screen_names req = oauth2.Request(method="GET", url=url1, parameters=params) #changed from "GET" to "POST" as twitter recommends signature_method = oauth2.SignatureMethod_HMAC_SHA1() req.sign_request(signature_method, consumer, token) url = req.to_url() response = urllib.request.urlopen(url) data = response.read().decode('utf-8') data = json.loads(data) return data
def request(host, path, url_params, consumer_key, consumer_secret, token, token_secret): """Returns response for API request.""" # Unsigned URL encoded_params = "" if url_params: encoded_params = urllib.urlencode(url_params) url = "http://%s%s?%s" % (host, path, encoded_params) print "URL: %s" % (url,) # Sign the URL consumer = oauth2.Consumer(consumer_key, consumer_secret) oauth_request = oauth2.Request("GET", url, {}) oauth_request.update( { "oauth_nonce": oauth2.generate_nonce(), "oauth_timestamp": oauth2.generate_timestamp(), "oauth_token": token, "oauth_consumer_key": consumer_key, } ) token = oauth2.Token(token, token_secret) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() print "Signed URL: %s\n" % (signed_url,) # Connect try: conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() except urllib2.HTTPError, error: response = json.loads(error.read())
def request(host, path, url_params, consumer_key="FH-RvZ_ScMpTCdMb1esSoQ", consumer_secret="QvfkebxG2ol0aZqem4Bka4LZZ6Y", token="-4NwiPsWveiVcTkVBC-5vXXgnnVk6r_l", token_secret="F2Q00ewraK8qfnm6yW2h3h-HG2g"): """Returns response for API request.""" # Unsigned URL encoded_params = '' if url_params: encoded_params = urllib.urlencode(url_params) url = 'http://%s%s?%s' % (host, path, encoded_params) #print 'URL: %s' % (url,) # Sign the URL consumer = oauth2.Consumer(consumer_key, consumer_secret) oauth_request = oauth2.Request('GET', url, {}) oauth_request.update({'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': token, 'oauth_consumer_key': consumer_key}) token = oauth2.Token(token, token_secret) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() #print 'Signed URL: %s\n' % (signed_url,) # Connect try: conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() except urllib2.HTTPError, error: response = json.loads(error.read())
def get_response(lat, lon, token, consumer_key, consumer_secret, token_secret): url_params = {'term': 'coffee', 'sort': 1, 'll': lat + "," + lon} encoded_params = '' if url_params: encoded_params = urllib.urlencode(url_params) url = 'http://api.yelp.com/v2/search?%s' % (encoded_params) print 'URL: %s' % (url, ) # Sign the URL consumer = oauth2.Consumer(consumer_key, consumer_secret) oauth_request = oauth2.Request('GET', url, {}) oauth_request.update({ 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': token, 'oauth_consumer_key': consumer_key }) token = oauth2.Token(token, token_secret) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() print 'Signed URL: %s\n' % (signed_url, ) response = "" # Connect try: conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() except urllib2.HTTPError, error: response = json.loads(error.read())
def get_by_cache_key(klass, search_term): obj = memcache.get(search_term) # not in memcache, so check database and set memcache if not obj: obj = YelpCacheObject.all().filter('cache_key =', search_term).get() memcache.set(search_term, obj) # not in db, so hit yelp's api and put in db and memcache if not obj: url = '%s?%s' % (YELP_API_URL, search_term) # Sign the URL consumer = oauth.Consumer(YELP_CONSUMER_KEY, YELP_CONSUMER_SECRET) oauth_request = oauth.Request('GET', url, {}) oauth_request.update({ 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': oauth.generate_timestamp(), 'oauth_token': YELP_TOKEN, 'oauth_consumer_key': YELP_CONSUMER_KEY }) token = oauth.Token(YELP_TOKEN, YELP_TOKEN_SECRET) oauth_request.sign_request(oauth.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() obj = YelpCacheObject( cache_key=search_term, result=urlfetch.fetch(signed_url).content.strip(), ) obj.put() memcache.set(search_term, obj) return obj
def search(): params = { 'term': request.query.term, 'll': request.query.ll, 'limit': 20, 'radius_filter': (request.query.radius or 4000) } oauth_request = oauth2.Request( method = 'GET', url = 'https://api.yelp.com/v2/search/', parameters = params ) oauth_request.update( { 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': TOKEN, 'oauth_consumer_key': CONSUMER_KEY } ) token = oauth2.Token(TOKEN, TOKEN_SECRET) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() r = requests.get(signed_url) return r.json()
def request(host, path, url_params=None): url_params = url_params or {} url = 'http://{0}{1}?'.format(host, urllib.quote(path.encode('utf8'))) consumer = oauth2.Consumer(CONSUMER_KEY, CONSUMER_SECRET) oauth_request = oauth2.Request(method="GET", url=url, parameters=url_params) oauth_request.update( { 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': TOKEN, 'oauth_consumer_key': CONSUMER_KEY } ) token = oauth2.Token(TOKEN, TOKEN_SECRET) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() print u'Querying {0} ...'.format(url) conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() return response
def sign_request(self, url_params={}): """ Prepares OAuth authentication and signs the request """ url = 'http://{0}{1}'.format(self.API_HOST, self.API_SEARCH_PATH) consumer = oauth2.Consumer(self.CONSUMER_KEY, self.CONSUMER_SECRET) params = { 'oauth_token' : self.TOKEN, 'oauth_nonce' : oauth2.generate_nonce(), 'oauth_timestamp' : oauth2.generate_timestamp(), 'oauth_consumer_key' : self.CONSUMER_KEY } if url_params: params.update(url_params) oauth_request = oauth2.Request('GET', url, params) token = oauth2.Token(self.TOKEN, self.TOKEN_SECRET) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() return signed_url
def gen_jwt_params(params={}, user=None): """Generates valid JWT parameters. Params can overwrite all results, including timestamp, nonce and signature to produce an invalid request.""" req = BASE_PARAMS.copy() if user: req = { **req, **{ 'roles': settings.ROLES['Teacher'] if user.is_teacher else settings.ROLES['Student'], 'user_id': user.lti_id, 'custom_username': user.username, 'custom_user_email': user.email, 'custom_user_full_name': user.full_name, }, } req['oauth_timestamp'] = str(int(time.time())) req['oauth_nonce'] = str(oauth2.generate_nonce()) req = {**req, **params} if 'oauth_signature' in params: req['oauth_signature'] = req['oauth_signature'] else: req['oauth_signature'] = get_signature(req) return {'jwt_params': lti_view.encode_lti_params(req)}
def set_verifier(self, oauth_verifier): if self.request_token is None: raise AuthHandlerError( ("Request token is not defined. " "This ususally means that the access token has been loaded " "from a file.")) self.request_token.set_verifier(oauth_verifier) access_token_parms = { 'oauth_consumer_key': self.key, 'oauth_nonce': oauth2.generate_nonce(), 'oauth_signature_method': "HMAC-SHA1", 'oauth_timestamp': str(int(time.time())), 'oauth_token': self.request_token.key, 'oauth_verifier': self.request_token.verifier } req = oauth2.Request(method="GET", url=ACCESS_TOKEN_URL, parameters=access_token_parms) req.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), self.consumer, self.request_token) resp = urlopen_and_read(req.to_url()) access_token_resp = dict(urllib.parse.parse_qsl(resp)) self.access_token = oauth2.Token( access_token_resp["oauth_token"], access_token_resp["oauth_token_secret"])
def request(self): ''' Returns an oauth2 request object to be used for connecting to the streaming API endpoint. For debugging purposes, the returned request object is cached in self._last_request. >>> req = stream.request >>> print req.to_url() #doctest: +ELLIPSIS https://sitestream.twitter.com/2b/site.json?... ''' parameters = { 'oauth_version': "1.0", 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': int(time.time()), 'follow': ','.join(map(str, self.follow)), 'with': self.stream_with, 'oauth_token': self.token.key, 'oauth_consumer_key': self.consumer.key } request = oauth.Request(METHOD, self.url, parameters=parameters) request.sign_request( oauth.SignatureMethod_HMAC_SHA1(), self.consumer, self.token) self._last_request = request logger.debug("OAuth Request Object Generated. %s" % request) return request
def search(std_url,payload): ''' This method handles OAUTH and url signing for the yelp search API v2. It inputs the std url and the arguments. This outputs the json response from the API. ''' consumer = oauth2.Consumer(CONSUMER_KEY, CONSUMER_SECRET) oauth_request = oauth2.Request(method="GET", url=std_url, parameters=payload) oauth_request.update( { 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': TOKEN, 'oauth_consumer_key': CONSUMER_KEY } ) #print(std_url) token = oauth2.Token(TOKEN, TOKEN_SECRET) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() conn = urllib2.urlopen(signed_url,None) try: response = json.loads(conn.read()) finally: conn.close() return response
def request(host, path, url_params=None): url_params = url_params or {} url = 'https://{0}{1}?'.format(host, urllib.quote(path.encode('utf8'))) print url consumer = oauth2.Consumer(CONSUMER_KEY, CONSUMER_SECRET) oauth_request = oauth2.Request(method="GET", url=url, parameters=url_params) oauth_request.update( { 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': TOKEN, 'oauth_consumer_key': CONSUMER_KEY } ) token = oauth2.Token(TOKEN, TOKEN_SECRET) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() return response
def request(host, path, url_params, consumer_key, consumer_secret, token, token_secret): """Returns response for API request.""" # Unsigned URL encoded_params = None if url_params: encoded_params = urllib.urlencode(url_params) url = 'http://%s%s?%s' % (host, path, encoded_params) print 'URL: %s' % (url, ) # Sign the URL consumer = oauth2.Consumer(consumer_key, consumer_secret) oauth_request = oauth2.Request('GET', url, {}) oauth_request.update({ 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': token, 'oauth_consumer_key': consumer_key }) token = oauth2.Token(token, token_secret) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() print 'Signed URL: %s\n' % (signed_url, ) # Connect try: conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() except urllib2.HTTPError, error: response = json.loads(error.read())
def _generate_valid_signed_request_url(self, url, method='GET', querystring={}): consumer = oauth.Consumer(self.oauth_consumer_key, self.oauth_consumer_secret) oauth_params = { 'oauth_version': '1.0', 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': int(time.time()) } if querystring: oauth_params.update(querystring) signature_method = oauth.SignatureMethod_HMAC_SHA1() request = oauth.Request(method=method, url=url, parameters=oauth_params) request.sign_request(signature_method, consumer, None) signed_querystring = urlparse.urlparse(request.to_url())[4] return '{0}?{1}'.format(url, signed_querystring)
def get_signed_uri(self, serialized_body, uri, http_method): # There is no requirement for the token in two-legged # OAuth but we still need the token object. token = oauth.Token(key='', secret='') consumer = oauth.Consumer(key=self.oauth_key, secret=self.oauth_secret) parameters = { 'user': self.user, 'oauth_version': '1.0', 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': int(time.time()) } try: req = oauth.Request( method=http_method, body=serialized_body, url=uri, parameters=parameters ) except AssertionError: logger.error('uri: %s' % uri) logger.error('body: %s' % serialized_body) raise signature_method = oauth.SignatureMethod_HMAC_SHA1() req.sign_request(signature_method, consumer, token) return req.to_url()
def request(host, path, url_params=None): url_params = url_params or {} encoded_params = urllib.urlencode(url_params) path = unicodedata.normalize('NFKD', unicode(path)).encode('ascii','ignore') url = 'http://{0}{1}?{2}'.format(host, path, encoded_params) consumer = oauth2.Consumer(CONSUMER_KEY, CONSUMER_SECRET) oauth_request = oauth2.Request('GET', url, {}) oauth_request.update( { 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': TOKEN, 'oauth_consumer_key': CONSUMER_KEY } ) token = oauth2.Token(TOKEN, TOKEN_SECRET) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() try: conn = urllib2.urlopen(signed_url, None) response = json.loads(conn.read()) conn.close() except HTTPError as error: sys.exit('Encountered HTTP error {0}. Abort program.'.format(error.code)) return response
def _makeOAuthRequest(self, url, token=None, params=None, http_method="GET"): '''Make a OAuth request from url and parameters Args: url: The Url to use for creating OAuth Request parameters: The URL parameters http_method: The HTTP method to use Returns: A OAauthRequest object ''' oauth_base_params = { 'oauth_version': "1.0", 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': int(time.time()) } if params: params.update(oauth_base_params) else: params = oauth_base_params if not token: token = self._access_token request = oauth.Request(method=http_method, url=url, parameters=params) request.sign_request(self._signature_method, self._Consumer, token) return request
def requestData(location): ''' Authenticates a request and returns data from Yelp API. ''' data = [] url = 'http://api.yelp.com/v2/business/' + location + '?' consumer = oauth2.Consumer(CONSUMER_KEY, CONSUMER_SECRET) oauth_request = oauth2.Request(method="GET", url=url) oauth_request.update( { 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': TOKEN, 'oauth_consumer_key': CONSUMER_KEY } ) token = oauth2.Token(TOKEN, TOKEN_SECRET) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() req = requests.get(signed_url) content = json.loads(req.content) data.append(content) return data
def get_barcodes(users=None, start_date=None): url = 'https://5339579.restlets.api.netsuite.com/app/site/hosting/restlet.nl?script=384&deploy=1&start_date=%s&end_date=%s' params = { 'oauth_version': "1.0", 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': "%s" % int(time.time()), 'oauth_token': token.key, 'oauth_consumer_key': consumer.key } if not start_date: ba_obj = Barcodes.objects.all().order_by('-created') start_date = '11/01/2019' if ba_obj: start_date = ba_obj[0].created.strftime("%m/%d/%Y %H:%M") url = url % (start_date, datetime.now().strftime("%m/%d/%Y %H:%M")) headers = create_request_auth_header(http_method, url, params) res = requests.get(url, headers=headers) res = json.loads(res.content.decode()) if res: querysetlist = [] for val in res: check_re = Barcodes.objects.filter(sku=val['sku']) if not check_re: querysetlist.append(Barcodes(sku=val['sku'], user=users)) if querysetlist: Barcodes.objects.bulk_create(querysetlist) return res
def requestYelp(latlong): print "-----------------------------\n Using Yelp API" term = 'restaurant' limit = 5 #encoded_params = urllib.urlencode(url_params) url = 'http://api.yelp.com/v2/search?term=' + term + '&ll=' + latlong + '&limit=' + str( limit) #'http://{0}{1}?{2}'.format(host, path, encoded_params) consumer = oauth2.Consumer(CONSUMER_KEY, CONSUMER_SECRET) oauth_request = oauth2.Request('GET', url, {}) oauth_request.update({ 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': TOKEN, 'oauth_consumer_key': CONSUMER_KEY }) token = oauth2.Token(TOKEN, TOKEN_SECRET) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() conn = urllib2.urlopen(signed_url, None) try: json_data = json.loads(conn.read()) finally: conn.close() #if json_data['status'] == 'OK': for place in json_data['businesses']: print '%s\n' % (place['name'])
def get_team_details_from_team_id(team_id): params = { 'oauth_version': "1.0", 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': str(int(time.time())), 'file': 'teamdetails', 'version': 3.2, 'teamID': team_id, } req = oauth.Request(method="GET", url=url_content, parameters=params) req.sign_request(signature_method, consumer,token) with contextlib.closing(urllib2.urlopen(req.to_url(), timeout=10)) as x: # send the request responseData = x.read() #return responseData root = ET.fromstring(responseData) #for child in root.findall('CurrentMatchRound'): for child in root.findall('Teams'): t = child.find("Team") id = t.find('TeamID').text name = t.find('TeamName').text birth = t.find('FoundedDate').text r = t.find("Region") region = r.find('RegionName').text l = t.find("League") league = l.find('LeagueName').text team = {"team_name":name,"team_id":int(id), "team_birth":birth,"team_region":region,"league_name":league} return team
def basic_yelp_request(location,keyword="omelette"): """ Adapted from Yelp API Search Example https://github.com/Yelp/yelp-api/blob/master/v2/python/search.py """ # Prepare URL url_params = {} url_params['location'] = location url_params['term'] = keyword encoded_params = urllib.urlencode(url_params) host = 'api.yelp.com' path = '/v2/search' url = 'http://%s%s?%s' % (host, path, encoded_params) # Sign URL consumer = oauth2.Consumer(keys["YELP_KEY"], keys["YELP_SECRET"]) oauth_request = oauth2.Request('GET', url, {}) oauth_request.update({'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': keys["YELP_TOKEN"], 'oauth_consumer_key': keys["YELP_KEY"]}) token = oauth2.Token(keys["YELP_TOKEN"], keys["YELP_TOKEN_SECRET"]) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() # Connect try: conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() except urllib2.HTTPError, error: response = json.loads(error.read())
def request(url_params): """ Retrieves data from the yelp api given search parameters Args: url_params: (String) the part of a url that contains the what the user wants to search Returns: response: (Dictionary) contains all the information from yelp api """ url = "https://api.yelp.com/v2/search/" consumer = oauth2.Consumer(CONSUMER_KEY, CONSUMER_SECRET) oauth_request = oauth2.Request(method="GET", url=url, parameters=url_params) oauth_request["oauth_nonce"] = oauth2.generate_nonce() oauth_request["oauth_timestamp"] = oauth2.generate_timestamp() oauth_request["oauth_token"] = TOKEN oauth_request["oauth_consumer_key"] = CONSUMER_KEY token = oauth2.Token(TOKEN,TOKEN_SECRET) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() print(signed_url) conn = urllib2.urlopen(signed_url, None) response = json.loads(conn.read()) conn.close() return response
def _build_request(self, string, reverse): """ Returns a signed oauth request for the given query """ request = oauth2.Request( method='GET', parameters={ 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': int(time.time()), 'oauth_version': '1.0', }, url='%s?location=%s&flags=J%s' % ( '%s://yboss.yahooapis.com/geo/placefinder' % self.scheme, urllib.quote(string.encode('utf-8')), '&gflags=R' if reverse else '', # todo refactor ), ) request.sign_request( oauth2.SignatureMethod_HMAC_SHA1(), oauth2.Consumer(self.consumer_key, self.consumer_secret), None, ) return request
def prepare_request(url, url_params): reqconfig = read_reqauth() config = read_config() token = oauth.Token(key=reqconfig.oauth_token, secret=reqconfig.oauth_token_secret) consumer = oauth.Consumer(key=config.consumer_key, secret=config.consumer_secret) params = { "oauth_version": "1.0", "oauth_nonce": oauth.generate_nonce(), "oauth_timestamp": str(int(time.time())), "oauth_token": token.key, "oauth_consumer_key": consumer.key, } params.update(url_params) req = oauth.Request(method="GET", url=url, parameters=params) signature_method = oauth.SignatureMethod_HMAC_SHA1() req.sign_request(signature_method, consumer, token) return req.to_url()
def send_tweet(self, msg): host = 'api.twitter.com' endpoint = '/1/statuses/update.json' url = 'http://' + host + endpoint token = oauth2.Token(key=config['twitter_access_token'], secret=config['twitter_access_secret']) consumer = oauth2.Consumer(key=config['twitter_consumer_token'], secret=config['twitter_consumer_secret']) params = { 'status' : msg, 'oauth_token' : token.key, 'oauth_consumer_key' : consumer.key, 'oauth_nonce' : oauth2.generate_nonce(), 'oauth_timestamp' :int(time.time()), } req = oauth2.Request(method="POST", url=url, parameters=params) signature_method = oauth2.SignatureMethod_HMAC_SHA1() req.sign_request(signature_method, consumer, token) body = req.to_postdata() conn = httplib.HTTPConnection('api.twitter.com') conn.request('POST', '/1/statuses/update.json', body) rsp = conn.getresponse() return rsp.status
def get_signed_uri(self, serialized_body, uri, http_method): # There is no requirement for the token in two-legged # OAuth but we still need the token object. token = oauth.Token(key='', secret='') consumer = oauth.Consumer(key=self.oauth_key, secret=self.oauth_secret) parameters = { 'user': self.user, 'oauth_version': '1.0', 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': int(time.time()) } try: req = oauth.Request(method=http_method, body=serialized_body, url=uri, parameters=parameters) except AssertionError: logger.error('uri: %s' % uri) logger.error('body: %s' % serialized_body) raise signature_method = oauth.SignatureMethod_HMAC_SHA1() req.sign_request(signature_method, consumer, token) return req.to_url()
def validateAuthorization(self, pin) : #Generate Token self.token.set_verifier(pin) #access params access_token_params = { 'oauth_consumer_key': flickrAuthConstants.keys['apikey'], 'oauth_nonce': oauth2.generate_nonce(), 'oauth_signature_method':"HMAC-SHA1", 'oauth_timestamp': str(int(time.time())), 'oauth_token': self.req_token['oauth_token'], 'oauth_verifier' : pin } #setup request req = oauth2.Request(method="GET", url=flickrAuthConstants.access_token_url, parameters=access_token_params) #create the signature signature = oauth2.SignatureMethod_HMAC_SHA1().sign(req,self.consumer,self.token) # assign the signature to the request req['oauth_signature'] = signature try: #make the request h = httplib2.Http(".cache") resp, content = h.request(req.to_url(), "GET") #parse the response self.access_token = dict(urlparse.parse_qsl(content)) except Exception, e: print e;
def search(term, address): consumer_key = 'YQjC8cOZxSyb-x21hpoLxg' consumer_secret = 'AJ6u905ojzMr9VkHDN_BkAbQrIA' token = '4Q20XFJ24cB8SL1CRKWY_2kNYqGnk60y' token_secret = '2hPhKm5s4kt8L5EicFD3h26cLh4' consumer= oauth2.Consumer(consumer_key,consumer_secret) url= 'http://api.yelp.com/v2/search?term=%s&location=%s&limit=%d&format=json&radius_filter=400&category=food'%(term, address, 5) oauth_request = oauth2.Request('GET', url, {}) oauth_request.update({'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': token, 'oauth_consumer_key': consumer_key}) token = oauth2.Token(token, token_secret) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() #connect try: conn = urllib2.urlopen(signed_url) try: response =json.load(conn) finally: conn.close() except urllib2.HTTPError,error: response=json.load(error)
def validateTokenOnFlickr(self): params = { 'method':'flickr.auth.oauth.checkToken', 'oauth_nonce': oauth2.generate_nonce(), 'oauth_signature_method':"HMAC-SHA1", 'oauth_timestamp': str(int(time.time())), 'oauth_consumer_key':flickrAuthConstants.keys['apikey'], 'oauth_token':self.access_token['oauth_token'] ,'format':'json' ,'nojsoncallback':1 } # Create our request. Change method, etc. accordingly. req = oauth2.Request(method="GET", url=flickrAuthConstants.base_url, parameters=params); # Create the signature signature = oauth2.SignatureMethod_HMAC_SHA1().sign(req, self.consumer, self.token); req['oauth_signature'] = signature; h = httplib2.Http(".cache") resp, jsonData = h.request(req.to_url(), "GET") content = json.loads(jsonData); return content['stat'];
def post_response_for_url(self, url, context, account): parameters = self.params parameters['oauth_nonce'] = oauth.generate_nonce() parameters['oauth_timestamp'] = '%s' % int(time.time()) if account: parameters['account'] = account elif self.account: parameters['account'] = self.account for key in context: if isinstance(context[key],collections.Iterable): parameters[key] = quote(context[key]) else: parameters[key] = context[key] req = oauth.Request(method="POST", url=url, parameters=parameters) # Sign the request. signature_method = oauth.SignatureMethod_HMAC_SHA1() req.sign_request(signature_method, self.consumer, None) response, content = self.request(url, method="POST", body=req.to_postdata(), headers={'Content-Type': 'application/x-www-form-urlencoded'}, redirections=httplib2.DEFAULT_MAX_REDIRECTS, connection_type=None) if response['status'] != '200': raise Exception("Invalid response %s" % response['status']) return ContextIOResponse(response, content)
def get_profile_banner_info(screen_name, user_id): # e.g. # https://api.twitter.com/1.1/users/profile_banner.json?screen_name=rjsinha url1 = "https://api.twitter.com/1.1/users/profile_banner.json" params = { "oauth_version": "1.0", "oauth_nonce": oauth2.generate_nonce(), "oauth_timestamp": int(time.time()) } params["oauth_consumer_key"] = consumer.key params["oauth_token"] = token.key #params["screen_name"] = screen_name params["user_id"] = user_id req = oauth2.Request(method="GET", url=url1, parameters=params) signature_method = oauth2.SignatureMethod_HMAC_SHA1() req.sign_request(signature_method, consumer, token) url = req.to_url() response = urllib.request.urlopen(url) data = response.read().decode('utf-8') data = json.loads(data) return data
def post(body, title=None, type='text', state='published', tags='', date=None): endpoint = TUMBLR + BLOG + '/post' if date is None: date = datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S GMT') params = { 'type': type, 'state': state, 'tags': tags, 'date': date, 'title': title, 'body': body, 'oauth_version': '1.0', 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': int(time.time()), 'oauth_token': ACCESS_TOKEN, 'oauth_consumer_key': CONSUMER_KEY } req = oauth.Request(method='POST', url=endpoint, parameters=params) sig_method = oauth.SignatureMethod_HMAC_SHA1() req.sign_request(sig_method, consumer, token) print(params) data = urlencode(params).encode('utf-8') resp, content = client.request(endpoint, 'POST', data) if resp['status'] != '201': raise Exception('Post creation failed.')
def get_followers_data(follower_ids): #18k per 15 mins url1 = "https://api.twitter.com/1.1/users/lookup.json" params = { "oauth_version": "1.0", "oauth_nonce": oauth2.generate_nonce(), "oauth_timestamp": int(time.time()) } params["oauth_consumer_key"] = consumer.key params["oauth_token"] = token.key params["user_id"] = str(follower_ids)[:-1][1:] req = oauth2.Request( method="GET", url=url1, parameters=params) #changed from "GET" to "POST" as twitter recommends signature_method = oauth2.SignatureMethod_HMAC_SHA1() req.sign_request(signature_method, consumer, token) url = req.to_url() response = urllib.request.urlopen(url) data = response.read().decode('utf-8') data = json.loads(data) return data
def request(url, url_params=None): consumer_key = creds['consumer_key'] consumer_secret = creds['consumer_secret'] token = creds['token'] token_secret = creds['token_secret'] url_params = url_params or {} consumer = oauth2.Consumer(consumer_key, consumer_secret) oauth_request = oauth2.Request(method="GET", url=url, parameters=url_params) oauth_request.update({ 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': token, 'oauth_consumer_key': consumer_key }) token = oauth2.Token(token, token_secret) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() raw = urllib.urlopen(signed_url).read() data = json.loads(raw) return data
def __oatuh(self, url): """ Puth the oatuh2 token in the url Return: A signed url, that can be passed to the yelp API """ consumer = oauth2.Consumer(self.consumer_key, self.consumer_secret) oauth_request = oauth2.Request('GET', url, {}) oauth_request.update( { 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': self.token, 'oauth_consumer_key': self.consumer_key } ) oauth_token = oauth2.Token(self.token, self.token_secret) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, oauth_token) signed_url = oauth_request.to_url() return signed_url
def request(host, path, key, key_secret, token, token_secret, url_params=None): """ Prepares OAuth authentication and sends the request to the API. Args: host (str): The domain host of the API. path (str): The path of the API after the domain. url_params (dict): An optional set of query parameters in the request. Returns: dict: The JSON response from the request. Raises: urllib2.HTTPError: An error occurs from the HTTP request. """ url_params = url_params or {} url = 'http://{0}{1}?'.format(host, urllib.quote(path.encode('utf8'))) consumer = oauth2.Consumer(key, key_secret) oauth_request = oauth2.Request(method="GET", url=url, parameters=url_params) oauth_request.update({ 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': token, 'oauth_consumer_key': key }) token = oauth2.Token(token, token_secret) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() return response
def search(term, address): consumer_key = 'YQjC8cOZxSyb-x21hpoLxg' consumer_secret = 'AJ6u905ojzMr9VkHDN_BkAbQrIA' token = '4Q20XFJ24cB8SL1CRKWY_2kNYqGnk60y' token_secret = '2hPhKm5s4kt8L5EicFD3h26cLh4' consumer = oauth2.Consumer(consumer_key, consumer_secret) url = 'http://api.yelp.com/v2/search?term=%s&location=%s&limit=%d&format=json&radius_filter=400&category=food' % ( term, address, 5) oauth_request = oauth2.Request('GET', url, {}) oauth_request.update({ 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': token, 'oauth_consumer_key': consumer_key }) token = oauth2.Token(token, token_secret) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() #connect try: conn = urllib2.urlopen(signed_url) try: response = json.load(conn) finally: conn.close() except urllib2.HTTPError, error: response = json.load(error)
def request(host, path, url_params=None): #url_params = url_params or {} encoded_params = urllib.urlencode(url_params) url = 'http://{0}{1}?{2}'.format(host, path, encoded_params) consumer = oauth2.Consumer(CONSUMER_KEY, CONSUMER_SECRET) oauth_request = oauth2.Request('GET', url, {}) oauth_request.update( { 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': TOKEN, 'oauth_consumer_key': CONSUMER_KEY } ) token = oauth2.Token(TOKEN, TOKEN_SECRET) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() print 'Querying {0} ...'.format(url) conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() return response
def get_kit_skus(start_date=None): url = 'https://5339579.restlets.api.netsuite.com/app/site/hosting/restlet.nl?script=376&deploy=1&start_date=%s&end_date=%s' params = { 'oauth_version': "1.0", 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': "%s" % int(time.time()), 'oauth_token': token.key, 'oauth_consumer_key': consumer.key } if not start_date: kit_obj = KitSkus.objects.all().order_by('-created') start_date = '10/24/2019' if kit_obj: start_date = kit_obj[0].created.strftime("%m/%d/%Y") url = url % (start_date, datetime.now().strftime("%m/%d/%Y")) headers = create_request_auth_header(http_method, url, params) res = requests.get(url, headers=headers) res = json.loads(res.content.decode()) querylist = [] kit_list = [] for val in res: try: kit_list.append(val['kit']) querylist.append(KitSkus(kit=val['kit'], sku=val['sku'])) except: continue del_li = KitSkus.objects.filter(kit__in=kit_list) if del_li: del_li.delete() if querylist: KitSkus.objects.bulk_create(querylist)
def requester(host, path, url_params, consumer_key, consumer_secret, token, token_secret): """Returns response for API request.""" # Unsigned URL encoded_params = '' if url_params: encoded_params = urllib.urlencode(url_params) url = 'http://%s%s?%s' % (host, path, encoded_params) # Sign the URL consumer = oauth2.Consumer(consumer_key, consumer_secret) oauth_request = oauth2.Request('GET', url, {}) oauth_request.update({'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': token, 'oauth_consumer_key': consumer_key}) token = oauth2.Token(token, token_secret) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() # Connect try: conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() except urllib2.HTTPError, error: response = json.loads(error.read())
def api_save_kit_sku(data, kit_country, fulfill_type): url = 'https://5339579.restlets.api.netsuite.com/app/site/hosting/restlet.nl?script=396&deploy=1' params = { 'oauth_version': "1.0", 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': "%s" % int(time.time()), 'oauth_token': token.key, 'oauth_consumer_key': consumer.key } body = { 'kit_country': kit_country, 'fulfill_type': fulfill_type, 'kit_items': data } http_method = 'POST' headers = create_request_auth_header(http_method, url, params) response = requests.post(url, json=body, headers=headers) res = {'code': 1001} if response.status_code != 200: response = json.loads(response.content.decode()) if 'error' in response: res.update({ 'code' : 1001, 'msg' : response['error']['message'] }) return res response = json.loads(response.content.decode()) res.update({ 'code': 1, 'id': response }) return res
def yelp_req(url): """ Pass in a url that follows the format of Yelp API, and this function will return either a JSON object or error messages. """ oauth_request = oauth2.Request('GET', url, {}) oauth_request.update( { 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': TOKEN, 'oauth_consumer_key': CONSUMER_KEY } ) consumer = oauth2.Consumer(CONSUMER_KEY, CONSUMER_SECRET) token = oauth2.Token(TOKEN, TOKEN_SECRET) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() return response
def request(host, path, url_params=None): # Prepares OAuth authentication and sends the request to the API. Args: # host (str): The domain host of the API. # path (str): The path of the API after the domain. # url_params (dict): An optional set of query parameters in the request. # Returns: dict: The JSON response from the request. # Raises: urllib2.HTTPError: An error occurs from the HTTP request. url_params = url_params or {} url = 'http://{0}{1}?'.format(host, urllib.quote(path.encode('utf8'))) consumer = oauth2.Consumer(CONSUMER_KEY, CONSUMER_SECRET) oauth_request = oauth2.Request(method="GET", url=url, parameters=url_params) oauth_request.update( { 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': TOKEN, 'oauth_consumer_key': CONSUMER_KEY } ) token = oauth2.Token(TOKEN, TOKEN_SECRET) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, token) signed_url = oauth_request.to_url() print u'Querying {0} ...'.format(url) conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() return response
def get_series_id_from_name(series_name): params = { 'oauth_version': "1.0", 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': str(int(time.time())), 'file': 'search', 'version': 1.2, 'searchType': 3, 'searchString': series_name } req = oauth.Request(method="GET", url=url_content, parameters=params) req.sign_request(signature_method, consumer, token) with contextlib.closing(urllib2.urlopen(req.to_url(), timeout=10)) as x: # send the request responseData = x.read() #print responseData root = ET.fromstring(responseData) for child in root.findall('SearchResults'): for res in child.findall('Result'): id = res.find('ResultID').text name = res.find('ResultName').text if (name==series_name): return int(id)
def _makeOAuthRequest(self, url, token=None, params=None, http_method="GET"): """Make a OAuth request from url and parameters Args: url: The Url to use for creating OAuth Request parameters: The URL parameters http_method: The HTTP method to use Returns: A OAauthRequest object """ oauth_base_params = { "oauth_version": "1.0", "oauth_nonce": oauth.generate_nonce(), "oauth_timestamp": int(time.time()), } if params: params.update(oauth_base_params) else: params = oauth_base_params if not token: token = self._access_token request = oauth.Request(method=http_method, url=url, parameters=params) request.sign_request(self._signature_method, self._Consumer, token) return request
def getBars(offset, metro_index): global token args = { 'location': getMetro(metro_index), 'category_filter': 'nightlife', 'limit': 20, 'offset': offset } url = 'http://api.yelp.com/v2/search?' consumer = oauth2.Consumer(consumer_key, consumer_secret) oauth_request = oauth2.Request('GET', url, args) oauth_request.update({ 'oauth_nonce': oauth2.generate_nonce(), 'oauth_timestamp': oauth2.generate_timestamp(), 'oauth_token': token, 'oauth_consumer_key': consumer_key }) new_token = oauth2.Token(token, token_secret) oauth_request.sign_request(oauth2.SignatureMethod_HMAC_SHA1(), consumer, new_token) signed_url = oauth_request.to_url() # logging.info('Signed URL: %s' % signed_url) # Connect try: conn = urllib2.urlopen(signed_url, None) try: response = json.loads(conn.read()) finally: conn.close() except urllib2.HTTPError, error: response = json.loads(error.read())
def __init__(self, application_name, consumer_key, consumer_secret, token_key=None, token_secret=None): self.server = 'api-public.netflix.com' self.connection = httplib.HTTPConnection(self.server, '80') self.catalog = NetflixCatalog(self) self.params = { 'oauth_version': "1.0", 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': int(time.time()), 'output': 'json', 'application_name': application_name, } self.signature_method = oauth.SignatureMethod_HMAC_SHA1() self.consumer = oauth.Consumer(key=consumer_key, secret=consumer_secret) self.params['oauth_consumer_key'] = self.consumer.key if token_key and token_secret: self.token = oauth.Token(key=token_key, secret=token_secret) self.params['oauth_token'] = self.token.key self.user = NetflixUser() else: self.user = None
def yahoo_get_resource(url, oauth_token, oauth_token_secret, extras=None): base_url = 'http://fantasysports.yahooapis.com/fantasy/v2/' params = { 'format': 'json', 'oauth_version': "1.0", 'oauth_nonce': oauth.generate_nonce(), 'oauth_timestamp': int(time.time()), } if extras: params = dict(params.items() + extras.items()) token = oauth.Token(key=oauth_token, secret=oauth_token_secret) consumer = oauth.Consumer(key=consumer_key, secret=consumer_secret) params['oauth_token'] = token.key params['oauth_consumer_key'] = consumer.key signature_method = oauth.SignatureMethod_HMAC_SHA1() oauth_request = oauth.Request.from_consumer_and_token(consumer, token=token, http_method='GET', http_url=base_url+url, parameters=params) oauth_request.sign_request(signature_method, consumer, token) #print 'REQUEST' url = oauth_request.to_url() #print url resp, content = httplib2.Http.request(oauth.Client(consumer), url, 'GET') #print 'GOT' #print resp return resp, json.loads(content)