def reg_twitter(self, token_key=None, token_secret=None, token_pin=None): import autosubliminal.notifiers.twitter as twitter_notifier if not token_key and not token_secret: # Getting request token oauth_client = OAuth1Session( client_key=twitter_notifier.CONSUMER_KEY, client_secret=twitter_notifier.CONSUMER_SECRET) try: response = oauth_client.fetch_request_token( twitter_notifier.REQUEST_TOKEN_URL) except Exception as e: message = 'Something went wrong.../n' + e.message return PageTemplate( filename='/general/message.mako').render( message=message) # Authorize url = oauth_client.authorization_url( twitter_notifier.AUTHORIZATION_URL) token_key = response.get('oauth_token') token_secret = response.get('oauth_token_secret') return PageTemplate( filename='/config/config-regtwitter.mako').render( url=url, token_key=token_key, token_secret=token_secret) if token_key and token_secret and token_pin: # Getting access token oauth_client = OAuth1Session( client_key=twitter_notifier.CONSUMER_KEY, client_secret=twitter_notifier.CONSUMER_SECRET, resource_owner_key=token_key, resource_owner_secret=token_secret, verifier=token_pin) try: response = oauth_client.fetch_access_token( twitter_notifier.ACCESS_TOKEN_URL) except Exception as e: message = 'Something went wrong.../n' + e.message return PageTemplate( filename='/general/message.mako').render( message=message) # Store access token autosubliminal.TWITTERKEY = response.get('oauth_token') autosubliminal.TWITTERSECRET = response.get( 'oauth_token_secret') # Render template message = 'Twitter is now set up, remember to save your config and remember to test twitter!' \ '<br><a href="' + autosubliminal.WEBROOT + '/config/notification">Return</a>' return PageTemplate(filename='/general/message.mako').render( message=message)
def authenticate(consumer_key, consumer_secret): """ Authenticate against the Twitter API """ # This implements the so called PIN-Based OAuth flow as described here: # https://developer.twitter.com/en/docs/basics/authentication/overview/pin-based-oauth if credentials.exists(): click.confirm( "This will overwrite existing credentials, are you sure?", abort=True) # Step 1: fetch a request token oauth = OAuth1Session(consumer_key, consumer_secret) try: request_token_response = oauth.fetch_request_token( "https://api.twitter.com/oauth/request_token?oauth_callback=oob") except TokenRequestDenied: raise click.ClickException( "Invalid consumer secret/consumer key combination") # Step 2: get an authorization url and ask user to enter the PIN authorization_url = oauth.authorization_url( "https://api.twitter.com/oauth/authorize") pin = input("In order to authenticate, go to the following URL, " "authorize the app and copy the PIN:\n" f"{authorization_url}\n" "Enter PIN: ") # Step 3: get an access token using the PIN oauth = OAuth1Session( client_key=consumer_key, client_secret=consumer_secret, resource_owner_key=request_token_response["oauth_token"], resource_owner_secret=request_token_response["oauth_token_secret"], verifier=pin, ) try: access_token_response = oauth.fetch_access_token( "https://api.twitter.com/oauth/access_token") except TokenRequestDenied: raise click.ClickException("Entered PIN is invalid") # Create new OAuth1 instance that can be used by the `requests` library for # authenticating requests and store it for later use. credentials.save( OAuth1( client_key=consumer_key, client_secret=consumer_secret, resource_owner_key=access_token_response["oauth_token"], resource_owner_secret=access_token_response["oauth_token_secret"], )) print("Authentication saved, bieberhose is ready to go! 🚀")
def continue_flow(request, redirect_response): """ Continues the oauth flow. This will fetch the login tokens and login the user if all information were given. Otherwise the registration modal will be displayed. :param request: :param redirect_response: :return: """ client_id = os.environ.get('OAUTH_TWITTER_CLIENTID', None) client_secret = os.environ.get('OAUTH_TWITTER_CLIENTKEY', None) LOG.debug("Read OAuth id/secret: none? %s/%s", client_id is None, client_secret is None) pincode = redirect_response.split('oauth_verifier=')[1] access_token_url = 'https://api.twitter.com/oauth/access_token' oauth_token = request.session['twitter_oauth_token'] oauth_token_secret = request.session['twitter_oauth_token_secret'] oauth_client = OAuth1Session(client_id, client_secret=client_secret, resource_owner_key=oauth_token, resource_owner_secret=oauth_token_secret, verifier=pincode) resp = oauth_client.fetch_access_token(access_token_url) user_data = {'id': resp['id'], 'nickname': resp['screen_name']} missing_data = [key for key in oauth_values if len(user_data[key]) == 0] return get_oauth_ret_dict(user_data=user_data, missing_data=missing_data)
def start_flow(**kwargs): """ Starts the oauth flow. This will return a dict which causes a redirect to the providers page. :param kwargs: should have a redirect_uri and a request :return: """ redirect_uri = kwargs.get('redirect_uri') request = kwargs.get('request') LOG.debug("Read OAuth id/secret: none? %s/%s", CLIENT_ID is None, CLIENT_SECRET is None) request_token_url = 'https://api.twitter.com/oauth/request_token' authorization_url = 'https://api.twitter.com/oauth/authorize' oauth_client = OAuth1Session(CLIENT_ID, client_secret=CLIENT_SECRET, callback_uri=redirect_uri) resp = oauth_client.fetch_request_token(request_token_url) url = oauth_client.authorization_url(authorization_url) request.session['twitter_oauth_token'] = resp.get('oauth_token') request.session['twitter_oauth_token_secret'] = resp.get( 'oauth_token_secret') LOG.debug("Please go to %s and authorize access", authorization_url) return {'authorization_url': url, 'error': ''}
def __init__(self, consumer_key, consumer_secret, oauth_token=None, mobile=False): self._consumer_key = consumer_key self._consumer_secret = consumer_secret self._oauth_token = oauth_token self._session = OAuth1Session(consumer_key, consumer_secret) self._session.mount('http://', HTTPAdapter(max_retries=5)) self._session.mount('https://', HTTPAdapter(max_retries=5)) if oauth_token: self._session._populate_attributes(oauth_token) self.request_token = None self._oauth_type = None self.request_token_url = 'http://fanfou.com/oauth/request_token' self.access_token_url = 'http://fanfou.com/oauth/access_token' self.authorize_url = 'http://m.fanfou.com/oauth/authorize' \ if mobile else 'http://fanfou.com/oauth/authorize' self._me = None self.draft_box = [] self.mentions = Timeline(self, None, 'statuses/mentions') self.replies = Timeline(self, None, 'statuses/replies') self.public_timeline = Timeline(self, None, 'statuses/public_timeline')
def continue_flow(request, redirect_response): """ :param request: :param redirect_response: :return: """ client_id = os.environ.get('OAUTH_TWITTER_CLIENTID', None) client_secret = os.environ.get('OAUTH_TWITTER_CLIENTKEY', None) logger( 'Twitter OAuth', 'Read OAuth id/secret: none? {}'.format(client_id is None, client_secret is None)) pincode = redirect_response.split('oauth_verifier=')[1] access_token_url = 'https://api.twitter.com/oauth/access_token' oauth_token = request.session['twitter_oauth_token'] oauth_token_secret = request.session['twitter_oauth_token_secret'] oauth_client = OAuth1Session(client_id, client_secret=client_secret, resource_owner_key=oauth_token, resource_owner_secret=oauth_token_secret, verifier=pincode) resp = oauth_client.fetch_access_token(access_token_url) user_data = {'id': resp['id'], 'nickname': resp['screen_name']} missing_data = [key for key in oauth_values if len(user_data[key]) == 0] return {'user': user_data, 'missing': missing_data, 'error': ''}
def start_flow(request, redirect_uri): """ :param request: :param redirect_uri: :return: """ client_id = os.environ.get('OAUTH_TWITTER_CLIENTID', None) client_secret = os.environ.get('OAUTH_TWITTER_CLIENTKEY', None) logger( 'Twitter OAuth', 'Read OAuth id/secret: none? {}'.format(client_id is None, client_secret is None)) request_token_url = 'https://api.twitter.com/oauth/request_token' authorization_url = 'https://api.twitter.com/oauth/authorize' oauth_client = OAuth1Session(client_id, client_secret=client_secret, callback_uri=redirect_uri) resp = oauth_client.fetch_request_token(request_token_url) url = oauth_client.authorization_url(authorization_url) request.session['twitter_oauth_token'] = resp.get('oauth_token') request.session['twitter_oauth_token_secret'] = resp.get( 'oauth_token_secret') logger('Twitter OAuth', 'Please go to {} and authorize access'.format(authorization_url)) return {'authorization_url': url, 'error': ''}
def main(args): """ main """ ret = 0 try: oauth = OAuth1Session(CONSUMER_KEY, client_secret=CONSUMER_SECRET, callback_uri=CALLBACK_URI) fetch_response = oauth.fetch_request_token(REQUEST_TOKEN_URL) resource_owner_key = fetch_response.get('oauth_token') resource_owner_secret = fetch_response.get('oauth_token_secret') #print('resource_owner_key', resource_owner_key) #print('resource_owner_secret', resource_owner_secret) auth_url = oauth.authorization_url(AUTHORIZE_URL) print('enter this auth url into browser.', auth_url) print('and get the verifier(from html source).') print('') verifier = input('input verifier:') oauth = OAuth1Session(CONSUMER_KEY, client_secret=CONSUMER_SECRET, resource_owner_key=resource_owner_key, resource_owner_secret=resource_owner_secret) fetch_response = oauth.fetch_access_token(ACCESS_TOKEN_URL, verifier=verifier) resource_owner_key = fetch_response.get('oauth_token') resource_owner_secret = fetch_response.get('oauth_token_secret') print('access_token', resource_owner_key) print('access_secret', resource_owner_secret) except Exception as e: print(e.__class__.__name__) print(e) ret = 1 return ret
def __init__(self, cfg): self.cfg = cfg self.api_url = cfg.api_url self.session = OAuth1Session(self.cfg.consumer_key, self.cfg.consumer_secret) self.access_token = self.cfg.user.get('access_token') if not self.access_token: if self.cfg.xauth: self.access_token = self.xauth() else: self.access_token = self.oauth() self.session._populate_attributes(self.access_token) self.cfg.user['access_token'] = self.access_token
def xauth(self, username, password): import oauthlib.oauth1.rfc5849.utils # patch to allow x_auth_* params oauthlib.oauth1.rfc5849.utils.filter_oauth_params = lambda _: _ # noinspection PyProtectedMember client = self._session._client.client class OAuth1Client(oauthlib.oauth1.rfc5849.Client): def get_oauth_params(self, request): params = super(OAuth1Client, self).get_oauth_params(request) args = [ ('x_auth_username', username), ('x_auth_password', password), ('x_auth_mode', 'client_auth') ] params += args return params sess = OAuth1Session(client.client_key, client.client_secret, client_class=OAuth1Client) token = sess.fetch_access_token(self.access_token_url, verifier='x') self._oauth_token = token self._session._populate_attributes(token) return token
def xauth(self): # 1. form base request args # 2. generate signature, add to base args # 3. generate Authorization header from base args username = get_input(cstring('[-]请输入用户名或邮箱>', 'cyan')) password = getpass.getpass(cstring('[-]请输入密码>', 'cyan')) # 这些实际上并不是url params,但是他们与其他url params一样参与签名,最终成为Authorization header的值 args = [('x_auth_username', username), ('x_auth_password', password), ('x_auth_mode', 'client_auth')] class OAuth1ClientPatch(OAuth1Client): """Patch oauthlib.oauth1.Client for xauth""" def get_oauth_params(self, request): params = super().get_oauth_params(request) params.extend(args) return params sess = OAuth1Session(self.cfg.consumer_key, self.cfg.consumer_secret, client_class=OAuth1ClientPatch) access_token = sess.fetch_access_token(self.cfg.access_token_url, verifier='123') return access_token
print(str(index) + ' : ' + token.get('user') + ' (created: ' + token.get('timestamp') + ')') print('a : add a new token') print('q : quit program') choice = input('Your choice?: ') if choice == 'q': sys.exit() chosen_token = {} client_key = chosen_credentials.get('client_key') client_secret = chosen_credentials.get('client_secret') if choice == 'a': print('Adding a token...') print('Step 0: access API catalog (using only client security context)') oauth_session = OAuth1Session(client_key, client_secret=client_secret) url = base_url + '/' r = oauth_session.get(url, headers=DEFAULT_JSON_HEADER) response = r.json() print(json.dumps(response, indent=4, sort_keys=True)) request_token_url = extract_link(response, 'oauthRequestToken') authorization_url = extract_link(response, 'oauthAuthorizeRequestToken') #authorization_url = 'https://my.deere.com/consentToUseOfData' access_token_url = extract_link(response, 'oauthAccessToken') wait = input('Enter to continue...') print() print('Step 1: use urls from catalog to fetch a request token (using same client security context)') oauth_session = OAuth1Session(client_key, client_secret=client_secret, callback_uri=callback_uri) r = oauth_session.fetch_request_token(url=request_token_url) print(json.dumps(r, indent=4, sort_keys=True))
def __init__(self, consumer_key, consumer_secret=None): self._oauth = OAuth(client_key=consumer_key, client_secret=consumer_secret)
class Client: def __init__(self, consumer_key, consumer_secret=None): self._oauth = OAuth(client_key=consumer_key, client_secret=consumer_secret) def search(self, query: str = None, category: Category = None, type: str = None, genre: str = None, artist: str = None, year_min: int = None, year_max: int = None, size_min: int = None, size_max: int = None, sort: SortType = None, sort_order: SortOrder = SortOrder.ASC) -> [File]: """ Search files :param query: The search string (from 1 to 200 symbols). :param category: The category of the files to search. :param type: Type of the file to search (e.g. pdf, mp3, jpg, ...). :param genre: Filter by music genre. :param artist: Filter by artist name. :param year_min: Filter by minimum year of upload. :param year_max: Filter by maximum year of upload. :param size_min: Filter by minimum size in bytes. :param size_max: Filter by maximum size in bytes. :param sort: Type for the sorting. :param sort_order: Order of the sorting. :return: Return a list of the fetched files. """ params = {} def add_param(key, value): if value is not None: params[key] = value add_param('query', query) add_param('type', type) add_param('genre', genre) add_param('artist', artist) add_param('year_min', year_min) add_param('year_max', year_max) add_param('size_min', size_min) add_param('size_max', size_max) # Convert the category into a number if category is not None: params['category'] = category._value_ # Format the sort parameter if sort is not None: params['sort'] = '%s,%s' % (sort._value_, sort_order._value_) logger.info('Search with params: %s' % params) response = self._get_json(url='https://search.4shared.com/v1_2/files', params=params) files = response['files'] return [File(json) for json in files] def download(self, id: str) -> bytes: url = ' https://api.4shared.com/v1_2/files/%s/download' % id response = self._oauth.get(url) return response.content def _get_json(self, url, **kwargs): return self._request_json('GET', url, **kwargs) def _request_json(self, method, url, **kwargs): request = self._oauth.request(method, url, headers={'Accept': 'application/json'}, **kwargs) return request.json()
import pickle from requests_oauthlib.oauth1_session import OAuth1Session import json from numpy import random DEFAULT_JSON_HEADER = {'Accept': 'application/vnd.deere.axiom.v3+json'} base_url = 'https://apicert.soa-proxy.deere.com/platform' client_key = 'johndeere-54ET8agkbEm5s5WT83Kfyx57' client_secret = 'af433adb114ea5539aca09cc0c09f53cb52a2237' oauth_session = OAuth1Session( client_key, client_secret=client_secret, resource_owner_key='c2eb1ca4-dc44-4d92-adcd-d0888359af78', resource_owner_secret= 'Xi42JPNcK5xKoxsiv2MuK5Wr/TPkGRzmu/oAlCIOk19VBdwP8RzE+ZzAms0dFL7FS96m+qX7ag2Z7WuO24W01bxdZkHaiWf24lNR+BaQwu4=' ) r = oauth_session.get(base_url + '/', headers=DEFAULT_JSON_HEADER) def corn_or_soy(): if random.randint(2) == 0: return "CORN" else: return "SOY" def my_handle_endpoint(this_choice): _response = None _url = this_choice if _url is not None: