def archive_item(item_id):
access_token = WF.get_password('pocket_access_token')
pocket_instance = Pocket(config.CONSUMER_KEY, access_token)
try:
pocket_instance.archive(item_id, wait=False)
return 'Link archived'
except PocketException:
return 'Connection error'
def archive_item(item_id):
access_token = wf.get_password('pocket_access_token')
pocket_instance = Pocket(config.CONSUMER_KEY, access_token)
try:
pocket_instance.archive(item_id, wait=False)
return 'Link archived'
except Exception:
return 'Connection error'
class PocketApp:
DEFAULT_WORDS_PER_MINUTE = 180
REDIRECT_URL = 'http://www.google.com'
def __init__(self):
self._configs = Configs()
self._storage = Storage()
self._pocket = Pocket(self._configs.get('consumer_key'),
self._configs.get('access_token'))
def configure(self, consumer_key, access_token, words_per_minute,
sort_field):
self._configs.set('consumer_key', consumer_key)
self._configs.set('access_token', access_token)
self._configs.set('words_per_minute', words_per_minute)
self._configs.set('sort_field', sort_field)
self._configs.set('last_fetch', 0)
self._configs.write()
self._storage.clear()
self._pocket = Pocket(consumer_key, access_token)
def init_consumer_key(self, consumer_key):
self._pocket = Pocket(consumer_key)
def get_request_token(self):
return self._pocket.get_request_token(self.REDIRECT_URL)
def get_access_token(self, request_token):
return self._pocket.get_access_token(request_token)
def add_article(self, url, title=None, tags=None):
if isinstance(tags, tuple):
tags = ','.join(list(tags))
try:
return self._pocket.add(url, title, tags)
except PocketException as e:
raise_from(self._check_exception(e), e)
def get_articles(self, limit=None, order=None):
if self._storage.is_empty():
self.fetch_articles(True)
articles = self._storage.read(limit, order)
sort_field = self._configs.get('sort_field')
if not sort_field:
sort_field = 'reading_time'
articles = sorted(articles, key=itemgetter(sort_field))
return articles
def search(self, search, state, tag, sort):
try:
# search_state = self._configs.get('search_state')
# if search_state and not state:
# state = search_state
articles = self._pocket.retrieve(search=search,
state=state,
tag=tag,
sort=sort)
return self._get_articles_index(articles)
except PocketException as e:
raise_from(self._check_exception(e), e)
def archive_article(self, item_id):
try:
self._pocket.archive(int(item_id)).commit()
except PocketException as e:
raise_from(self._check_exception(e), e)
def find_article(self, item_id):
index = self._storage.read()
for article in index:
if str(article['id']) == str(item_id):
return article
return None
def fetch_articles(self, output_progress=False):
spinner = None
if output_progress:
spinner = Spinner('Loading articles ')
articles_index = []
last_fetch = self._configs.get('last_fetch')
offset = 0
count = 20
while (True):
try:
articles = self._pocket.retrieve(state='unread',
count=count,
offset=offset,
since=last_fetch)
except PocketException as e:
spinner.finish()
raise_from(self._check_exception(e), e)
if not articles['list']:
break
articles_index.extend(self._get_articles_index(articles))
offset += count
if spinner:
spinner.next()
if spinner:
spinner.finish()
sort_field = self._configs.get('sort_field')
if not sort_field:
sort_field = 'reading_time'
articles_index = sorted(articles_index, key=itemgetter(sort_field))
self._storage.write(articles_index)
self._configs.set('last_fetch', self._get_timestamp(datetime.now()))
self._configs.write()
def _get_articles_index(self, articles):
wpm = self._configs.get('words_per_minute')
if not wpm:
wpm = self.DEFAULT_WORDS_PER_MINUTE
wpm = int(wpm)
articles_index = []
articles_list = articles['list']
if isinstance(articles_list, list) and len(articles_list) == 0:
return articles_index
for article in articles_list.values():
word_count = int(article.get('word_count', 0))
if word_count == 0:
reading_time = -1
else:
reading_time = int(math.ceil(word_count / wpm))
title = article.get('resolved_title', None)
if not title:
title = article['given_title']
url = article.get('resolved_url', None)
if not url:
url = article['given_url']
index = {
'id': article['item_id'],
'title': title,
'url': url,
'word_count': word_count,
'reading_time': reading_time
}
articles_index.append(index)
return articles_index
def _get_timestamp(self, date):
return int(time.mktime(date.timetuple()))
def _check_exception(self, e):
if isinstance(e, PocketAutException):
raise AppNotConfigured('Application is not configured')
raise AppException(e.message)
class PocketHelper:
__metaclass__ = Singleton
def __init__(self):
self.p = Pocket(consumer_key=Config.POCKET_CONSUMER_KEY,access_token=Config.POCKET_ACCESS_TOKEN)
def run_spotify(self,item,url,function_to_run, key):
if 'spotify' in url.lower():
logger.info(u'Getting url for {} from Pocket'.format(item['resolved_title']))
flag = False
strict = False
collect_skipped = False
delete = False
if 'tags' in item:
if 'sort' in item['tags']:
flag = True
if 'strict' in item['tags']:
strict = True
if 'collect' in item['tags']:
collect_skipped = True
if 'delete' in item['tags']:
delete = True
logger.info('url: {}, sort: {}, strict: {}, collect: {}, delete: {}'.format(url,flag, strict, collect_skipped, delete))
if delete:
self.delete_playlist_mark_read(playlist_url=url,key=key)
else:
function_to_run(url,flag,strict, collect_skipped)
def run_youtube(self,item,url,function_to_run, key):
if 'youtube' in url.lower():
logger.info(u'Getting url for {} from Pocket'.format(item['resolved_title']))
limit = None
strict = False
collect_skipped = False
delete = False
if 'tags' in item:
if any(key.startswith('recent') for key in item['tags']):
for key in item['tags'].keys():
if key.startswith('recent'):
limit = int(key.split('recent')[-1])
if key.startswith('strict'):
strict = True
if key.startswith('collect'):
collect_skipped = True
if key.startswith('delete'):
delete = True
logger.debug('url: {}, limit: {}, strict: {}, collect: {}, delete: {}'.format(url,limit, strict, collect_skipped, delete))
if delete:
self.delete_playlist_mark_read(playlist_url=url,limit=limit,key=key)
else:
function_to_run(url,limit,strict, collect_skipped)
def delete_playlist_mark_read(self, playlist_url,key,limit=None):
if 'youtube' in playlist_url:
youtube=Youtube()
playlist_name, playlist_desc, playlist_id = youtube.get_playlist_id_name_description(playlist_url, limit)
elif 'spotify' in playlist_url:
spotify = Spotify()
playlist_name, playlist_desc, tracks = spotify.get_playlist_name_desc_tracks(playlist_url)
gmusic = GoogleMusic()
gmusic.delete_playlist_if_exists(playlist_name)
self.p.archive(key)
self.p.commit()
def scan_items(self,function_to_run, youtube=False, spotify=False):
if (youtube is None) and (spotify is None):
raise ValueError('Either Youtube flag or Spotify Flag should be given')
logger.info('Scanning Pocket........')
items=self.p.retrieve(state='unread', detailType='complete')
for key in items['list'].keys():
item = items['list'][key]
url = item['given_url']
if spotify:
self.run_spotify(function_to_run=function_to_run, item=item, url=url, key=key)
if youtube:
self.run_youtube(function_to_run=function_to_run, item=item, url=url,key=key)
logger.info('Scanning Pocket completed')
class PocketApp:
DEFAULT_WORDS_PER_MINUTE = 180
REDIRECT_URL = 'http://www.google.com'
def __init__(self):
self._configs = Configs()
self._storage = Storage()
self._pocket = Pocket(
self._configs.get('consumer_key'),
self._configs.get('access_token')
)
def configure(self, consumer_key, access_token,
words_per_minute, sort_field):
self._configs.set('consumer_key', consumer_key)
self._configs.set('access_token', access_token)
self._configs.set('words_per_minute', words_per_minute)
self._configs.set('sort_field', sort_field)
self._configs.set('last_fetch', 0)
self._configs.write()
self._storage.clear()
def get_request_token(self, consumer_key):
return self._pocket.get_request_token(
consumer_key, self.REDIRECT_URL
)
def get_access_token(self, consumer_key, request_token):
return self._pocket.get_access_token(
consumer_key, request_token
)
def add_article(self, url, title=None, tags=None):
if isinstance(tags, tuple):
tags = ','.join(list(tags))
try:
return self._pocket.add(url, title, tags)
except PocketException as e:
raise_from(self._check_exception(e), e)
def get_articles(self, limit=None, order=None):
if self._storage.is_empty():
self.fetch_articles(True)
articles = self._storage.read(limit, order)
sort_field = self._configs.get('sort_field')
if not sort_field:
sort_field = 'reading_time'
articles = sorted(articles,
key=itemgetter(sort_field))
return articles
def search(self, search, state, tag, sort):
try:
articles = self._pocket.retrieve(search=search,
state=state,
tag=tag,
sort=sort)
return self._get_articles_index(articles)
except PocketException as e:
raise_from(self._check_exception(e), e)
def archive_article(self, item_id):
try:
self._pocket.archive(int(item_id)).commit()
except PocketException as e:
raise_from(self._check_exception(e), e)
def find_article(self, item_id):
index = self._storage.read()
for article in index:
if str(article['id']) == str(item_id):
return article
return None
def fetch_articles(self, output_progress=False):
spinner = None
if output_progress:
spinner = Spinner('Loading articles ')
articles_index = []
last_fetch = self._configs.get('last_fetch')
offset = 0
count = 20
while(True):
try:
articles = self._pocket.retrieve(
state='unread',
count=count,
offset=offset,
since=last_fetch
)
except PocketException as e:
spinner.finish()
raise_from(self._check_exception(e), e)
if not articles['list']:
break
articles_index.extend(self._get_articles_index(articles))
offset += count
if spinner:
spinner.next()
if spinner:
spinner.finish()
sort_field = self._configs.get('sort_field')
if not sort_field:
sort_field = 'reading_time'
articles_index = sorted(articles_index,
key=itemgetter(sort_field))
self._storage.write(articles_index)
self._configs.set('last_fetch', self._get_timestamp(datetime.now()))
self._configs.write()
def _get_articles_index(self, articles):
wpm = self._configs.get('words_per_minute')
if not wpm:
wpm = self.DEFAULT_WORDS_PER_MINUTE
wpm = int(wpm)
articles_index = []
articles_list = articles['list']
if isinstance(articles_list, list) and len(articles_list) == 0:
return articles_index
for article in articles_list.values():
word_count = int(article['word_count'])
if word_count == 0:
reading_time = -1
else:
reading_time = math.ceil(word_count / wpm)
title = article['resolved_title']
if not title:
title = article['given_title']
url = article['resolved_url']
if not url:
url = article['given_url']
index = {
'id': article['item_id'],
'title': title,
'url': url,
'word_count': article['word_count'],
'reading_time': reading_time
}
articles_index.append(index)
return articles_index
def _get_timestamp(self, date):
return int(time.mktime(date.timetuple()))
def _check_exception(self, e):
if isinstance(e, PocketAutException):
raise AppNotConfigured('Application is not configured')
raise AppException(e.message)
