def process_data(self, token, trigger_id, date_triggered): """ get the data from the service :param trigger_id: trigger ID to process :param date_triggered: the date of the last trigger :type trigger_id: int :type date_triggered: datetime :return: list of data found from the date_triggered filter :rtype: list """ data = [] if token is not None: token_key, token_secret = token.split('#TH#') client = ReaderClient(self.consumer_key, self.consumer_secret, token_key, token_secret) bookmarks = client.get_bookmarks( added_since=date_triggered).content for bookmark in bookmarks.values(): for b in bookmark: if 'article' in b: title = '' if 'title' in b['article']: title = b['article']['title'] link = '' if 'url' in b['article']: link = b['article']['url'] content = '' if 'excerpt' in b['article']: content = b['article']['excerpt'] data.append({ 'title': title, 'link': link, 'content': content }) return data
def actualizar(): cred=getAuth() # If no client credentials are passed to ReaderClient's constructor, they # will be looked for in your environment variables """ coneccion = pymongo.MongoClient("localhost") db = coneccion.readability db.drop_collection("bookmarks") datos=db.bookmarks""" client = ReaderClient(token_key=cred[0],token_secret=cred[1],consumer_key=consumer_key,consumer_secret=consumer_secret) print client bookmarks_response = client.get_bookmarks() dic=bookmarks_response.json() for k in dic["bookmarks"]: print k["article"]["title"]
def process_data(self, token, trigger_id, date_triggered): """ get the data from the service """ data = [] if token is not None: token_key, token_secret = token.split('#TH#') client = ReaderClient( self.consumer_key, self.consumer_secret, token_key, token_secret) bookmarks = client.get_bookmarks( added_since=date_triggered).content for bookmark in bookmarks.values(): for b in bookmark: if 'article' in b: title = '' if 'title' in b['article']: title = b['article']['title'] link = '' if 'url' in b['article']: link = b['article']['url'] content = '' if 'excerpt' in b['article']: content = b['article']['excerpt'] data.append( {'title': title, 'link': link, 'content': content}) return data
class ServiceReadability(ServicesMgr): def __init__(self, token=None): base = 'https://www.readability.com' self.AUTH_URL = '{}/api/rest/v1/oauth/authorize/'.format(base) self.REQ_TOKEN = '{}/api/rest/v1/oauth/request_token/'.format(base) self.ACC_TOKEN = '{}/api/rest/v1/oauth/access_token/'.format(base) self.consumer_key = settings.TH_READABILITY['consumer_key'] self.consumer_secret = settings.TH_READABILITY['consumer_secret'] self.token = token if token: token_key, token_secret = self.token.split('#TH#') self.client = ReaderClient(token_key, token_secret, self.consumer_key, self.consumer_secret) def read_data(self, **kwargs): """ get the data from the service :param kwargs: contain keyword args : trigger_id at least :type kwargs: dict :rtype: list """ date_triggered = kwargs['date_triggered'] trigger_id = kwargs['trigger_id'] data = [] if self.token is not None: bookmarks = self.client.get_bookmarks( added_since=date_triggered).content for bookmark in bookmarks.values(): for b in bookmark: if 'article' in b: title = '' if 'title' in b['article']: title = b['article']['title'] link = '' if 'url' in b['article']: link = b['article']['url'] content = '' if 'excerpt' in b['article']: content = b['article']['excerpt'] data.append( {'title': title, 'link': link, 'content': content}) cache.set('th_readability_' + str(trigger_id), data) return data def process_data(self, **kwargs): """ get the data from the cache :param kwargs: contain keyword args : trigger_id at least :type kwargs: dict """ kw = {'cache_stack': 'th_readability', 'trigger_id': str(kwargs['trigger_id'])} return super(ServiceReadability, self).process_data(**kw) def save_data(self, trigger_id, **data): """ let's save the data :param trigger_id: trigger ID from which to save data :param data: the data to check to be used and save :type trigger_id: int :type data: dict :return: the status of the save statement :rtype: boolean """ status = False if self.token and 'link' in data and\ data['link'] is not None and\ len(data['link']) > 0: # get the data of this trigger trigger = Readability.objects.get(trigger_id=trigger_id) bookmark_id = self.client.add_bookmark(url=data['link']) if trigger.tag is not None and len(trigger.tag) > 0: try: self.client.add_tags_to_bookmark( bookmark_id, tags=(trigger.tag.lower())) sentence = str('readability {} created item id {}').format( data['link'], bookmark_id) logger.debug(sentence) status = True except Exception as e: logger.critical(e) status = False else: sentence = "no token or link provided for trigger ID {} " logger.critical(sentence.format(trigger_id)) status = False return status def auth(self, request): """ let's auth the user to the Service """ request_token = super(ServiceReadability, self).auth(request) callback_url = self.callback_url(request, 'readability') # URL to redirect user to, to authorize your app auth_url_str = '%s?oauth_token=%s&oauth_callback=%s' auth_url = auth_url_str % (self.AUTH_URL, request_token['oauth_token'], callback_url) return auth_url def callback(self, request): """ Called from the Service when the user accept to activate it """ kwargs = {'access_token': '', 'service': 'ServiceReadability', 'return': 'readability'} return super(ServiceReadability, self).callback(request, **kwargs)
class ReaderClientMultipleBookmarkTest(unittest.TestCase): """ Tests for bookmark functionality """ def setUp(self): """ Add a few bookmarks. """ token_key, token_secret = xauth() self.reader_client = ReaderClient(token_key=token_key, token_secret=token_secret) self.urls = [ 'http://www.theatlantic.com/technology/archive/2013/01/the-never-before-told-story-of-the-worlds-first-computer-art-its-a-sexy-dame/267439/', 'http://www.theatlantic.com/business/archive/2013/01/why-smart-poor-students-dont-apply-to-selective-colleges-and-how-to-fix-it/272490/', ] self.favorite_urls = [ 'http://www.theatlantic.com/sexes/archive/2013/01/the-lonely-existence-of-mel-feit-mens-rights-advocate/267413/', 'http://www.theatlantic.com/technology/archive/2013/01/women-in-combat-an-idea-whose-time-has-come-aided-by-technology/272483/' ] self.archive_urls = [ 'http://www.theatlantic.com/business/archive/2013/01/what-economics-can-and-cant-tell-us-about-the-legacy-of-legal-abortion/267459/', 'http://www.theatlantic.com/business/archive/2013/01/5-ways-to-understand-just-how-absurd-spains-26-unemployment-rate-is/272502/' ] self.all_urls = self.urls + self.favorite_urls + self.archive_urls for url in self.urls: response = self.reader_client.add_bookmark(url) self.assertTrue(response.status_code in [201, 202]) for url in self.favorite_urls: response = self.reader_client.add_bookmark(url, favorite=True) self.assertTrue(response.status_code in [201, 202]) for url in self.archive_urls: response = self.reader_client.add_bookmark(url, archive=True) self.assertTrue(response.status_code in [201, 202]) def test_get_bookmarks(self): """ Test getting all bookmarks """ response = self.reader_client.get_bookmarks() self.assertEqual(response.status_code, 200) self.assertEqual( len(response.json()['bookmarks']), len(self.all_urls)) # test favorite bookmarks response = self.reader_client.get_bookmarks(favorite=True) self.assertEqual(response.status_code, 200) self.assertEqual( len(response.json()['bookmarks']), len(self.favorite_urls)) for bm in response.json()['bookmarks']: self.assertTrue(bm['article']['url'] in self.favorite_urls) # test archive bookmarks response = self.reader_client.get_bookmarks(archive=True) self.assertEqual(response.status_code, 200) self.assertEqual( len(response.json()['bookmarks']), len(self.archive_urls)) for bm in response.json()['bookmarks']: self.assertTrue(bm['article']['url'] in self.archive_urls) def tearDown(self): """ Remove all added bookmarks. """ for bm in self.reader_client.get_bookmarks().json()['bookmarks']: del_response = self.reader_client.delete_bookmark(bm['id']) self.assertEqual(del_response.status_code, 204)
class ReaderClientSingleBookmarkTest(unittest.TestCase): """ Tests that only need one bookmark """ def setUp(self): """ Get a client and add a bookmark """ token_key, token_secret = xauth() self.reader_client = ReaderClient(token_key=token_key, token_secret=token_secret) self.url = 'http://www.theatlantic.com/technology/archive/2013/01/the-never-before-told-story-of-the-worlds-first-computer-art-its-a-sexy-dame/267439/' add_response = self.reader_client.add_bookmark(self.url) self.assertTrue(add_response.status_code in [201, 202]) def tearDown(self): """ Remove all added bookmarks. """ for bm in self.reader_client.get_bookmarks().json()['bookmarks']: del_response = self.reader_client.delete_bookmark(bm['id']) self.assertEqual(del_response.status_code, 204) def test_get_bookmark(self): """ Test getting one bookmark by id """ bookmark_id = self._get_bookmark_data()['id'] bm_response = self.reader_client.get_bookmark(bookmark_id) self.assertEqual(bm_response.status_code, 200) some_expected_keys = set(['article', 'user_id', 'favorite', 'id']) received_keys = set(bm_response.json().keys()) self.assertTrue(some_expected_keys.issubset(received_keys)) def test_bookmark_tag_functionality(self): """ Test adding, fetching and deleting tags on a bookmark. """ bookmark_id = self._get_bookmark_data()['id'] # test getting empty tags tag_response = self.reader_client.get_bookmark_tags(bookmark_id) self.assertEqual(tag_response.status_code, 200) self.assertEqual(len(tag_response.json()['tags']), 0) # test adding tags tags = ['tag', 'another tag'] tag_string = ', '.join(tags) tag_add_response = \ self.reader_client.add_tags_to_bookmark(bookmark_id, tag_string) self.assertEqual(tag_add_response.status_code, 202) # re-fetch tags. should have 2 retag_response = self.reader_client.get_bookmark_tags(bookmark_id) self.assertEqual(retag_response.status_code, 200) self.assertEqual(len(retag_response.json()['tags']), 2) for tag in retag_response.json()['tags']: self.assertTrue(tag['text'] in tags) # test getting tags for user user_tag_resp = self.reader_client.get_tags() self.assertEqual(user_tag_resp.status_code, 200) self.assertEqual(len(user_tag_resp.json()['tags']), 2) for tag in user_tag_resp.json()['tags']: self.assertTrue(tag['text'] in tags) # test getting a single tag while we're here single_tag_resp = self.reader_client.get_tag(tag['id']) self.assertEqual(single_tag_resp.status_code, 200) self.assertTrue('applied_count' in single_tag_resp.json()) self.assertTrue('id' in single_tag_resp.json()) self.assertTrue('text' in single_tag_resp.json()) # delete tags for tag in retag_response.json()['tags']: del_response = self.reader_client.delete_tag_from_bookmark( bookmark_id, tag['id']) self.assertEqual(del_response.status_code, 204) # check that tags are gone tag_response = self.reader_client.get_bookmark_tags(bookmark_id) self.assertEqual(tag_response.status_code, 200) self.assertEqual(len(tag_response.json()['tags']), 0) def _get_bookmark_data(self): """ Convenience method to get a single bookmark's data. """ bm_response = self.reader_client.get_bookmarks() self.assertEqual(bm_response.status_code, 200) bm_response_json = bm_response.json() self.assertTrue(len(bm_response_json['bookmarks']) > 0) return bm_response_json['bookmarks'][0]
class ReaderClientSingleBookmarkTest(TestCase): """Tests that only need one bookmark """ def setUp(self): """Get a client and add a bookmark """ token_pair = xauth(CONSUMER_KEY, CONSUMER_SECRET, USERNAME, PASSWORD) self.token_key = token_pair[0] self.token_secret = token_pair[1] self.base_client = ReaderClient(CONSUMER_KEY, CONSUMER_SECRET, self.token_key, self.token_secret) self.url = 'http://www.theatlantic.com/technology/archive/2013/01/the-never-before-told-story-of-the-worlds-first-computer-art-its-a-sexy-dame/267439/' add_response = self.base_client.add_bookmark(self.url) self.assertEqual(add_response.status, 202) def tearDown(self): """Remove all added bookmarks. """ for bm in self.base_client.get_bookmarks().content['bookmarks']: del_response = self.base_client.delete_bookmark(bm['id']) self.assertEqual(del_response.status, 204) def test_get_bookmark(self): """Test getting one bookmark by id """ # get a bookmark id bm_response = self.base_client.get_bookmarks() self.assertEqual(bm_response.status, 200) self.assertTrue(len(bm_response.content['bookmarks']) > 0) bookmark_id = bm_response.content['bookmarks'][0]['id'] bm_response = self.base_client.get_bookmark(bookmark_id) self.assertEqual(bm_response.status, 200) some_expected_keys = set(['article', 'user_id', 'favorite', 'id']) received_keys = set(bm_response.content.keys()) self.assertTrue(some_expected_keys.issubset(received_keys)) def test_bookmark_tag_functionality(self): """Test adding, fetching and deleting tags on a bookmark. """ # get a bookmark id bm_response = self.base_client.get_bookmarks() self.assertEqual(bm_response.status, 200) self.assertTrue(len(bm_response.content['bookmarks']) > 0) bookmark_id = bm_response.content['bookmarks'][0]['id'] # test getting empty tags tag_response = self.base_client.get_bookmark_tags(bookmark_id) self.assertEqual(tag_response.status, 200) self.assertEqual(len(tag_response.content['tags']), 0) # test adding tags tags = ['tag', 'another tag'] tag_string = ', '.join(tags) tag_add_response = \ self.base_client.add_tags_to_bookmark(bookmark_id, tag_string) self.assertEqual(tag_add_response.status, 202) # re-fetch tags. should have 2 retag_response = self.base_client.get_bookmark_tags(bookmark_id) self.assertEqual(retag_response.status, 200) self.assertEqual(len(retag_response.content['tags']), 2) for tag in retag_response.content['tags']: self.assertTrue(tag['text'] in tags) # test getting tags for user user_tag_resp = self.base_client.get_tags() self.assertEqual(user_tag_resp.status, 200) self.assertEqual(len(user_tag_resp.content['tags']), 2) for tag in user_tag_resp.content['tags']: self.assertTrue(tag['text'] in tags) # test getting a single tag while we're here single_tag_resp = self.base_client.get_tag(tag['id']) self.assertEqual(single_tag_resp.status, 200) self.assertTrue('applied_count' in single_tag_resp.content) self.assertTrue('id' in single_tag_resp.content) self.assertTrue('text' in single_tag_resp.content) # delete tags for tag in retag_response.content['tags']: del_response = self.base_client.delete_tag_from_bookmark( bookmark_id, tag['id']) self.assertEqual(del_response.status, 204) # check that tags are gone tag_response = self.base_client.get_bookmark_tags(bookmark_id) self.assertEqual(tag_response.status, 200) self.assertEqual(len(tag_response.content['tags']), 0)
class ReaderClientMultipleBookmarkTest(TestCase): """Tests for bookmark functionality """ def setUp(self): """Add a few bookmarks. """ token_pair = xauth(CONSUMER_KEY, CONSUMER_SECRET, USERNAME, PASSWORD) self.token_key = token_pair[0] self.token_secret = token_pair[1] self.base_client = ReaderClient(CONSUMER_KEY, CONSUMER_SECRET, self.token_key, self.token_secret) self.urls = [ 'http://www.theatlantic.com/technology/archive/2013/01/the-never-before-told-story-of-the-worlds-first-computer-art-its-a-sexy-dame/267439/', 'http://www.theatlantic.com/business/archive/2013/01/why-smart-poor-students-dont-apply-to-selective-colleges-and-how-to-fix-it/272490/', ] self.favorite_urls = [ 'http://www.theatlantic.com/sexes/archive/2013/01/the-lonely-existence-of-mel-feit-mens-rights-advocate/267413/', 'http://www.theatlantic.com/technology/archive/2013/01/women-in-combat-an-idea-whose-time-has-come-aided-by-technology/272483/' ] self.archive_urls = [ 'http://www.theatlantic.com/business/archive/2013/01/what-economics-can-and-cant-tell-us-about-the-legacy-of-legal-abortion/267459/', 'http://www.theatlantic.com/business/archive/2013/01/5-ways-to-understand-just-how-absurd-spains-26-unemployment-rate-is/272502/' ] self.all_urls = self.urls + self.favorite_urls + self.archive_urls for url in self.urls: add_response = self.base_client.add_bookmark(url) self.assertEqual(add_response.status, 202) for url in self.favorite_urls: add_response = self.base_client.add_bookmark(url, favorite=True) self.assertEqual(add_response.status, 202) for url in self.archive_urls: add_response = self.base_client.add_bookmark(url, archive=True) self.assertEqual(add_response.status, 202) def test_get_bookmarks(self): """Test getting all bookmarks """ bm_response = self.base_client.get_bookmarks() self.assertEqual(bm_response.status, 200) self.assertEqual(len(bm_response.content['bookmarks']), len(self.all_urls)) # test favorite bookmarks bm_response = self.base_client.get_bookmarks(favorite=True) self.assertEqual(bm_response.status, 200) self.assertEqual(len(bm_response.content['bookmarks']), len(self.favorite_urls)) for bm in bm_response.content['bookmarks']: self.assertTrue(bm['article']['url'] in self.favorite_urls) # test archive bookmarks bm_response = self.base_client.get_bookmarks(archive=True) self.assertEqual(bm_response.status, 200) self.assertEqual(len(bm_response.content['bookmarks']), len(self.archive_urls)) for bm in bm_response.content['bookmarks']: self.assertTrue(bm['article']['url'] in self.archive_urls) def tearDown(self): """Remove all added bookmarks. """ for bm in self.base_client.get_bookmarks().content['bookmarks']: del_response = self.base_client.delete_bookmark(bm['id']) self.assertEqual(del_response.status, 204)
class ServiceReadability(ServicesMgr): def __init__(self, token=None): base = 'https://www.readability.com' self.AUTH_URL = '{}/api/rest/v1/oauth/authorize/'.format(base) self.REQ_TOKEN = '{}/api/rest/v1/oauth/request_token/'.format(base) self.ACC_TOKEN = '{}/api/rest/v1/oauth/access_token/'.format(base) self.consumer_key = settings.TH_READABILITY['consumer_key'] self.consumer_secret = settings.TH_READABILITY['consumer_secret'] self.token = token if token: token_key, token_secret = self.token.split('#TH#') self.client = ReaderClient(token_key, token_secret, self.consumer_key, self.consumer_secret) def read_data(self, **kwargs): """ get the data from the service :param kwargs: contain keyword args : trigger_id at least :type kwargs: dict :rtype: list """ date_triggered = kwargs['date_triggered'] trigger_id = kwargs['trigger_id'] data = [] if self.token is not None: bookmarks = self.client.get_bookmarks( added_since=date_triggered).content for bookmark in bookmarks.values(): for b in bookmark: if 'article' in b: title = '' if 'title' in b['article']: title = b['article']['title'] link = '' if 'url' in b['article']: link = b['article']['url'] content = '' if 'excerpt' in b['article']: content = b['article']['excerpt'] data.append({ 'title': title, 'link': link, 'content': content }) cache.set('th_readability_' + str(trigger_id), data) return data def process_data(self, **kwargs): """ get the data from the cache :param kwargs: contain keyword args : trigger_id at least :type kwargs: dict """ kw = { 'cache_stack': 'th_readability', 'trigger_id': str(kwargs['trigger_id']) } return super(ServiceReadability, self).process_data(**kw) def save_data(self, trigger_id, **data): """ let's save the data :param trigger_id: trigger ID from which to save data :param data: the data to check to be used and save :type trigger_id: int :type data: dict :return: the status of the save statement :rtype: boolean """ status = False if self.token and 'link' in data and\ data['link'] is not None and\ len(data['link']) > 0: # get the data of this trigger trigger = Readability.objects.get(trigger_id=trigger_id) bookmark_id = self.client.add_bookmark(url=data['link']) if trigger.tag is not None and len(trigger.tag) > 0: try: self.client.add_tags_to_bookmark( bookmark_id, tags=(trigger.tag.lower())) sentence = str('readability {} created item id {}').format( data['link'], bookmark_id) logger.debug(sentence) status = True except Exception as e: logger.critical(e) status = False else: sentence = "no token or link provided for trigger ID {} " logger.critical(sentence.format(trigger_id)) status = False return status def auth(self, request): """ let's auth the user to the Service """ request_token = super(ServiceReadability, self).auth(request) callback_url = self.callback_url(request, 'readability') # URL to redirect user to, to authorize your app auth_url_str = '%s?oauth_token=%s&oauth_callback=%s' auth_url = auth_url_str % (self.AUTH_URL, request_token['oauth_token'], callback_url) return auth_url def callback(self, request): """ Called from the Service when the user accept to activate it """ kwargs = { 'access_token': '', 'service': 'ServiceReadability', 'return': 'readability' } return super(ServiceReadability, self).callback(request, **kwargs)
class ServiceReadability(ServicesMgr): def __init__(self, token=None): base = 'https://www.readability.com' self.AUTH_URL = '{}/api/rest/v1/oauth/authorize/'.format(base) self.REQ_TOKEN = '{}/api/rest/v1/oauth/request_token/'.format(base) self.ACC_TOKEN = '{}/api/rest/v1/oauth/access_token/'.format(base) self.consumer_key = settings.TH_READABILITY['consumer_key'] self.consumer_secret = settings.TH_READABILITY['consumer_secret'] if token: token_key, token_secret = token.split('#TH#') self.client = ReaderClient(token_key, token_secret, self.consumer_key, self.consumer_secret) def read_data(self, token, trigger_id, date_triggered): """ get the data from the service :param trigger_id: trigger ID to process :param date_triggered: the date of the last trigger :type trigger_id: int :type date_triggered: datetime :return: list of data found from the date_triggered filter :rtype: list """ data = [] if token is not None: bookmarks = self.client.get_bookmarks( added_since=date_triggered).content for bookmark in bookmarks.values(): for b in bookmark: if 'article' in b: title = '' if 'title' in b['article']: title = b['article']['title'] link = '' if 'url' in b['article']: link = b['article']['url'] content = '' if 'excerpt' in b['article']: content = b['article']['excerpt'] data.append( {'title': title, 'link': link, 'content': content}) cache.set('th_readability_' + str(trigger_id), data) return data def process_data(self, trigger_id): """ get the data from the cache :param trigger_id: trigger ID from which to save data :type trigger_id: int """ cache_data = cache.get('th_readability_' + str(trigger_id)) return PublishingLimit.get_data('th_readability_', cache_data, trigger_id) def save_data(self, token, trigger_id, **data): """ let's save the data :param trigger_id: trigger ID from which to save data :param **data: the data to check to be used and save :type trigger_id: int :type **data: dict :return: the status of the save statement :rtype: boolean """ status = False if token and 'link' in data and\ data['link'] is not None and\ len(data['link']) > 0: # get the data of this trigger trigger = Readability.objects.get(trigger_id=trigger_id) bookmark_id = self.client.add_bookmark(url=data['link']) if trigger.tag is not None and len(trigger.tag) > 0: try: self.client.add_tags_to_bookmark( bookmark_id, tags=(trigger.tag.lower())) sentence = str('readability {} created item id {}').format( data['link'], bookmark_id) logger.debug(sentence) status = True except Exception as e: logger.critical(e) status = False else: sentence = "no token or link provided for trigger ID {} " logger.critical(sentence.format(trigger_id)) status = False return status def auth(self, request): """ let's auth the user to the Service """ callback_url = 'http://%s%s' % ( request.get_host(), reverse('readability_callback')) request_token = self.get_request_token() # Save the request token information for later request.session['oauth_token'] = request_token['oauth_token'] request.session['oauth_token_secret'] = request_token[ 'oauth_token_secret'] # URL to redirect user to, to authorize your app auth_url_str = '%s?oauth_token=%s&oauth_callback=%s' auth_url = auth_url_str % (self.AUTH_URL, request_token['oauth_token'], callback_url) return auth_url def callback(self, request): """ Called from the Service when the user accept to activate it """ try: # finally we save the user auth token # As we already stored the object ServicesActivated # from the UserServiceCreateView now we update the same # object to the database so : # 1) we get the previous objet us = UserService.objects.get( user=request.user, name=ServicesActivated.objects.get(name='ServiceReadability')) # 2) Readability API require to use 4 parms consumer_key/secret + # token_key/secret instead of usually get just the token # from an access_token request. So we need to add a string # seperator for later use to slpit on this one access_token = self.get_access_token( request.session['oauth_token'], request.session['oauth_token_secret'], request.GET.get('oauth_verifier', '') ) us.token = access_token.get('oauth_token') + \ '#TH#' + access_token.get('oauth_token_secret') # 3) and save everything us.save() except KeyError: return '/' return 'readability/callback.html' def get_request_token(self): oauth = OAuth1Session(self.consumer_key, client_secret=self.consumer_secret) return oauth.fetch_request_token(self.REQ_TOKEN) def get_access_token(self, oauth_token, oauth_token_secret, oauth_verifier): # Using OAuth1Session oauth = OAuth1Session(self.consumer_key, client_secret=self.consumer_secret, resource_owner_key=oauth_token, resource_owner_secret=oauth_token_secret, verifier=oauth_verifier) oauth_tokens = oauth.fetch_access_token(self.ACC_TOKEN) return oauth_tokens