def start_fetch_request_token(self):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer, http_url="%s/api/auth/request_token" % self.server_url
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, None)
webbrowser.open(oauth_request.to_url())
def access_resource(self,
relative_url,
access_token,
method="GET",
params=None):
full_url = self.server_url + relative_url
url = urlparse.urlparse(full_url)
full_params = cgi.parse_qs(url.query)
for key in full_params:
full_params[key] = full_params[key][0]
if params:
full_params.update(params)
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=access_token,
http_url=full_url,
parameters=full_params,
http_method=method)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, access_token)
if method == "GET":
response = get_response(oauth_request.to_url())
else:
response = post_response(full_url, oauth_request.to_postdata())
return response
def execute(self, url, params, consumer, access_token, method='POST', mode='header'):
headers = {}
headers.setdefault('User-Agent', "python")
headers.setdefault("Accept", "text/html")
headers.setdefault("Content-Type", "application/x-www-form-urlencoded")
request = OAuthRequest.from_consumer_and_token(
self.consumer,
http_url=url,
http_method=method,
token=access_token,
parameters=params,
)
request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), consumer, access_token)
if mode == 'header':
headers.update(request.to_header())
else:
url = request.get_normalized_http_url()
params = request.to_postdata()
multipart_encode({})
host, path = _url_spllit(url)
conn = httplib.HTTPConnection(host)
conn.request(method, path, params, headers)
resp = conn.getresponse()
json = resp.read()
conn.close()
return json
def createOauthRequest(http_url, params, default_params):
validateOptions(params, default_params)
default_params.update(params)
params = default_params
http_method = 'GET'
token = params.pop('token', None)
base_url = 'https://www.pesapal.com/api/'
if testing:
base_url = 'https://demo.pesapal.com/api/'
url = base_url + http_url
if not consumer_key:
raise MissingKeyError('provide consumer key')
if not consumer_secret:
raise MissingKeyError('provide consumer consumer_secret')
oauth_consumer = oauth.OAuthConsumer(consumer_key, consumer_secret)
request = OAuthRequest.from_consumer_and_token(oauth_consumer,
http_url=url,
http_method=http_method,
parameters=params)
request.sign_request(SIGNATURE_METHOD, oauth_consumer, token)
return request.to_url()
def access_resource(self,
relative_url,
access_token,
method="GET",
params=None):
full_url = self.server_url + relative_url
url = urlparse.urlparse(full_url)
full_params = cgi.parse_qs(url.query)
for key in full_params:
full_params[key] = full_params[key][0]
if params:
full_params.update(params)
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token = access_token,
http_url = full_url,
parameters = full_params,
http_method=method
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, access_token)
if method == "GET":
response = get_response(oauth_request.to_url())
else:
response = post_response(full_url, oauth_request.to_postdata())
return response
def load(self, url, method="GET", parameters=None, raw=False):
oauth_request = OAuthRequest.from_consumer_and_token(self.consumer,
token=self.access_token, http_url=url, http_method=method,
parameters=parameters)
oauth_request.sign_request(self.signature_method, self.consumer,
self.access_token)
return self.oauth_fetch(oauth_request, raw)
def access_api_resource(self, relative_url, access_token, method="GET"):
full_url = self.server_url + relative_url
# Escape each parameter value.
url = urlparse.urlparse(full_url)
query_params = cgi.parse_qs(url.query)
for key in query_params:
query_params[key] = query_params[key][0]
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=access_token,
http_url=full_url,
parameters=query_params,
http_method=method)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, access_token)
file = None
ret = None
try:
if method == "GET":
file = urllib2.urlopen(oauth_request.to_url())
else:
file = urllib2.urlopen(url.path, oauth_request.to_postdata())
except urllib2.HTTPError, error:
# We don't want to treat HTTP error codes (401, 404, etc.) like
# exceptional scenarios. We want to pass them along like anything
# else.
# Luckily, the exception raised here acts very much like an
# `HTTPResponse` object. Good enough for our purposes.
file = error
def build(http_url, token, http_method='GET'):
# build and return oauth request url
match = re.match('(.+):(.+)@(.+)', token)
try:
token = oauth.OAuthToken(
match.group(1),
match.group(2)
)
except Exception:
raise InvalidAccessToken('the provided access token is invalid.')
url = BASE_API_URI + http_url
if not consumer_key:
raise MissingKeyError('provide consumer key')
if not consumer_secret:
raise MissingKeyError('provide consumer consumer_secret')
oauth_consumer = oauth.OAuthConsumer(consumer_key, consumer_secret)
request = OAuthRequest.from_consumer_and_token(
oauth_consumer,
http_url=url,
token=token,
http_method=http_method,
parameters={}
)
request.sign_request(SIGNATURE_METHOD, oauth_consumer, token)
return request.to_url()
def createOauthRequest(http_url, params, default_params):
validateOptions(params, default_params)
default_params.update(params)
params = default_params
http_method = "GET"
token = params.pop("token", None)
base_url = "https://www.pesapal.com/api/"
if testing:
base_url = "https://demo.pesapal.com/api/"
url = base_url + http_url
if not consumer_key:
raise MissingKeyError("provide consumer key")
if not consumer_secret:
raise MissingKeyError("provide consumer consumer_secret")
oauth_consumer = oauth.OAuthConsumer(consumer_key, consumer_secret)
request = OAuthRequest.from_consumer_and_token(
oauth_consumer, http_url=url, http_method=http_method, parameters=params
)
request.sign_request(SIGNATURE_METHOD, oauth_consumer, token)
return request.to_url()
def start_fetch_request_token(self):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
http_url="%s/api/auth/request_token" % self.server_url)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, None)
webbrowser.open(oauth_request.to_url())
def build_oauth_request(self, http_url, token=None,
http_method="GET", parameters=None):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer, token=token, http_method=http_method,
http_url=http_url, parameters=parameters
)
oauth_request.sign_request(self.signature_method, self.consumer, token)
return oauth_request
def exchange_request_token_for_access_token(self, token):
oauth_request = OAuthRequest.from_consumer_and_token(self.consumer,
token=token, http_url=URL_OAUTH_ACCESS_TOKEN)
oauth_request.sign_request(self.signature_method, self.consumer,
token)
resp = self.oauth_fetch(oauth_request, raw=True)
self.access_token = OAuthToken.from_string(resp)
return self.access_token
def login():
oauth_request = OAuthRequest.from_consumer_and_token(
consumer,
callback='http://127.0.0.1:5000/oauth_callback',
http_url='http://www.khanacademy.org/api/auth/request_token'
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), consumer, None)
return redirect(oauth_request.to_url())
def get(self, path, token=None, prefix="/api"):
url = "http://%s%s%s" % (self.host, prefix, path)
request = OAuthRequest.from_consumer_and_token(
self.consumer,
token,
http_method='GET',
http_url=url
)
return self._send_request(request, token)
def start_fetch_request_token(self, callback=None):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
callback=callback,
http_url="%s/api/auth/request_token" % self.server_url
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, None)
return oauth_request.to_url()
def get(self, path, token=None, prefix="/api"):
url = "http://%s%s%s" % (self.host, prefix, path)
request = OAuthRequest.from_consumer_and_token(
self.consumer,
token,
http_method='GET',
http_url=url
)
return self._send_request(request, token)
def start_fetch_request_token(self, callback=None):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
callback=callback,
http_url="%s/api/auth/request_token" % self.server_url)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, None)
return oauth_request.to_url()
def post(self, path, post_params, token=None, prefix="/api"):
url = "http://%s%s%s" % (self.host, prefix, path)
request = OAuthRequest.from_consumer_and_token(
self.consumer,
token,
http_method='POST',
http_url=url,
parameters=post_params
)
return self._send_request(request, token)
def post(self, path, post_params, token=None, prefix="/api"):
url = "http://%s%s%s" % (self.host, prefix, path)
request = OAuthRequest.from_consumer_and_token(
self.consumer,
token,
http_method='POST',
http_url=url,
parameters=post_params
)
return self._send_request(request, token)
def start_fetch_request_token(self, callback=None):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
callback=callback,
http_url="%s/api/auth/request_token" % self.server_url
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, None)
print 'opening webbrowser with', oauth_request.to_url()
webbrowser.open(oauth_request.to_url())
def fetch_access_token(self, request_token):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer, token=request_token, http_url="%s/api/auth/access_token" % self.server_url
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, request_token)
response = get_response(oauth_request.to_url())
return OAuthToken.from_string(response)
def url_for_request_token(self, callback=None, parameters=None):
http_url = "%s/api/auth/request_token" % self.server_url
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
http_url=http_url,
callback=callback,
parameters=parameters)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, None)
return oauth_request.to_url()
def url_for_request_token(self, callback=None, parameters=None):
http_url = "%s/api/auth/request_token" % self.server_url
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
http_url = http_url,
callback = callback,
parameters = parameters
)
oauth_request.sign_request(
OAuthSignatureMethod_HMAC_SHA1(), self.consumer, None
)
return oauth_request.to_url()
def fetch_access_token(self, request_token):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=request_token,
http_url="%s/api/auth/access_token" % self.server_url)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, request_token)
response = get_response(oauth_request.to_url())
return OAuthToken.from_string(response)
def _get_authorize_request(self):
params = {}
if self.desktop:
url = self._url_autorize
params['oauth_callback'] = 'oob'
else:
url = self._url_authenticate
if self.force_login:
params['force_login'] = '******'
return OAuthRequest.from_consumer_and_token(self.consumer,
token=self.token,
http_url=url,
parameters=params)
def getOauthRequest(self, http_url, params, default_params):
self.validateOptions(params, default_params)
default_params.update(params)
params = default_params
http_method = 'GET'
token = params.pop('token', None)
url = self.base_url + http_url
request = OAuthRequest.from_consumer_and_token(self.oauth_consumer,
http_url=url,
http_method=http_method,
parameters=params)
request.sign_request(SIGNATURE_METHOD, self.oauth_consumer, token)
return request
def get_auth_url(self):
""" """
request = OAuthRequest.from_consumer_and_token(
self.consumer,
http_url = self.request_token_url,
callback = self.callback)
request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, None)
resp = urllib2.urlopen(urllib2.Request( request.to_url()))
token = resp.read()
request_token = OAuthToken.from_string(token)
self.request_token = request_token
request = OAuthRequest.from_token_and_callback(
token=request_token, http_url=self.authenticate_url,
callback = self.callback
)
return request.to_url()
def url_for_access_token(self, request_token, callback=None, parameters=None, verifier=None):
http_url = "%s/api/auth/access_token" % self.server_url
if not verifier and request_token.verifier:
verifier = request_token.verifier
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token = request_token,
http_url = http_url,
callback = callback,
parameters = parameters,
verifier = verifier
)
oauth_request.sign_request(
OAuthSignatureMethod_HMAC_SHA1(), self.consumer, request_token
)
return oauth_request.to_url()
def post_resources(self,
relative_url,
access_token,
method="POST",
data=None,
content_type=None):
full_url = self.server_url + relative_url
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=access_token,
http_url=full_url,
http_method=method)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, access_token)
return post_response(oauth_request.to_url(), data, content_type)
def post_resources(self,
relative_url,
access_token,
method="POST",
data=None,
content_type=None):
full_url = self.server_url + relative_url
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=access_token,
http_url=full_url,
http_method=method
)
oauth_request.sign_request(
OAuthSignatureMethod_HMAC_SHA1(), self.consumer, access_token)
return post_response(oauth_request.to_url(), data, content_type)
def url_for_access_token(self,
request_token,
callback=None,
parameters=None,
verifier=None):
http_url = "%s/api/auth/access_token" % self.server_url
if not verifier and request_token.verifier:
verifier = request_token.verifier
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=request_token,
http_url=http_url,
callback=callback,
parameters=parameters,
verifier=verifier)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, request_token)
return oauth_request.to_url()
def getOauthRequest(self, http_url, params, default_params):
self.validateOptions(params, default_params)
default_params.update(params)
params = default_params
http_method='GET'
token = params.pop('token', None)
url = self.base_url + http_url
request = OAuthRequest.from_consumer_and_token(
self.oauth_consumer,
http_url= url,
http_method=http_method,
parameters=params
)
request.sign_request(SIGNATURE_METHOD, self.oauth_consumer, token)
return request
def access_resource(self, relative_url, access_token):
full_url = self.server_url + relative_url
url = urlparse.urlparse(full_url)
query_params = cgi.parse_qs(url.query)
for key in query_params:
query_params[key] = query_params[key][0]
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token = access_token,
http_url = full_url,
parameters = query_params
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, access_token)
response = get_response(oauth_request.to_url())
return response.strip()
def oauth_callback():
oauth_token = request.args.get("oauth_token", "")
oauth_secret = request.args.get("oauth_token_secret", "")
oauth_verifier = request.args.get("oauth_verifier", "")
request_token = OAuthToken(oauth_token, oauth_secret)
request_token.set_verifier(oauth_verifier)
session["request_token"] = request_token.to_string()
oauth_request = OAuthRequest.from_consumer_and_token(
consumer,
token=request_token,
http_url='http://www.khanacademy.org/api/auth/access_token',
callback=None,
parameters=None,
verifier=request_token.verifier
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), consumer, request_token)
r = requests.get(oauth_request.to_url())
access_token = OAuthToken.from_string(r.text)
session['oauth_token'] = access_token.to_string()
return redirect(url_for("index"))
def access_resource(self, relative_url, access_token):
full_url = self.server_url + relative_url
url = urlparse.urlparse(full_url)
query_params = cgi.parse_qs(url.query)
for key in query_params:
query_params[key] = query_params[key][0]
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=access_token,
http_url=full_url,
parameters=query_params)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, access_token)
response = get_response(oauth_request.to_url())
return response.strip()
def index():
access_token = session.get('oauth_token')
if access_token is None:
return redirect(url_for('login'))
full_url='http://www.khanacademy.org/api/v1/user'
url=urlparse.urlparse(full_url)
query_params = cgi.parse_qs(url.query)
for key in query_params:
query_params[key] = query_params[key][0]
token=OAuthToken.from_string(access_token)
oauth_request = OAuthRequest.from_consumer_and_token(
consumer,
token=token,
http_url='http://www.khanacademy.org/api/v1/user',
parameters=query_params,
http_method='GET'
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), consumer, token)
r = requests.get(oauth_request.to_url()).content
data=json.loads(r)
return render_template("index.html", email=str(data['student_summary']['email']))
def access_api_resource(self, relative_url, access_token, method="GET"):
full_url = self.server_url + urllib2.quote(relative_url)
print "full_url %s" % full_url
# Escape each parameter value.
url = urlparse.urlparse(full_url)
query_params = cgi.parse_qs(url.query)
for key in query_params:
query_params[key] = query_params[key][0]
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token = access_token,
http_url = full_url,
parameters = query_params,
http_method = method
)
oauth_request.sign_request(
OAuthSignatureMethod_HMAC_SHA1(), self.consumer, access_token
)
file = None
ret = None
try:
if method == "GET":
file = urllib2.urlopen(oauth_request.to_url())
else:
file = urllib2.urlopen(url.path, oauth_request.to_postdata())
except urllib2.HTTPError, error:
# We don't want to treat HTTP error codes (401, 404, etc.) like
# exceptional scenarios. We want to pass them along like anything
# else.
# Luckily, the exception raised here acts very much like an
# `HTTPResponse` object. Good enough for our purposes.
file = error
def auth(self, request_token, verifier):
self.request_token = OAuthToken.from_string(request_token)
request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=self.request_token,
http_url=self.access_token_url,
verifier=str(verifier)
)
request.sign_request(
OAuthSignatureMethod_HMAC_SHA1(),
self.consumer,
self.request_token
)
#if mode == 'header':
# resp = urllib2.urlopen(urllib2.Request(url, headers=request.to_header()))
#else:
# resp = urllib2.urlopen(urllib2.Request(request.to_url()))
resp = urllib2.urlopen(urllib2.Request(request.to_url()))
string = resp.read()
access_token = OAuthToken.from_string(string)
self.access_token = access_token
self._process_access_token(string)
def http(self, method, url, params, filedatas=None):
headers = {}
headers.setdefault('User-Agent', "BAYE.ME social comment")
# headers.setdefault("Accept", "text/html")
self._process_params(params)
request = OAuthRequest.from_consumer_and_token(
self.consumer,
http_url=url,
http_method=method,
token=self.access_token,
parameters=params
)
request.sign_request(
OAuthSignatureMethod_HMAC_SHA1(), self.consumer,
self.access_token
)
if method == 'POST':
url = request.get_normalized_http_url()
else:
url = request.to_url()
signed_params = request.to_postdata()
if filedatas:
_params = urlparse.parse_qs(signed_params, keep_blank_values=True)
content_type, body = self.encode_multipart(_params, filedatas)
else:
content_type, body = "application/x-www-form-urlencoded", signed_params
headers.setdefault("Content-Type", content_type)
host, path = _split_url(url)
conn = httplib.HTTPConnection(host)
conn.request(method, path, body, headers)
resp = conn.getresponse()
json = resp.read()
conn.close()
return self._process_result(json)
def authorisation_url(self, token):
oauth_request = OAuthRequest.from_consumer_and_token(self.consumer,
token=token, http_url=URL_OAUTH_AUTHENTICATE)
oauth_request.sign_request(self.signature_method, self.consumer, token)
return oauth_request.to_url()
def _get_request_request(self):
"""Return an OauthRequest instance to request the token"""
return OAuthRequest.from_consumer_and_token(self.consumer, callback=None,
http_url=self._url_request)
def _get_access_request(self):
"""Return an OauthRequest instance to authorize"""
return OAuthRequest.from_consumer_and_token(self.consumer,
token=self.token,
verifier=self.token.verifier,
http_url=self._url_access)
def _get_resource_request(self, url, parameters, http_method='GET'):
return OAuthRequest.from_consumer_and_token(self.consumer,
http_url=url,
token=self.token,
parameters=parameters,
http_method=http_method)
