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 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 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 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 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 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 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!'
consumer_secret = twitter_key.C_SECRET
def split_parameter(parameters):
result_list = [tuple(parameter.split('='))
for parameter in parameters.split('&')]
return dict(result_list)
consumer = Consumer(consumer_key, consumer_secret)
client = Client(consumer, None)
result = client.request('http://api.twitter.com/oauth/request_token',
'GET')
request_token_map = split_parameter(result[1])
request_token = Token(request_token_map['oauth_token'],
request_token_map['oauth_token_secret'])
print 'Please access "http://api.twitter.com/oauth/authorize?oauth_token='+request_token.key+'".'
pin = raw_input('PIN:')
request_token.set_verifier(pin)
client.token = request_token
result = client.request('http://api.twitter.com/oauth/access_token',
'POST')
access_token_map = split_parameter(result[1])
print result[1]
print 'User key: '+access_token_map['oauth_token']
print 'User secret: '+access_token_map['oauth_token_secret']
raw_input('Push any key to quit.')
consumer_key = '03qZsTOrjpcKnDotiwhC5g'
consumer_secret = 'R9OYu68Wy6YgxmI8IbKPVIHrzeeANNmvjqvxPIXQE'
def split_parameter(parameters):
result_list = [tuple(parameter.split('='))
for parameter in parameters.split('&')]
return dict(result_list)
consumer = Consumer(consumer_key, consumer_secret)
client = Client(consumer, None)
result = client.request('http://api.twitter.com/oauth/request_token',
'GET')
request_token_map = split_parameter(result[1])
request_token = Token(request_token_map['oauth_token'],
request_token_map['oauth_token_secret'])
print 'Please access "http://api.twitter.com/oauth/authorize?oauth_token='+request_token.key+'".'
pin = raw_input('PIN:')
request_token.set_verifier(pin)
client.token = request_token
result = client.request('http://api.twitter.com/oauth/access_token',
'POST')
access_token_map = split_parameter(result[1])
print result[1]
print 'User key: '+access_token_map['oauth_token']
print 'User secret: '+access_token_map['oauth_token_secret']
raw_input('Push any key to quit.')
class Tumblr(object):
base_url = 'api.tumblr.com/v2'
request_token_url = 'http://www.tumblr.com/oauth/request_token'
authorize_url = 'http://www.tumblr.com/oauth/authorize'
access_token_url = 'http://www.tumblr.com/oauth/access_token'
def __init__(self, consumer=None, token=None, client_kwargs={}, headers={}, callback_url=None, verifier=None):
self.headers = headers
self.callback_url = callback_url
if 'User-Agent' not in self.headers:
self.headers['User-Agent'] = 'Tumblr Python Library'
if consumer and token:
self.consumer = Consumer(**consumer)
self.token = Token(token['oauth_token'], token['oauth_token_secret'])
if verifier:
self.token.set_verifier(verifier)
self.client = Client(self.consumer, self.token, **client_kwargs)
elif consumer:
self.consumer = Consumer(**consumer)
self.token = None
self.client = Client(self.consumer, **client_kwargs)
else:
self.consumer = None
self.token = None
self.client = httplib2.Http(**client_kwargs)
def request_token(self):
callback_url = self.callback_url or 'oob'
resp, content = self.client.request(self.request_token_url, 'POST', headers=self.headers)
if resp['status'] != '200':
raise TumblrException
request_tokens = dict(parse_qsl(content))
request_tokens['oauth_callback'] = callback_url
redirect_url = self.authorize_url + '?' + urllib.urlencode(request_tokens)
return (request_tokens, redirect_url)
def authorized_token(self):
resp, content = self.client.request(self.access_token_url, 'POST', headers=self.headers)
if resp['status'] != '200':
print resp
print content
return dict(parse_qsl(content))
def blog(self, hostname, call, method='get', **kwargs):
kwargs['api_key'] = self.consumer.key
if method.lower() == 'get':
uri = 'http://{baseurl}/blog/{hostname}{call}?{qs}'.format(baseurl=self.base_url, hostname=hostname, call=call, qs=urllib.urlencode(kwargs))
body = ''
else:
uri = 'http://{baseurl}/blog/{hostname}{call}'.format(baseurl=self.base_url, hostname=hostname, call=call)
body = urllib.urlencode(kwargs)
print "%s: %s" % (method.upper(), uri)
_resp, answ = self.client.request(uri, method.upper(), body, headers=self.headers)
answ = json.loads(answ)
if answ['meta']['status'] != 200:
raise TumblrException(repr(answ))
else:
return answ['response']
def user(self, call, method='get', **kwargs):
kwargs['api_key'] = self.consumer.key
if method.lower() == 'get':
uri = 'http://{baseurl}/user{call}{qs}'.format(baseurl=self.base_url, call=call, qs=('?' + urllib.urlencode(kwargs)) if kwargs.keys() else '')
body = ''
else:
uri = 'http://{baseurl}/user{call}'.format(baseurl=self.base_url, call=call)
body = urllib.urlencode(kwargs)
print "%s: %s [%s]" % (method.upper(), uri, body)
_resp, answ = self.client.request(uri, method.upper(), body, headers=self.headers)
answ = json.loads(answ)
if answ['meta']['status'] != 200:
raise TumblrException(repr(answ))
else:
return answ['response']
