def __init__(self, app=None, base_url=None, consumer_key=None, consumer_secret=None, **kwargs): RauthServiceMixin.__init__(self, app=app, base_url=base_url) OAuth1Service.__init__(self, consumer_key=consumer_key, consumer_secret=consumer_secret, **kwargs)
def __init__(self, consumer_key, consumer_secret, verbose=0, cache_name='tokens.dat'): #cache stores tokens and hashes on disk so we avoid #requesting them every time. self.cache = shelve.open(cache_name, writeback=False) self.verbose = verbose self.oauth = OAuth1Service( name='fitbit', consumer_key=consumer_key, consumer_secret=consumer_secret, request_token_url='http://api.fitbit.com/oauth/request_token', access_token_url='http://api.fitbit.com/oauth/access_token', authorize_url='http://www.fitbit.com/oauth/authorize', header_auth=False) self.access_token = self.cache.get('fitbit_access_token', None) self.access_token_secret = self.cache.get('fitbit_access_token_secret', None) self.request_token = self.cache.get('fitbit_request_token', None) self.request_token_secret = self.cache.get( 'fitbit_request_token_secret', None) self.encoded_user_id = self.cache.get('fitbit_encoded_user_id', None) self.pin = self.cache.get('fitbit_pin', None) #If this is our first time running- get new tokens if (self.need_request_token()): self.get_request_token() got_access_token = self.get_access_token() if (not got_access_token): print "Error: Unable to get access token"
def __init__(self, verbose = False): """ Constructor. Loads the config file and initialises the smugmug service """ self.verbose = verbose config_parser = ConfigParser.RawConfigParser() config_parser.read(SmugMug.smugmug_config) try: self.username = config_parser.get('SMUGMUG','username') self.consumer_key = config_parser.get('SMUGMUG','consumer_key') self.consumer_secret = config_parser.get('SMUGMUG','consumer_secret') self.access_token = config_parser.get('SMUGMUG','access_token') self.access_token_secret = config_parser.get('SMUGMUG','access_token_secret') except: raise Exception("Config file is missing or corrupted. Run 'python smugmug.py'") self.smugmug_service = OAuth1Service( name='smugmug', consumer_key=self.consumer_key, consumer_secret=self.consumer_secret, request_token_url=self.smugmug_request_token_uri, access_token_url=self.smugmug_access_token_uri, authorize_url=self.smugmug_authorize_uri) self.request_token, self.request_token_secret = self.smugmug_service.get_request_token(method='GET', params={'oauth_callback':'oob'}) self.smugmug_session = self.smugmug_service.get_session((self.access_token, self.access_token_secret))
def get_goodreads_access_token(): """ Gets access token and access token secret.""" # Gets the key, secret from shell enviroment. app_key = environ["KEY"] app_secret = environ["SECRET"] # Creates the goodreads object to generate access token. goodreads = OAuth1Service( consumer_key=app_key, consumer_secret=app_secret, name='goodreads', request_token_url='http://www.goodreads.com/oauth/request_token', authorize_url='http://www.goodreads.com/oauth/authorize', access_token_url='http://www.goodreads.com/oauth/access_token', base_url='http://www.goodreads.com/' ) request_token, request_token_secret = goodreads.get_request_token(header_auth=True) authorize_url = goodreads.get_authorize_url(request_token) print 'Visit this URL in your browser: ' + authorize_url accepted = 'n' while accepted.lower() != 'y': # you need to access the authorize_link via a browser, # and manually authorize your app to access your account. accepted = raw_input('Have you authorized me? (y/n) ') session = goodreads.get_auth_session(request_token, request_token_secret) ACCESS_TOKEN = session.access_token ACCESS_TOKEN_SECRET = session.access_token_secret
def record_values(self, weight, unit, hasImpedance, impendance): for user in self.config['users']: if (weight > user['weight_threshold']): login = user['login'] log.info(f"Logging weight {weight} for user {login}.") oauth = OAuth1Service( name='fatsecret', consumer_key=self.config['app_key'], consumer_secret=self.config['app_secret'], request_token_url='https://www.fatsecret.com/oauth/request_token', access_token_url='https://www.fatsecret.com/oauth/access_token', authorize_url='https://www.fatsecret.com/oauth/authorize', base_url='https://platform.fatsecret.com/rest/server.api' ) session = oauth.get_session((user['token'], user['secret'])) params = { 'method': 'weight.update', 'format': 'json', 'current_weight_kg': weight, 'weight_type': unit, } r = session.get('https://platform.fatsecret.com/rest/server.api', params=params) log.info(f'Logging result: {r.text}') return log.warning(f'Could not find user to log {weight}')
def __init__(self, consumer_key: str, consumer_secret: str, access_token: Optional[str] = None, access_token_secret: Optional[str] = None): self.consumer_key = consumer_key self.consumer_secret = consumer_secret self.access_token = access_token self.access_token_secret = access_token_secret self.client = OAuth1Service( consumer_key=consumer_key, consumer_secret=consumer_secret, name='goodreads', request_token_url=Goodreads.request_token_url, authorize_url=Goodreads.authorize_url, access_token_url=Goodreads.access_token_url, base_url=Goodreads.base_url) if self.access_token and self.access_token_secret: self.session = OAuth1Session( consumer_key=self.consumer_key, consumer_secret=self.consumer_secret, access_token=self.access_token, access_token_secret=self.access_token_secret) else: self.session = None self._current_user: Optional[User] = None
def __init__(self, settings): """ Connect to Magento REST Api using OAuth 1.0 authentication. We need an ADMIN role with sufficient access to insert articles. Magento API Guide: http://www.magentocommerce.com/api/rest/introduction.html """ self.name = settings.get('MAGENTO_SERVICE_NAME') self.api_url = settings.get('MAGENTO_API_BASE') self.request_token_url = settings.get('MAGENTO_REQUEST_TOKEN_URL') self.authorize_url = settings.get('MAGENTO_AUTHORIZE_URL') self.access_token_url = settings.get('MAGENTO_ACCESS_TOKEN_URL') self.consumer_key = settings.get('MAGENTO_TOKEN_KEY') self.consumer_secret = settings.get('MAGENTO_TOKEN_SEC') self.access_token = settings.get('MAGENTO_ACCESS_KEY') self.access_token_secret = settings.get('MAGENTO_ACCESS_SEC') self.oauth = OAuth1Service( name=self.name, consumer_key=self.consumer_key, consumer_secret=self.consumer_secret, request_token_url=self.request_token_url, authorize_url=self.authorize_url, access_token_url=self.access_token_url, base_url=self.api_url, ) self.request_headers = { 'Content-Type': 'application/json', 'Accept': 'application/json' } self.encoder = ScrapyJSONEncoder()
def auth(): "Save authentication credentials to a JSON file" auth = "auth.json" auth_data = {} if pathlib.Path(auth).exists(): auth_data = json.load(open(auth)) click.echo( "Create a Goodreads developer key at https://www.goodreads.com/api/keys and paste it here:" ) developer_key = click.prompt("Developer key", default=auth_data.get( "goodreads_developer_key", "")) click.echo("Please also paste the secret:") developer_secret = click.prompt( "Developer secret", default=auth_data.get("goodreads_developer_secret")) click.echo() click.echo( "Please enter your Goodreads user ID (numeric) or just paste your Goodreads profile URL." ) user_id = click.prompt("User-ID or URL", default=auth_data.get("goodreads_user_id", "")) user_id = user_id.strip("/").split("/")[-1].split("-")[0] if not user_id.isdigit(): raise Exception( "Your user ID has to be a number! {} does not look right".format( user_id)) auth_data["goodreads_developer_key"] = developer_key auth_data["goodreads_developer_secret"] = developer_secret auth_data["goodreads_user_id"] = user_id auth_data["shelves"] = get_shelves(auth_data) open(auth, "w").write(json.dumps(auth_data, indent=4) + "\n") if not (auth_data.get("goodreads_user_access_token") and auth_data.get("goodreads_user_access_secret")): oauth_service = OAuth1Service( consumer_key=auth_data["goodreads_developer_key"], consumer_secret=auth_data["goodreads_developer_secret"], name="goodreads", request_token_url="https://www.goodreads.com/oauth/request_token", authorize_url="https://www.goodreads.com/oauth/authorize", access_token_url="https://www.goodreads.com/oauth/access_token", base_url="https://www.goodreads.com/", ) request_token, request_token_secret = oauth_service.get_request_token( header_auth=True) authorize_url = oauth_service.get_authorize_url(request_token) click.prompt("Visit this URL in your browser: " + authorize_url) session = oauth_service.get_auth_session(request_token, request_token_secret) auth_data["goodreads_user_access_token"] = session.access_token auth_data["goodreads_user_access_secret"] = session.access_token_secret open(auth, "w").write(json.dumps(auth_data, indent=4) + "\n") click.echo( "All done. You can now add books with `books add` or change them with `books edit`, and the changes will be pushed to Goodreads." )
def get_oauth_service(): return OAuth1Service( consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET, name='goodreads', request_token_url='http://www.goodreads.com/oauth/request_token', authorize_url='http://www.goodreads.com/oauth/authorize', access_token_url='http://www.goodreads.com/oauth/access_token', base_url='http://www.goodreads.com/')
def twitter_service(): return OAuth1Service( name='twitter', consumer_key=settings.TWITTER_APP_KEY, consumer_secret=settings.TWITTER_APP_SECRET, request_token_url='https://api.twitter.com/oauth/request_token', access_token_url='https://api.twitter.com/oauth/access_token', authorize_url='https://api.twitter.com/oauth/authorize', )
def __init__(self): self.goodreads = OAuth1Service( consumer_key=self.goodreads_key, consumer_secret=self.goodreads_secret, name="goodreads", request_token_url="https://www.goodreads.com/oauth/request_token", authorize_url="https://www.goodreads.com/oauth/authorize", access_token_url="https://www.goodreads.com/oauth/access_token", base_url="https://www.goodreads.com/", )
def service(self): if not self._service: self._service = OAuth1Service( consumer_key=KEY, consumer_secret=SECRET, request_token_url='{}/oauth/request_token'.format(BASE_URL), authorize_url='{}/oauth/authorize'.format(BASE_URL), access_token_url='{}/oauth/access_token'.format(BASE_URL), base_url=BASE_URL) return self._service
def authorize(path_to_keys): api_keys = json.load(open(path_to_keys, 'rb')) KEY = api_keys['KEY'] SECRET = api_keys['SECRET'] goodreads = OAuth1Service( consumer_key=KEY, consumer_secret=SECRET, name='goodreads', request_token_url='http://www.goodreads.com/oauth/request_token', authorize_url='http://www.goodreads.com/oauth/authorize', access_token_url='http://www.goodreads.com/oauth/access_token', base_url='http://www.goodreads.com/') # head_auth=True is important here; this doesn't work with oauth2 for some reason request_token, request_token_secret = goodreads.get_request_token( header_auth=True) authorize_url = goodreads.get_authorize_url(request_token) print 'Visit this URL in your browser: ' + authorize_url accepted = 'n' while accepted.lower() == 'n': # you need to access the authorize_link via a browser, # and proceed to manually authorize the consumer accepted = raw_input('Have you authorized me? (y/n) ') session = goodreads.get_auth_session(request_token, request_token_secret) time.sleep(1) # Grab the user id user_xml = session.get('https://www.goodreads.com/api/auth_user') user_id = BeautifulSoup(user_xml.content).find('user').get('id') # Build reviewed book query response = session.get( 'https://www.goodreads.com/review/list/' '{u:s}.xml?key=XOjn5TvF7yh0VUK0re8v4Q&v=2'.format(u=user_id)) parsed_html = BeautifulSoup(response.content) title_tags = parsed_html.body.findAll('title') titles = [tag.text for tag in title_tags] score = 0 for book in OFFICIAL_BOOKS: if book in titles: score += 1 print("Your score is {s:.2f}%".format(s=float(score) / len(OFFICIAL_BOOKS) * 100)) import pdb pdb.set_trace()
def goodreads_api(): goodreads = OAuth1Service( consumer_key=os.environ['GOODREADS_API_KEY'], consumer_secret=os.environ['GOODREADS_API_SECRET'], name='goodreads', request_token_url='http://www.goodreads.com/oauth/request_token', authorize_url='http://www.goodreads.com/oauth/authorize', access_token_url='http://www.goodreads.com/oauth/access_token', base_url='http://www.goodreads.com/') return goodreads
def __init__(self): super(TwitterSignIn, self).__init__('twitter') ###OAuth1Service self.service = OAuth1Service( name='twitter', consumer_key=self.consumer_id, consumer_secret=self.consumer_secret, request_token_url='https://api.twitter.com/oauth/request_token', authorize_url='https://api.twitter.com/oauth/authorize', access_token_url='https://api.twitter.com/oauth/access_token', base_url='https://api.twitter.com/1.1/')
def authorize(): service = OAuth1Service(name='bitbucket', consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET, request_token_url=OAUTH_REQUEST, access_token_url=OAUTH_ACCESS, authorize_url=OAUTH_AUTH) rtoken, rtokensecret = service.get_request_token(method='GET') auth_url = service.get_authorize_url(rtoken) print "Visit this url and copy&paste your PIN.\n{0}".format(auth_url) pin = raw_input('Please enter your PIN:') r = service.get_access_token('POST', request_token=rtoken, request_token_secret=rtokensecret, data={'oauth_verifier': pin}) content = r.content return content['oauth_token'], content['oauth_token_secret']
def __init__(self): if self.config is None: self.config = configparser.ConfigParser() self.config.read('config_secret.ini') self.user = self.config.get('provider', 'user') self.twitter = OAuth1Service( name='twitter', consumer_key=self.config.get('provider', 'consumer_key'), consumer_secret=self.config.get('provider', 'consumer_secret'), request_token_url='https://api.twitter.com/oauth/request_token', access_token_url='https://api.twitter.com/oauth/access_token', authorize_url='https://api.twitter.com/oauth/authorize', base_url='https://api.twitter.com/1.1/')
def setUp(self): self.auth = OAuth1Service( name='hardtail_python', consumer_key='JpU9Lb1PEpFtLgC7XOlkw', consumer_secret='k6TsCWbybimpcBMhi8o5simuuoX3XjoMGtG5Ij9U', request_token_url='https://api.twitter.com/oauth/request_token', access_token_url='https://api.twitter.com/oauth/access_token', authorize_url='https://api.twitter.com/oauth/authorize') self.access_token = { 'access_token': '132108032-vQ58uSC6HE0IOOMtmZcRjjko4gbykAOmDF4Vg3tI', 'access_token_secret': 'Q2uMS4NvwPhAs6BthJ19ImdYCixXmxfUos1B76D4' } self.endpoint = 'https://api.twitter.com/1.1/{path}.json'
def gr(self): if self._gr is not None: return self._gr self._gr = OAuth1Service( consumer_key=self._developer_key, consumer_secret=self._developer_secret, name='goodreads', request_token_url=self.request_token_url, authorize_url=self.authorize_url, access_token_url=self.access_token_url, base_url=self.base_url, ) return self._gr
def setUp(self): RauthTestCase.setUp(self) # mock service for testing service = OAuth1Service( 'example', consumer_key='123', consumer_secret='456', request_token_url='http://example.com/request_token', access_token_url='http://example.com/access_token', authorize_url='http://example.com/authorize') self.service = service # mock response content self.response.content = 'oauth_token=123&oauth_token_secret=456'
def request(self, method, url, oauth_token=None, **kwargs): ''' Make a request using an `oauth_token` obtained via the :func:`authorized_handler`. ''' url = self._expand_url(url) if oauth_token is None and self.tokengetter_f is not None: oauth_token = self.tokengetter_f() # take apart the 2-tuple if oauth_token is not None: oauth_token, oauth_token_secret = oauth_token else: oauth_token_secret = None # call the parent implementation return RauthResponse(OAuth1Service.request(self, method, url, access_token=oauth_token, access_token_secret=oauth_token_secret, **kwargs))
def oauth_init(self): """Start outh and return authorization url.""" service = OAuth1Service( consumer_key=self.client_key, consumer_secret=self.client_secret, name='goodreads', request_token_url='http://www.goodreads.com/oauth/request_token', authorize_url='http://www.goodreads.com/oauth/authorize', access_token_url='http://www.goodreads.com/oauth/access_token', base_url='http://www.goodreads.com/') request_token, request_token_secret = service.get_request_token( header_auth=True) auth_url = service.get_authorize_url(request_token) # Store service for finalizing self.request_token = request_token self.request_token_secret = request_token_secret self.service = service return auth_url
def post_photo(user, blog_hostname, comment): tumblr = OAuth1Service( name='tumblr', consumer_key=user_token, consumer_secret=user_secret, request_token_url='http://www.tumblr.com/oauth/request_token', authorize_url='http://www.tumblr.com/oauth/authorize', access_token_url='http://www.tumblr.com/oauth/access_token', ) image_data = requests.get( comment.details().content.get_absolute_url_for_image_type( 'original')).content image_data = urllib2.quote(image_data) url = get_share_page_url_with_tracking(comment, user, 'tumblr') params = { 'type': 'photo', 'state': 'published', 'tags': 'DrawQuest', 'link': url, 'source': url, 'caption': comment.quest.title + ' on DrawQuest', 'data': [image_data], } resp = tumblr.post( 'http://api.tumblr.com/v2/blog/{0}/post'.format(blog_hostname), params, access_token=access_token, access_token_secret=access_token_secret) resp.raise_for_status() if resp.json['meta'][ 'status'] != 201: # 201: Created. http://www.tumblr.com/docs/en/api/v2#posting raise ServiceError("Error posting to Tumblr: " + resp.json['meta']['msg']) @bgwork.defer def rewards(): economy.credit_personal_share(user)
def setUp(self): RauthTestCase.setUp(self) self.request_token_url = 'http://example.com/request' self.access_token_url = 'http://example.com/access' self.authorize_url = 'http://example.com/authorize' self.base_url = 'http://example.com/api/' self.service = OAuth1Service(self.consumer_key, self.consumer_secret, name='service', request_token_url=self.request_token_url, access_token_url=self.access_token_url, authorize_url=self.authorize_url, base_url=self.base_url) self.session = self.service.get_session(('123', '456')) # patches self.session.request = self.fake_request self.service.get_session = self.fake_get_session
def twitter(request, username): twitter = OAuth1Service( name='twitter', consumer_key=settings.TWITTER_CONSUMER_KEY, consumer_secret=settings.TWITTER_CONSUMER_SECRET, request_token_url=settings.TWITTER_API_URL + 'oauth/request_token', access_token_url=settings.TWITTER_API_URL + 'oauth/access_token', authorize_url=settings.TWITTER_API_URL + 'oauth/authorize', header_auth=True) url = '{0}1/statuses/user_timeline.json?include_rts=false' \ '&exclude_replies=true&count=50&screen_name={1}'.format( settings.TWITTER_API_URL, username) r = twitter.request('GET', url, access_token=settings.TWITTER_USER_KEY, access_token_secret=settings.TWITTER_USER_SECRET) return HttpResponse(content=json.dumps(r.response.json), status=r.response.status_code, content_type=r.response.headers['content-type'])
def get_new_session(self): goodreads = OAuth1Service( consumer_key=self.api_key, consumer_secret=self.api_secret, name='goodreads', request_token_url='https://www.goodreads.com/oauth/request_token', authorize_url='https://www.goodreads.com/oauth/authorize', access_token_url='https://www.goodreads.com/oauth/access_token', base_url='https://www.goodreads.com/') req_token, req_token_secret = goodreads.get_request_token( header_auth=True) authorise_url = goodreads.get_authorize_url(req_token) print('Visit this URL in your browser: ' + authorise_url) accepted = 'n' while accepted.lower() != 'y': accepted = input('Have you authorized me? (y/n) ') session = goodreads.get_auth_session(req_token, req_token_secret) self.access_token = session.access_token self.access_token_secret = session.access_token_secret self.session = session
def __init__(self, consumer_key, consumer_secret, session_token=None): """ Create unauthorized session or open existing authorized session :param consumer_key: App API Key. Register at http://platform.fatsecret.com/api/ :type consumer_key: str :param consumer_secret: Secret app API key :type consumer_secret: str :param session_token: Access Token / Access Secret pair from existing authorized session :type session_token: tuple """ self.consumer_key = consumer_key self.consumer_secret = consumer_secret # Needed for new access. Generated by running get_authorize_url() self.request_token = None self.request_token_secret = None # Required for accessing user info. Generated by running authenticate() self.access_token = None self.access_token_secret = None self.oauth = OAuth1Service( name='fatsecret', consumer_key=consumer_key, consumer_secret=consumer_secret, request_token_url='http://www.fatsecret.com/oauth/request_token', access_token_url='http://www.fatsecret.com/oauth/access_token', authorize_url='http://www.fatsecret.com/oauth/authorize', base_url='http://platform.fatsecret.com/rest/server.api') # Open prior session or default to unauthorized session if session_token: self.access_token = session_token[0] self.access_token_secret = session_token[1] self.session = self.oauth.get_session(token=session_token) else: # Default to unauthorized session self.session = self.oauth.get_session()
def _request(rtype, url, params={}, data=None): cfg = config.parseconfig() session = requests if cfg['btoken'] and cfg['btoken_secret']: service = OAuth1Service(name='bitbucket', consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET, request_token_url=OAUTH_REQUEST, access_token_url=OAUTH_ACCESS, authorize_url=OAUTH_AUTH) session = service.get_auth_session(cfg['btoken'], cfg['btoken_secret']) r = None if data: r = getattr(session, rtype)(url, data=data, params=params, verify=cfg['sslverify']) else: r = getattr(session, rtype)(url, params=params) if not 200 <= r.status_code < 300: raise requests.exceptions.HTTPError('[{0}] {1}'.format( r.status_code, r.url)) return r.json()
def oath_start(self): """ Start oauth, get tokens return authorization url""" # Create auth service goodreads_service = OAuth1Service( consumer_key=self.client_key, consumer_secret=self.client_secret, name='goodreads', request_token_url='http://www.goodreads.com/oauth/request_token', authorize_url='http://www.goodreads.com/oauth/authorize', access_token_url='http://www.goodreads.com/oauth/access_token', base_url='http://www.goodreads.com/') # Get tokens and authorization link self.request_token, self.request_token_secret = \ goodreads_service.get_request_token(header_auth=True) authorize_url = goodreads_service.get_authorize_url(self.request_token) print 'To authorize access visit: ' + authorize_url # Store service for finishing self.goodreads_service = goodreads_service return authorize_url
def authorize(): goodreads = OAuth1Service( consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET, name='goodreads', request_token_url='http://www.goodreads.com/oauth/request_token', authorize_url='http://www.goodreads.com/oauth/authorize', access_token_url='http://www.goodreads.com/oauth/access_token', base_url='http://www.goodreads.com/') request_token, request_token_secret = goodreads.get_request_token( header_auth=True) authorize_url = goodreads.get_authorize_url(request_token) print('Visit this URL in your browser: ' + authorize_url) accepted = 'n' while accepted.lower() == 'n': # you need to access the authorize_link via a browser, # and proceed to manually authorize the consumer accepted = input('Have you authorized me? (y/n) ') session = goodreads.get_auth_session(request_token, request_token_secret) pickle.dump(session, open(SESSION, "wb")) return session