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 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 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
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)
