source: python/implugin.py @ 199d51c

#!/usr/bin/python

import sys
import bjsonrpc
from bjsonrpc.handlers import BaseHandler

import operator
import random
import re
import socket
import time

import requests

# List of functions an IM plugin can export. This library will indicate to
# BitlBee which functions are actually implemented so omitted features
# will be disabled, but note that some/many functions are simply mandatory.
# (Currently login/-out, buddy_msg.)
SUPPORTED_FUNCTIONS = [
        'login', 'keepalive', 'logout', 'buddy_msg', 'set_away',
        'send_typing', 'add_buddy', 'remove_buddy', 'add_permit',
        'add_deny', 'rem_permit', 'rem_deny', 'get_info', 'chat_invite',
        'chat_kick', 'chat_leave', 'chat_msg', 'chat_with', 'chat_join',
        'chat_topic'
]

class RpcForwarder(object):
        """Tiny object that forwards RPCs from local Python code to BitlBee
        with a marginally nicer syntax. This layer could eventually be
        used to add basic parameter checking though I don't think that should
        be done here."""
        
        def __init__(self, methods, target):
                for m in methods:
                        # imc(b)_ prefix is not useful here, chop it.
                        # (Maybe do this in BitlBee already as well.)
                        newname = re.sub("^imcb?_", "", m)
                        self.__setattr__(newname, target.__getattr__(m))

class BitlBeeIMPlugin(BaseHandler):
        # Protocol name to be used in the BitlBee CLI, etc.
        NAME = "rpc-test"

        # See account.h (TODO: Add constants.)
        ACCOUNT_FLAGS = 0
        
        # Supported away states. If your protocol supports a specific set of
        # away states, put them in a list in this variable.
        AWAY_STATES = None
        
        # Filled in during initialisation:
        # Version code in hex. So if you need to do comparisions, for example
        # check "self.bitlbee_version >= 0x030202" for versions 3.2.2+
        bitlbee_version = None
        # Full version string
        bitlbee_version_str = None
        # Will become an RpcForwarder object to call into BitlBee
        bee = None
        
        BASE_URL = "https://newsblur.com"
        
        @classmethod
        def _factory(cls, *args, **kwargs):
                def handler_factory(connection):
                        handler = cls(connection, *args, **kwargs)
                        return handler
                return handler_factory
        
        #def __init__(self, connection, *args, **kwargs):
        #       BaseHandler.__init__(self,connection)

        def url(self, path):
                return (self.BASE_URL + path)

        def init(self, bee):
                self.bee = RpcForwarder(bee["method_list"], self._conn.call)
                self.bitlbee_version = bee["version"]
                self.bitlbee_version_str = bee["version_str"]

                # TODO: See how to call into the module here.
                return {
                        "name": self.NAME,
                        "method_list": list(set(dir(self)) & set(SUPPORTED_FUNCTIONS)),
                        "account_flags": self.ACCOUNT_FLAGS,
                        "away_state_list": self.AWAY_STATES,
                        "settings": {
                                "oauth": {
                                        "default": "off",
                                        "type": "bool",
                                },
                                "test": {
                                        "default": "123",
                                        "type": "int",
                                },
                                "stringetje": {
                                        "default": "testje",
                                        "flags": 0x04,
                                }
                        },
                }
        
        def login(self, account):
                self.ua = requests.Session()
                creds = {"username": account["user"], "password": account["pass"]}
                r = self.ua.post(self.url("/api/login"), creds)
                if r.status_code != 200:
                        self.bee.error("HTTP error %d" % r.status_code)
                        self.bee.logout(True)
                elif r.json()["errors"]:
                        self.bee.error("Authentication error")
                        self.bee.logout(False)
                else:
                        self.bee.add_buddy("rss", None)
                        self.bee.connected()
                        self.seen_hashes = set()
                        self.keepalive()

        def logout(self):
                self.bee.error("Ok bye!")

        def buddy_msg(self, handle, msg, flags):
                feed = self.feeds[handle]
                cmd = re.split(r"\s+", msg)
        
        def set_set(self, setting, value):
                print "Setting %s changed to %r" % (setting, value)
        
        # BitlBee will call us here every minute which is actually a neat way
        # to get periodic work (like RSS polling) scheduled. :-D
        def keepalive(self):
                r = self.ua.post(
                        self.url("/reader/unread_story_hashes"),
                        {"include_timestamps": True})
                if r.status_code != 200:
                        self.bee.error("HTTP error %d" % r.status_code)
                        return

                # Throw all unread-post hashes in a long list and sort it by posting time.
                #feed_hashes = r.json()["unread_feed_story_hashes"]
                wtf = r.json()
                feed_hashes = wtf["unread_feed_story_hashes"]
                all_hashes = []
                for feed, hashes in feed_hashes.iteritems():
                        all_hashes += [tuple(h) for h in hashes]
                all_hashes.sort(key=operator.itemgetter(1))
                
                # Look at the most recent 20, grab the ones we haven't shown yet.
                req_hashes = []
                for hash, _ in all_hashes[-20:]:
                        if hash not in self.seen_hashes:
                                req_hashes.append(hash)
                
                if not req_hashes:
                        return
                print req_hashes
                
                # Grab post details.
                r = self.ua.post(self.url("/reader/river_stories"), {"h": req_hashes})
                if r.status_code != 200:
                        self.bee.error("HTTP error %d" % r.status_code)
                        return
                
                # Response is not in the order we requested. :-(
                wtf = r.json()
                stories = {}
                for s in wtf["stories"]:
                        stories[s["story_hash"]] = s
                
                for s in (stories[hash] for hash in req_hashes):
                        line = "%(story_title)s <%(story_permalink)s>" % s
                        ts = int(s.get("story_timestamp", "0"))
                        self.bee.buddy_msg("rss", line, 0, ts)
                        self.seen_hashes.add(s["story_hash"])
                        print s["story_hash"]


def RunPlugin(plugin, debug=True):
        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        sock.bind("/tmp/rpcplugins/test2")
        sock.listen(3)
        
        srv = bjsonrpc.server.Server(sock, plugin._factory())
        
        srv.debug_socket(debug)
        srv.serve()

RunPlugin(BitlBeeIMPlugin)