Partway through separating everything out.

[halbot.git] / hal.py

#!/usr/bin/env python
from __future__ import generators
import html, re, irclib, ircbot, thread, sys, atexit, bz2, logging, traceback, time, threadsafe_sched, os
from dateutil.parser import parse as raw_time_parser
from cPickle import dumps as pickle, loads as depickle
DEBUG = 0
irclib.DEBUG = DEBUG

nick = "Hal"
hal = ircbot.SingleServerIRCBot([("localhost", 6667)], nick, "Halbot")
hal.connect("localhost", 6667, nick)
time.sleep(0.1)
hal.connection.join("#casualgameplay")
hal.connection.privmsg("NickServ", "identify Orqv)>y!")
is_re = re.compile(" (is|are|was|were)( |$)", re.IGNORECASE)
nick_re = re.compile(nick + "[:,] ", re.IGNORECASE)
private = "p"
scheduler = threadsafe_sched.scheduler()
os.environ['TZ'] = "GMT"
time.tzset()
SAVE_VERSION = 3

class Perms(object):
  symbols = {}
  def __init__(self, level, symbol=None):
    self.level = level
    self.symbol = symbol
    if symbol:
      Perms.symbols[symbol] = self
  def __cmp__(self, other):
    return self.level - other.level
  def __str__(self):
    if self.symbol:
      return self.symbol
    else:
      return str(self.level)
  #@staticmethod
  def from_symbol(symbol):
    return Perms.symbols.get(symbol, Perms.present)
  from_symbol = staticmethod(from_symbol)
Perms.ban = Perms(-2)
Perms.none = Perms(-1)
Perms.present = Perms(0)
Perms.voice = Perms(1, "+")
Perms.hop = Perms(2, "%")
Perms.op = Perms(3, "@")
Perms.admin = Perms(4, "&")
Perms.owner = Perms(5, "~")
Perms.ircop = Perms(6)

my_users = ircbot.IRCDict()
factoid_dbs = ircbot.IRCDict()
locked_dbs = ircbot.IRCDict()
reminder_dbs = ircbot.IRCDict()
subscription_dbs = ircbot.IRCDict()
try:
  db = open("hal.db")
  zipped = db.read()
  pickled = bz2.decompress(zipped)
  (version, data) = depickle(pickled)
  if version == SAVE_VERSION:
    (my_users, factoid_dbs, locked_dbs, reminder_dbs, subscription_dbs) = data
  elif version == 2:
    (my_users, factoid_dbs, locked_dbs, reminder_dbs) = data
  else:
    sys.exit("Unrecognized database version.")
  db.close()
  del db, zipped, pickled
except IOError:
  pass

logging.getLogger().addHandler(logging.FileHandler("error.log"))

class Buffer(object):
  def __init__(self, prefix=""):
    self.data = prefix
  def write(self, unbuffered):
    self.data += unbuffered

def get_timestamp(when=None):
  if when == None:
    when = time.time()
  return time.ctime(when) + " " + time.tzname[time.daylight]

def parse_time(time_string):
  return time.mktime(raw_time_parser(time_string).timetuple())

def safe_call(func, args):
  try:
    func(*args)
  except Exception, e:
    if isinstance(e, SystemExit):
      raise
    buffer = Buffer("Exception in function %s at %s:\n" 
                               % (func.__name__, get_timestamp()))
    traceback.print_exc(file=buffer)
    logging.getLogger().error(buffer.data)
    # Try to report the error interactively.
    if len(args) >= 2 and type(args[0]) == type(args[1]) == str:
      try:
        reply(args[0], args[1], "Ow!  Ohh, man, that didn't feel good.  " \
                                +"Somebody get FunnyMan, quick!")
      except Exception:
        pass
    elif len(args) and type(args[0]) == str:
      try:
        reply('', args[0], "Ow!  Ohh, man, that didn't feel good.  " \
                                +"Somebody get FunnyMan, quick!", all=True)
      except Exception:
        pass

