async def zaloguj(ctx):
ajdi = str(ctx.message.author.id)
global sesje
global oauth
global zapisane
try:
if ajdi in zapisane:
print(ajdi, "wpisał !zaloguj, próbuję wznowić sesję.")
at = zapisane[ajdi]['at']
ats = zapisane[ajdi]['ats']
auth = rauth.OAuth1Session(consumer_key=client_key,
consumer_secret=client_secret,
access_token=at,
access_token_secret=ats)
sesje[ajdi] = auth
response = auth.get(base_url + "services/users/user")
await ctx.send(f'Wznowiono poprzednia sesje logowania.')
print("Udane")
else:
print("Tworzę nową sesje dla", ajdi)
oauth = rauth.OAuth1Service(consumer_key=client_key,
consumer_secret=client_secret,
name="DiscordBot",
request_token_url=request_token_url,
authorize_url=authorize_url,
access_token_url=access_token_url)
params = {'oauth_callback': 'oob', 'scopes': SCOPES}
tokeny = oauth.get_request_token(params=params)
request_token, request_token_secret = tokeny
zapisane[ajdi] = {'rt': request_token, 'rts': request_token_secret}
url = oauth.get_authorize_url(request_token)
await ctx.send("Wysłano link w prywatnej wiadomości.")
await ctx.author.send(
"Odwiedź poniższy link i odpisz mi: !pin twojpin")
await ctx.author.send(url)
except:
print("Tworzę nową sesje dla", ajdi)
oauth = rauth.OAuth1Service(consumer_key=client_key,
consumer_secret=client_secret,
name="DiscordBot",
request_token_url=request_token_url,
authorize_url=authorize_url,
access_token_url=access_token_url)
params = {'oauth_callback': 'oob', 'scopes': SCOPES}
tokeny = oauth.get_request_token(params=params)
request_token, request_token_secret = tokeny
zapisane[ajdi] = {'rt': request_token, 'rts': request_token_secret}
url = oauth.get_authorize_url(request_token)
await ctx.send("Wysłano link w prywatnej wiadomości.")
await ctx.author.send("Odwiedź poniższy link i odpisz mi: !pin twojpin"
)
await ctx.author.send(url)
def __init__(self, conf):
super(Discogs, self).__init__(conf)
import rauth
# http://www.discogs.com/developers/#header:home-rate-limiting
self.rate_limit = 3.0
self.conf = conf
self.discogs = rauth.OAuth1Service(
consumer_key=DISCOGS_KEY,
consumer_secret=DISCOGS_SECRET,
request_token_url='https://api.discogs.com/oauth/request_token',
access_token_url='https://api.discogs.com/oauth/access_token',
authorize_url='https://www.discogs.com/oauth/authorize')
token = self._get_token_from_config()
if not token or not all(token):
# raise RuntimeError("No Discogs token in configuration!")
token = self._get_token_from_user()
# raises KeyError
print("Got token: {}".format(token))
print("Please save this information in your configuration.")
exit(1)
self.session = self.discogs.get_session(token)
self._setup_session()
def init_server(CONSUMER_KEY, CONSUMER_SECRET, SERVER_URL):
# Create an OAuth1Service using rauth.
service = rauth.OAuth1Service(
name='test',
consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
request_token_url=SERVER_URL + '/api/auth2/request_token',
access_token_url=SERVER_URL + '/api/auth2/access_token',
authorize_url=SERVER_URL + '/api/auth2/authorize',
base_url=SERVER_URL + '/api/auth2')
callback_server = create_callback_server()
# 1. Get a request token.
request_token, secret_request_token = service.get_request_token(
params={
'oauth_callback':
'http://%s:%d/' %
(CALLBACK_BASE, callback_server.server_address[1])
})
# 2. Authorize your request token.
authorize_url = service.get_authorize_url(request_token)
webbrowser.open(authorize_url)
callback_server.handle_request()
callback_server.server_close()
# 3. Get an access token.
session = service.get_auth_session(request_token,
secret_request_token,
params={'oauth_verifier': VERIFIER})
return session
def login(self):
request_token_url = 'https://api.login.yahoo.com/oauth/v2/get_request_token'
authorize_url = 'https://api.login.yahoo.com/oauth/v2/request_auth'
access_token_url = 'https://api.login.yahoo.com/oauth/v2/get_token'
yahoo = rauth.OAuth1Service(
consumer_key=configs.OAUTH_CONSUMER_KEY,
consumer_secret=configs.OAUTH_SHARED_SECRET,
name='yahoo',
access_token_url=access_token_url,
authorize_url=authorize_url,
request_token_url=request_token_url,
base_url='https://api.login.yahoo.com/oauth/v2/')
request_token, request_token_secret = yahoo.get_request_token \
(data={'oauth_callback': 'http://127.0.0.1/'})
print("Request Token:")
print(" - oauth_token = %s" % request_token)
print(" - oauth_token_secret = %s" % request_token_secret)
auth_url = yahoo.get_authorize_url(request_token)
print('Visit this URL in your browser: ' + auth_url)
pin = input('Enter PIN from browser: ')
session = yahoo.get_auth_session(request_token,
request_token_secret,
method='POST',
data={'oauth_verifier': pin})
return session
def __init__(self, consumer_key, consumer_secret, access_token=None,
access_token_secret=None, session_handle=None):
self.saved_token = None
if all(x is not None for x in (access_token, access_token_secret, session_handle)):
self.saved_token = {
"access_token": access_token,
"access_token_secret": access_token_secret,
"session_handle": session_handle
}
self.oauth = rauth.OAuth1Service(
consumer_key=consumer_key,
consumer_secret=consumer_secret,
name="yahoo",
request_token_url="https://api.login.yahoo.com/oauth/v2/get_request_token",
access_token_url="https://api.login.yahoo.com/oauth/v2/get_token",
authorize_url="https://api.login.yahoo.com/oauth/v2/request_auth",
base_url="http://fantasysports.yahooapis.com/")
self.last_request = time.time()
if (self.saved_token is not None and
self.saved_token["access_token"] and
self.saved_token["access_token_secret"] and
self.saved_token["session_handle"]):
# refresh access token, it may not have expired yet but refresh anyway
self.refresh_access_token()
else:
request_token, request_token_secret = \
self.oauth.get_request_token(params={"oauth_callback": "oob"})
authorize_url = self.oauth.get_authorize_url(request_token)
print "Sign in here: " + str(authorize_url)
verification_code = raw_input("Enter code: ")
self.access_token_time = time.time()
raw_access = self.oauth.get_raw_access_token(
request_token, request_token_secret,
params={"oauth_verifier": verification_code})
parsed_access_token = parse_utf8_qsl(raw_access.content)
self.saved_token = {
"access_token": parsed_access_token["oauth_token"],
"access_token_secret": parsed_access_token["oauth_token_secret"],
"session_handle": parsed_access_token["oauth_session_handle"]
}
print self.saved_token
self.session = self.oauth.get_session(
(self.saved_token["access_token"],
self.saved_token["access_token_secret"])
)
def _create_service(self, key):
return rauth.OAuth1Service(
name='smugcli',
consumer_key=key[0],
consumer_secret=key[1],
request_token_url=REQUEST_TOKEN_URL,
access_token_url=ACCESS_TOKEN_URL,
authorize_url=AUTHORIZE_URL,
base_url=API_ORIGIN + '/api/v2')
def get_oauth_service():
consumer_key, consumer_secret = json.loads(base64.b64decode(constants.CONSUMER_DATA))
return rauth.OAuth1Service(
consumer_key=consumer_key,
consumer_secret=consumer_secret,
request_token_url=constants.ENDPOINT_REQUEST,
access_token_url=constants.ENDPOINT_ACCESS,
authorize_url=constants.ENDPOINT_AUTHORIZE,
base_url=constants.ENDPOINT_BASE)
def get_khan_session(consumer_key,
consumer_secret,
username,
password,
server_url='http://www.khanacademy.org',
callback_address='127.0.0.1:0'):
"""Create an authenticated Khan Academy API session using rauth OAuth 1.0 flow.
This session give you access to the "Login Required" calls described
in the API Explorer.
You need a consumer key and consumer secret:
http://www.khanacademy.org/api-apps/register
You should also provide Khan Academy username and password. Only
coachs can access information about other users.
"""
# Create an OAuth1Service using rauth.
service = rauth.OAuth1Service(
consumer_key,
consumer_secret,
name='khan',
request_token_url=server_url + '/api/auth2/request_token',
access_token_url=server_url + '/api/auth2/access_token',
authorize_url=server_url + '/api/auth2/authorize',
base_url=server_url + '/api/auth2')
callback_server = create_callback_server(parse_address(callback_address))
# 1. Get a request token.
request_token, secret_request_token = service.get_request_token(
params={
'oauth_callback': 'http://%s:%d/' % callback_server.server_address
})
# 2. Authorize your request token.
params = {
'oauth_token': request_token,
'identifier': username,
'password': password
}
handle = threading.Thread(target=callback_server.handle_request)
handle.start()
requests.post(service.authorize_url, params)
handle.join()
callback_server.server_close()
# 3. Get an access token.
session = service.get_auth_session(request_token,
secret_request_token,
params={'oauth_verifier': VERIFIER})
return session
def __init__(self, key, secret):
self.consumer_key = key
self.consumer_secret = secret
self.service = rauth.OAuth1Service(
consumer_key=key,
consumer_secret=secret,
name='libsync',
access_token_url=API_BASE_URL + 'oauth/access_token',
authorize_url=API_BASE_URL + 'oauth/authorize',
request_token_url=API_BASE_URL + 'oauth/request_token',
base_url=API_BASE_URL)
def __init__(self, consumer_key, api_base = 'http://api.shapeways.com'):
'''
consumer_key is the (public,secret) consumer key for your application, provided by Shapeways
'''
self.service = rauth.OAuth1Service(
consumer_key = consumer_key[0],
consumer_secret = consumer_key[1],
name = 'shapeways',
access_token_url = api_base + '/oauth1/access_token/v1',
authorize_url = api_base + '/login',
request_token_url = api_base + '/oauth1/request_token/v1',
base_url = api_base,
)
def run_tests(identifier, passw, CONSUMER_KEY, CONSUMER_SECRET):
global SERVER_URL
SERVER_URL = SERVER_URL
# Create an OAuth1Service using rauth.
service = rauth.OAuth1Service(
name='test',
consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
request_token_url=SERVER_URL + '/api/auth2/request_token',
access_token_url=SERVER_URL + '/api/auth2/access_token',
authorize_url=SERVER_URL + '/api/auth2/authorize',
base_url=SERVER_URL + '/api/auth2')
callback_server = create_callback_server()
# 1. Get a request token.
request_token, secret_request_token = service.get_request_token(
params={'oauth_callback': SERVER_URL + '/api/auth/default_callback'})
noClickParams = {
'oauth_token': request_token,
'identifier': identifier,
'password': passw
}
# 2. Authorize your request token.
authorize_url = service.get_authorize_url(request_token)
post_url = SERVER_URL + '/api/auth2/authorize'
r = requests.post(post_url, data=noClickParams)
access_url = urlparse.parse_qs(urlparse.urlparse(r.url).query)
oauth_verifier_raw = access_url["oauth_verifier"][0]
oauth_verifier = oauth_verifier_raw.encode('ascii', 'ignore')
callback_server.server_close()
# 3. Get an access token.
session = service.get_auth_session(
request_token,
secret_request_token,
params={'oauth_verifier': oauth_verifier})
# Repeatedly prompt user for a resource and make authenticated API calls.
return session
def run_tests():
global CONSUMER_KEY, CONSUMER_SECRET, SERVER_URL
# Set consumer key, consumer secret, and server base URL from user input or
# use default values.
CONSUMER_KEY = raw_input("consumer key: ") or CONSUMER_KEY
CONSUMER_SECRET = raw_input("consumer secret: ") or CONSUMER_SECRET
SERVER_URL = raw_input("server base url: ") or SERVER_URL
# Create an OAuth1Service using rauth.
service = rauth.OAuth1Service(
name='test',
consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
request_token_url=SERVER_URL + '/api/auth2/request_token',
access_token_url=SERVER_URL + '/api/auth2/access_token',
authorize_url=SERVER_URL + '/api/auth2/authorize',
base_url=SERVER_URL + '/api/auth2')
callback_server = create_callback_server()
# 1. Get a request token.
request_token, secret_request_token = service.get_request_token(
params={
'oauth_callback':
'http://%s:%d/' %
(CALLBACK_BASE, callback_server.server_address[1])
})
# 2. Authorize your request token.
authorize_url = service.get_authorize_url(request_token)
webbrowser.open(authorize_url)
callback_server.handle_request()
callback_server.server_close()
# 3. Get an access token.
session = service.get_auth_session(request_token,
secret_request_token,
params={'oauth_verifier': VERIFIER})
# Repeatedly prompt user for a resource and make authenticated API calls.
print
while (True):
get_api_resource(session)
def get_results(params):
consumer_key = "6FrOHXBf9sz7aM21TDkOeA"
consumer_secret = "KvYtMWGPninQULxRF5E1OuaugjNUmdA3rBeGUQyBXb4gptXhuKehJrB1qEqnArTJ"
service = rauth.OAuth1Service(
consumer_key=consumer_key,
consumer_secret=consumer_secret,
request_token_url="https://api.yelp.com/oauth2/token",
base_url="http://api.yelp.com/v2/")
token, token_secret = service.get_request_token()
print(token, token_secret)
request = session.get("http://api.yelp.com/v2/search", params=params)
data = request.json()
session.close()
return data
def message_received(client, server, message):
global callback_server
#if len(message) > 200:
# message = message[:200]+'..'
print("Client(%d) said: %s" % (client['id'], message))
if (message == "login"):
id_client = str(client['id'])
# Create an OAuth1Service using rauth.
SERVICES_ARRAY[id_client] = rauth.OAuth1Service(
name=id_client,
consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
request_token_url=SERVER_URL + '/api/auth2/request_token',
access_token_url=SERVER_URL + '/api/auth2/access_token',
authorize_url=SERVER_URL + '/api/auth2/authorize',
base_url=SERVER_URL + '/api/auth2')
#callback_server = create_callback_server()
# 1. Get a request token.
#request_token, secret_request_token = service.get_request_token(
# params={'oauth_callback': 'http://%s:%d/' %
# (CALLBACK_BASE, callback_server.server_address[1])})
request_token, secret_request_token = SERVICES_ARRAY[
id_client].get_request_token(
params={
'oauth_callback':
'http://%s:%d?id_client=%s' %
(CALLBACK_BASE, callback_server.server_address[1],
id_client)
})
REQUEST_TOKENS_ARRAY[id_client] = request_token
SECRET_REQUEST_TOKEN_ARRAY[id_client] = secret_request_token
# 2. Authorize your request token.
authorize_url = SERVICES_ARRAY[id_client].get_authorize_url(
request_token)
#server.send_message_to_all("url:"+authorize_url)
#print authorize_url
# 3. Send Authorize url
url_data = {"url": authorize_url}
json_data = json.dumps(url_data)
server.send_message(client, json_data)
def __init__(self, conf):
super(Discogs, self).__init__()
# http://www.discogs.com/developers/#header:home-rate-limiting
self.rate_limit = 3.0
# OAuth1 authentication
import rauth
discogs = rauth.OAuth1Service(
consumer_key='sYGBZLljMPsYUnmGOzTX',
consumer_secret='TtuLoHxEGvjDDOVMgmpgpXPuxudHvklk',
request_token_url='https://api.discogs.com/oauth/request_token',
access_token_url='https://api.discogs.com/oauth/access_token',
authorize_url='https://www.discogs.com/oauth/authorize')
# read token from config file
token = (conf.get('discogs', 'token'), conf.get('discogs', 'secret'))
# get from user
if not token or not all(token):
req_token, req_secret = discogs.get_request_token(headers=HEADERS)
print('Discogs requires authentication with your own account.\n'
'Disable discogs in the config file or use this link to '
'authenticate:\n%s' % discogs.get_authorize_url(req_token))
data = {'oauth_verifier': raw_input('Verification code: ')}
try:
token = discogs.get_access_token(req_token,
req_secret,
data=data,
headers=HEADERS)
except KeyError as err:
self.log.critical(err.message)
exit()
# save token to config file
if not conf.has_section('discogs'):
conf.add_section('discogs')
conf.set('discogs', 'token', token[0])
conf.set('discogs', 'secret', token[1])
conf.save()
self.session = discogs.get_session(token)
self.session.headers.update(HEADERS)
# avoid filling cache with unusable entries
if requests_cache \
and not hasattr(self.session.cache, '_ignored_parameters'):
self.session._is_cache_disabled = True # pylint: disable=W0212
def __init__(self, conf):
super(Discogs, self).__init__()
import rauth
# http://www.discogs.com/developers/#header:home-rate-limiting
self.rate_limit = 3.0
self.conf = conf
self.discogs = rauth.OAuth1Service(
consumer_key=DISCOGS_KEY,
consumer_secret=DISCOGS_SECRET,
request_token_url='https://api.discogs.com/oauth/request_token',
access_token_url='https://api.discogs.com/oauth/access_token',
authorize_url='https://www.discogs.com/oauth/authorize')
token = self._get_token_from_config()
if not token or not all(token):
token = self._get_token_from_user()
self._save_token_to_config(token)
self.session = self.discogs.get_session(token)
self._setup_session()
# avoid filling cache with unusable entries
if requests_cache \
and not hasattr(self.session.cache, '_ignored_parameters'):
self.session._is_cache_disabled = True # pylint: disable=W0212
def run_tests():
global CONSUMER_KEY, CONSUMER_SECRET, SERVER_URL
# Set consumer key, consumer secret, and server base URL from user input or
# use default values.
CONSUMER_KEY = CONSUMER_KEY
CONSUMER_SECRET = CONSUMER_SECRET
SERVER_URL = SERVER_URL
# Create an OAuth1Service using rauth.
service = rauth.OAuth1Service(
name='test',
consumer_key=CONSUMER_KEY,
consumer_secret=CONSUMER_SECRET,
request_token_url=SERVER_URL + '/api/auth2/request_token',
access_token_url=SERVER_URL + '/api/auth2/access_token',
authorize_url=SERVER_URL + '/api/auth2/authorize',
base_url=SERVER_URL + '/api/auth2')
callback_server = create_callback_server()
# 1. Get a request token.
request_token, secret_request_token = service.get_request_token(
params={'oauth_callback':
SERVER_URL + '/api/auth/default_callback'}) #'http://%s:%d/' %
#(CALLBACK_BASE, callback_server.server_address[1])})
logging.debug(request_token)
logging.debug(secret_request_token)
passw = 'clave1234'
noClickParams = {
'oauth_token': request_token,
'identifier': 'utpbakhan',
'password': passw
}
# 2. Authorize your request token.
authorize_url = service.get_authorize_url(request_token)
logging.debug(authorize_url)
#webbrowser.open(authorize_url) #Abre ventana para hacer click en aceptar y loguearse
#LINKS
#https://github.com/Khan/khan-api/wiki/Khan-Academy-API-Authentication
#http://es.python-requests.org/es/latest/user/quickstart.html#cabeceras-personalizadas
#https://teamtreehouse.com/community/khan-academy-api-authentication-in-nodejs
#http://www.pythonforbeginners.com/requests/using-requests-in-python
#hacer peticion POST a authorize_url con los parametros request_token, user, pass
#headers = {'content-type': 'application/json'}
post_url = SERVER_URL + '/api/auth2/authorize'
#credentials = json.dumps(noClickParams)
#session = requests.Session()
#print session
#r = session.post('https://www.khanacademy.org/api/auth2/authorize', data=noClickParams)#, headers=headers)
#session = requests.Session()
#print session
#r = session.post(post_url, data=noClickParams)
#print r.status_code
r = requests.post(post_url, data=noClickParams)
logging.debug(r.url)
logging.debug(r.text)
logging.debug(r.status_code)
#print r
access_url = urlparse.parse_qs(urlparse.urlparse(r.url).query)
oauth_verifier_raw = access_url["oauth_verifier"][0]
oauth_verifier = oauth_verifier_raw.encode('ascii', 'ignore')
logging.debug(oauth_verifier)
#callback_server.handle_request() #Esto esperaba el click de aceptar
callback_server.server_close()
# 3. Get an access token.
session = service.get_auth_session(
request_token,
secret_request_token,
params={'oauth_verifier': oauth_verifier})
# Repeatedly prompt user for a resource and make authenticated API calls.
#print
#while(True):
# get_api_resource(session)
logging.debug(session)
logging.debug(session)
#!/usr/bin/python
import rauth
from _credentials import consumer_key, consumer_secret
base_url = "https://api.fitbit.com"
request_token_url = base_url + "/oauth/request_token"
access_token_url = base_url + "/oauth/access_token"
authorize_url = "http://www.fitbit.com/oauth/authorize"
fitbit = rauth.OAuth1Service(name="fitbit",
consumer_key=consumer_key,
consumer_secret=consumer_secret,
request_token_url=request_token_url,
access_token_url=access_token_url,
authorize_url=authorize_url,
base_url=base_url)
request_token, request_token_secret = fitbit.get_request_token()
print " request_token = %s" % request_token
print " request_token_secret = %s" % request_token_secret
print
authorize_url = fitbit.get_authorize_url(request_token)
print "Go to the following page in your browser: " + authorize_url
print
accepted = 'n'
while accepted.lower() == 'n':
