Pocket.recipe

#!/usr/bin/env python2
# vim:ft=python tabstop=8 expandtab shiftwidth=4 softtabstop=4
from calibre.constants import config_dir
from calibre.utils.config import JSONConfig
from calibre.web.feeds.news import BasicNewsRecipe
from collections import namedtuple
from os import path
from time import localtime, strftime, time

import errno
import json
import mechanize
import operator

try:
    from urllib.error import HTTPError
except ImportError:
    from urllib2 import HTTPError

__license__ = 'GPL v3'
__copyright__ = '2019, David Orchard'

class PocketConfig:
    __file_path = path.join(config_dir, 'custom_recipes', 'Pocket.json')

    class AuthState:
        FirstRun = 1
        Authorizing = 2
        Authorized = 3

    def __init__(self, state = AuthState.FirstRun, token = None, user = None):
        # Default values
        self.state = state
        self.token = token
        self.user = user

    @staticmethod
    def from_file():
        config = PocketConfig()
        config.load()
        return config

    def load(self):
        try:
            with open(self.__file_path) as config:
                config = json.load(config)

            if isinstance(config, dict):
                for key in self.__dict__.keys():
                    if config[key]:
                        setattr(self, key, config[key])
        except IOError as e:
            # File not found
            if e.errno != errno.ENOENT:
               raise e

    def save(self):
        with open(self.__file_path, 'w') as config:
            json.dump(self.__dict__, config)

class Pocket(BasicNewsRecipe):
    config = PocketConfig.from_file()

    title = strftime('Pocket [%a, %d %b %Y]', localtime())
    __author__ = 'David Orchard'
    description = '''
        Fetches articles saved with <a href="https://getpocket.com/">Pocket</a> and archives them.<br>
    ''' + ('''
        Click <a href="https://getpocket.com/connected_applications">here</a>
        to disconnect Calibre from the Pocket account "{}".
    '''.format(config.user) if config.user else '''
        Run 'Fetch News' with this source scheduled to initiate authentication with Pocket.
    ''')
    publisher = 'Pocket.com'
    category = 'info, custom, Pocket'

    # User-configurable settings
    oldest_article = 7
    max_articles_per_feed = 100
    archive_downloaded = True
    series_name = 'Pocket'

    # Inherited developer settings
    auto_cleanup = True
    no_stylesheets = True
    use_embedded_content = False
    ignore_duplicate_articles = {'url'}

    # Custom developer settings
    consumer_key = '87006-2ecad30a91903f54baf0ee05'
    redirect_uri = 'https://calibre-ebook.com/'
    base_url = 'https://app.getpocket.com'
    to_archive = []

    def first_run(self):
        request = mechanize.Request("https://getpocket.com/v3/oauth/request",
                (u'{{'
                    '"consumer_key":"{0}",'
                    '"redirect_uri":"{1}"'
                '}}').format(
                    self.consumer_key,
                    self.redirect_uri
                ),
                headers = {
                    'Content-Type': 'application/json; charset=UTF8',
                    'X-Accept': 'application/json'
                }
            )
        response = self.browser.open(request)
        response = json.load(response)
        self.config = PocketConfig(
                state = PocketConfig.AuthState.Authorizing,
                token = response['code']
        )

    def authorize(self):
        assert self.config.state == PocketConfig.AuthState.Authorizing, "Authorization process not yet begun"
        assert self.config.token, "No request token"
        request = mechanize.Request("https://getpocket.com/v3/oauth/authorize",
                (u'{{'
                    '"consumer_key":"{0}",'
                    '"code":"{1}"'
                '}}').format(
                    self.consumer_key,
                    self.config.token
                ),
                headers = {
                    'Content-Type': 'application/json; charset=UTF8',
                    'X-Accept': 'application/json'
                }
            )
        try:
            response = self.browser.open(request)
            response = json.load(response)
            self.config = PocketConfig(
                    state = PocketConfig.AuthState.Authorized,
                    token = response["access_token"],
                    user = response["username"],
            )
        except HTTPError as e:
            if e.code == 403:
                # The code has already been used, or the user denied access
                self.reauthorize()
            raise e

    def parse_index(self):
        assert self.config.state == PocketConfig.AuthState.Authorized, "Not yet authorized"
        assert self.config.token, "No access token"
        request = mechanize.Request("https://getpocket.com/v3/get",
                (u'{{'
                    '"consumer_key":"{0}",'
                    '"access_token":"{1}",'
                    '"count":"{2}",'
                    '"since":"{3}",'
                    '"state":"unread",'
                    '"detailType":"complete",'
                    '"sort":"newest"'
                '}}').format(
                    self.consumer_key,
                    self.config.token,
                    self.max_articles_per_feed,
                    int(time()) - 86400 * self.oldest_article
                ),
                headers = {
                    'Content-Type': 'application/json; charset=UTF8',
                    'X-Accept': 'application/json'
                }
            )

        try:
            response = self.browser.open(request)
            response = json.load(response)
        except HTTPError as e:
            if e.code == 401:
                # Calibre access has been removed
                self.reauthorize()
            raise e

        if not response['list']:
            self.abort_recipe_processing('No unread articles in the Pocket account "{}"'.format(self.config.user))

        if self.archive_downloaded and response['list']:
            self.to_archive = [item['item_id'] for item in response['list'].values()]

        return [('Unread', [
            {
                'title': item['resolved_title'],
                'url': item['resolved_url'],
                'date': item['time_added'],
                'description': item['excerpt'],
            }
            for item in sorted(response['list'].values(), key = lambda x: x['sort_id'])
        ] if response['list'] else [])]

    def reauthorize(self):
        self.config = PocketConfig();
        self.ensure_authorization()

    def ensure_authorization(self):
        if self.config.state is PocketConfig.AuthState.FirstRun:
            self.first_run()
            self.config.save()
            self.abort_recipe_processing('''
                Calibre must be granted access to your Pocket account. Please click
                <a href="https://getpocket.com/auth/authorize?request_token={0}&redirect_uri={1}">here</a>
                to authenticate via a browser, and then re-fetch the news.
            '''.format(self.config.token, self.redirect_uri))
        elif self.config.state is PocketConfig.AuthState.Authorizing:
            self.authorize()
            self.config.save()

    def get_browser(self, *args, **kwargs):
        self.browser = BasicNewsRecipe.get_browser(self)
        self.ensure_authorization()
        return self.browser

    def archive(self):
        assert self.config.state == PocketConfig.AuthState.Authorized, "Not yet authorized"
        assert self.config.token, "No access token"

        if not self.to_archive:
            return

        archived_time = int(time())
        request = mechanize.Request("https://getpocket.com/v3/send",
                (u'{{'
                    '"consumer_key":"{0}",'
                    '"access_token":"{1}",'
                    '"actions":{2}'
                '}}').format(
                    self.consumer_key,
                    self.config.token,
                    json.dumps([{
                        'action': 'archive',
                        'item_id': item_id,
                        'time': archived_time,
                    } for item_id in self.to_archive])
                ),
                headers = {
                    'Content-Type': 'application/json; charset=UTF8',
                    'X-Accept': 'application/json'
                }
            )
        response = self.browser.open(request)

    def cleanup(self):
        # If we're in another state, then downloading didn't complete
        # (e.g. reauthorization needed) so there is no archiving to do
        if self.config.state == PocketConfig.AuthState.Authorized:
            self.archive()

    # TODO: This works with EPUB, but not mobi/azw3
    # BUG: https://bugs.launchpad.net/calibre/+bug/1838486
    def postprocess_book(self, oeb, opts, log):
        oeb.metadata.add('series', self.series_name)