15 files changed, 776 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..72364f9
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,89 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# IPython Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# dotenv
+.env
+
+# virtualenv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+
+# Rope project settings
+.ropeproject
diff --git a/README.org b/README.org
new file mode 100644
index 0000000..18641d4
--- /dev/null
+++ b/README.org
@@ -0,0 +1,23 @@
+* Setting up the bot
+D'bolla is a no bullshit extensible IRC/Slack bot written for Python 3.5 using
+asyncio.
+
+** Install dependencies:
+
+#+BEGIN_SRC bash
+    pip install websockets
+#+END_SRC
+
+** Configure
+Copy dbolla.conf.example to dbolla.conf and edit this file. You can
+specify multiples of the same connection by prefixing the config section with
+'slack:' or 'irc:' followed by a unique name for this connection.
+
+** Running
+Simply run the command:
+
+#+BEGIN_SRC bash
+    ./bin/dbolla -c /path/to/my/dbolla.conf
+#+END_SRC
+
+* Writing a Plugin
diff --git a/bin/dbolla b/bin/dbolla
new file mode 100755
index 0000000..7a1eba6
--- /dev/null
+++ b/bin/dbolla
@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+# -*- mode: python -*-
+import asyncio
+import functools
+import logging.config
+
+from warmachine.config import Config
+from warmachine.connections.irc import AioIRC
+from warmachine.connections.slack import SlackWS
+
+logging.config.dictConfig({
+    'version': 1,
+    'disable_existing_loggers': False,
+
+    'formatters': {
+        'standard': {
+            'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s',
+        }
+    },
+    'handlers': {
+        'console': {
+            'class': 'logging.StreamHandler',
+            'level': 'DEBUG',
+            'formatter': 'standard',
+        },
+    },
+    'loggers': {
+        'websockets': {
+            'level': 'INFO',
+            'handlers': ['console', ]
+        },
+        '': {
+            'level': 'DEBUG',
+            'handlers': ['console', ]
+        }
+    }
+})
+
+
+class Bot(object):
+    def __init__(self, settings):
+        self.log = logging.getLogger(self.__class__.__name__)
+        self._loop = asyncio.get_event_loop()
+
+        self.settings = settings
+
+        self.connections = {}
+        self.tasks = []
+
+        self.loaded_plugins = []
+
+        self.load_plugin('asdf')
+
+    def start(self):
+        for connection in self.connections:
+            t = asyncio.ensure_future(connection.connect())
+            t.add_done_callback(functools.partial(self.on_connect, connection))
+
+        self._loop.run_forever()
+
+    def add_connection(self, connection):
+        self.connections[connection] = {}
+
+    def on_connect(self, connection, task):
+        asyncio.ensure_future(self.process_message(connection))
+
+    async def process_message(self, connection):
+        """
+        Constantly read new messages from the connection in a non-blocking way
+        """
+        while True:
+            message = await connection.read()
+            if not message:
+                continue
+
+            for p in self.loaded_plugins:
+                self.log.debug('Calling {}'.format(p.__class__.__name__))
+                await p.recv_msg(connection, message)
+
+            self.log.debug('MSG {}: {}'.format(
+                connection.__class__.__name__, message))
+
+    def load_plugin(self, path):
+        """
+        Loads plugins
+        """
+        from importlib import import_module
+
+        mod_path, cls_name = 'warmachine.addons.giphy.GiphySearch'.rsplit('.', 1)
+
+        mod = import_module(mod_path)
+
+        if hasattr(mod, cls_name):
+            cls = getattr(mod, cls_name)()
+
+        self.loaded_plugins.append(cls)
+
+    def reload_plugin(self, path):
+        """
+        Reload a plugin
+        """
+
+    def unload_plugin(self, path):
+        """
+        Unload a plugin
+        """
+
+if __name__ == "__main__":
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-c', '--config', help='define warmachine config file',
+                        type=str)
+    args = parser.parse_args()
+
+    if args.config:
+        settings = Config(args.config)
+    else:
+        sys.exit(1)
+
+    bot = Bot(settings)
+
+    for s in settings.sections():
+        options = settings.options_as_dict(s)
+        if options.get('enable', False) == 'true':
+            if s.startswith('slack'):
+                bot.add_connection(SlackWS(options))
+            # elif s.startswith('irc'):
+            #     bot.add_connection(AioIRC(options))
+
+    bot.start()
diff --git a/dbolla.conf.example b/dbolla.conf.example
new file mode 100644
index 0000000..206a394
--- /dev/null
+++ b/dbolla.conf.example
@@ -0,0 +1,20 @@
+[irc:freenode]
+# Address to the server Defaut: irc.freenode.org
+server=irc.freenode.org
+# Port to the server Default: 6697
+port=6697
+# Use SSL | default: true
+ssl=true
+# The nickname the bot should use
+nick=warmachine
+# Shows up in Real Name
+name=War Machine
+# Password to connect to the server
+password=
+
+[slack:myslack]
+# In your Slack account go to the admin section followed by
+# "Custom Integrations". Click on bots and create a new bot user.
+
+# Slack bot API token
+token=xoxb-random_acharacters
diff --git a/warmachine/addons/__init__.py b/warmachine/addons/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/warmachine/addons/__init__.py
diff --git a/warmachine/addons/base.py b/warmachine/addons/base.py
new file mode 100644
index 0000000..aa23c78
--- /dev/null
+++ b/warmachine/addons/base.py
@@ -0,0 +1,6 @@
+import logging
+
+
+class WarMachinePlugin(object):
+    def __init__(self):
+        self.log = logging.getLogger(self.__class__.__name__)
diff --git a/warmachine/addons/giphy.py b/warmachine/addons/giphy.py
new file mode 100644
index 0000000..a9bdac1
--- /dev/null
+++ b/warmachine/addons/giphy.py
@@ -0,0 +1,33 @@
+import urllib.request
+import json
+
+from .base import WarMachinePlugin
+
+__author__ = 'jason@zzq.org'
+__class_name__ = 'GiphySearch'
+__version__ = 1.0
+
+
+class GiphySearch(WarMachinePlugin):
+    async def recv_msg(self, connection, message):
+        if message['message'].startswith('!giphy '):
+            search_terms = ' '.join(message['message'].split(' ')[1:])
+
+            self.log.debug('Searching giphy.com for: {}'.format(search_terms))
+
+            url = ('http://api.giphy.com/v1/gifs/search?'
+                   'q={}&api_key=dc6zaTOxFJmzC&limit=1'.format(
+                       search_terms.replace(' ', '%20')))
+
+            # TODO: This blocks
+            req = urllib.request.Request(url)
+            data = urllib.request.urlopen(req).read().decode('utf-8')
+
+            data = json.loads(data)
+            self.log.debug(data)
+            try:
+                result = data['data'][0]['images']['original']['url']
+                await connection.say(result, message['channel'])
+            except IndexError as e:
+                await connection.say('No match for: {}'.format(search_terms),
+                                     message['channel'])
diff --git a/warmachine/addons/standup.py b/warmachine/addons/standup.py
new file mode 100644
index 0000000..a21efdd
--- /dev/null
+++ b/warmachine/addons/standup.py
@@ -0,0 +1,28 @@
+from .base import WarMachinePlugin
+
+
+class StandUpPlugin(WarMachinePlugin):
+    """
+    WarMachine stand up plugin.
+
+    Commands:
+        !standup-add <24 hr time to kick off> <SunMTWThFSat> [channel]
+        !standup-remove [channel]
+    """
+    async def recv_msg(self, connection, message):
+        if not message['message'].startswith('!standup'):
+            return
+
+        self.log.debug('standup recv: {}'.format(message))
+
+        cmd = message['message'].split(' ')[0]
+        parts = message['message'].split(' ')[1:]
+
+        if cmd == '!standup-add':
+            await connection.say('Scheduling standup for {} on {}'.format(
+                parts[1], parts[2]))
+
+        # await connection.say('{}, {}'.format(cmd, parts), message['channel'])
+
+    async def start_standup(self, connection):
+        pass
diff --git a/warmachine/config.py b/warmachine/config.py
new file mode 100644
index 0000000..6be84e3
--- /dev/null
+++ b/warmachine/config.py
@@ -0,0 +1,20 @@
+import configparser
+
+
+class Config(configparser.ConfigParser):
+    def __init__(self, config_path=None):
+        super().__init__()
+
+        self.config_path = config_path
+
+        if self.config_path:
+            self.read(self.config_path)
+
+    def options_as_dict(self, section):
+        """
+        Returns:
+           dict: Dictionary of the options defined in this config
+        """
+        d = dict(self.items(section))
+        d['section_name'] = section
+        return d
diff --git a/warmachine/connections/__init__.py b/warmachine/connections/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/warmachine/connections/__init__.py
diff --git a/warmachine/connections/base.py b/warmachine/connections/base.py
new file mode 100644
index 0000000..e68e9b9
--- /dev/null
+++ b/warmachine/connections/base.py
@@ -0,0 +1,40 @@
+INITALIZED = 'Initalized'
+CONNECTED = 'Connected'
+
+
+class Connection(object):
+    def connect(self, *args, **kwargs):
+        """
+        This is called by the main start method. It should prepare your
+        Connection and connect.
+        """
+        raise NotImplementedError('{} must implement `connect` method'.format(
+            self.__class__.__name__))
+
+    def read(self):
+        """
+        Dictionary of data in the following format:
+        {
+          'sender': 'username/id',
+          'channel': 'channel name' or None,
+          'message': 'actual message',
+        }
+
+        Returns:
+            dict: Data from the connection that the bot should consider.
+        """
+        raise NotImplementedError('{} must implement `read` method'.format(
+            self.__class__.__name__))
+
+    def id(self):
+        """
+        Unique ID for this connection. Since there can be more than one
+        connection it should be unique per actual connection to the server. For
+        example `bot nickname` + `server host:port`. This is used to store
+        settings and other information.
+
+        Returns:
+           str: Unique ID for this connection object
+        """
+        raise NotImplementedError('{} must implement `id` method'.format(
+            self.__class__.__name__))
diff --git a/warmachine/connections/irc.py b/warmachine/connections/irc.py
new file mode 100644
index 0000000..f7f682c
--- /dev/null
+++ b/warmachine/connections/irc.py
@@ -0,0 +1,64 @@
+import asyncio
+import logging
+
+from .base import Connection, INITALIZED
+from ..utils.decorators import memoize
+
+
+class AioIRC(Connection):
+    def __init__(self, host, port):
+        self._loop = asyncio.get_event_loop()
+        self.log = logging.getLogger(self.__class__.__name__)
+
+        self.status = INITALIZED
+
+        self.transport = None
+        self.protocol = None
+        self.reader = None
+        self.writer = None
+
+        self.host = host
+        self.port = port
+        self.nick = 'warmachin49'
+        self.user = 'WarMachine'
+
+        self.server_info = {
+            'host': ''
+        }
+
+    async def connect(self):
+        self.log.info('Connecting to {}:{}'.format(self.host, self.port))
+
+        self.reader, self.writer = await asyncio.open_connection(
+            self.host, self.port)
+
+        self.writer.write('NICK {} r\n'.format(self.nick).encode())
+        self.writer.write('USER {} 8 * :War Machine\r\n'.format(
+            self.user).encode())
+
+        return True
+
+    @asyncio.coroutine
+    def read(self):
+        if self.reader.at_eof():
+            raise Exception('eof')
+        if self.reader:
+            message = yield from self.reader.readline()
+
+            # if not self.server_info['host']:
+            #     self.server_info['host'] = message.split(' ')[0].replace(':', '')
+
+            # if message.startswith('PING'):
+            #     yield from self.send_pong()
+            #     return
+
+            return message.decode().strip()
+
+    async def send_pong(self):
+        msg = 'PONG :{}'.format(self.server_info['host'])
+        return self.writer.write(msg)
+
+    @property
+    @memoize
+    def id(self):
+        return 'asdfasdf'
diff --git a/warmachine/connections/slack.py b/warmachine/connections/slack.py
new file mode 100644
index 0000000..b1a5390
--- /dev/null
+++ b/warmachine/connections/slack.py
@@ -0,0 +1,281 @@
+import asyncio
+import json
+import logging
+from pprint import pformat
+from urllib.parse import urlencode
+
+import websockets
+
+from .base import Connection, INITALIZED, CONNECTED
+
+
+#: Define slack as a config section prefix
+__config_prefix__ = 'slack'
+
+
+class SlackWS(Connection):
+    def __init__(self, options, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self._loop = asyncio.get_event_loop()
+        self.log = logging.getLogger(self.__class__.__name__)
+        self.host = None
+        self.token = options['token']
+
+        self._info = None
+        self.reconnect_url = ''
+
+        self.channel_map = {}  # channel and im info keyed by the slack id
+        self.user_map = {}     # user info keyed by their slack id
+        self.user_nick_to_id = {}  # slack user id mapped to the (nick)name
+
+        self.ws = None
+
+        self.status = INITALIZED
+
+    async def connect(self):
+        self.host = self.authenticate()
+        self.log.info('Connecting to {}'.format(self.host))
+        self.ws = await websockets.connect(self.host)
+
+    async def read(self):
+        if self.ws:
+            message = json.loads(await self.ws.recv())
+
+            # Slack is acknowledging a message was sent. Do nothing
+            if 'type' not in message and 'reply_to' in message:
+                # {'ok': True,
+                #  'reply_to': 1,
+                #  'text': "['!whois', 'synic']",
+                #  'ts': '1469743355.000150'}
+                return
+
+            # Handle actual messages
+            elif message['type'] == 'message' and 'subtype' not in message:
+                return await self.process_message(message)
+            else:
+                if 'subtype' in message:
+                    # This is a message with a subtype and should be processed
+                    # differently
+                    msgtype = '{}_{}'.format(
+                        message['type'], message['subtype'])
+                else:
+                    msgtype = message['type']
+
+                # Look for on_{type} methods to pass the dictionary to for
+                # additional processing
+                func_name = 'on_{}'.format(msgtype)
+                if hasattr(self, func_name):
+                    getattr(self, func_name)(message)
+                else:
+                    self.log.debug('{} does not exist for message: {}'.format(
+                        func_name, message))
+
+    async def say(self, message, destination_id):
+        """
+        Say something in the provided channel or IM by id
+        """
+        await self._send(json.dumps({
+            'id': 1,  # TODO: this should be a get_msgid call or something
+            'type': 'message',
+            'channel': destination_id,
+            'text': message
+        }))
+
+    async def _send(self, message):
+        """
+        Send ``message`` to the connected slack server
+        """
+        await self.ws.send(message)
+
+    def authenticate(self):
+        """
+        Populate ``self._info``
+
+        Returns:
+            str: websocket url to connect to
+        """
+        import urllib.request
+        url = 'https://slack.com/api/rtm.start?{}'.format(
+            urlencode(
+                {'token':
+                 self.token}))
+        self.log.debug('Connecting to {}'.format(url))
+        req = urllib.request.Request(url)
+
+        r = urllib.request.urlopen(req).read().decode('utf-8')
+        self._info = json.loads(r)
+
+        if not self._info.get('ok', True):
+            raise Exception('Slack Error: {}'.format(
+                self._info.get('error', 'Unknown Error')))
+
+        self.process_connect_info()
+
+        self.log.debug('Got websocket url: {}'.format(self._info.get('url')))
+        return self._info.get('url')
+
+    def process_connect_info(self):
+        """
+        Processes the connection info provided by slack
+        """
+        if not self._info:
+            return
+
+        self.status = CONNECTED
+
+        # Map users
+        for u in self._info.get('users', []):
+            self.user_map[u['id']] = u
+            self.user_nick_to_id[u['name']] = u['id']
+
+        # Map IM
+        for i in self._info.get('ims', []):
+            self.channel_map[i['id']] = i
+
+        # Map Channels
+        for c in self._info.get('channels', []):
+            self.channel_map[c['id']] = c
+
+    async def process_message(self, msg):
+        # Built-in !whois action
+        if 'text' not in msg:
+            raise Exception(msg)
+        if msg['text'].startswith('!whois'):
+            nicknames = msg['text'].split(' ')[1:]
+            for n in nicknames:
+                await self.say(pformat(self.user_map[self.user_nick_to_id[n]]),
+                               msg['channel'])
+            return
+
+        retval = {
+            'sender': msg['user'],
+            'channel': msg['channel'],
+            'message': msg['text']
+        }
+        return retval
+
+    def on_user_change(self, msg):
+        """
+        The user_change event is sent to all connections for a team when a team
+        member updates their profile or data. Clients can use this to update
+        their local cache of team members.
+
+        https://api.slack.com/events/user_change
+        """
+        user_info = msg['user']
+        old_nick = self.user_map[user_info['id']]['nick']
+
+        self.user_map[user_info['id']] = user_info
+
+        # Update the nick mapping if the user changed their nickname
+        if old_nick != user_info['nick']:
+            del self.user_nick_to_id[old_nick]
+            self.user_nick_to_id[user_info['nick']] = user_info['id']
+
+    def on_reconnect_url(self, msg):
+        """
+        The reconnect_url event is currently unsupported and experimental.
+
+        https://api.slack.com/events/reconnect_url
+        """
+        # self.reconnect_url = msg['url']
+        # self.log.debug('updated_reconnect_url: {}'.format(self.reconnect_url))
+
+    def on_presence_change(self, msg):
+        self.log.debug('updated_presence: {} ({}) was: {} is_now: {}'.format(
+            msg['user'], self.user_map[msg['user']]['name'],
+            self.user_map[msg['user']]['presence'],
+            msg['presence']
+        ))
+        self.user_map[msg['user']]['presence'] = msg['presence']
+
+    async def on_group_join(self, channel):
+        """
+        The group_joined event is sent to all connections for a user when that
+        user joins a private channel. In addition to this message, all existing
+        members of the private channel will receive a group_join message event.
+
+        https://api.slack.com/events/group_joined
+        """
+        # {
+        #     'channel': {
+        #         'members': ['U0286NL58', 'U1U05AF5J'],
+        #         'id': 'G1W837CGP',
+        #         'is_group': True,
+        #         'is_archived': False,
+        #         'latest': {
+        #             'user': 'U0286NL58',
+        #             'subtype': 'group_join',
+        #             'ts': '1469746594 .000002',
+        #             'type': 'message',
+        #             'text': '<@U0286NL58|jason> has joined the group'
+        #         },
+        #         'is_mpim': False,
+        #         'unread_count': 0,
+        #         'purpose': {
+        #             'creator': '',
+        #             'value': '',
+        #             'last_set': 0
+        #         },
+        #         'is_open': True,
+        #         'topic': {
+        #             'creator': '',
+        #             'value': '',
+        #             'last_set': 0
+        #         },
+        #         'creator': 'U0286NL58',
+        #         'unread_count_display': 0,
+        #         'name': 'wm-test',
+        #         'last_read': '1469746594.000002',
+        #         'created': 1469746594
+        #     },
+        #     'type': 'group_joined'
+        # }
+
+    def on_message_message_changed(self, msg):
+        """
+        A message_changed message is sent when a message in a channel is edited
+        using the chat.update method. The message property contains the updated
+        message object.
+
+        When clients receive this message type, they should look for an
+        existing message with the same message.ts in that channel. If they
+        find one the existing message should be replaced with the new one.
+
+        https://api.slack.com/events/message/message_changed
+        """
+        # {
+        #     'hidden': True,
+        #     'event_ts': '1469748743.218081',
+        #     'subtype': 'message_changed',
+        #     'message': {
+        #         'attachments': [{
+        #             'id': 1,
+        #             'image_width': 800,
+        #             'fallback': '800x450px image',
+        #             'from_url':
+        # 'http://media1.giphy.com/media/3o85fPE3Irg8Wazl9S/giphy.gif',
+        #             'image_bytes': 4847496,
+        #             'image_url':
+        # 'http://media1.giphy.com/media/3o85fPE3Irg8Wazl9S/giphy.gif',
+        #             'image_height': 450,
+        #             'is_animated': True
+        #         }],
+        #         'type': 'message',
+        #         'ts': '1469748743.000019',
+        #         'text':
+        # '<http://media1.giphy.com/media/3o85fPE3Irg8Wazl9S/giphy.gif>',
+        #         'user': 'U1U05AF5J'
+        #     },
+        #     'channel': 'G1W837CGP',
+        #     'ts': '1469748743.000020',
+        #     'type': 'message',
+        #     'previous_message': {
+        #         'type': 'message',
+        #         'ts': '1469748743.000019',
+        #         'text':
+        # '<http://media1.giphy.com/media/3o85fPE3Irg8Wazl9S/giphy.gif>',
+        #         'user': 'U1U05AF5J'
+        #     }
+        # }
diff --git a/warmachine/utils/__init__.py b/warmachine/utils/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/warmachine/utils/__init__.py
diff --git a/warmachine/utils/decorators.py b/warmachine/utils/decorators.py
new file mode 100644
index 0000000..e049e79
--- /dev/null
+++ b/warmachine/utils/decorators.py
@@ -0,0 +1,40 @@
+from collections import Hashable
+import functools
+from hashlib import sha1 as hash_
+import logging
+
+
+class memoize(object):
+    """
+    Decorator that caches a function's return value each time it is called with
+    the same arguments.
+    """
+    def __init__(self, func):
+        self.func = func
+        self.cache = {}
+        self.log = logging.getLogger('memoize')
+
+    @classmethod
+    def _hash(cls, string):
+        return hash_(string.encode()).hexdigest()
+
+    def __call__(self, *args, **kwargs):
+        # if not isinstance(args, Hashable) or not isinstance(kwargs, Hashable):
+        #     self.log.debug('Uncacheable')
+        #     return self.func(*args, **kwargs)
+
+        h = self._hash(str(args) + str(kwargs))
+        if h in self.cache:
+            self.log.debug('Using cached value for {}({}, {})'.format(
+                self.func.__name__, ', '.join(str(a) for a in args),
+                ','.join('{}={} '.format(k, v) for k, v in kwargs.items())))
+            return self.cache[h]
+        else:
+            self.log.debug('Caching value')
+            value = self.func(*args, **kwargs)
+            self.cache[h] = value
+
+            return value
+
+    def __get__(self, obj, objtype):
+        return functools.partial(self.__call__, obj)