""" 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 . """ 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 __init__(self, config, server, modlist): """ 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. Classes that are interested in allowing an indirect call to their do routine should add themselves to modlist inside their __init__. This will allow other modules to call do and see if anything can handle text they may have seen (such as in recursive commands). """ self.config = config self.server = server self.modlist = modlist # add self to the object list modlist.append(self) # print what was loaded, for debugging print("loaded " + self.__class__.__name__) def attach_to_server(self, server): """Call register_handlers against the given server.""" self.register_handlers(server) 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) server.add_global_handler('privmsg', self.on_privmsg) 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 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) 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) skip_recursion_scan = False try: skip_recursion_scan = self.config.getboolean(self.__class__.__name__, 'meta.skip_recursion_scan') except NoOptionError: pass except NoSectionError: pass if replypath is not None and skip_recursion_scan is False: what = self.try_recursion(connection, event, nick, userhost, replypath, what, admin_unlocked) # broken because ??? ## try reloading #self.reload(connection, event, nick, userhost, replypath, what, admin_unlocked) self.do(connection, event, nick, userhost, replypath, what, admin_unlocked) 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 if replypath is not None: what = self.try_recursion(connection, event, nick, userhost, replypath, what, admin_unlocked) self.do(connection, event, nick, userhost, replypath, what, admin_unlocked) def reload(self, connection, event, nick, userhost, replypath, what, admin_unlocked): """Reload this module's code and then create a new object of it, removing the old.""" whats = what.split(' ') if whats[0] == 'reload' and admin_unlocked: # re-read and re-compile module from source on disk reload(sys.modules[self.__module__]) # find the class declaration for the current module for name, obj in inspect.getmembers(sys.modules[self.__module__]): if inspect.isclass(obj) and str(obj).find(self.__module__) > 0: # remove existing object from in-memory stuff self.modlist.remove(self) self.unregister_handlers() # create new object, like how we did initially obj(self.config, self.server, self.modlist) def reply(self, connection, replypath, replystr): """ 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 replypath is None: return replystr else: connection.privmsg(replypath, replystr) def try_recursion(self, connection, event, nick, userhost, replypath, what, admin_unlocked): """ Scan message for subcommands to execute and use as part of this command. Upon seeing a line intended for this module, see if there are subcommands that we should do what is basically a text replacement on. The intent is to allow things like the following: command arg1 [anothercommand arg1 arg2] where the output of anothercommand is command's arg2..n. It's mostly for amusement purposes, but maybe there are legitimate uses. This is intended to be attempted after you've determined the line should be handled by your module. """ start_idx = what.find('[') subcmd = what[start_idx+1:] end_idx = subcmd.rfind(']') subcmd = subcmd[:end_idx] attempt = what if start_idx == -1 or end_idx == -1 or len(subcmd) == 0: # no nested commands at all if replypath is a real value, so don't do a damn thing if replypath is not None: return attempt # no more replacements found, see if what we had is workable else: for module in self.modlist: ret = module.do(connection, event, nick, userhost, None, attempt, admin_unlocked) if ret is not None: return ret # if we got here, it's not workable. just return what we got return attempt else: # we have a subcmd, see if there's another one nested ret = self.try_recursion(connection, event, nick, userhost, None, subcmd, admin_unlocked) if ret is not None: blarg = attempt.replace('['+subcmd+']', ret) if replypath is not None: return blarg else: return self.try_recursion(connection, event, nick, userhost, None, blarg, admin_unlocked) else: return attempt 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.skip_recursion_scan') list.remove('meta.skip_recursion_scan') 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") """ dbfile = self.config.get('dr.botzo', 'database') conn = sqlite3.connect(dbfile) return conn 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;