def safe(func):
  return lambda *args: safe_call(func, args)

def troggie(func):
  def continue_if_no_troggie(who, where, *args, **kwargs):
    if where in hal.channels:
      chan = hal.channels[where]
      if "troggie" not in chan.userdict:
        func(who, where, *args, **kwargs)
  return continue_if_no_troggie

def resize(list_or_tuple, length):
  '''Creates a new list or tuple of length 'length', using as many elements from
     list_or_tuple as possible and right-padding with "".  Does not modify 
     list_or_tuple.'''
  if len(list_or_tuple) < length:
    if type(list_or_tuple) == list:
      return list_or_tuple + [""] * (length - len(list_or_tuple))
    else:
      return list_or_tuple + ("",) * (length - len(list_or_tuple))
  else:
    return list_or_tuple[:length]

irc = hal.ircobj
class Whois(object):
  registered = False
  ircop = False
  channel_perms = None
  def __init__(self):
    self.channel_perms = {}

waiting_commands = {}
whois_info = {}

def got_command(who, where, command, args=""):
  if not command in commands:
    command = 'raise error'
    args = "I don't understand that."
  waiting = waiting_commands.get(who, [])
  if not waiting:
    (required_perms, do_it) = commands[command]
    if where == private and required_perms <= Perms.owner:
      safe_call(do_it, (who, where, args))
    elif required_perms <= Perms.voice and where in hal.channels:
      chan = hal.channels[where]
      if who in chan.voiceddict or who in chan.hopdict or who in chan.operdict \
          or who in chan.admindict or who in chan.ownerdict:
        safe_call(do_it, (who, where, args))
      else:
        return
    else:
      waiting_commands[who] = [(where, command, args)]
      hal.connection.whois((who,))
  else:
    waiting.append((where, command, args))

def reply(who, where, what, all=False):
  if where == private:
    hal.connection.privmsg(who, what)
  elif all:
    hal.connection.privmsg(where, what)
  else:
    hal.connection.privmsg(where, "%s: %s" % (who, what))

def get_perms(who, where):
  user = whois_info[who]
  if user.ircop:
    return Perms.ircop
  if where == private:
    server_perm = Perms.owner
  else:
    server_perm = whois_info[who].channel_perms.get(where, Perms.none)
  if user.registered:
    my_perm = my_users.get(who, Perms.none)
  else:
    my_perm = Perms.none
  return max(server_perm, my_perm)

commands = {}

commands['raise error'] = (Perms.voice, reply)

def ping(who, where, args):
  reply(who, where, "Pong!")
commands['ping'] = (Perms.voice, ping)

class TestException(Exception): pass

def error(who, where, args):
  raise TestException, str(args)
commands['error'] = (Perms.ircop, error)

def join(who, where, args):
  hal.connection.join(where)
commands['do join'] = (Perms.op, join)

def save(who=None, where=None, args=None):
  pickled = pickle((
                    SAVE_VERSION, 
                    (my_users, factoid_dbs, locked_dbs, reminder_dbs, 
                     subscription_dbs)
                  ))
  zipped = bz2.compress(pickled)
  db = open("hal.db", "w")
  db.write(zipped)
  db.close()
  if who:
    reply(who, where, "Database saved.")
commands['save'] = (Perms.ircop, save)
atexit.register(save)

def shutdown(who, where, args):
  hal.connection.quit("Daisy, daaaisy...")
  raise SystemExit
commands['shutdown'] = (Perms.ircop, shutdown)

def title(who, where, args, all=False):
  try:
    reply(who, where, "[%s]" % (html.get_title(args)), all)
  except Exception, e:
    print e
    reply(who, where, "Error retrieving URL '%s'." % args, all)
title = troggie(title)
commands['title'] = (Perms.voice, title)

def title_implicit(who, where, args):
  title(who, where, args, all=True)
commands['title implicit'] = (Perms.voice, title_implicit)

def calc(who, where, args):
  try:
    reply(who, where, "Google says: %s" % html.google_calc(args), all=True)
  except Exception, e:
    print e
    reply(who, where, "Ewwww... Google barfed on me.", all=True)
#calc = troggie(calc)
commands['calc'] = (Perms.voice, calc)

def google(who, where, args):
  try:
    url = html.first_google(args)
    reply(who, where, "Google says: %s [%s]." % (url, html.get_title(url)), all=True)
  except Exception, e:
    print e
    reply(who, where, "Ewwww... Google barfed on me.", all=True)
#google = troggie(google)
commands['google'] = (Perms.voice, google)

def jig(who, where, args):
  google(who, where, args + " site:jayisgames.com")
#jig = troggie(jig)
commands['jig'] = (Perms.voice, jig)

def wp(who, where, args):
  google(who, where, args + " site:en.wikipedia.org")
commands['wp'] = (Perms.voice, wp)
commands['wikipedia'] = (Perms.voice, wp)

def weather(who, where, args):
  reply(who, where, "I'm sorry, troggie isn't here, and I don't know how to do that.")
weather = troggie(weather)
commands['weather'] = (Perms.voice, weather)

weak_mask_re = re.compile(".+!.+@.+")

def ignore(who, where, args):
  if args.lower().strip() == "list":
    banlist = ", ".join([user for user in my_users if my_users[user] == Perms.ban])
    reply(who, where, "Currently ignoring: %s" % banlist)
    return
  if not weak_mask_re.search(args):
    reply(who, where, "Please give a full nick!user@host mask.")
    return
  my_users[args] = Perms.ban
  reply(who, where, "Done.")
commands['ignore'] = (Perms.ircop, ignore)

def unignore(who, where, args):
  if args in my_users and my_users[args] == Perms.ban:
    my_users[args] = Perms.none
    reply(who, where, "Done.")
  else:
    reply(who, where, "I wasn't ignoring them.")
commands['unignore'] = (Perms.ircop, unignore)

def extract_my_db(dbs, who, where, default_maker):
  if where == private:
    key = who
  else:
    key = where
  if key not in dbs:
    default = default_maker()
    dbs[key] = default
  return dbs[key]

def get_fact_dbs(who, where):
  factoids = extract_my_db(factoid_dbs, who, where, ircbot.IRCDict)
  locked = extract_my_db(locked_dbs, who, where, ircbot.IRCDict)
  return (factoids, locked)

def do_is(who, where, args):
  (key, to_be, garbage, fact) = args
  (factoids, locked) = get_fact_dbs(who, where)
  if key.endswith('?'):
    key = key[:-1]
  if locked.get(key):
    reply(who, where, "I'm sorry, %s, I'm afraid I can't do that." % who, all=True)
    return
  elif fact:
    factoids[key] = (to_be, fact)
  elif key in factoids:
    del factoids[key]
do_is = troggie(do_is)
commands['do is'] = (Perms.voice, do_is)

def forget(who, where, args):
  (factoids, locked) = get_fact_dbs(who, where)
  key = args
  if locked.get(key):
    reply(who, where, "I'm sorry, %s, I'm afraid I can't do that." % who, all=True)
  elif key in factoids:
    del factoids[key]
    reply(who, where, "I forgot %s." % key)
  else:
    reply(who, where, "I don't have anything matching '%s'." % key)
forget = troggie(forget)
commands['forget'] = (Perms.voice, forget)

def force(who, where, args):
  (factoids, locked) = get_fact_dbs(who, where)
  if not is_re.search(args):
    reply(who, where, "Syntax: $force a (is/are/was/were) b")
    return
  (key, to_be, garbage, fact) = resize(is_re.split(args, 1),4)
  if key.endswith('?'):
    key = key[:-1]
  if fact:
    factoids[key] = (to_be, fact)
  elif key in factoids:
    del factoids[key]
commands['force'] = (Perms.op, force)

def lock(who, where, args):
  (factoids, locked) = get_fact_dbs(who, where)
  if args.endswith('?'):
    args = args[:-1]
  if not locked.get(args):
    locked[args] = True
    reply(who, where, "Done.")
  else:
    reply(who, where, "It's already locked.")
commands['lock'] = (Perms.op, lock)

def unlock(who, where, args):
  (factoids, locked) = get_fact_dbs(who, where)
  if args.endswith('?'):
    args = args[:-1]
  if locked.get(args):
    locked[args] = False
    reply(who, where, "Done.")
  else:
    reply(who, where, "It's not locked.")
commands['unlock'] = (Perms.op, unlock)

def factoid(who, where, args, implicit=False):
  (factoids, locked) = get_fact_dbs(who, where)
  if args.endswith('?'):
    args = args[:-1]
  if args in factoids:
    (to_be, fact) = factoids[args]
    if not implicit and fact.count("$who"):
      implicit = True
    response = ""
    lfact = fact.lower()
    if lfact.startswith("<"):
      if lfact.startswith("<raw>"):
        response = fact[5:].lstrip()
      elif lfact.startswith("<reply>"):
        response = fact[7:].lstrip()
      elif lfact.startswith("<action>"):
        response = "\x01ACTION %s\x01" % fact[8:].lstrip()
    if not response:
      response = "I hear that %s %s %s" % (args, to_be, fact)
    response = response.replace("$who", who)
    reply(who, where, response, all=implicit)
  elif not implicit:
    reply(who, where, "I don't have anything matching '%s'." % args)
commands['fact'] = (Perms.voice, factoid)
commands['factoid'] = (Perms.voice, factoid)

def factoid_implicit(who, where, args):
  factoid(who, where, args, implicit=True)
factoid_implicit = troggie(factoid_implicit)
commands['factoid implicit'] = (Perms.voice, factoid_implicit)

def get_time(who, where, args):
  reply(who, where, "Current time is: " + get_timestamp())
commands['time'] = (Perms.voice, get_time)

def get_reminder_db(who, where):
  return extract_my_db(reminder_dbs, who, where, lambda: [])

def describe_reminder(reminder):
  (when, message, groups, repeat) = reminder
  description = '"%s" at %s.' % (message, get_timestamp(when))
  if groups:
    groupstr = ",".join(groups)
    description += "  Groups: " + groupstr
  if repeat:
    hours = repeat / 3600
    minutes = str(repeat / 60 % 60).zfill(2)
    description += "  Repeating every %d:%s." % (hours, minutes)
  return description

reminder_res = {"add": re.compile(r'^"((?:[^"]|\")*)" +at +([^"]*)$',
                                  re.IGNORECASE),
                "set": re.compile(r'^(\d+) +(\w+) +(.*)$', re.IGNORECASE),
                "repeat h+:mm": re.compile(r'^(\d+) +every +(\d+):(\d\d)$', 
                                           re.IGNORECASE),
                "repeat x units": re.compile(r'^(\d+) +every +(\d+) +' + 
                                             r'(week|day|hour|minute)s?$',
                                             re.IGNORECASE),
                "repeat off": re.compile(r'^(\d+) +(off|disable|stop|never|none'
                                        +r'|remove)$', 
                                         re.IGNORECASE)
               }

time_units = {"minute": 60,
              "hour": 60*60,
              "day": 60*60*24,
              "week": 60*60*24*7}

def safeint(intstr):
  try:
    return int(intstr)
  except ValueError:
    return -1

def reminder_index(who, where, reminders, whichstr):
  which = safeint(whichstr)
  if which < 1:
    reply(who, where, "Which reminder?")
    return -1
  if which > len(reminders):
    reply(who, where, "I don't have that many reminders.")
    return -1
  return which - 1

def real_where(who, where):
  if where == private:
    return who
  return where

def fire_reminder(where, reminders, reminder):
  (when, message, groups, repeat) = reminder
  curtime = time.time()
  if when < (curtime - 60):
    delay = curtime - when
    reply('', where, "Reminder delayed by %d minutes: %s" % (delay // 60, 
          message), all=True)
  else:
    delay = 0
    reply('', where, message, all=True)
  if repeat:
    if repeat < delay:
      skip = delay // repeat
      reply('', where, "(skipping %d delayed repititions)" % skip, all=True)
      real_repeat = (skip + 1) * repeat
    else:
      real_repeat = repeat
    reminder[0] += real_repeat
    schedule_reminder(where, reminders, reminder)
  else:
    reminders.remove(reminder)
fire_reminder = safe(fire_reminder)

def schedule_reminder(where, reminders, reminder):
  scheduler.enterabs(reminder[0], 0, fire_reminder, (where, reminders, reminder))

def add_reminder(who, where, reminders, reminder):
  if len(reminders) < 10 or where == "#casualgameplay":
    reminders.append(reminder)
    schedule_reminder(real_where(who, where), reminders, reminder)
    reply(who, where, "Done.")
  else:
    reply(who, where, 
          "I'm sorry, %s, I'm afraid I can't do that.  You're limited to 10."
                    % who)

def cancel_reminder(where, reminders, reminder):
  try:
    scheduler.cancel((reminder[0], 0, fire_reminder, (where, reminders, reminder)))
  except ValueError:
    pass

def reschedule(who, where, reminders, reminder, when):
  rwhere = real_where(who, where)
  cancel_reminder(rwhere, reminders, reminder)
  reminder[0] = when
  schedule_reminder(rwhere, reminders, reminder)

def reminder(who, where, reminder_args):
  (command, args) = resize(reminder_args.split(" ", 1), 2)
  reminders = get_reminder_db(who, where)
  if not command:
    reply(who, where, "Available reminder commands: add del list set repeat help")
  elif command in ("add", "new", "create", "make"):
    parsed = reminder_res["add"].search(args)
    if not parsed:
      reply(who, where, "I don't understand that.  Try $reminder help add")
      return
    (msg, whenstr) = parsed.groups()
    try:
      when = parse_time(whenstr)
    except ValueError:
      reply(who, where, "I don't understand that time.")
      return
    reminder = [when, msg, [], 0]
    add_reminder(who, where, reminders, reminder)
  elif command in ("del", "delete", "remove", "rm"):
    which = reminder_index(who, where, reminders, args)
    if which == -1:
      return
    reminder = reminders[which]
    del reminders[which]
    cancel_reminder(real_where(who, where), reminders, reminder)
    reply(who, where, "Deleted reminder %d: %s" % 
                                    (which+1, describe_reminder(reminder)))
  elif command in ("list", "show"):
    if len(reminders) > 5:
      reply(who, where, "Listing %d reminders in private " % len(reminders)
                        + "to avoid channel clutter")
      where = private
    if not reminders:
      reply(who, where, "No reminders.")
    index = 1
    for reminder in reminders:
      reply(who, where, "%2d. %s" % (index, describe_reminder(reminder)))
      index += 1
  elif command in ("change", "alter", "set"):
    parsed = reminder_res["set"].search(args)
    if not parsed:
      reply(who, where, "I don't understand that.  Try $reminder help set")
      return
    (whichstr, property, value) = parsed.groups()
    which = reminder_index(who, where, reminders, whichstr)
    if which == -1:
      return
    reminder = reminders[which]
    lproperty = property.lower()
    if lproperty in ("message", "msg"):
      reminder[1] = value
    elif lproperty == "time":
      try:
        when = parse_time(value)
        reschedule(who, where, reminders, reminder, when)
      except ValueError:
        reply(who, where, "I don't understand that time.")
        return
    elif lproperty in ("group", "groups"):
      groups = value.split(",")
      groups = [group.strip() for group in groups]
      reminder[2] = groups
    reply(who, where, "Done.")
  elif command == "repeat":
    parse_hm = reminder_res["repeat h+:mm"].search(args)
    parse_units = reminder_res["repeat x units"].search(args)
    parse_off = reminder_res["repeat off"].search(args)
    parsed = parse_hm or parse_units or parse_off
    if parsed:
      which = reminder_index(who, where, reminders, parsed.groups()[0])
      if which == -1:
        return
      reminder = reminders[which]
    else:
      reply(who, where, "I don't understand that.  Try $reminder help repeat")
      return
    if parse_hm:
      (whichstr, hourstr, minutestr) = parsed.groups()
      hours = safeint(hourstr)
      if hours < 0:
        reply(who, where, "Bad number of hours.")
        return
      minutes = safeint(minutestr)
      # Mathematicians, read at your own peril.
      if 59 < minutes < 0: 
        reply(who, where, "Bad number of minutes.")
        return
      if hours == minutes == 0:
        reply(who, where, "Repeating continuously sounds like a bad idea.")
        return
      reminder[3] = 60 * (minutes + 60 * hours)
      reply(who, where, 
            "Reminder number %d now repeating every %d hours and %d minutes." 
                         % (which+1,               hours,      minutes))
    elif parse_units:
      (whichstr, numstr, unit) = parsed.groups()
      unit = unit.lower()
      num = safeint(numstr)
      if numstr < 1:
        reply(who, where, "Bad number of %ss." % unit)
        return
      if unit not in time_units:
        reply(who, where, "I don't know that unit.")
        return
      reminder[3] = num * time_units[unit]
      reply(who, where, "Reminder number %d now repeating every %d %ss." 
                                    % (which+1,               num, unit))
    else: # parse_off
      reminder[3] = 0
      reply(who, where, "Repeating disabled on reminder %d." % which+1)
        
  elif command == "help":
    if not args:
      reply(who, where, "To get help on a specific command, type $reminder " \
                        + "help <command> (e.g. $reminder help add).  " \
                        + "Available reminder commands: add del list set "\
                        + "repeat help")
    elif args in ("add", "new", "create", "make"):
      reply(who, where, '$reminder add "<msg>" at <time>:  Adds a new ' \
                        + "reminder.  When <time> comes, I will say <msg>.  A" \
                        + " variety of time formats are supported.  Use $time" \
                        + " to get my current time for comparison.")
    elif args in ("del", "delete", "remove", "rm"):
      reply(who, where, "$reminder del <reminder>: Delete reminder number " \
                        + "<reminder>.");
    elif args in ("change", "alter", "set"):
      reply(who, where, "$reminder set <reminder> <property> <value>: Change" \
                        + " <property> of reminder number <reminder> to " \
                        + "<value>.  Availale properties: message, time, group")
    elif args in ("list", "show"):
      reply(who, where, "$reminder list: Print a list of reminders.  If there" \
                        + " are more than 5, I will reply in private.")
    elif args == "repeat":
      reply(who, where, "$reminder repeat <reminder> every <interval>: " \
                        + "Reminder number <reminder> will be repeated every " \
                        + "<interval>.  Use $reminder repeat <reminder> off to"\
                        + " stop repeating a reminder.")
    elif args == "help":
      reply(who, where, "$reminder help <command>: get help on <command>.  " \
                        + "You know, like you just did.")
  else:
    reply(who, where, "I don't understand that.")
commands['reminder'] = (Perms.admin, reminder)
commands['reminders'] = (Perms.admin, reminder)

def subscribe(who, where, args):
  if where == private:
    reply(who, where, "Don't you think subscribing to reminders that are" +
                      " already in PM is a bit... pointless?")
    return


def do_commands(who):
  user = whois_info[who]
  for where, command, args in waiting_commands[who]:
    if command not in commands:
      command = 'raise error'
      args = "I don't understand that."
    (required_perms, do_it) = commands[command]
    if required_perms <= get_perms(who, where):
      safe_call(do_it, (who, where, args))
  waiting_commands[who] = []

#@safe
def got_whois(conn, event):
  user = event.arguments()[0]
  whois_info[user] = Whois()
got_whois = safe(got_whois)
irc.add_global_handler("whoisuser", got_whois)
irc.add_global_handler("nosuchnick", got_whois)

#@safe
def got_registered(conn, event):
  args = event.arguments()
  if len(args) == 2 and args[1] == "is a registered nick":
    user = args[0]
    whois_info[user].registered = True
got_registered = safe(got_registered)
irc.add_global_handler("307", got_registered)

#@safe
def got_channels(conn, event):
  args = event.arguments()
  if len(args) == 2:
    user = args[0]
    channels = args[1].split()
    for c in channels:
      if c[0] != "#":
        whois_info[user].channel_perms[c[1:]] = Perms.from_symbol(c[0])
      else:
        whois_info[user].channel_perms[c] = Perms.present
got_channels = safe(got_channels)
irc.add_global_handler("whoischannels", got_channels)

#@safe
def got_servop(conn, event):
  args = event.arguments()
  if len(args) == 2:
    user = args[0]
    whois_info[user].ircop = True
got_servop = safe(got_servop)
irc.add_global_handler("whoisoperator", got_servop)

#@safe
def got_whoend(conn, event):
  who = event.arguments()[0]
  do_commands(who)
  if False:
    user = whois_info[who]
    print "Who info for %s:" % who
    print "Registered: %s" % user.registered
    print "IRCop: %s" % user.ircop
    p = user.channel_perms
    perms = "".join([("%s: %s, " % (k, p[k])) for k in p])[:-2]
    print "Channel info: %s" % perms
got_whoend = safe(got_whoend)
irc.add_global_handler("endofwhois", got_whoend)

#@safe
def got_invite(conn, event):
  who = irclib.nm_to_n(event.source())
  where = event.arguments()[0]
  got_command(who, where, "do join")
got_invite = safe(got_invite)
irc.add_global_handler("invite", got_invite)

#@safe
def got_msg(conn, event):
  for user in my_users:
    if irclib.mask_matches(event.source(), user):
      if my_users[user] == Perms.ban:
        return
  msg = event.arguments()[0]
  who = irclib.nm_to_n(event.source())
  (command, args) = resize(msg.split(" ", 1),2)
  if command and command[0] == "$":
    command = command[1:]

  if event.eventtype() == 'privmsg':
    where = private
  else:
    where = event.target()
    if msg.count("http://"):
      got_command(who, where, "title implicit", html.extract_url(msg))
    if msg[0] != "$":
      if nick_re.match(msg):
        (me, command, args) = resize(msg.split(" ", 2),3)
        if command in commands:
          pass
        elif is_re.search(msg):
          command = "do is"
          args = is_re.split(msg.split(" ", 1)[1], 1)
        else:
          command = "factoid implicit"
          args = msg.split(" ", 1)[1]
      else:
        if command in commands and commands[command][0] <= Perms.voice:
          pass
        elif is_re.search(msg):
          command = "do is"
          args = is_re.split(msg, 1)
        else:
          command = "factoid implicit"
          args = msg
  got_command(who, where, command, args)  
got_msg = safe(got_msg)
irc.add_global_handler("privmsg", got_msg)
irc.add_global_handler("pubmsg", got_msg)


def debug_console():
  while DEBUG:
    cmd = sys.stdin.readline().strip()
    if cmd:
      hal.connection.send_raw(cmd)
thread.start_new_thread(debug_console, ())

def run_reminders():
  for where in reminder_dbs.keys():
    db = reminder_dbs[where]
    for reminder in db:
      schedule_reminder(where, db, reminder)
  while True: # Looping in case of errors.
    safe(scheduler.run_forever)()
thread.start_new_thread(run_reminders, ())

hal.ircobj.process_forever(None)