Python pocket.Pocket类代码示例

 def dispatch(self, request, *args, **kwargs):
     if not request.session.get('access_token'):
         request_token = Pocket.get_request_token(consumer_key=settings.CONSUMER_KEY)
         request.session['request_token'] = request_token
         auth_url = Pocket.get_auth_url(code=request_token, redirect_uri='http://localhost:8000/token')
         return HttpResponseRedirect(auth_url)
     return super(HomeView, self).dispatch(request, *args, **kwargs)

    def get_client(self):
        """
        Connects to Pocket API using OAuth
        """
        request_token = pckt.get_request_token(
            consumer_key=self.consumer_key,
            redirect_uri=self.REDIRECT_URI
        )
        log.debug(request_token)

        # URL to redirect user to, to authorize your app
        auth_url = pckt.get_auth_url(
            code=request_token,
            redirect_uri=self.REDIRECT_URI
        )
        log.debug(auth_url)

        # only needed to authorize your app the first time
        #request_token2 = input('request token: ')

        if not self.access_token:
            self.access_token = pckt.get_access_token(
                consumer_key=self.consumer_key, code=request_token)
            log.debug(self.access_token)

        return pckt(
            consumer_key=self.consumer_key,
            access_token=self.access_token)

def delete_item(item_id):
    access_token = wf.get_password('pocket_access_token')
    pocket_instance = Pocket(CONSUMER_KEY, access_token)
    try:
        pocket_instance.delete(item_id, wait=False)
        return 'Link deleted'
    except ConnectionError:
        return 'Connection error'

def get_request_token():
    consumer_key = get_consumer_key()
    request_token = Pocket.get_request_token(consumer_key = consumer_key)
    auth_url = Pocket.get_auth_url(code=request_token)
    os.system('open "{0}"'.format(auth_url))
    time.sleep(5)

    return request_token

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 form_valid(self, form):
     pocket_instance = Pocket(settings.CONSUMER_KEY, self.request.session['access_token'])
     file = self.request.FILES['file']
     for url in file.readlines():
         pocket_instance.add(url.decode().rstrip())
         # pocket_instance.bulk_add(item_id='', url=url.decode().rstrip())
     # pocket_instance.commit()
     return super(HomeView, self).form_valid(form)

def connect_to_pocket(request):
    redirect_uri = request.build_absolute_uri(reverse('feed_pocket_success'))
    request_token = Pocket.get_request_token(
        consumer_key=settings.POCKET_CONSUMER_KEY,
        redirect_uri=redirect_uri)
    auth_url = Pocket.get_auth_url(code=request_token,
                                   redirect_uri=redirect_uri)
    request.user.profile.pocket_request_token = request_token
    request.user.profile.save()
    return HttpResponseRedirect(auth_url)

def push_to_pocket(link_id):
    link = Document.find_one({'user': g.user._id, '_id': ObjectId(link_id)})
    if link:
        user = User.find_one({'_id': link.user})
        pocket_instance = Pocket(POCKET_APP_TOKEN,
                                 user.credentials['pocket']['token'])
        pocket_instance.add(link.url, wait=False)
        link.read = True
        link.save()
    return "OK"

def pocket_login():
    """Calling into authorize will cause the OpenID auth machinery to kick
    in.  When all worked out as expected, the remote application will
    redirect back to the callback URL provided.
    """
    redirect_uri = url_for('pocket_authorized', _external=True)
    request_token = Pocket.get_request_token(consumer_key=POCKET_APP_TOKEN,
                                             redirect_uri=redirect_uri)
    session['request_token'] = request_token
    return redirect(Pocket.get_auth_url(code=request_token,
                                        redirect_uri=redirect_uri))

def add_item(item):
    if item is not None:
        access_token = wf.get_password('pocket_access_token')
        pocket_instance = Pocket(config.CONSUMER_KEY, access_token)
        try:
            pocket_instance.add(
                url=item['url'], title=item['title'], tags="alfred")
            return True
        except InvalidQueryException:
            pass
    return False

def auth():
    pocket = Pocket(config.POCKET_CONSUMER_KEY, config.BASE_URL +
            url_for('auth_callback'))
    try:
        code = pocket.get_request_token()
        url = pocket.get_authorize_url(code)
    except APIError as apie:
        return str(apie)
    session.pop('code', None)
    session['code'] = code
    return redirect(url)

def send_to_pocket(url):
    if mconfig:
        if 'share_settings' in mconfig:
            if 'pocket' in mconfig['share_settings']:
                pocket_config = mconfig['share_settings']['pocket']
                pc = Pocket(
                    consumer_key=pocket_config['consumer_key'],
                    access_token=pocket_config['access_token']
                )
                return pc.add( url=url )
        else:
            return {"status":0,"message":"Pocket not configured."}
    else:
        return {"status":0,"message":"No configuration file found."}

    def auth(self, request):
        """
            let's auth the user to the Service
        """
        callback_url = "http://%s%s" % (request.get_host(), reverse("pocket_callback"))

        request_token = Pocket.get_request_token(consumer_key=self.consumer_key, redirect_uri=callback_url)

        # Save the request token information for later
        request.session["request_token"] = request_token

        # URL to redirect user to, to authorize your app
        auth_url = Pocket.get_auth_url(code=request_token, redirect_uri=callback_url)

        return auth_url

def delete_item(item_id):
    access_token = WF.get_password('pocket_access_token')
    pocket_instance = Pocket(config.CONSUMER_KEY, access_token)
    try:
        pocket_instance.delete(item_id, wait=False)

        # remove entry in cache
        item_list = WF.cached_data('pocket_list', max_age=0)
        if type(item_list) is list and len(item_list) > 0:
            item_list[:] = [
                d for d in item_list if d.get('item_id') != item_id]
            WF.cache_data('pocket_list', item_list)

        return 'Link deleted'
    except PocketException:
        return 'Connection error'

    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 object
            us = UserService.objects.get(
                user=request.user,
                name=ServicesActivated.objects.get(name='ServicePocket'))
            # 2) then get the token
            access_token = Pocket.get_access_token(
                consumer_key=self.consumer_key,
                code=request.session['request_token'])

            us.token = access_token
            # 3) and save everything
            us.save()
        except KeyError:
            return '/'

        return 'pocket/callback.html'