def from_consumer_and_token(oauth_consumer,
token=None,
callback=None,
verifier=None,
http_method=HTTP_METHOD,
http_url=None,
parameters=None):
if not parameters:
parameters = {}
defaults = {
constants.OAUTH_CONSUMER_KEY: oauth_consumer.key,
constants.OAUTH_TIMESTAMP: generate_timestamp(),
constants.OAUTH_NONCE: generate_nonce(),
constants.OAUTH_VERSION: OAuthRequest.version,
}
defaults.update(parameters)
parameters = defaults
if token:
parameters[constants.OAUTH_TOKEN] = token.key
if token.callback:
parameters[constants.OAUTH_CALLBACK] = token.callback
# 1.0a support for verifier.
if verifier:
parameters[constants.OAUTH_VERIFIER] = verifier
elif callback:
# 1.0a support for callback in the request token request.
parameters[constants.OAUTH_CALLBACK] = callback
return PortalOAuthRequest(http_method, http_url, parameters)
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 from_consumer_and_token(
oauth_consumer,
token=None,
callback=None,
verifier=None,
http_method=HTTP_METHOD,
http_url=None,
parameters=None,
):
if not parameters:
parameters = {}
defaults = {
constants.OAUTH_CONSUMER_KEY: oauth_consumer.key,
constants.OAUTH_TIMESTAMP: generate_timestamp(),
constants.OAUTH_NONCE: generate_nonce(),
constants.OAUTH_VERSION: OAuthRequest.version,
}
defaults.update(parameters)
parameters = defaults
if token:
parameters[constants.OAUTH_TOKEN] = token.key
if token.callback:
parameters[constants.OAUTH_CALLBACK] = token.callback
# 1.0a support for verifier.
if verifier:
parameters[constants.OAUTH_VERIFIER] = verifier
elif callback:
# 1.0a support for callback in the request token request.
parameters[constants.OAUTH_CALLBACK] = callback
return PortalOAuthRequest(http_method, http_url, parameters)
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': oauth.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 = oauth.OAuthRequest(http_method="GET",
http_url=ACCESS_TOKEN_URL,
parameters=access_token_parms)
req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), self.consumer,
self.request_token)
resp = urllib2.urlopen(req.to_url())
access_token_resp = dict(urlparse.parse_qsl(resp.read()))
self.access_token = oauth.OAuthToken(
access_token_resp["oauth_token"],
access_token_resp["oauth_token_secret"])
def sign_request(self, consumer, signature_method):
"""Add oauth parameters and sign the request with the given method.
Args:
consumer: The OAuthConsumer set with a key and secret.
signature_method: A supported method for signing the built request.
"""
params = {
"oauth_consumer_key": consumer.key,
"oauth_timestamp": oauth.generate_timestamp(),
"oauth_nonce": oauth.generate_nonce(),
"oauth_version": oauth.OAuthRequest.version,
}
# PHP OAuth library contains a bug which interferes with signing. Since
# some containers use this library, we will implement a workaround here.
if self.use_body_as_signing_parameter:
params[self.get_post_body()] = ""
else:
# Otherwise, use the oauth_body_hash extension to sign the request body.
if self.post_body:
body_hash = b64encode(hashlib.sha1(self.get_post_body()).digest())
params["oauth_body_hash"] = body_hash
if self.get_security_token():
self.set_parameter("xoauth_requestor_id", None)
self.set_parameters(params)
self.oauth_request.sign_request(signature_method, consumer, None)
def __init__(self,
key=None,
secret=None,
callback=None,
access_token_key=None,
access_token_secret=None,
request_token_key=None,
request_token_secret=None):
self.key = key or method_call.API_KEY
self.secret = secret or method_call.API_SECRET
if self.key is None or self.secret is None:
raise ValueError("API keys have not been set.")
if callback is None:
callback = "http://api.flickr.com/services/rest/?method=flickr.test.echo&api_key=%s" % self.key
params = {
'oauth_timestamp': str(int(time.time())),
'oauth_signature_method': "HMAC-SHA1",
'oauth_version': "1.0",
'oauth_callback': callback,
'oauth_nonce': oauth.generate_nonce(),
'oauth_consumer_key': self.key
}
self.consumer = oauth.OAuthConsumer(key=self.key, secret=self.secret)
if (access_token_key is None) and (request_token_key is None):
req = oauth.OAuthRequest(http_method="GET",
http_url=TOKEN_REQUEST_URL,
parameters=params)
req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, None)
resp = urllib2.urlopen(req.to_url())
request_token = dict(urlparse.parse_qsl(resp.read()))
self.request_token = oauth.OAuthToken(
request_token['oauth_token'],
request_token['oauth_token_secret'])
self.access_token = None
elif request_token_key is not None:
self.access_token = None
self.request_token = oauth.OAuthToken(request_token_key,
request_token_secret)
else:
self.request_token = None
self.access_token = oauth.OAuthToken(access_token_key,
access_token_secret)
def sign_request(self, consumer, signature_method):
"""Add oauth parameters and sign the request with the given method.
Args:
consumer: The OAuthConsumer set with a key and secret.
signature_method: A supported method for signing the built request.
"""
params = {
"oauth_consumer_key": consumer.key,
"oauth_timestamp": oauth.generate_timestamp(),
"oauth_nonce": oauth.generate_nonce(),
"oauth_version": oauth.OAuthRequest.version,
}
self.set_parameters(params)
self.oauth_request.sign_request(signature_method, consumer, None)
def make_oauth_request(self,
http_method='GET',
http_url={},
has_param=False,
parameters=None,
token=None):
param = {
'oauth_version': '1.0',
'oauth_timestamp': int(time.time()),
'oauth_nonce': oauth.generate_nonce(),
'oauth_signature_method': 'HMAC-SHA1',
'oauth_consumer_key': self.consumer.key
}
if (parameters):
param.update(parameters)
if (token):
param.update({'oauth_token': token.key})
oauth_request = oauth.OAuthRequest(http_method=http_method,
http_url=http_url,
parameters=param)
oauth_request.sign_request(self.signature_method, self.consumer, token)
oauth_header = oauth_request.to_header()
if http_method == 'POST':
postdata = oauth_request.to_postdata()
req = urllib2.Request(http_url, postdata, oauth_header)
else:
if has_param:
url = oauth_request.to_url()
req = urllib2.Request(url)
else:
url = http_url
req = urllib2.Request(url, None, oauth_header)
try:
req = urllib2.urlopen(req)
return req.read()
except urllib2.URLError as e:
return e
except urllib2.HTTPError as e:
return e
def build_access_headers(self,
method,
resource_url,
params=None,
request_token=None):
"""Build OAuth access headers for a future request.
Args:
method: The HTTP method being used (e.g. 'GET' or 'POST').
resource_url: The full url the request will be made to.
params: A dictionary of parameters to add to what's already on the url.
Typically, this would consist of POST parameters.
Returns:
A tuple of (header_dict, params) where header_dict is a dictionary
of header names and values appropriate for passing into dropbox.rest.RESTClient
and params is a dictionary like the one that was passed in, but augmented with
oauth-related parameters as appropriate.
"""
if params is None:
params = {}
else:
params = params.copy()
oauth_params = {
'oauth_consumer_key': self.consumer.key,
'oauth_timestamp': oauth.generate_timestamp(),
'oauth_nonce': oauth.generate_nonce(),
'oauth_version': oauth.OAuthRequest.version,
}
token = request_token if request_token else self.token
if token:
oauth_params['oauth_token'] = token.key
params.update(oauth_params)
oauth_request = oauth.OAuthRequest.from_request(method,
resource_url,
parameters=params)
oauth_request.sign_request(self.signature_method, self.consumer, token)
return oauth_request.to_header(), params
def __init__(self,
tokens,
nojsoncallback=True,
format='json',
parameters=None):
self.keys = hidden.keys()
self.dbtokens = tokens
self.dbtokens["token"].encode("ascii")
self.dbtokens["token_secret"].encode('ascii')
if self.dbtokens is not None:
self.consumer = oauth.OAuthConsumer(
self.keys["oauth_consumer_key"],
self.keys["oauth_consumer_secret"])
self.token = oauth.OAuthToken(
self.dbtokens["token"].encode("ascii"),
self.dbtokens["token_secret"].encode("ascii"))
if nojsoncallback:
self.nojsoncallback = 1
else:
self.nojsoncallback = 0
if not parameters:
parameters = {}
self.url = "https://api.flickr.com/services/rest"
defaults = {
"format": format,
"nojsoncallback": self.nojsoncallback,
"oauth_timestamp": oauth.generate_timestamp(),
"oauth_nonce": oauth.generate_nonce(),
"signature_method": "HMAC-SHA1",
"oauth_token": self.token.key,
"api_key": self.consumer.key
}
#print defaults
self.parameters = defaults
else:
print "token is none"
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': oauth.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 = oauth.OAuthRequest(http_method="GET", http_url=ACCESS_TOKEN_URL, parameters=access_token_parms)
req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),self.consumer,self.request_token)
resp = urllib2.urlopen(req.to_url())
access_token_resp = dict(urlparse.parse_qsl(resp.read()))
self.access_token = oauth.OAuthToken(access_token_resp["oauth_token"],access_token_resp["oauth_token_secret"])
def search(command,vertical="web",count=10,start=0,more={}):
params = {
'oauth_version': "1.0",
'oauth_nonce': oauth.generate_nonce(),
'oauth_timestamp': int(time.time()),
'q': quote_plus(command),
'count': count,
'start': start,
'format': 'json',
'ads.recentSource': SOURCE_TAG
}
params.update(more)
url = SEARCH_API_URL_V2 + vertical
consumer = oauth.OAuthConsumer(CC_KEY,CC_SECRET)
req = oauth.OAuthRequest.from_consumer_and_token(consumer,http_method="GET", http_url=url, parameters=params)
signature_method = oauth.OAuthSignatureMethod_HMAC_SHA1()
req.sign_request(signature_method, consumer, None)
resp=req.to_url()
return rest.load_json(resp)
def sign_request(self, consumer, signature_method):
"""Add oauth parameters and sign the request with the given method.
Args:
consumer: The OAuthConsumer set with a key and secret.
signature_method: A supported method for signing the built request.
"""
params = {
'oauth_consumer_key': consumer.key,
'oauth_timestamp': oauth.generate_timestamp(),
'oauth_nonce': oauth.generate_nonce(),
'oauth_version': oauth.OAuthRequest.version,
}
if self.get_security_token():
self.set_parameter("xoauth_requestor_id", None)
self.set_parameters(params)
self.oauth_request.sign_request(signature_method, consumer, None)
def sign_request(self, consumer, signature_method):
"""Add oauth parameters and sign the request with the given method.
Args:
consumer: The OAuthConsumer set with a key and secret.
signature_method: A supported method for signing the built request.
"""
params = {
'oauth_consumer_key': consumer.key,
'oauth_timestamp': oauth.generate_timestamp(),
'oauth_nonce': oauth.generate_nonce(),
'oauth_version': oauth.OAuthRequest.version,
}
if self.get_security_token():
self.set_parameter("xoauth_requestor_id", None)
self.set_parameters(params)
self.oauth_request.sign_request(signature_method, consumer, None)
def complete_parameters(self,url,params = {},exclude_signature = []):
defaults = {
'oauth_timestamp': str(int(time.time())),
'oauth_nonce': oauth.generate_nonce(),
'signature_method': "HMAC-SHA1",
'oauth_token':self.access_token.key,
'oauth_consumer_key':self.consumer.key,
}
excluded = {}
for e in exclude_signature :
excluded[e] = params.pop(e)
defaults.update(params)
req = oauth.OAuthRequest(http_method="POST", http_url=url, parameters=defaults)
req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),self.consumer,self.access_token)
req.parameters.update(excluded)
return req
def sign_request(self, consumer, signature_method):
"""Add oauth parameters and sign the request with the given method.
Args:
consumer: The OAuthConsumer set with a key and secret.
signature_method: A supported method for signing the built request.
"""
params = {
'oauth_consumer_key': consumer.key,
'oauth_timestamp': oauth.generate_timestamp(),
'oauth_nonce': oauth.generate_nonce(),
'oauth_version': oauth.OAuthRequest.version,
}
# PHP OAuth library contains a bug which interferes with signing. Since
# some containers use this library, we will implement a workaround here.
if self.use_body_as_signing_parameter:
params[self.get_post_body()] = ""
else:
# Otherwise, use the oauth_body_hash extension to sign the request body.
if self.post_body:
if VERBOSE > 0:
logging.info("post_body => %s" % str(self.post_body))
if self.add_bodyhash:
body_hash = b64encode(
hashlib.sha1(self.get_post_body()).digest())
params['oauth_body_hash'] = body_hash
if self.get_security_token():
self.set_parameter("xoauth_requestor_id", None)
self.set_parameters(params)
if VERBOSE > 0:
key, raw = signature_method.build_signature_base_string(
self.oauth_request, consumer, None)
logging.info("build_signature key => %s" % key)
logging.info("build_signature raw => %s" % raw)
self.oauth_request.sign_request(signature_method, consumer, None)
def make_oauth_request(self, http_method = 'GET', http_url = {}, has_param = False, parameters = None, token = None):
param = {
'oauth_version': '1.0',
'oauth_timestamp': int(time.time()),
'oauth_nonce': oauth.generate_nonce(),
'oauth_signature_method': 'HMAC-SHA1',
'oauth_consumer_key': self.consumer.key
}
if(parameters):
param.update(parameters)
if(token):
param.update({ 'oauth_token': token.key })
oauth_request = oauth.OAuthRequest(http_method = http_method, http_url = http_url, parameters = param)
oauth_request.sign_request(self.signature_method, self.consumer, token)
oauth_header = oauth_request.to_header()
if http_method == 'POST':
postdata = oauth_request.to_postdata()
req = urllib2.Request(http_url, postdata, oauth_header)
else:
if has_param:
url = oauth_request.to_url()
req = urllib2.Request(url)
else:
url = http_url
req = urllib2.Request(url, None, oauth_header)
try:
req = urllib2.urlopen(req)
return req.read()
except urllib2.URLError as e:
return e
except urllib2.HTTPError as e:
return e
def sign_request(self, consumer, signature_method):
"""Add oauth parameters and sign the request with the given method.
Args:
consumer: The OAuthConsumer set with a key and secret.
signature_method: A supported method for signing the built request.
"""
params = {
'oauth_consumer_key': consumer.key,
'oauth_timestamp': oauth.generate_timestamp(),
'oauth_nonce': oauth.generate_nonce(),
'oauth_version': oauth.OAuthRequest.version,
}
# PHP OAuth library contains a bug which interferes with signing. Since
# some containers use this library, we will implement a workaround here.
if self.use_body_as_signing_parameter:
params[self.get_post_body()] = ""
else:
# Otherwise, use the oauth_body_hash extension to sign the request body.
if self.post_body:
if VERBOSE > 0:
logging.info("post_body => %s" % str(self.post_body))
body_hash = b64encode(hashlib.sha1(self.get_post_body()).digest())
params['oauth_body_hash'] = body_hash
if self.get_security_token():
self.set_parameter("xoauth_requestor_id", None)
self.set_parameters(params)
if VERBOSE > 0:
key, raw = signature_method.build_signature_base_string(
self.oauth_request, consumer, None)
logging.info("build_signature key => %s" % key)
logging.info("build_signature raw => %s" % raw)
self.oauth_request.sign_request(signature_method, consumer, None)
def build_access_headers(self, method, resource_url, params=None, request_token=None):
"""Build OAuth access headers for a future request.
Args:
method: The HTTP method being used (e.g. 'GET' or 'POST').
resource_url: The full url the request will be made to.
params: A dictionary of parameters to add to what's already on the url.
Typically, this would consist of POST parameters.
Returns:
A tuple of (header_dict, params) where header_dict is a dictionary
of header names and values appropriate for passing into dropbox.rest.RESTClient
and params is a dictionary like the one that was passed in, but augmented with
oauth-related parameters as appropriate.
"""
if params is None:
params = {}
else:
params = params.copy()
oauth_params = {
'oauth_consumer_key': self.consumer.key,
'oauth_timestamp': oauth.generate_timestamp(),
'oauth_nonce': oauth.generate_nonce(),
'oauth_version': oauth.OAuthRequest.version,
}
token = request_token if request_token else self.token
if token:
oauth_params['oauth_token'] = token.key
params.update(oauth_params)
oauth_request = oauth.OAuthRequest.from_request(method, resource_url, parameters=params)
oauth_request.sign_request(self.signature_method, self.consumer, token)
return oauth_request.to_header(), params
def complete_parameters(self, url, params={}, exclude_signature=[]):
defaults = {
'oauth_timestamp': str(int(time.time())),
'oauth_nonce': oauth.generate_nonce(),
'signature_method': "HMAC-SHA1",
'oauth_token': self.access_token.key,
'oauth_consumer_key': self.consumer.key,
}
excluded = {}
for e in exclude_signature:
excluded[e] = params.pop(e)
defaults.update(params)
req = oauth.OAuthRequest(http_method="POST",
http_url=url,
parameters=defaults)
req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), self.consumer,
self.access_token)
req.parameters.update(excluded)
return req
def oauth_get_request_token(oaConsumer, url):
'''Get an OAuth request token URL to use for verification. Returns a
tuple of (token, url). The 'url' parameter indicates the destination
for redirection once the user has validated the request.'''
oaSig = oauth.OAuthSignatureMethod_HMAC_SHA1()
oaReq = oauth.OAuthRequest(
http_method = 'GET',
http_url = OAUTH2_ENDPOINT_URL + '/get_request_token',
parameters = {
'oauth_nonce' : oauth.generate_nonce(),
'oauth_timestamp' : oauth.generate_timestamp(),
'oauth_consumer_key' : oaConsumer.key,
'oauth_version' : '1.0',
'xoauth_lang_pref' : 'en-us',
'oauth_callback' : url,
}
)
oaReq.sign_request(oaSig, oaConsumer, None)
reqTokenResp = None
try:
reqTokenResp = urllib2.urlopen(oaReq.to_url())
reqTokenRespContent = ''.join(reqTokenResp.readlines())
oaReqToken = oauth.OAuthToken.from_string(reqTokenRespContent)
return (
oaReqToken,
OAUTH2_ENDPOINT_URL + '/request_auth?' +
urllib.urlencode([('oauth_token', oaReqToken.key)])
)
except urllib2.HTTPError, e:
raise CascadeHTTPError(e)
def __init__(self,key = None, secret = None, callback = None,
access_token_key = None, access_token_secret = None,
request_token_key = None, request_token_secret = None):
self.key = key or method_call.API_KEY
self.secret = secret or method_call.API_SECRET
if self.key is None or self.secret is None:
raise ValueError("API keys have not been set.")
if callback is None :
callback = "http://api.flickr.com/services/rest/?method=flickr.test.echo&api_key=%s"%self.key
params = {
'oauth_timestamp': str(int(time.time())),
'oauth_signature_method':"HMAC-SHA1",
'oauth_version': "1.0",
'oauth_callback': callback,
'oauth_nonce': oauth.generate_nonce(),
'oauth_consumer_key': self.key
}
self.consumer = oauth.OAuthConsumer(key=self.key, secret=self.secret)
if (access_token_key is None) and (request_token_key is None) :
req = oauth.OAuthRequest(http_method="GET", http_url=TOKEN_REQUEST_URL, parameters=params)
req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),self.consumer,None)
resp = urllib2.urlopen(req.to_url())
request_token = dict(urlparse.parse_qsl(resp.read()))
self.request_token = oauth.OAuthToken(request_token['oauth_token'],request_token['oauth_token_secret'])
self.access_token = None
elif request_token_key is not None :
self.access_token = None
self.request_token = oauth.OAuthToken(request_token_key,request_token_secret)
else :
self.request_token = None
self.access_token = oauth.OAuthToken(access_token_key,access_token_secret)
def __init__(self, tokens, nojsoncallback=True, format='json', parameters=None):
self.keys = hidden.keys()
self.dbtokens = tokens
self.dbtokens["token"].encode("ascii")
self.dbtokens["token_secret"].encode('ascii')
if self.dbtokens is not None:
self.consumer = oauth.OAuthConsumer(self.keys["oauth_consumer_key"], self.keys["oauth_consumer_secret"])
self.token = oauth.OAuthToken(self.dbtokens["token"].encode("ascii"), self.dbtokens["token_secret"].encode("ascii"))
if nojsoncallback:
self.nojsoncallback = 1
else:
self.nojsoncallback = 0
if not parameters:
parameters = {}
self.url = "https://api.flickr.com/services/rest"
defaults = {
"format": format,
"nojsoncallback": self.nojsoncallback,
"oauth_timestamp": oauth.generate_timestamp(),
"oauth_nonce": oauth.generate_nonce(),
"signature_method": "HMAC-SHA1",
"oauth_token": self.token.key,
"api_key": self.consumer.key
}
#print defaults
self.parameters = defaults
else:
print "token is none"
def user_authorize(self):
defaults = hidden.keys().copy()
defaults["oauth_timestamp"] = oauth.generate_timestamp()
defaults["oauth_nonce"] = oauth.generate_nonce()
defaults["oauth_signature_method"] = "HMAC-SHA1"
defaults["oauth_version"] = "1.0"
defaults["oauth_callback"] = "https://www.flickr.com/"
# Setup the consumer with api_key and api_secret
consumer = oauth.OAuthConsumer(defaults["oauth_consumer_key"],
defaults["oauth_consumer_secret"])
# Create request
oauth_req = oauth.OAuthRequest(http_method="GET",
http_url=self.url_req_token,
parameters=defaults)
# Create signature
oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
consumer, None)
url = oauth_req.to_url()
print '* Calling Flickr...'
print
connection = urllib.urlopen(url)
data = connection.read()
request_token = {
"oauth_token": re.findall("oauth_token=(.+)&", data)[0],
"oauth_token_secret": re.findall("oauth_token_secret=(.+)",
data)[0]
}
#print request_token
token = oauth.OAuthToken(request_token["oauth_token"],
request_token["oauth_token_secret"])
print "Go to the following link in your browser:"
print "http://www.flickr.com/services/oauth/authorize?oauth_token=%s&perms=read" % request_token[
'oauth_token']
print
oauth_verifier = raw_input("Enter the verifier - ")
print
defaults["oauth_token"] = request_token["oauth_token"]
defaults["oauth_verifier"] = oauth_verifier
del defaults["oauth_consumer_secret"]
oauth_req = oauth.OAuthRequest(http_method="GET",
http_url=self.url_access_token,
parameters=defaults)
oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
consumer, token)
url = oauth_req.to_url()
connection = urllib.urlopen(url)
data = connection.read()
defaults["oauth_token"] = re.findall("oauth_token=(.+?)&", data)[0]
defaults["oauth_token_secret"] = re.findall(
"oauth_token_secret=(.+?)&", data)[0]
defaults["username"] = re.findall("username=(.+)", data)[0]
defaults["user_nsid"] = re.findall("user_nsid=(.+?)&", data)[0]
self.tokens["token"] = defaults["oauth_token"]
self.tokens["token_secret"] = defaults["oauth_token_secret"]
# Replace %40 in user_id, or the request url would be wrong
if "%40" in defaults["user_nsid"]:
self.user_id = defaults["user_nsid"].replace("%40", "@")
print self.user_id
else:
self.user_id = defaults["user_nsid"]
cur.execute('''INSERT INTO Tokens (token, secret) VALUES (?, ?)''',
(defaults["oauth_token"], defaults["oauth_token_secret"]))
# Named placeholders style
cur.execute('SELECT id FROM Tokens WHERE token=:t AND secret=:ts', {
"t": defaults["oauth_token"],
"ts": defaults["oauth_token_secret"]
})
token_id = cur.fetchone()[0]
# Store username in database
cur.execute(
'''
INSERT OR IGNORE INTO Users (name, token_id, user_id) VALUES (?, ?, ?)''',
(defaults["username"], token_id, self.user_id))
conn.commit()
def post(self):
# Loop around Cascade call to allow for retrying if we need to
# refresh our OAuth access token.
cascadeResp = None
oaTokStr = self._oaToken.to_string()
for attemptNo in range(0, 2):
# We do our own Cascade request / response handling here, as the
# API doesn't provide access to the underlying HTTP objects, which
# we want to expose to our callers.
oaReq = oauth.OAuthRequest(
http_method = u'POST',
http_url = cascade.JSON11_ENDPOINT_URL,
parameters = {
u'oauth_nonce' : oauth.generate_nonce(),
u'oauth_timestamp' : oauth.generate_timestamp(),
u'oauth_consumer_key' : self._oaConsumer.key,
u'oauth_token' : self._oaToken.key,
u'oauth_version' : u'1.0'
}
)
oaReq.sign_request(self._oaSig, self._oaConsumer, self._oaToken)
headers = { 'Content-Type' : 'application/json' }
url = oaReq.to_url();
try:
cascadeReq = urllib2.Request(
url = url,
data = self.request.body,
headers = headers
)
cascadeResp = urllib2.urlopen(cascadeReq)
# We've gotten a 200 response, we're done
break
except urllib2.HTTPError, e:
# Only attempt access token refresh if we haven't already done
# so, and think that it might work.
#
# XXX: Note that there appears to be some bug in the Yahoo!
# OAuth implementation that causes really stale tokens to
# be rejected with 999 rather than 401.
if attemptNo > 0 or (e.code != 401 and e.code != 999):
cascadeResp = e
break
self._oaToken = cascade.oauth_refresh_access_token(
self._oaConsumer,
self._oaToken
)
except DownloadError, e:
# We see this if we're getting throttled, wherein Yahoo! will
# return an HTTP status code 999 and leave the TCP connection
# open, timing out the request.
#
# XXX: Because of the stale OAuth token bug mentioned above, we
# consider this a situation where we should refresh our
# OAuth token.
if attemptNo > 0:
raise e
self._oaToken = cascade.oauth_refresh_access_token(
self._oaConsumer,
self._oaToken
)
def test_gen_nonce(self):
nonce = oauth.generate_nonce()
self.assertEqual(len(nonce), 8)
nonce = oauth.generate_nonce(20)
self.assertEqual(len(nonce), 20)
def user_authorize(self):
defaults = hidden.keys().copy()
defaults["oauth_timestamp"] = oauth.generate_timestamp()
defaults["oauth_nonce"] = oauth.generate_nonce()
defaults["oauth_signature_method"] = "HMAC-SHA1"
defaults["oauth_version"] = "1.0"
defaults["oauth_callback"] = "https://www.flickr.com/"
# Setup the consumer with api_key and api_secret
consumer = oauth.OAuthConsumer(defaults["oauth_consumer_key"], defaults["oauth_consumer_secret"])
# Create request
oauth_req = oauth.OAuthRequest(http_method="GET", http_url=self.url_req_token, parameters=defaults)
# Create signature
oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),consumer, None)
url = oauth_req.to_url()
print '* Calling Flickr...'
print
connection = urllib.urlopen(url)
data = connection.read()
request_token = {
"oauth_token": re.findall("oauth_token=(.+)&",data)[0],
"oauth_token_secret": re.findall("oauth_token_secret=(.+)",data)[0]
}
#print request_token
token = oauth.OAuthToken(request_token["oauth_token"], request_token["oauth_token_secret"])
print "Go to the following link in your browser:"
print "http://www.flickr.com/services/oauth/authorize?oauth_token=%s&perms=read" % request_token['oauth_token']
print
oauth_verifier = raw_input("Enter the verifier - ")
print
defaults["oauth_token"] = request_token["oauth_token"]
defaults["oauth_verifier"] = oauth_verifier
del defaults["oauth_consumer_secret"]
oauth_req = oauth.OAuthRequest(http_method="GET", http_url=self.url_access_token, parameters=defaults)
oauth_req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),consumer, token)
url = oauth_req.to_url()
connection = urllib.urlopen(url)
data = connection.read()
defaults["oauth_token"] = re.findall("oauth_token=(.+?)&", data)[0]
defaults["oauth_token_secret"] = re.findall("oauth_token_secret=(.+?)&", data)[0]
defaults["username"] = re.findall("username=(.+)",data)[0]
defaults["user_nsid"] = re.findall("user_nsid=(.+?)&",data)[0]
self.tokens["token"] = defaults["oauth_token"]
self.tokens["token_secret"] = defaults["oauth_token_secret"]
# Replace %40 in user_id, or the request url would be wrong
if "%40" in defaults["user_nsid"]:
self.user_id = defaults["user_nsid"].replace("%40","@")
print self.user_id
else:
self.user_id = defaults["user_nsid"]
cur.execute('''INSERT INTO Tokens (token, secret) VALUES (?, ?)''',
(defaults["oauth_token"], defaults["oauth_token_secret"]) )
# Named placeholders style
cur.execute('SELECT id FROM Tokens WHERE token=:t AND secret=:ts', {"t":defaults["oauth_token"], "ts":defaults["oauth_token_secret"]} )
token_id = cur.fetchone()[0]
# Store username in database
cur.execute('''
INSERT OR IGNORE INTO Users (name, token_id, user_id) VALUES (?, ?, ?)'''
,(defaults["username"], token_id, self.user_id) )
conn.commit()
def oauth_get_access_token(oaConsumer, oaReqToken):
'''Get an OAuth access token from the given token (either request or
access). Returns an oauth.OAuthToken, possibly with some extra
instance variables set to reflect presence of OAuth extension
attributes in the response (e.g. session handle, expiration time,
etc). Can be called with an access token to attempt a refresh (which
still returns a new token).'''
oaSig = oauth.OAuthSignatureMethod_HMAC_SHA1()
oaReqParams = {
'oauth_nonce' : oauth.generate_nonce(),
'oauth_timestamp' : oauth.generate_timestamp(),
'oauth_consumer_key' : oaConsumer.key,
'oauth_token' : oaReqToken.key,
'oauth_version' : '1.0',
}
# If our token has a session handle, add it to our parmeter dictionary.
# This should only be the case if we're requesting a new access token
# (i.e. not doing a token refresh, as access tokens do not have a
# verifier).
if 'verifier' in oaReqToken.__dict__:
oaReqParams['oauth_verifier'] = oaReqToken.verifier
# If our token has a session handle, add it to our parmeter dictionary.
# This should only be the case if we're doing a token refresh from an
# access token.
if 'session_handle' in oaReqToken.__dict__:
oaReqParams['oauth_session_handle'] = oaReqToken.session_handle
oaReq = oauth.OAuthRequest(
http_method = 'GET',
http_url = OAUTH2_ENDPOINT_URL + '/get_token',
parameters = oaReqParams
)
oaReq.sign_request(oaSig, oaConsumer, oaReqToken)
accTokenResp = None
try:
accTokenResp = urllib2.urlopen(oaReq.to_url())
accTokenRespContent = ''.join(accTokenResp.readlines())
accTok = oauth.OAuthToken.from_string(accTokenRespContent)
# Look for any extra query parameters that provide data from OAuth
# extensions that we might care about. Specifically, make sure to
# grab the session handle so that we can refresh the access token.
accTokParams = cgi.parse_qs(
accTokenRespContent,
keep_blank_values = False
)
if 'oauth_expires_in' in accTokParams:
accTok.expires_on = \
int(time.time()) + \
int(accTokParams['oauth_expires_in'][0])
if 'oauth_session_handle' in accTokParams:
accTok.session_handle = accTokParams['oauth_session_handle'][0]
if 'oauth_authorization_expires_in' in accTokParams:
accTok.authorization_expires_on = \
int(time.time()) + \
int(accTokParams['oauth_authorization_expires_in'][0])
if 'xoauth_yahoo_guid' in accTokParams:
accTok.yahoo_guid = accTokParams['xoauth_yahoo_guid'][0]
return accTok
except urllib2.HTTPError, e:
raise CascadeHTTPError(e)
def cmd_call(argv):
'''Make a single Cascade call.'''
op = OptionParser(
usage = '''%prog call <method> [options]
Calls the Cascade method <method>. Parameters to the call should be passed on
stdin as a JSON blob. The results of the call are written to stdout.'''
)
op.add_option(
'-i', dest = 'input', default = None,
help = '''set the file from which to read input (default: stdin)'''
)
op.add_option(
'-u', '--url-params', dest = 'urlParams', action = 'store_true',
default = False,
help = '''send OAuth parameters as URL query parameters, rather than
using an Authorization header.'''
)
op.add_option(
'-k', '--oauth-consumer-key', dest = 'oauthConsumerKey', default = None,
help = '''the OAuth consumer key; required'''
)
op.add_option(
'-s', '--oauth-consumer-secret', dest = 'oauthConsumerSecret', default = None,
help = '''the OAuth consumer secret; required'''
)
op.add_option(
'-a', '--oauth-access-token', dest = 'oauthAccessToken', default = None,
help = '''the OAuth access token to use, in the form of a query string
from oauth_token_to_query_string(); this is the preferred method of specifying
an access token, over --oauth-access-token-* (default: %default)'''
)
op.add_option(
'--oauth-access-token-key', dest = 'oauthAccessTokenKey', default = None,
help = '''the OAuth access token key; required'''
)
op.add_option(
'--oauth-access-token-secret', dest = 'oauthAccessTokenSecret',
default = None,
help = '''the OAuth access token secret; required'''
)
op.add_option(
'--oauth-timestamp', dest = 'oauthTimestamp', type = 'int',
default = oauth.generate_timestamp(),
help = '''the timestamp to use for OAuth signing, in epoch seconds
(default: %default)'''
)
op.add_option(
'--oauth-nonce', dest = 'oauthNonce', default = oauth.generate_nonce(),
help = '''the nonce to use for OAuth signing (default: %default)'''
)
opts, args = op.parse_args(argv)
PROG_NAME = op.get_prog_name()
# Get our method name and parameters
if len(args) != 1:
op.print_usage(sys.stderr)
sys.exit(1)
methodName = args[0]
inputFile = sys.stdin
if opts.input:
inputFile = open(opts.input, 'r')
methodParams = simplejson.loads(''.join(inputFile.readlines()))
if opts.input:
inputFile.close()
# Create our OAuth consumer
if opts.oauthConsumerKey and \
opts.oauthConsumerSecret:
oaConsumer = oauth.OAuthConsumer(
opts.oauthConsumerKey,
opts.oauthConsumerSecret
)
else:
sys.stderr.write(
'\'%s\': consumer key options not specified\n' % (PROG_NAME)
)
op.print_usage(sys.stderr)
sys.exit(1)
# Create our OAuth access token
if opts.oauthAccessToken:
oaTok = oauth_token_from_query_string(opts.oauthAccessToken)
elif opts.oauthAccessTokenKey and \
opts.oauthAccessTokenSecret:
oaTok = oauth.OAuthToken(
opts.oauthAccessTokenKey,
opts.oauthAccessTokenSecret
)
else:
sys.stderr.write(
'\'%s\': access token options not specified\n' % (PROG_NAME)
)
op.print_usage(sys.stderr)
sys.exit(1)
# Make the call, overriding any OAuth parametsrs as specified
jc = JSON11Client(oaConsumer, oaTok, not opts.urlParams)
oauthDefaults = {}
if opts.oauthNonce:
oauthDefaults['oauth_nonce'] = opts.oauthNonce
if opts.oauthTimestamp:
oauthDefaults['oauth_timestamp'] = opts.oauthTimestamp
try:
result = jc.call(
methodName,
params = methodParams,
oauthDefaults = oauthDefaults
)
except CascadeHTTPError, e:
sys.stderr.write('\'%s\': call failed %s\n' % (PROG_NAME, str(e)))
sys.exit(1)
def call(self, method, params = [{}], id = None, oauthDefaults = {}):
'''Call the given method using the specified parameters (which are
passed directly as the 'params' value in the JSON payload).
Returns a result object derived from un-serializing the response
JSON data. The optional 'id' value is the Cascade call ID, which
is not sent in the request if un-specified.
The 'oauthDefaults' dictionary can be used to specify default OAuth
parameter values. For example, one can use this to force a specific
nonce or timestamp value. Any parameters not specifed in this
dictionary fall back to their OAuth defaults (e.g. generate a new
nonce).
Raises a CascadeHTTPError if problems arise.'''
# Populate OAuth parameters
oauthParameters = {
'oauth_nonce' : oauth.generate_nonce(),
'oauth_timestamp' : oauth.generate_timestamp(),
'oauth_consumer_key' : self.__oaConsumer.key,
'oauth_version' : '1.0'
}
oauthParameters.update(oauthDefaults)
# Populate Cascade parameters
data = {
'method' : method,
'params' : params
}
if id:
data['id'] = id
data = simplejson.dumps(data)
for attemptNo in range(0, 2):
logging.debug('Making request %d / 2' % (attemptNo + 1))
# Set the token every time through our loop, as we may have changed
# our token due to it being stale
oauthParameters['oauth_token'] = self.__oaToken.key
# Construct and sign the request within our retry loop so that
# we pick up any refresh of the access token
oaReq = oauth.OAuthRequest(
http_method = 'POST',
http_url = JSON11_ENDPOINT_URL,
parameters = oauthParameters
)
oaReq.sign_request(self.__oaSig, self.__oaConsumer, self.__oaToken)
headers = { 'Content-Type' : 'application/json' }
url = JSON11_ENDPOINT_URL
if self.__sendAuthorizationHeader:
headers.update(oaReq.to_header())
else:
url = oaReq.to_url()
logging.debug('HTTP headers: ' + pprint.pformat(headers))
cascadeResp = None
try:
cascadeReq = urllib2.Request(
url = url,
data = data,
headers = headers
)
cascadeResp = urllib2.urlopen(cascadeReq)
return simplejson.loads(''.join(cascadeResp.readlines()))
except urllib2.HTTPError, e:
logging.info(
'HTTP request failed: code=%d; message=\'%s\'' % (
e.code, e.msg
)
)
# If we see something other than a 401 on our first attempt
# to make the call, give up. Otherwise, attempt to refresh
# our access token and try again.
if attemptNo > 0 or e.code != 401:
raise CascadeHTTPError(e)
logging.info('Refreshing OAuth access token ' + self.__oaToken.key)
self.__oaToken = oauth_refresh_access_token(
self.__oaConsumer,
self.__oaToken
)
logging.info('New OAuth access token is ' + self.__oaToken.key)
finally: