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':