def access_token(self, request_token: dict, verifier: str) -> dict: url = urljoin(self.base_url, "/OAuth/access_token") token = Token(request_token["oauth_token"], request_token["oauth_token_secret"]) token.set_verifier(verifier) self.client.token = token header, content = self.client.request(url, "POST") return parse_qs(content)
def get_access_token(config, token, sec, verifier): consumer = Consumer(config['consumer_key'], config['consumer_sec']) token = Token(token, sec) token.set_verifier(verifier) client = Client(consumer, token) response, content = client.request(ACCESS_TOKEN_URL) access_token = dict(urlparse.parse_qsl(content)) print access_token
def get_access_token(self, key, secret, verifier): token = Token(key, secret) token.set_verifier(verifier) oauth_request = Request.from_consumer_and_token( self.consumer, http_method="POST", token=token, http_url=self.request_token_url) oauth_request.sign_request(SignatureMethod_HMAC_SHA1(), self.consumer, None) return self.fetch_access_token(oauth_request)
def on_auth(): # リクエストトークンとverifierを用いてアクセストークンを取得 request_token = session['request_token'] token = Token(request_token['oauth_token'], request_token['oauth_token_secret']) token.set_verifier(request.args['oauth_verifier']) client = Client(consumer, token) resp, content = client.request(ACCESS_TOKEN_URL) # アクセストークンをセッションに記録しておく session['access_token'] = dict(urlparse.parse_qsl(content)) return redirect(url_for('index'))
def get(self, ckey, csec): """ oauthを行う。 tokenを要求した後、PINの入力を受付け、 その結果、token情報を返す """ """ リプライをパースするλ式 oauth_token=IE&oauth_token_secret=0x&oauth_callback_confirmed=true' を {'oauth_token_secret': '0x', 'oauth_token': 'IEb', 'oauth_callback_confirmed': 'true'} のようにする """ parseparam = lambda x: dict(map(lambda y: y.split('='), x.split("&"))) # 設定ファイルに情報があるならそこからもらい返す ukey, usec = self.getfromcfg() if ukey != "" and usec != "": return( (ukey, usec) ) # oauth用のクラス定義 client = Client(Consumer(ckey, csec), None) # トークンの要求 liRes = client.request(self.urlReqToken, 'GET') diRes = parseparam(liRes[1]) # 得たトークンを基にPINの要求を行う request_token = Token(diRes["oauth_token"], diRes["oauth_token_secret"]) print("plz access: " + self.urlReqPin + request_token.key) stPin = raw_input('PIN:') request_token.set_verifier(stPin) # 実際のキーをもらう client.token = request_token liRes = client.request(self.urlReqKey, 'POST') # 情報をパースする diRes = parseparam(liRes[1]) ukey = diRes["oauth_token"] usec = diRes["oauth_token_secret"] # 設定ファイルに書き込む self.setcfg(ukey, usec) return( (ukey, usec, diRes["user_id"], diRes["screen_name"]) )
def doSetup(self): print 'Running twitter setup...' consumer = Consumer(self.consumer_key, self.consumer_secret) print consumer client = Client(consumer) resp, content = client.request(TWITTER_REQUEST_TOKEN_URL, "GET") if resp['status'] != '200': raise Exception("Invalid response %s." % resp['status']) self.request_token = dict(urlparse(content)) print "Request Token:" print " - oauth_token = %s" % self.request_token[ 'oauth_token'] print " - oauth_token_secret = %s" % self.request_token[ 'oauth_token_secret'] print # Step 2: Redirect to the provider. Since this is a CLI script we do not # redirect. In a web application you would redirect the user to the URL # below. print "Go to the following link in your browser:" print "%s?oauth_token=%s" % (TWITTER_AUTHORIZE_URL, self.request_token['oauth_token']) print # After the user has granted access to you, the consumer, the provider will # redirect you to whatever URL you have told them to redirect to. You can # usually define this in the oauth_callback argument as well. accepted = 'n' while accepted.lower() == 'n': accepted = raw_input('Have you authorized me? (y/n) ') oauth_verifier = raw_input('What is the PIN? ') # Step 3: Once the consumer has redirected the user back to the oauth_callback # URL you can request the access token the user has approved. You use the # request token to sign this request. After this is done you throw away the # request token and use the access token returned. You should store this # access token somewhere safe, like a database, for future use. token = Token(self.request_token['oauth_token'], self.request_token['oauth_token_secret']) token.set_verifier(oauth_verifier) client = Client(consumer, token) resp, content = client.request(TWITTER_ACCESS_TOKEN_URL, "POST") self.access_token = dict(urlparse(content)) print "Access Token:" print " - oauth_token = %s" % self.access_token['oauth_token'] print " - oauth_token_secret = %s" % self.access_token[ 'oauth_token_secret'] print print "You may now access protected resources using the access tokens above."
def invoke(self, controller, selection): target = selection[0] consumer = Consumer(target.app_id, target.app_secret) def request(client, *args, **kwargs): response, body = client.request(*args, **kwargs) if response["status"] != "200": raise TwitterAPIError(body) return body try: oauth_token = cherrypy.request.params.get("oauth_token") oauth_verifier = cherrypy.request.params.get("oauth_verifier") oauth_secret_session_key = "twitter_auth.%s.oauth_secret" % self.id if not oauth_token or not oauth_verifier: # Obtain a request token client = Client(consumer) location = Location.get_current(relative=False) location.query_string["item_action"] = self.id callback = quote_plus(str(location)) body = request( client, "https://api.twitter.com/oauth/request_token" "?oauth_callback=" + callback, "GET") data = dict(parse_qsl(body)) session[oauth_secret_session_key] = data["oauth_token_secret"] # Redirect the user to the login form auth_url = ("https://api.twitter.com/oauth/authorize?" "oauth_token=%s" "&oauth_callback=%s" % (data["oauth_token"], callback)) raise cherrypy.HTTPRedirect(auth_url) else: token = Token(oauth_token, session[oauth_secret_session_key]) token.set_verifier(oauth_verifier) client = Client(consumer, token) body = request(client, 'https://api.twitter.com/oauth/access_token', "POST") data = dict(parse_qsl(body)) target.auth_token = data["oauth_token"] target.auth_secret = data["oauth_token_secret"] datastore.commit() except TwitterAPIError, ex: notify_user(translations(ex), category="error", transient=False)
def access_token(self, request): oauth_token = request.session.get('flickr_token_session') if not oauth_token: raise FlickrError, 'No saved oauth_token from previous request, are sessions enabled?' token = Token.from_string(oauth_token) if token.key != request.GET.get('oauth_token', 'no-no-no'): raise FlickrError, 'oauth_token mismatch!' """ Access token """ params = {'oauth_verifier': request.GET.get('oauth_verifier') } rq = self.get_oauth_request(url=self.ACCESS_TOKEN_URL, token=token, **params) response = self.get_response(rq) self.token = Token.from_string(response).to_string() """ Check token """ data = self.get('flickr.auth.oauth.checkToken') data['token'] = self.token return data
def auth_complete(self, *args, **kwargs): """Return user, might be logged in""" # Multiple unauthorized tokens are supported (see #521) name = self.AUTH_BACKEND.name + 'unauthorized_token_name' token = None unauthed_tokens = self.request.session.get(name) or [] if not unauthed_tokens: raise AuthTokenError(self, 'Missing unauthorized token') for unauthed_token in unauthed_tokens: token = Token.from_string(unauthed_token) if token.key == self.data.get('oauth_token', 'no-token'): unauthed_tokens = list(set(unauthed_tokens) - set([unauthed_token])) self.request.session[name] = unauthed_tokens self.request.session.modified = True break else: raise AuthTokenError(self, 'Incorrect tokens') try: access_token = self.access_token(token) except HTTPError, e: if e.code == 400: raise AuthCanceled(self) else: raise
def unauthorized_token(self): """Return request for unauthorized token (first stage)""" request = self.oauth_request( token=None, url=self.REQUEST_TOKEN_URL, extra_params=self.request_token_extra_arguments() ) response = self.fetch_response(request) return Token.from_string(response)
def auth_complete(self, *args, **kwargs): """Return user, might be logged in""" # Multiple unauthorized tokens are supported (see #521) name = self.AUTH_BACKEND.name + 'unauthorized_token_name' token = None unauthed_tokens = self.request.session.get(name) or [] if not unauthed_tokens: raise AuthTokenError(self, 'Missing unauthorized token') for unauthed_token in unauthed_tokens: token = Token.from_string(unauthed_token) if token.key == self.data.get('oauth_token', 'no-token'): unauthed_tokens = list( set(unauthed_tokens) - set([unauthed_token])) self.request.session[name] = unauthed_tokens self.request.session.modified = True break else: raise AuthTokenError(self, 'Incorrect tokens') try: access_token = self.access_token(token) except HTTPError, e: if e.code == 400: raise AuthCanceled(self) else: raise
def unauthorized_token(self): """Return request for unauthorized token (first stage)""" request = self.oauth_request( token=None, url=self.REQUEST_TOKEN_URL, extra_params=self.request_token_extra_arguments()) return Token.from_string(self.fetch_response(request))
def authenticate(self, oauth_token, oauth_token_secret, oauth_verifier): token = Token(oauth_token, oauth_token_secret) token.set_verifier(oauth_verifier) client = OAuthClient(self.consumer, token) resp, content = client.request( self.ACCESS_TOKEN_URL, self.ACCESS_TOKEN_METHOD ) if resp['status'] != '200': raise AuthException('Authentication failed: {0!s}'.format(content)) access_token = dict(urlparse.parse_qsl(content)) return ( access_token['oauth_token'], access_token['oauth_token_secret'])
def main(args): conf = configparser.SafeConfigParser() try: conf.read(args.configfile) consumer_key = conf.get('general', 'consumer_key') consumer_secret = conf.get('general', 'consumer_secret') user_key = conf.get('general', 'user_key') user_secret = conf.get('general', 'user_secret') except Exception as e: print('err: (', args.configfile, ')', e, file=sys.stderr) sys.exit(1) twclient = Client( Consumer(consumer_key, consumer_secret), Token(user_key, user_secret), ) if args.replyid is None: ret = twclient.request( 'https://api.twitter.com/1.1/statuses/update.json', 'POST', urlencode({'status': args.message})) else: ret = twclient.request( 'https://api.twitter.com/1.1/statuses/update.json', 'POST', urlencode({ 'status': args.message, 'in_reply_to_status_id': args.replyid })) if int(ret[0]['status']) == 200: print(ret[1].decode('utf-8')) else: print('err:', ret[0]['status'], file=sys.stderr) print(ret[1].decode('utf-8')) sys.exit(2)
def access_token(self, token): """Return request for access token value""" request = self.oauth_request(token, self.ACCESS_TOKEN_URL) try: return Token.from_string(self.fetch_response(request)) except TypeError: raise AuthException(self, 'Couldn\'t get a token')
def request(self, url, params={}, data={}, files={}): """ Return: status code, json object, status reason """ # Setup if self.oauth_token: self.token = Token(self.oauth_token['oauth_token'], self.oauth_token['oauth_token_secret']) req = self._make_request(self.base_url + url, data) req_files = {} try: if files: for (name, fpath) in files.items(): req_files[name] = open(fpath, 'rb') r = requests.post( self.base_url + url, headers=req.to_header(), data=data, files=req_files if req_files else None ) except requests.RequestException as ex: print >> sys.stderr, ex sys.exit(1) except: print >> sys.stderr sys.exit(1) finally: for name, ofile in req_files.items(): ofile.close() return r.status_code, r.json(), r.reason
class EvernoteAuth(ConsumerBasedOAuth): """Evernote OAuth authentication mechanism""" AUTHORIZATION_URL = EVERNOTE_AUTHORIZATION_URL REQUEST_TOKEN_URL = EVERNOTE_REQUEST_TOKEN_URL ACCESS_TOKEN_URL = EVERNOTE_ACCESS_TOKEN_URL SERVER_URL = '%s' % EVERNOTE_SERVER AUTH_BACKEND = EvernoteBackend SETTINGS_KEY_NAME = 'EVERNOTE_CONSUMER_KEY' SETTINGS_SECRET_NAME = 'EVERNOTE_CONSUMER_SECRET' def access_token(self, token): """Return request for access token value""" request = self.oauth_request(token, self.ACCESS_TOKEN_URL) try: response = self.fetch_response(request) except HTTPError, e: # Evernote returns a 401 error when AuthCanceled if e.code == 401: raise exceptions.AuthCanceled(self) else: raise params = parse_qs(response) # evernote sents a empty secret token, this way it doesn't fires up the # exception response = response.replace('oauth_token_secret=', 'oauth_token_secret=None') token = Token.from_string(response) token.user_info = params return token
def api_request(self, url, method, oauth_token, oauth_token_secret, oauth_verifier): token = Token(oauth_token, oauth_token_secret) token.set_verifier(oauth_verifier) client = OAuthClient(self.consumer, token) resp, content = client.request( '{0}.json'.format(url), method ) if resp['status'] != '200': raise AuthException( 'Getting info failed url:{0!s} content: {1!s}'. format(url, content)) return json.loads(content)
def request(self, url, method="GET", params={}, body='', headers=''): if not self.consumer_key or not self.consumer_secret or not self.access_token or not self.access_token_secret: message = "BaseOAuth: Required parameters not provided." logger.error(message) raise Exception(message) consumer = Consumer(key=self.consumer_key, secret=self.consumer_secret) token = Token(key=self.access_token, secret=self.access_token_secret) client = Client(consumer, token) _url = url if url[-1] != '?': _url += '?' _url += '&'.join( map(lambda x: "{}={}".format(x, params[x]), params.keys())) url = _url logger.info("{}: {}, Body: {}, Headers: {}".format( method, url, body, headers)) resp, content = client.request(url, method=method, body=body, headers=headers) return content
def auth_complete(self, *args, **kwargs): """Return user, might be logged in""" name = self.AUTH_BACKEND.name + 'unauthorized_token_name' try: unauthed_token, access_type = self.request.session.get(name) except ValueError: unauthed_token = self.request.session.get(name) access_type = 'read' if not unauthed_token: raise ValueError('Missing unauthorized token') token = Token.from_string(unauthed_token) if token.key != self.data.get('oauth_token', 'no-token'): raise ValueError( 'Incorrect tokens, %s != %s (%s, %s)', (token.key, self.data.get('oauth_token', 'no-token'), self.request.GET.get('oauth_token'), self.request.POST.get('oauth_token')) ) access_token = self.access_token(token) data = self.user_data(access_token) if data is not None: data['access_token'] = access_token.to_string() data['access_type'] = access_type kwargs.update({'response': data, self.AUTH_BACKEND.name: True}) return authenticate(*args, **kwargs)
def authenticate(self, key, secret): consumer = Consumer(settings.TWITTER_CONSUMER_KEY, settings.TWITTER_CONSUMER_SECRET) token = Token(key, secret) client = Client(consumer, token) response, content = client.request(twitter_auth_settings.ACCESS_TOKEN_URL, "GET") if not response.get('status') == '200': raise TwitterAuthException("Invalid response from Twitter.", response) access_token = dict(cgi.parse_qsl(content)) # if we have an access token, it means we have authenticated with Twitter user, created = User.objects.get_or_create(username=access_token['screen_name']) if created: twitter_user_created.send( sender="TwitterAuth", user=user, screen_name=access_token['screen_name'], user_id=access_token['user_id'] ) # give the user a temporary password - it should never be needed since # Twitter is providing the authentication token. user.set_password(User.objects.make_random_password(length=12)) user.save() # update credentials user.twitterauth.oauth_token = access_token.get('oauth_token') user.twitterauth.oauth_secret = access_token.get('oauth_token_secret') user.twitterauth.save() twitter_user_authenticated.send(sender='TwitterAuth', user=user) return user
def doSetup(self): print "Running twitter setup..." consumer = Consumer(self.consumer_key, self.consumer_secret) print consumer client = Client(consumer) resp, content = client.request(TWITTER_REQUEST_TOKEN_URL, "GET") if resp["status"] != "200": raise Exception("Invalid response %s." % resp["status"]) self.request_token = dict(urlparse(content)) print "Request Token:" print " - oauth_token = %s" % self.request_token["oauth_token"] print " - oauth_token_secret = %s" % self.request_token["oauth_token_secret"] print # Step 2: Redirect to the provider. Since this is a CLI script we do not # redirect. In a web application you would redirect the user to the URL # below. print "Go to the following link in your browser:" print "%s?oauth_token=%s" % (TWITTER_AUTHORIZE_URL, self.request_token["oauth_token"]) print # After the user has granted access to you, the consumer, the provider will # redirect you to whatever URL you have told them to redirect to. You can # usually define this in the oauth_callback argument as well. accepted = "n" while accepted.lower() == "n": accepted = raw_input("Have you authorized me? (y/n) ") oauth_verifier = raw_input("What is the PIN? ") # Step 3: Once the consumer has redirected the user back to the oauth_callback # URL you can request the access token the user has approved. You use the # request token to sign this request. After this is done you throw away the # request token and use the access token returned. You should store this # access token somewhere safe, like a database, for future use. token = Token(self.request_token["oauth_token"], self.request_token["oauth_token_secret"]) token.set_verifier(oauth_verifier) client = Client(consumer, token) resp, content = client.request(TWITTER_ACCESS_TOKEN_URL, "POST") self.access_token = dict(urlparse(content)) print "Access Token:" print " - oauth_token = %s" % self.access_token["oauth_token"] print " - oauth_token_secret = %s" % self.access_token["oauth_token_secret"] print print "You may now access protected resources using the access tokens above."
def fetch(self, oauth_request, url): # via headers # -> Token self.connection.request(oauth_request.method, url, headers=oauth_request.to_header()) response = self.connection.getresponse() res = response.read() return Token.from_string(res)
def get_token(self): try: return Token.from_string(self.token) except ValueError, e: if self.token: raise FlickrInvalidTokenAuth(e) else: raise FlickrError, 'Error when calling flickr API: trying to build a token from an empty string'
def get(self, ckey, csec): """ oauthを行う。 tokenを要求した後、PINの入力を受付け、 その結果、token情報を返す """ """ リプライをパースするλ式 oauth_token=IE&oauth_token_secret=0x&oauth_callback_confirmed=true' を {'oauth_token_secret': '0x', 'oauth_token': 'IEb', 'oauth_callback_confirmed': 'true'} のようにする """ parseparam = lambda x: dict(map(lambda y: y.split('='), x.split("&"))) # 設定ファイルに情報があるならそこからもらい返す ukey, usec = self.getfromcfg() if ukey != "" and usec != "": return ((ukey, usec)) # oauth用のクラス定義 client = Client(Consumer(ckey, csec), None) # トークンの要求 liRes = client.request(self.urlReqToken, 'GET') diRes = parseparam(liRes[1]) # 得たトークンを基にPINの要求を行う request_token = Token(diRes["oauth_token"], diRes["oauth_token_secret"]) print("plz access: " + self.urlReqPin + request_token.key) stPin = raw_input('PIN:') request_token.set_verifier(stPin) # 実際のキーをもらう client.token = request_token liRes = client.request(self.urlReqKey, 'POST') # 情報をパースする diRes = parseparam(liRes[1]) ukey = diRes["oauth_token"] usec = diRes["oauth_token_secret"] # 設定ファイルに書き込む self.setcfg(ukey, usec) return ((ukey, usec, diRes["user_id"], diRes["screen_name"]))
def make_api_call(self, kind, url, token, method="GET", **kwargs): if isinstance(token, basestring): token = Token.from_string(token) client = Client(self.consumer, token=token) request_kwargs = dict(method=method) if method == "POST": request_kwargs["body"] = urlencode(kwargs["params"]) response, content = client.request(url, **request_kwargs) return self._process_response(kind, response, content)
def access_token(self, request): oauth_token = request.session.get('flickr_token_session') if not oauth_token: raise FlickrError, 'No saved oauth_token from previous request, are sessions enabled?' token = Token.from_string(oauth_token) if token.key != request.GET.get('oauth_token', 'no-no-no'): raise FlickrError, 'oauth_token mismatch!' """ Access token """ params = {'oauth_verifier': request.GET.get('oauth_verifier')} rq = self.get_oauth_request(url=self.ACCESS_TOKEN_URL, token=token, **params) response = self.get_response(rq) self.token = Token.from_string(response).to_string() """ Check token """ data = self.get('flickr.auth.oauth.checkToken') data['token'] = self.token return data
def __init__(self, api_key: str, api_secret: str, token_key: str, token_secret: str, base_url: str = "https://www.plurk.com"): consumer = Consumer(api_key, api_secret) # type:Consumer token = Token(token_key, token_secret) # type:Token self.client = Client(consumer, token) # type:Client self.base_url = base_url # type:str
def fetch_token(self, request): resp, content = self.request(request.url, headers=request.to_header()) if 200 == int(resp['status']): token = Token.from_string(content) params = cgi.parse_qs(content, keep_blank_values=False) user_id = params.get('douban_user_id',[None])[0] return token.key,token.secret, user_id else: raise Exception('{}: {}'.format(resp['status'], content))
def begin(self, request, data): """ Try to get Request Token from OAuth Provider and redirect user to provider's site for approval. """ request = self.get_request( http_url = self.REQUEST_TOKEN_URL, parameters = dict(oauth_callback = self.get_callback(request))) content = self.load_request(request) request = self.get_request(token = Token.from_string(content), http_url=self.AUTHORIZE_URL) raise RedirectException(request.to_url())
def fetch(self, oauth_request, url): """ via headers :returns: Token (by oauth2) instance :rtype: Token """ self.connection.request(oauth_request.method, url, headers=oauth_request.to_header()) response = self.connection.getresponse() res = response.read() return Token.from_string(res)
def do_auth(self, access_token, *args, **kwargs): """Finish the auth process once the access_token was retrieved""" if isinstance(access_token, basestring): access_token = Token.from_string(access_token) data = self.user_data(access_token) if data is not None: data["access_token"] = access_token.to_string() kwargs.update({"auth": self, "response": data, self.AUTH_BACKEND.name: True}) return authenticate(*args, **kwargs)
def consumer_oauth_url_request(backend, url, user_or_id, redirect_uri="/", json=True): """Builds and retrieves an OAuth signed response.""" user = UserSocialAuth.resolve_user_or_id(user_or_id) oauth_info = user.social_auth.filter(provider=backend.AUTH_BACKEND.name)[0] token = Token.from_string(oauth_info.tokens["access_token"]) request = build_consumer_oauth_request(backend, token, url, redirect_uri) response = "\n".join(dsa_urlopen(request.to_url()).readlines()) if json: response = simplejson.loads(response) return response
def do_auth(self, access_token, *args, **kwargs): """Finish the auth process once the access_token was retrieved""" if isinstance(access_token, six.string_types): access_token = Token.from_string(access_token) data = self.user_data(access_token) if data is not None: data["access_token"] = access_token.to_string() kwargs.update({"auth": self, "response": data, self.AUTH_BACKEND.name: True}) return authenticate(*args, **kwargs)
def begin(self, request, data): """ Try to get Request Token from OAuth Provider and redirect user to provider's site for approval. """ request = self.get_request( http_url=self.REQUEST_TOKEN_URL, parameters=dict(oauth_callback=self.get_callback(request))) content = self.load_request(request) request = self.get_request(token=Token.from_string(content), http_url=self.AUTHORIZE_URL) raise RedirectException(request.to_url())
def oauthdance( consumer_key, consumer_secret, request_token_url="http://twitter.com/oauth/request_token", authorize_url="http://twitter.com/oauth/authorize", access_token_url="http://twitter.com/oauth/access_token", ): """ """ from oauth2 import Consumer, Client, Token from urlparse import parse_qsl con = Consumer(consumer_key, consumer_secret) cli = Client(con) res, bod = cli.request(request_token_url, "GET") assert res["status"] == "200", "Expected status=200, got %s." % res["status"] tok = dict(parse_qsl(bod)) tok = Token(tok["oauth_token"], tok["oauth_token_secret"]) print "Visit this URL to get a PIN:" print " %s?oauth_token=%s" % (authorize_url, tok.key) pin = raw_input("PIN: ").strip() tok.set_verifier(pin) cli = Client(con, tok) res, bod = cli.request(access_token_url, "GET") assert res["status"] == "200", "Expected status=200, got %s." % res["status"] tok = dict(parse_qsl(bod)) tok = Token(tok["oauth_token"], tok["oauth_token_secret"]) print "Your token key is: ", tok.key print "And your secret is:", tok.secret return tok
def consumer_oauth_url_request(backend, url, user_or_id, redirect_uri='/', json=True): """Builds and retrieves an OAuth signed response.""" user = UserSocialAuth.resolve_user_or_id(user_or_id) oauth_info = user.social_auth.filter(provider=backend.AUTH_BACKEND.name)[0] token = Token.from_string(oauth_info.tokens['access_token']) request = build_consumer_oauth_request(backend, token, url, redirect_uri) response = '\n'.join(dsa_urlopen(request.to_url()).readlines()) if json: response = simplejson.loads(response) return response
def auth_url(self, request, perms='read', callback=None): """ Request token """ params = {'oauth_callback': callback} rq = self.get_oauth_request(url=self.REQUEST_TOKEN_URL, token=None, **params) response = self.get_response(rq) token = Token.from_string(response) request.session['flickr_token_session'] = token.to_string() """ User auth """ params = {'perms': perms, } rq = self.get_oauth_request(url=self.AUTHORIZATION_URL, token=token, **params) return rq.to_url()
def __init__(self, ckey, csec, ukey, usec, use_cache=True): self.client = Client(Consumer(ckey, csec), Token(ukey, usec)) self.client.to_url = self._override_tourl try: f = open(self.fnCache, 'rb') except IOError: print("no cache file") self._write_Cache() else: self.objCache = pickle.load(f)
def auth_complete(self, *args, **kwargs): """Return user, might be logged in""" unauthed_token = self.request.session.get(self.unauthorized_token_name) if not unauthed_token: raise ValueError('Missing unauthorized token') token = Token.from_string(unauthed_token) if token.key != self.data.get('oauth_token', 'no-token'): raise ValueError('Incorrect tokens') access_token = self.access_token(token) return access_token.to_string()
def SendMsg(self, update): token = Token(key=self.access_key, secret=self.access_secret) consumer = Consumer(key=self.consumer_key, secret=self.consumer_secret) client = Client(consumer, token) request_uri = 'https://api.twitter.com/1/statuses/update.json' data = { u'status': unicodedata.normalize('NFKD', update[:140]).encode('ASCII', 'ignore') } resp = client.request(request_uri, 'POST', urllib.urlencode(data))[0] print resp.content print resp.status
def access_token(self, token): """Return request for access token value""" # Fitbit is a bit different - it passes user information along with # the access token, so temporarily store it to vie the user_data # method easy access later in the flow! request = self.oauth_request(token, self.ACCESS_TOKEN_URL) response = self.fetch_response(request) token = Token.from_string(response) params = parse_qs(response) token.encoded_user_id = params.get("encoded_user_id", [None])[0] token.fullname = params.get("fullname", [None])[0] token.username = params.get("username", [None])[0] return token
def unauthorized_token(self): """Makes first request to oauth. Returns an unauthorized Token.""" request_token_url = self.REQUEST_TOKEN_URL scope = self.get_scope_argument() if scope: request_token_url = request_token_url + '?' + urlencode(scope) request = self.oauth_request( token=None, url=request_token_url, extra_params=self.request_token_extra_arguments()) response = self.fetch_response(request) return Token.from_string(response)
def get_request_token(self, callback='oob'): path = self.get_oauth_path('get_request_token') url = self.get_url(path) request = Request.from_consumer_and_token(self.consumer, None, 'GET', url, {'oauth_callback': callback}) request.sign_request(self.signature_method, self.consumer, None) response = self.client.get(path, request) self.assertEquals(response.status_code, 200) params = dict(parse_qsl(response.content)) return Token(params['oauth_token'], params['oauth_token_secret'])
def unauthorized_token(self): """Makes first request to oauth. Returns an unauthorized Token.""" request_token_url = self.REQUEST_TOKEN_URL scope = self.get_scope() if scope: qs = "scope=" + self.SCOPE_SEPARATOR.join(scope) request_token_url = request_token_url + "?" + qs request = self.oauth_request( token=None, url=request_token_url, extra_params=self.request_token_extra_arguments() ) response = self.fetch_response(request) return Token.from_string(response)
def __init__(self, consumer_key, consumer_secret, token_key, token_secret): consumer = Consumer(key=consumer_key, secret=consumer_secret) token = Token(key=token_key, secret=token_secret) proxy_info = None if hasattr(settings, 'PROXY_HOST') and \ hasattr(settings, 'PROXY_PORT'): proxy_info = ProxyInfo(proxy_type=PROXY_TYPE_HTTP, proxy_host=settings.PROXY_HOST, proxy_port=settings.PROXY_PORT) self.client = Client(consumer=consumer, token=token, proxy_info=proxy_info)
def oauth_request(self, url, key, secret, http_method="GET", http_headers=None): consumer = Consumer(key=self.consumer_key, secret=self.consumer_secret) token = Token(key=key, secret=secret) client = Client(consumer, token) resp, content = client.request(url, method=http_method, headers=http_headers) return content
def unauthorized_token(self): """Makes first request to oauth. Returns an unauthorized Token.""" request_token_url = self.REQUEST_TOKEN_URL scope = self.get_scope_argument() if scope: request_token_url = request_token_url + '?' + urlencode(scope) request = self.oauth_request( token=None, url=request_token_url, extra_params=self.request_token_extra_arguments() ) response = self.fetch_response(request) return Token.from_string(response)
def unauthorized_token(self): """Makes first request to oauth. Returns an unauthorized Token.""" request_token_url = self.REQUEST_TOKEN_URL scope = self.get_scope() if scope: qs = 'scope=' + self.SCOPE_SEPARATOR.join(scope) request_token_url = request_token_url + '?' + qs request = self.oauth_request( token=None, url=request_token_url, extra_params=self.request_token_extra_arguments()) response = self.fetch_response(request) return Token.from_string(response)
def oauth_req(backend, token, url, http_method="GET", post_body=None, http_headers=None): consumer = OAuthConsumer(*backend.get_key_and_secret()) token = Token.from_string(token) client = Client(consumer, token) resp, content = client.request( url, method=http_method, body=post_body, headers=http_headers, force_auth_header=True ) return content
def test_oauth(): from oauth2 import Consumer, Token consumer = Consumer(key='7c26730528d8cf0b3b5c7f0477060c00', secret='toomanysecrets') digg = Digg(oauth_consumer=consumer) response = digg.oauth.getRequestToken(oauth_callback='oob') request_token = parse_qs(response) print 'Got request token!' print 'Go to the following URL to authorize this application' print 'http://digg.com/oauth/authorize?oauth_token=%s' % request_token['oauth_token'][0] sys.stdout.write('Type the verification number: ') verifier = sys.stdin.readline().rstrip('\r\n') request_token = Token(request_token['oauth_token'][0], request_token['oauth_token_secret'][0]) request_token.set_verifier(verifier) response = digg.oauth.getAccessToken(oauth_token=request_token) response = parse_qs(response) access_token = Token(response['oauth_token'][0], response['oauth_token_secret'][0]) print 'Got access token!' print digg.oauth.verify(oauth_token=access_token) print 'OAuth verification successful!'
def access_token(self, token): """Return request for access token value""" request = self.oauth_request(token, self.ACCESS_TOKEN_URL) response = self.fetch_response(request) params = parse_qs(response) # evernote sents a empty secret token, this way it doesn't fires up the # exception response = response.replace('oauth_token_secret=', 'oauth_token_secret=None') token = Token.from_string(response) token.user_info = params return token
def access_token(self, token, oauth_verifier): """Return request for access token value""" request = self.oauth_request(token, self.ACCESS_TOKEN_URL, oauth_verifier) response = self.fetch_response(request) params = parse_qs(response, keep_blank_values=False) user_data = dict() for key in 'user_id', 'screen_name': try: user_data[key] = params[key][0] except Exception: raise ValueError("'%s' not found in OAuth response." % key) return Token.from_string(response), user_data
def auth_complete(self, oauth_token, oauth_verifier): """Return user, might be logged in""" name = self.AUTH_BACKEND_NAME + 'unauthorized_token_name' unauthed_token = self.request.session[name] del self.request.session[name] if not unauthed_token: raise ValueError('Missing unauthorized token') token = Token.from_string(unauthed_token) if token.key != oauth_token: raise ValueError('Incorrect tokens') access_token, user_data = self.access_token(token, oauth_verifier) return user_data
def access_token(self, token): """Return request for access token value""" # Flickr is a bit different - it passes user information along with # the access token, so temporarily store it to view the user_data # method easy access later in the flow! request = self.oauth_request(token, self.ACCESS_TOKEN_URL) response = self.fetch_response(request) token = Token.from_string(response) params = parse_qs(response) token.user_nsid = params["user_nsid"][0] if "user_nsid" in params else None token.fullname = params["fullname"][0] if "fullname" in params else None token.username = params["username"][0] if "username" in params else None return token