Brian S. Stephan
1fe9575502
this comes with a recursion rewrite and simplification; it works a bit more intuitively, now, but i still haven't figured out what caused the bug that led me down this rabbit hole. in any event, Alias now rules the roost when it comes to recursion, which means it's a bit poorly named, but also means that there won't (shouldn't) be multiple accidental runs for one output, caused by multiple modules doing the recursion (despite only one really having a legitimate reason to) --- a classic case of the intended use of recursion (including the comment to only recurse when you *know* the input is for you) being lost and forgotten with time this also obsoletes meta.skip_recursion_scan. between this commit and the last, people would be wise to revise their config files
298 lines
11 KiB
Python
298 lines
11 KiB
Python
"""
|
|
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 __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
|
|
|
|
# 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()
|
|
|
|
# add self to the object list
|
|
modlist.append(self)
|
|
|
|
# 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)
|
|
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)
|
|
|
|
# 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)
|
|
|
|
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
|
|
|
|
# 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
|
|
|
|
self.do(connection, event, nick, userhost, replypath, what, admin_unlocked)
|
|
|
|
def reload(self):
|
|
"""Reload this module's code and then create a new object of it, removing the old."""
|
|
|
|
# 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)
|
|
self.register_handlers(self.server)
|
|
|
|
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 replystr is not None:
|
|
if replypath is None:
|
|
return replystr
|
|
else:
|
|
connection.privmsg(replypath, replystr)
|
|
|
|
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
|
|
|
|
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;
|