dr.botzo/Module.py

"""
Module - dr.botzo modular functionality base class
Copyright (C) 2010  Brian S. Stephan

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
"""

from ConfigParser import NoSectionError, NoOptionError

import inspect
import re
import sys
import sqlite3

from extlib import irclib

class Module(object):
    """Declare a base class used for creating classes that have real functionality."""

    def priority(self):
        return 50

    def __init__(self, irc, config, server):
        """
        Construct a feature module. Inheritors should not do anything special
        here, instead they should implement register_handlers and do, or else this will
        be a very uneventful affair.
        """

        self.irc = irc
        self.config = config
        self.server = server

        # open database connection
        dbfile = self.config.get('dr.botzo', 'database')
        self.conn = sqlite3.connect(dbfile)
        self.conn.row_factory = sqlite3.Row

        # setup regexp function in sqlite
        def regexp(expr, item):
            reg = re.compile(expr, re.IGNORECASE)
            return reg.search(item) is not None
        self.conn.create_function('REGEXP', 2, regexp)

        # set up database for this module
        self.db_init()

        # print what was loaded, for debugging
        print("loaded " + self.__class__.__name__)

    def register_handlers(self, server):
        """
        Hook handler functions into the IRC library. This is called by __init__ and sets
        up server.add_global_handlers. Classes inheriting from Module could implement this
        and set up the appropriate handlers, e.g.:

        server.add_global_handler('privmsg', self.on_privmsg)

        Module.on_pubmsg and Module.on_privmsg are defined so far, the rest, you're on your
        own.
        """

        server.add_global_handler('pubmsg', self.on_pubmsg, self.priority())
        server.add_global_handler('privmsg', self.on_privmsg, self.priority())

    def unregister_handlers(self):
        """
        Unhook handler functions from the IRC library. Inverse of the above.
        This is called by reload, to remove the soon-to-be old object from the server
        global handlers (or whatever has been added via register_handlers). Classes
        inheriting from Module could implement this, e.g.:

        server.remove_global_handler('privmsg', self.on_privmsg)
        """

        self.server.remove_global_handler('pubmsg', self.on_pubmsg)
        self.server.remove_global_handler('privmsg', self.on_privmsg)

    def save(self):
        """
        Save whatever the module may need to save. Sync files, etc.

        Implement this if you need it.
        """

    def shutdown(self):
        """
        Do pre-deletion type cleanup.

        Implement this to close databases, write to disk, etc.
        """

    def on_pubmsg(self, connection, event):
        """
        Handle pubmsg events. Does some variable setup and initial sanity checking before
        calling Module.do, which should be implemented by subclasses and what can be
        ultimately responsible for the work.

        Of course, you are free to reimplement on_pubmsg on your own too.
        """

        nick = irclib.nm_to_n(event.source())
        userhost = irclib.nm_to_uh(event.source())
        replypath = event.target()
        what = event.arguments()[0]

        admin_unlocked = False

        try:
            if userhost == self.config.get('dr.botzo', 'admin_userhost'):
                admin_unlocked = True
        except NoOptionError: pass

        # only do commands if the bot has been addressed directly
        addressed_pattern = '^' + connection.get_nickname() + '[:,]?\s+'
        addressed_re = re.compile(addressed_pattern)

        # see if we should just skip msg stuff entirely (common for stuff run via alias)
        internal_only = True
        try:
            internal_only = self.config.getboolean(self.__class__.__name__, 'meta.internal_only')
        except NoOptionError: pass
        except NoSectionError: pass
        if internal_only and replypath is not None:
            return

        need_prefix = True
        try:
            need_prefix = self.config.getboolean(self.__class__.__name__, 'meta.pubmsg_needs_bot_prefix')
        except NoOptionError: pass
        except NoSectionError: pass

        ignore_prefix = False
        try:
            ignore_prefix = self.config.getboolean(self.__class__.__name__, 'meta.pubmsg_ignore_bot_prefix')
        except NoOptionError: pass
        except NoSectionError: pass

        strip_bot_name_from_input = True
        try:
            strip_bot_name_from_input = self.config.getboolean(self.__class__.__name__, 'meta.strip_bot_name_from_input')
        except NoOptionError: pass
        except NoSectionError: pass

        if not addressed_re.match(what) and need_prefix:
            return
        elif addressed_re.match(what) and ignore_prefix:
            return
        elif strip_bot_name_from_input:
            what = addressed_re.sub('', what)

        try:
            return self.do(connection, event, nick, userhost, replypath, what, admin_unlocked)
        except Exception as e:
            print('EXCEPTION: ' + str(e))

    def on_privmsg(self, connection, event):
        """
        Handle privmsg events. Does some variable setup and initial sanity checking before
        calling Module.do, which should be implemented by subclasses and what can be
        ultimately responsible for the work.

        Of course, you are free to reimplement on_privmsg on your own too.
        """

        nick = irclib.nm_to_n(event.source())
        userhost = irclib.nm_to_uh(event.source())
        replypath = nick
        what = event.arguments()[0]

        admin_unlocked = False

        try:
            if userhost == self.config.get('dr.botzo', 'admin_userhost'):
                admin_unlocked = True
        except NoOptionError: pass

        # see if we should just skip msg stuff entirely (common for stuff run via alias)
        internal_only = True
        try:
            internal_only = self.config.getboolean(self.__class__.__name__, 'meta.internal_only')
        except NoOptionError: pass
        except NoSectionError: pass
        if internal_only and replypath is not None:
            return

        try:
            return self.do(connection, event, nick, userhost, replypath, what, admin_unlocked)
        except Exception as e:
            print('EXCEPTION: ' + str(e))

    def reply(self, connection, replypath, replystr, stop_responding=False):
        """
        Reply over IRC to replypath or return a string with the reply.
        Utility method to do the proper type of reply (either to IRC, or as a return
        to caller) depending on the target. Pretty simple, and included in the base
        class for convenience. It should be the last step for callers:

        return self.reply(connection, replypath, 'hello')
        """

        if replystr is not None:
            if replypath is None:
                return replystr
            else:
                connection.privmsg(replypath, replystr)
                if stop_responding:
                    return "NO MORE"

    def remove_metaoptions(self, list):
        """Remove metaoptions from provided list, which was probably from a config file."""

        list.remove('debug')
        # if this option has been provided, don't print it
        try:
            self.config.get(self.__class__.__name__, 'meta.pubmsg_needs_bot_prefix')
            list.remove('meta.pubmsg_needs_bot_prefix')
        except NoOptionError: pass
        try:
            self.config.get(self.__class__.__name__, 'meta.pubmsg_ignore_bot_prefix')
            list.remove('meta.pubmsg_ignore_bot_prefix')
        except NoOptionError: pass
        try:
            self.config.get(self.__class__.__name__, 'meta.strip_bot_name_from_input')
            list.remove('meta.strip_bot_name_from_input')
        except NoOptionError: pass
        try:
            self.config.get(self.__class__.__name__, 'meta.internal_only')
            list.remove('meta.internal_only')
        except NoOptionError: pass

    def retransmit_event(self, event):
        """
        Pretend that some event the bot has generated is rather an incoming IRC
        event. Why one would do this is unclear, but I wrote it and then realized
        I didn't need it.
        """

        self.server._handle_event(event)

    def get_db(self):
        """
        Get a database connection to sqlite3. Once grabbed, it should be closed
        when work is done. Modules that need a database connection should
        test for and create (or, eventually, alter) required table structure
        in their __init__ IF that structure does not already exist. Well-behaved
        modules should use a prefix in their table names (eg "karma_log" rather
        than "log")

        See also db_module_registered, below.
        """

        return self.conn

    def db_module_registered(self, modulename):
        """
        ask the database for a version number for a module. Return that version
        number if the module has registered, or None if not
        """

        conn = self.get_db()
        version = None
        try:
            cur = conn.cursor()
            cur.execute("SELECT version FROM drbotzo_modules WHERE module = :name",
                {'name': modulename})
            version = cur.fetchone()
            if (version != None):
                version = version[0]
        except sqlite3.Error as e:
            print("sqlite error:" + str(e))

        return version

    def db_init(self):
        """
        Set up the database tables and so on, if subclass is planning on using it.
        """

    def do(self, connection, event, nick, userhost, replypath, what, admin_unlocked):
        """
        Do the primary thing this module was intended to do.
        Implement this method in your subclass to have a fairly-automatic hook into
        IRC functionality. This is called by the default on_pubmsg and on_privmsg
        """

        print "looks like someone forgot to implement do!"

# vi:tabstop=4:expandtab:autoindent
# kate: indent-mode python;indent-width 4;replace-tabs on;