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(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_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 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 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
