From 0ab04a77e7edb63bd87889a4361549ef554a96d6 Mon Sep 17 00:00:00 2001
From: Chris Oliver <excid3@gmail.com>
Date: Sat, 13 Feb 2010 17:37:58 -0600
Subject: Fixed up the bot a ton, rewrote it from scratch

---
 conf/example.conf   |   21 +-
 conf/stylesheet.css |   10 +-
 irclib.py           | 1560 ---------------------------------------------------
 logbot.py           |  330 +++++------
 4 files changed, 181 insertions(+), 1740 deletions(-)
 delete mode 100644 irclib.py

diff --git a/conf/example.conf b/conf/example.conf
index cc2a4e2..099ab9d 100644
--- a/conf/example.conf
+++ b/conf/example.conf
@@ -1,11 +1,26 @@
 [irc]
-network = irc.freenode.net
+server = irc.freenode.net
 port = 6667
 channels = #keryx
 nick = Timber
-password = 
+
+# This your nick identification password
+password = testing
+
+# Comma separated list of owner nicks
 owners = excid3
 
 [log]
+# Location to store the logs
 folder = logs
-stylesheet = file:///C:\Users\Chris Oliver\Desktop\logbot\conf\stylesheet.css
+# Location of the stylesheet
+stylesheet = conf/stylesheet.css
+
+[format]
+join = -!- <span class="join">%user%</span> [%host%] has joined %channel%
+kick = -!- <span class="kick">%user%</span> was kicked from %channel% by %kicker% [%reason%]
+mode = -!- mode/<span class="mode">%channel%</span> [%modes% %person%] by %giver%
+part = -!- <span class="part">%user%</span> has parted %channel%
+pubmsg = <span class="person">&lt;%user%&gt;</span> %message%
+pubnotice = <span class="notice">-%user%:%channel%-</span> %message%
+quit = -!- <span class="quit">%user%</span> has quit [%reason%]
\ No newline at end of file
diff --git a/conf/stylesheet.css b/conf/stylesheet.css
index 6842b73..17318bd 100644
--- a/conf/stylesheet.css
+++ b/conf/stylesheet.css
@@ -4,12 +4,18 @@ body {
     font-size: 13px;
 }
 
-.time {
+h1 {
+    font-family: sans-serif;
+    font-size: 24px;
+    text-align: center;
+}
+
+a, .time {
     color: #525552;
     text-decoration: none;
 }
 
-.time:hover { text-decoration: underline; }
+a:hover, .time:hover { text-decoration: underline; }
 
 .person { color: #DD1144; }
 
diff --git a/irclib.py b/irclib.py
deleted file mode 100644
index 5f7141c..0000000
--- a/irclib.py
+++ /dev/null
@@ -1,1560 +0,0 @@
-# Copyright (C) 1999--2002  Joel Rosdahl
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library 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
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
-#
-# keltus <keltus@users.sourceforge.net>
-#
-# $Id: irclib.py,v 1.47 2008/09/25 22:00:59 keltus Exp $
-
-"""irclib -- Internet Relay Chat (IRC) protocol client library.
-
-This library is intended to encapsulate the IRC protocol at a quite
-low level.  It provides an event-driven IRC client framework.  It has
-a fairly thorough support for the basic IRC protocol, CTCP, DCC chat,
-but DCC file transfers is not yet supported.
-
-In order to understand how to make an IRC client, I'm afraid you more
-or less must understand the IRC specifications.  They are available
-here: [IRC specifications].
-
-The main features of the IRC client framework are:
-
-  * Abstraction of the IRC protocol.
-  * Handles multiple simultaneous IRC server connections.
-  * Handles server PONGing transparently.
-  * Messages to the IRC server are done by calling methods on an IRC
-    connection object.
-  * Messages from an IRC server triggers events, which can be caught
-    by event handlers.
-  * Reading from and writing to IRC server sockets are normally done
-    by an internal select() loop, but the select()ing may be done by
-    an external main loop.
-  * Functions can be registered to execute at specified times by the
-    event-loop.
-  * Decodes CTCP tagging correctly (hopefully); I haven't seen any
-    other IRC client implementation that handles the CTCP
-    specification subtilties.
-  * A kind of simple, single-server, object-oriented IRC client class
-    that dispatches events to instance methods is included.
-
-Current limitations:
-
-  * The IRC protocol shines through the abstraction a bit too much.
-  * Data is not written asynchronously to the server, i.e. the write()
-    may block if the TCP buffers are stuffed.
-  * There are no support for DCC file transfers.
-  * The author haven't even read RFC 2810, 2811, 2812 and 2813.
-  * Like most projects, documentation is lacking...
-
-.. [IRC specifications] http://www.irchelp.org/irchelp/rfc/
-"""
-
-import bisect
-import re
-import select
-import socket
-import string
-import sys
-import time
-import types
-
-VERSION = 0, 4, 8
-DEBUG = 0
-
-# TODO
-# ----
-# (maybe) thread safety
-# (maybe) color parser convenience functions
-# documentation (including all event types)
-# (maybe) add awareness of different types of ircds
-# send data asynchronously to the server (and DCC connections)
-# (maybe) automatically close unused, passive DCC connections after a while
-
-# NOTES
-# -----
-# connection.quit() only sends QUIT to the server.
-# ERROR from the server triggers the error event and the disconnect event.
-# dropping of the connection triggers the disconnect event.
-
-class IRCError(Exception):
-    """Represents an IRC exception."""
-    pass
-
-
-class IRC:
-    """Class that handles one or several IRC server connections.
-
-    When an IRC object has been instantiated, it can be used to create
-    Connection objects that represent the IRC connections.  The
-    responsibility of the IRC object is to provide an event-driven
-    framework for the connections and to keep the connections alive.
-    It runs a select loop to poll each connection's TCP socket and
-    hands over the sockets with incoming data for processing by the
-    corresponding connection.
-
-    The methods of most interest for an IRC client writer are server,
-    add_global_handler, remove_global_handler, execute_at,
-    execute_delayed, process_once and process_forever.
-
-    Here is an example:
-
-        irc = irclib.IRC()
-        server = irc.server()
-        server.connect(\"irc.some.where\", 6667, \"my_nickname\")
-        server.privmsg(\"a_nickname\", \"Hi there!\")
-        irc.process_forever()
-
-    This will connect to the IRC server irc.some.where on port 6667
-    using the nickname my_nickname and send the message \"Hi there!\"
-    to the nickname a_nickname.
-    """
-
-    def __init__(self, fn_to_add_socket=None,
-                 fn_to_remove_socket=None,
-                 fn_to_add_timeout=None):
-        """Constructor for IRC objects.
-
-        Optional arguments are fn_to_add_socket, fn_to_remove_socket
-        and fn_to_add_timeout.  The first two specify functions that
-        will be called with a socket object as argument when the IRC
-        object wants to be notified (or stop being notified) of data
-        coming on a new socket.  When new data arrives, the method
-        process_data should be called.  Similarly, fn_to_add_timeout
-        is called with a number of seconds (a floating point number)
-        as first argument when the IRC object wants to receive a
-        notification (by calling the process_timeout method).  So, if
-        e.g. the argument is 42.17, the object wants the
-        process_timeout method to be called after 42 seconds and 170
-        milliseconds.
-
-        The three arguments mainly exist to be able to use an external
-        main loop (for example Tkinter's or PyGTK's main app loop)
-        instead of calling the process_forever method.
-
-        An alternative is to just call ServerConnection.process_once()
-        once in a while.
-        """
-
-        if fn_to_add_socket and fn_to_remove_socket:
-            self.fn_to_add_socket = fn_to_add_socket
-            self.fn_to_remove_socket = fn_to_remove_socket
-        else:
-            self.fn_to_add_socket = None
-            self.fn_to_remove_socket = None
-
-        self.fn_to_add_timeout = fn_to_add_timeout
-        self.connections = []
-        self.handlers = {}
-        self.delayed_commands = [] # list of tuples in the format (time, function, arguments)
-
-        self.add_global_handler("ping", _ping_ponger, -42)
-
-    def server(self):
-        """Creates and returns a ServerConnection object."""
-
-        c = ServerConnection(self)
-        self.connections.append(c)
-        return c
-
-    def process_data(self, sockets):
-        """Called when there is more data to read on connection sockets.
-
-        Arguments:
-
-            sockets -- A list of socket objects.
-
-        See documentation for IRC.__init__.
-        """
-        for s in sockets:
-            for c in self.connections:
-                if s == c._get_socket():
-                    c.process_data()
-
-    def process_timeout(self):
-        """Called when a timeout notification is due.
-
-        See documentation for IRC.__init__.
-        """
-        t = time.time()
-        while self.delayed_commands:
-            if t >= self.delayed_commands[0][0]:
-                self.delayed_commands[0][1](*self.delayed_commands[0][2])
-                del self.delayed_commands[0]
-            else:
-                break
-
-    def process_once(self, timeout=0):
-        """Process data from connections once.
-
-        Arguments:
-
-            timeout -- How long the select() call should wait if no
-                       data is available.
-
-        This method should be called periodically to check and process
-        incoming data, if there are any.  If that seems boring, look
-        at the process_forever method.
-        """
-        sockets = map(lambda x: x._get_socket(), self.connections)
-        sockets = filter(lambda x: x != None, sockets)
-        if sockets:
-            (i, o, e) = select.select(sockets, [], [], timeout)
-            self.process_data(i)
-        else:
-            time.sleep(timeout)
-        self.process_timeout()
-
-    def process_forever(self, timeout=0.2):
-        """Run an infinite loop, processing data from connections.
-
-        This method repeatedly calls process_once.
-
-        Arguments:
-
-            timeout -- Parameter to pass to process_once.
-        """
-        while 1:
-            self.process_once(timeout)
-
-    def disconnect_all(self, message=""):
-        """Disconnects all connections."""
-        for c in self.connections:
-            c.disconnect(message)
-
-    def add_global_handler(self, event, handler, priority=0):
-        """Adds a global handler function for a specific event type.
-
-        Arguments:
-
-            event -- Event type (a string).  Check the values of the
-            numeric_events dictionary in irclib.py for possible event
-            types.
-
-            handler -- Callback function.
-
-            priority -- A number (the lower number, the higher priority).
-
-        The handler function is called whenever the specified event is
-        triggered in any of the connections.  See documentation for
-        the Event class.
-
-        The handler functions are called in priority order (lowest
-        number is highest priority).  If a handler function returns
-        \"NO MORE\", no more handlers will be called.
-        """
-        if not event in self.handlers:
-            self.handlers[event] = []
-        bisect.insort(self.handlers[event], ((priority, handler)))
-
-    def remove_global_handler(self, event, handler):
-        """Removes a global handler function.
-
-        Arguments:
-
-            event -- Event type (a string).
-
-            handler -- Callback function.
-
-        Returns 1 on success, otherwise 0.
-        """
-        if not event in self.handlers:
-            return 0
-        for h in self.handlers[event]:
-            if handler == h[1]:
-                self.handlers[event].remove(h)
-        return 1
-
-    def execute_at(self, at, function, arguments=()):
-        """Execute a function at a specified time.
-
-        Arguments:
-
-            at -- Execute at this time (standard \"time_t\" time).
-
-            function -- Function to call.
-
-            arguments -- Arguments to give the function.
-        """
-        self.execute_delayed(at-time.time(), function, arguments)
-
-    def execute_delayed(self, delay, function, arguments=()):
-        """Execute a function after a specified time.
-
-        Arguments:
-
-            delay -- How many seconds to wait.
-
-            function -- Function to call.
-
-            arguments -- Arguments to give the function.
-        """
-        bisect.insort(self.delayed_commands, (delay+time.time(), function, arguments))
-        if self.fn_to_add_timeout:
-            self.fn_to_add_timeout(delay)
-
-    def dcc(self, dcctype="chat"):
-        """Creates and returns a DCCConnection object.
-
-        Arguments:
-
-            dcctype -- "chat" for DCC CHAT connections or "raw" for
-                       DCC SEND (or other DCC types). If "chat",
-                       incoming data will be split in newline-separated
-                       chunks. If "raw", incoming data is not touched.
-        """
-        c = DCCConnection(self, dcctype)
-        self.connections.append(c)
-        return c
-
-    def _handle_event(self, connection, event):
-        """[Internal]"""
-        h = self.handlers
-        for handler in h.get("all_events", []) + h.get(event.eventtype(), []):
-            if handler[1](connection, event) == "NO MORE":
-                return
-
-    def _remove_connection(self, connection):
-        """[Internal]"""
-        self.connections.remove(connection)
-        if self.fn_to_remove_socket:
-            self.fn_to_remove_socket(connection._get_socket())
-
-_rfc_1459_command_regexp = re.compile("^(:(?P<prefix>[^ ]+) +)?(?P<command>[^ ]+)( *(?P<argument> .+))?")
-
-class Connection:
-    """Base class for IRC connections.
-
-    Must be overridden.
-    """
-    def __init__(self, irclibobj):
-        self.irclibobj = irclibobj
-
-    def _get_socket():
-        raise IRCError, "Not overridden"
-
-    ##############################
-    ### Convenience wrappers.
-
-    def execute_at(self, at, function, arguments=()):
-        self.irclibobj.execute_at(at, function, arguments)
-
-    def execute_delayed(self, delay, function, arguments=()):
-        self.irclibobj.execute_delayed(delay, function, arguments)
-
-
-class ServerConnectionError(IRCError):
-    pass
-
-class ServerNotConnectedError(ServerConnectionError):
-    pass
-
-
-# Huh!?  Crrrrazy EFNet doesn't follow the RFC: their ircd seems to
-# use \n as message separator!  :P
-_linesep_regexp = re.compile("\r?\n")
-
-class ServerConnection(Connection):
-    """This class represents an IRC server connection.
-
-    ServerConnection objects are instantiated by calling the server
-    method on an IRC object.
-    """
-
-    def __init__(self, irclibobj):
-        Connection.__init__(self, irclibobj)
-        self.connected = 0  # Not connected yet.
-        self.socket = None
-        self.ssl = None
-
-    def connect(self, server, port, nickname, password=None, username=None,
-                ircname=None, localaddress="", localport=0, ssl=False, ipv6=False):
-        """Connect/reconnect to a server.
-
-        Arguments:
-
-            server -- Server name.
-
-            port -- Port number.
-
-            nickname -- The nickname.
-
-            password -- Password (if any).
-
-            username -- The username.
-
-            ircname -- The IRC name ("realname").
-
-            localaddress -- Bind the connection to a specific local IP address.
-
-            localport -- Bind the connection to a specific local port.
-
-            ssl -- Enable support for ssl.
-
-            ipv6 -- Enable support for ipv6.
-
-        This function can be called to reconnect a closed connection.
-
-        Returns the ServerConnection object.
-        """
-        if self.connected:
-            self.disconnect("Changing servers")
-
-        self.previous_buffer = ""
-        self.handlers = {}
-        self.real_server_name = ""
-        self.real_nickname = nickname
-        self.server = server
-        self.port = port
-        self.nickname = nickname
-        self.username = username or nickname
-        self.ircname = ircname or nickname
-        self.password = password
-        self.localaddress = localaddress
-        self.localport = localport
-        self.localhost = socket.gethostname()
-        if ipv6:
-            self.socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
-        else:
-            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        try:
-            self.socket.bind((self.localaddress, self.localport))
-            self.socket.connect((self.server, self.port))
-            if ssl:
-                self.ssl = socket.ssl(self.socket)
-        except socket.error, x:
-            self.socket.close()
-            self.socket = None
-            raise ServerConnectionError, "Couldn't connect to socket: %s" % x
-        self.connected = 1
-        if self.irclibobj.fn_to_add_socket:
-            self.irclibobj.fn_to_add_socket(self.socket)
-
-        # Log on...
-        if self.password:
-            self.pass_(self.password)
-        self.nick(self.nickname)
-        self.user(self.username, self.ircname)
-        return self
-
-    def close(self):
-        """Close the connection.
-
-        This method closes the connection permanently; after it has
-        been called, the object is unusable.
-        """
-
-        self.disconnect("Closing object")
-        self.irclibobj._remove_connection(self)
-
-    def _get_socket(self):
-        """[Internal]"""
-        return self.socket
-
-    def get_server_name(self):
-        """Get the (real) server name.
-
-        This method returns the (real) server name, or, more
-        specifically, what the server calls itself.
-        """
-
-        if self.real_server_name:
-            return self.real_server_name
-        else:
-            return ""
-
-    def get_nickname(self):
-        """Get the (real) nick name.
-
-        This method returns the (real) nickname.  The library keeps
-        track of nick changes, so it might not be the nick name that
-        was passed to the connect() method.  """
-
-        return self.real_nickname
-
-    def process_data(self):
-        """[Internal]"""
-
-        try:
-            if self.ssl:
-                new_data = self.ssl.read(2**14)
-            else:
-                new_data = self.socket.recv(2**14)
-        except socket.error, x:
-            # The server hung up.
-            self.disconnect("Connection reset by peer")
-            return
-        if not new_data:
-            # Read nothing: connection must be down.
-            self.disconnect("Connection reset by peer")
-            return
-
-        lines = _linesep_regexp.split(self.previous_buffer + new_data)
-
-        # Save the last, unfinished line.
-        self.previous_buffer = lines.pop()
-
-        for line in lines:
-            if DEBUG:
-                print "FROM SERVER:", line
-
-            if not line:
-                continue
-
-            prefix = None
-            command = None
-            arguments = None
-            self._handle_event(Event("all_raw_messages",
-                                     self.get_server_name(),
-                                     None,
-                                     [line]))
-
-            m = _rfc_1459_command_regexp.match(line)
-            if m.group("prefix"):
-                prefix = m.group("prefix")
-                if not self.real_server_name:
-                    self.real_server_name = prefix
-
-            if m.group("command"):
-                command = m.group("command").lower()
-
-            if m.group("argument"):
-                a = m.group("argument").split(" :", 1)
-                arguments = a[0].split()
-                if len(a) == 2:
-                    arguments.append(a[1])
-
-            # Translate numerics into more readable strings.
-            if command in numeric_events:
-                command = numeric_events[command]
-
-            if command == "nick":
-                if nm_to_n(prefix) == self.real_nickname:
-                    self.real_nickname = arguments[0]
-            elif command == "welcome":
-                # Record the nickname in case the client changed nick
-                # in a nicknameinuse callback.
-                self.real_nickname = arguments[0]
-
-            if command in ["privmsg", "notice"]:
-                target, message = arguments[0], arguments[1]
-                messages = _ctcp_dequote(message)
-
-                if command == "privmsg":
-                    if is_channel(target):
-                        command = "pubmsg"
-                else:
-                    if is_channel(target):
-                        command = "pubnotice"
-                    else:
-                        command = "privnotice"
-
-                for m in messages:
-                    if type(m) is types.TupleType:
-                        if command in ["privmsg", "pubmsg"]:
-                            command = "ctcp"
-                        else:
-                            command = "ctcpreply"
-
-                        m = list(m)
-                        if DEBUG:
-                            print "command: %s, source: %s, target: %s, arguments: %s" % (
-                                command, prefix, target, m)
-                        self._handle_event(Event(command, prefix, target, m))
-                        if command == "ctcp" and m[0] == "ACTION":
-                            self._handle_event(Event("action", prefix, target, m[1:]))
-                    else:
-                        if DEBUG:
-                            print "command: %s, source: %s, target: %s, arguments: %s" % (
-                                command, prefix, target, [m])
-                        self._handle_event(Event(command, prefix, target, [m]))
-            else:
-                target = None
-
-                if command == "quit":
-                    arguments = [arguments[0]]
-                elif command == "ping":
-                    target = arguments[0]
-                else:
-                    target = arguments[0]
-                    arguments = arguments[1:]
-
-                if command == "mode":
-                    if not is_channel(target):
-                        command = "umode"
-
-                if DEBUG:
-                    print "command: %s, source: %s, target: %s, arguments: %s" % (
-                        command, prefix, target, arguments)
-                self._handle_event(Event(command, prefix, target, arguments))
-
-    def _handle_event(self, event):
-        """[Internal]"""
-        self.irclibobj._handle_event(self, event)
-        if event.eventtype() in self.handlers:
-            for fn in self.handlers[event.eventtype()]:
-                fn(self, event)
-
-    def is_connected(self):
-        """Return connection status.
-
-        Returns true if connected, otherwise false.
-        """
-        return self.connected
-
-    def add_global_handler(self, *args):
-        """Add global handler.
-
-        See documentation for IRC.add_global_handler.
-        """
-        self.irclibobj.add_global_handler(*args)
-
-    def remove_global_handler(self, *args):
-        """Remove global handler.
-
-        See documentation for IRC.remove_global_handler.
-        """
-        self.irclibobj.remove_global_handler(*args)
-
-    def action(self, target, action):
-        """Send a CTCP ACTION command."""
-        self.ctcp("ACTION", target, action)
-
-    def admin(self, server=""):
-        """Send an ADMIN command."""
-        self.send_raw(" ".join(["ADMIN", server]).strip())
-
-    def ctcp(self, ctcptype, target, parameter=""):
-        """Send a CTCP command."""
-        ctcptype = ctcptype.upper()
-        self.privmsg(target, "\001%s%s\001" % (ctcptype, parameter and (" " + parameter) or ""))
-
-    def ctcp_reply(self, target, parameter):
-        """Send a CTCP REPLY command."""
-        self.notice(target, "\001%s\001" % parameter)
-
-    def disconnect(self, message=""):
-        """Hang up the connection.
-
-        Arguments:
-
-            message -- Quit message.
-        """
-        if not self.connected:
-            return
-
-        self.connected = 0
-
-        self.quit(message)
-
-        try:
-            self.socket.close()
-        except socket.error, x:
-            pass
-        self.socket = None
-        self._handle_event(Event("disconnect", self.server, "", [message]))
-
-    def globops(self, text):
-        """Send a GLOBOPS command."""
-        self.send_raw("GLOBOPS :" + text)
-
-    def info(self, server=""):
-        """Send an INFO command."""
-        self.send_raw(" ".join(["INFO", server]).strip())
-
-    def invite(self, nick, channel):
-        """Send an INVITE command."""
-        self.send_raw(" ".join(["INVITE", nick, channel]).strip())
-
-    def ison(self, nicks):
-        """Send an ISON command.
-
-        Arguments:
-
-            nicks -- List of nicks.
-        """
-        self.send_raw("ISON " + " ".join(nicks))
-
-    def join(self, channel, key=""):
-        """Send a JOIN command."""
-        self.send_raw("JOIN %s%s" % (channel, (key and (" " + key))))
-
-    def kick(self, channel, nick, comment=""):
-        """Send a KICK command."""
-        self.send_raw("KICK %s %s%s" % (channel, nick, (comment and (" :" + comment))))
-
-    def links(self, remote_server="", server_mask=""):
-        """Send a LINKS command."""
-        command = "LINKS"
-        if remote_server:
-            command = command + " " + remote_server
-        if server_mask:
-            command = command + " " + server_mask
-        self.send_raw(command)
-
-    def list(self, channels=None, server=""):
-        """Send a LIST command."""
-        command = "LIST"
-        if channels:
-            command = command + " " + ",".join(channels)
-        if server:
-            command = command + " " + server
-        self.send_raw(command)
-
-    def lusers(self, server=""):
-        """Send a LUSERS command."""
-        self.send_raw("LUSERS" + (server and (" " + server)))
-
-    def mode(self, target, command):
-        """Send a MODE command."""
-        self.send_raw("MODE %s %s" % (target, command))
-
-    def motd(self, server=""):
-        """Send an MOTD command."""
-        self.send_raw("MOTD" + (server and (" " + server)))
-
-    def names(self, channels=None):
-        """Send a NAMES command."""
-        self.send_raw("NAMES" + (channels and (" " + ",".join(channels)) or ""))
-
-    def nick(self, newnick):
-        """Send a NICK command."""
-        self.send_raw("NICK " + newnick)
-
-    def notice(self, target, text):
-        """Send a NOTICE command."""
-        # Should limit len(text) here!
-        self.send_raw("NOTICE %s :%s" % (target, text))
-
-    def oper(self, nick, password):
-        """Send an OPER command."""
-        self.send_raw("OPER %s %s" % (nick, password))
-
-    def part(self, channels, message=""):
-        """Send a PART command."""
-        if type(channels) == types.StringType:
-            self.send_raw("PART " + channels + (message and (" " + message)))
-        else:
-            self.send_raw("PART " + ",".join(channels) + (message and (" " + message)))
-
-    def pass_(self, password):
-        """Send a PASS command."""
-        self.send_raw("PASS " + password)
-
-    def ping(self, target, target2=""):
-        """Send a PING command."""
-        self.send_raw("PING %s%s" % (target, target2 and (" " + target2)))
-
-    def pong(self, target, target2=""):
-        """Send a PONG command."""
-        self.send_raw("PONG %s%s" % (target, target2 and (" " + target2)))
-
-    def privmsg(self, target, text):
-        """Send a PRIVMSG command."""
-        # Should limit len(text) here!
-        self.send_raw("PRIVMSG %s :%s" % (target, text))
-
-    def privmsg_many(self, targets, text):
-        """Send a PRIVMSG command to multiple targets."""
-        # Should limit len(text) here!
-        self.send_raw("PRIVMSG %s :%s" % (",".join(targets), text))
-
-    def quit(self, message=""):
-        """Send a QUIT command."""
-        # Note that many IRC servers don't use your QUIT message
-        # unless you've been connected for at least 5 minutes!
-        self.send_raw("QUIT" + (message and (" :" + message)))
-
-    def send_raw(self, string):
-        """Send raw string to the server.
-
-        The string will be padded with appropriate CR LF.
-        """
-        if self.socket is None:
-            raise ServerNotConnectedError, "Not connected."
-        try:
-            if self.ssl:
-                self.ssl.write(string + "\r\n")
-            else:
-                self.socket.send(string + "\r\n")
-            if DEBUG:
-                print "TO SERVER:", string
-        except socket.error, x:
-            # Ouch!
-            self.disconnect("Connection reset by peer.")
-
-    def squit(self, server, comment=""):
-        """Send an SQUIT command."""
-        self.send_raw("SQUIT %s%s" % (server, comment and (" :" + comment)))
-
-    def stats(self, statstype, server=""):
-        """Send a STATS command."""
-        self.send_raw("STATS %s%s" % (statstype, server and (" " + server)))
-
-    def time(self, server=""):
-        """Send a TIME command."""
-        self.send_raw("TIME" + (server and (" " + server)))
-
-    def topic(self, channel, new_topic=None):
-        """Send a TOPIC command."""
-        if new_topic is None:
-            self.send_raw("TOPIC " + channel)
-        else:
-            self.send_raw("TOPIC %s :%s" % (channel, new_topic))
-
-    def trace(self, target=""):
-        """Send a TRACE command."""
-        self.send_raw("TRACE" + (target and (" " + target)))
-
-    def user(self, username, realname):
-        """Send a USER command."""
-        self.send_raw("USER %s 0 * :%s" % (username, realname))
-
-    def userhost(self, nicks):
-        """Send a USERHOST command."""
-        self.send_raw("USERHOST " + ",".join(nicks))
-
-    def users(self, server=""):
-        """Send a USERS command."""
-        self.send_raw("USERS" + (server and (" " + server)))
-
-    def version(self, server=""):
-        """Send a VERSION command."""
-        self.send_raw("VERSION" + (server and (" " + server)))
-
-    def wallops(self, text):
-        """Send a WALLOPS command."""
-        self.send_raw("WALLOPS :" + text)
-
-    def who(self, target="", op=""):
-        """Send a WHO command."""
-        self.send_raw("WHO%s%s" % (target and (" " + target), op and (" o")))
-
-    def whois(self, targets):
-        """Send a WHOIS command."""
-        self.send_raw("WHOIS " + ",".join(targets))
-
-    def whowas(self, nick, max="", server=""):
-        """Send a WHOWAS command."""
-        self.send_raw("WHOWAS %s%s%s" % (nick,
-                                         max and (" " + max),
-                                         server and (" " + server)))
-
-class DCCConnectionError(IRCError):
-    pass
-
-
-class DCCConnection(Connection):
-    """This class represents a DCC connection.
-
-    DCCConnection objects are instantiated by calling the dcc
-    method on an IRC object.
-    """
-    def __init__(self, irclibobj, dcctype):
-        Connection.__init__(self, irclibobj)
-        self.connected = 0
-        self.passive = 0
-        self.dcctype = dcctype
-        self.peeraddress = None
-        self.peerport = None
-
-    def connect(self, address, port):
-        """Connect/reconnect to a DCC peer.
-
-        Arguments:
-            address -- Host/IP address of the peer.
-
-            port -- The port number to connect to.
-
-        Returns the DCCConnection object.
-        """
-        self.peeraddress = socket.gethostbyname(address)
-        self.peerport = port
-        self.socket = None
-        self.previous_buffer = ""
-        self.handlers = {}
-        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.passive = 0
-        try:
-            self.socket.connect((self.peeraddress, self.peerport))
-        except socket.error, x:
-            raise DCCConnectionError, "Couldn't connect to socket: %s" % x
-        self.connected = 1
-        if self.irclibobj.fn_to_add_socket:
-            self.irclibobj.fn_to_add_socket(self.socket)
-        return self
-
-    def listen(self):
-        """Wait for a connection/reconnection from a DCC peer.
-
-        Returns the DCCConnection object.
-
-        The local IP address and port are available as
-        self.localaddress and self.localport.  After connection from a
-        peer, the peer address and port are available as
-        self.peeraddress and self.peerport.
-        """
-        self.previous_buffer = ""
-        self.handlers = {}
-        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.passive = 1
-        try:
-            self.socket.bind((socket.gethostbyname(socket.gethostname()), 0))
-            self.localaddress, self.localport = self.socket.getsockname()
-            self.socket.listen(10)
-        except socket.error, x:
-            raise DCCConnectionError, "Couldn't bind socket: %s" % x
-        return self
-
-    def disconnect(self, message=""):
-        """Hang up the connection and close the object.
-
-        Arguments:
-
-            message -- Quit message.
-        """
-        if not self.connected:
-            return
-
-        self.connected = 0
-        try:
-            self.socket.close()
-        except socket.error, x:
-            pass
-        self.socket = None
-        self.irclibobj._handle_event(
-            self,
-            Event("dcc_disconnect", self.peeraddress, "", [message]))
-        self.irclibobj._remove_connection(self)
-
-    def process_data(self):
-        """[Internal]"""
-
-        if self.passive and not self.connected:
-            conn, (self.peeraddress, self.peerport) = self.socket.accept()
-            self.socket.close()
-            self.socket = conn
-            self.connected = 1
-            if DEBUG:
-                print "DCC connection from %s:%d" % (
-                    self.peeraddress, self.peerport)
-            self.irclibobj._handle_event(
-                self,
-                Event("dcc_connect", self.peeraddress, None, None))
-            return
-
-        try:
-            new_data = self.socket.recv(2**14)
-        except socket.error, x:
-            # The server hung up.
-            self.disconnect("Connection reset by peer")
-            return
-        if not new_data:
-            # Read nothing: connection must be down.
-            self.disconnect("Connection reset by peer")
-            return
-
-        if self.dcctype == "chat":
-            # The specification says lines are terminated with LF, but
-            # it seems safer to handle CR LF terminations too.
-            chunks = _linesep_regexp.split(self.previous_buffer + new_data)
-
-            # Save the last, unfinished line.
-            self.previous_buffer = chunks[-1]
-            if len(self.previous_buffer) > 2**14:
-                # Bad peer! Naughty peer!
-                self.disconnect()
-                return
-            chunks = chunks[:-1]
-        else:
-            chunks = [new_data]
-
-        command = "dccmsg"
-        prefix = self.peeraddress
-        target = None
-        for chunk in chunks:
-            if DEBUG:
-                print "FROM PEER:", chunk
-            arguments = [chunk]
-            if DEBUG:
-                print "command: %s, source: %s, target: %s, arguments: %s" % (
-                    command, prefix, target, arguments)
-            self.irclibobj._handle_event(
-                self,
-                Event(command, prefix, target, arguments))
-
-    def _get_socket(self):
-        """[Internal]"""
-        return self.socket
-
-    def privmsg(self, string):
-        """Send data to DCC peer.
-
-        The string will be padded with appropriate LF if it's a DCC
-        CHAT session.
-        """
-        try:
-            self.socket.send(string)
-            if self.dcctype == "chat":
-                self.socket.send("\n")
-            if DEBUG:
-                print "TO PEER: %s\n" % string
-        except socket.error, x:
-            # Ouch!
-            self.disconnect("Connection reset by peer.")
-
-class SimpleIRCClient:
-    """A simple single-server IRC client class.
-
-    This is an example of an object-oriented wrapper of the IRC
-    framework.  A real IRC client can be made by subclassing this
-    class and adding appropriate methods.
-
-    The method on_join will be called when a "join" event is created
-    (which is done when the server sends a JOIN messsage/command),
-    on_privmsg will be called for "privmsg" events, and so on.  The
-    handler methods get two arguments: the connection object (same as
-    self.connection) and the event object.
-
-    Instance attributes that can be used by sub classes:
-
-        ircobj -- The IRC instance.
-
-        connection -- The ServerConnection instance.
-
-        dcc_connections -- A list of DCCConnection instances.
-    """
-    def __init__(self):
-        self.ircobj = IRC()
-        self.connection = self.ircobj.server()
-        self.dcc_connections = []
-        self.ircobj.add_global_handler("all_events", self._dispatcher, -10)
-        self.ircobj.add_global_handler("dcc_disconnect", self._dcc_disconnect, -10)
-
-    def _dispatcher(self, c, e):
-        """[Internal]"""
-        m = "on_" + e.eventtype()
-        if hasattr(self, m):
-            getattr(self, m)(c, e)
-
-    def _dcc_disconnect(self, c, e):
-        self.dcc_connections.remove(c)
-
-    def connect(self, server, port, nickname, password=None, username=None,
-                ircname=None, localaddress="", localport=0, ssl=False, ipv6=False):
-        """Connect/reconnect to a server.
-
-        Arguments:
-
-            server -- Server name.
-
-            port -- Port number.
-
-            nickname -- The nickname.
-
-            password -- Password (if any).
-
-            username -- The username.
-
-            ircname -- The IRC name.
-
-            localaddress -- Bind the connection to a specific local IP address.
-
-            localport -- Bind the connection to a specific local port.
-
-            ssl -- Enable support for ssl.
-
-            ipv6 -- Enable support for ipv6.
-
-        This function can be called to reconnect a closed connection.
-        """
-        self.connection.connect(server, port, nickname,
-                                password, username, ircname,
-                                localaddress, localport, ssl, ipv6)
-
-    def dcc_connect(self, address, port, dcctype="chat"):
-        """Connect to a DCC peer.
-
-        Arguments:
-
-            address -- IP address of the peer.
-
-            port -- Port to connect to.
-
-        Returns a DCCConnection instance.
-        """
-        dcc = self.ircobj.dcc(dcctype)
-        self.dcc_connections.append(dcc)
-        dcc.connect(address, port)
-        return dcc
-
-    def dcc_listen(self, dcctype="chat"):
-        """Listen for connections from a DCC peer.
-
-        Returns a DCCConnection instance.
-        """
-        dcc = self.ircobj.dcc(dcctype)
-        self.dcc_connections.append(dcc)
-        dcc.listen()
-        return dcc
-
-    def start(self):
-        """Start the IRC client."""
-        self.ircobj.process_forever()
-
-
-class Event:
-    """Class representing an IRC event."""
-    def __init__(self, eventtype, source, target, arguments=None):
-        """Constructor of Event objects.
-
-        Arguments:
-
-            eventtype -- A string describing the event.
-
-            source -- The originator of the event (a nick mask or a server).
-
-            target -- The target of the event (a nick or a channel).
-
-            arguments -- Any event specific arguments.
-        """
-        self._eventtype = eventtype
-        self._source = source
-        self._target = target
-        if arguments:
-            self._arguments = arguments
-        else:
-            self._arguments = []
-
-    def eventtype(self):
-        """Get the event type."""
-        return self._eventtype
-
-    def source(self):
-        """Get the event source."""
-        return self._source
-
-    def target(self):
-        """Get the event target."""
-        return self._target
-
-    def arguments(self):
-        """Get the event arguments."""
-        return self._arguments
-
-_LOW_LEVEL_QUOTE = "\020"
-_CTCP_LEVEL_QUOTE = "\134"
-_CTCP_DELIMITER = "\001"
-
-_low_level_mapping = {
-    "0": "\000",
-    "n": "\n",
-    "r": "\r",
-    _LOW_LEVEL_QUOTE: _LOW_LEVEL_QUOTE
-}
-
-_low_level_regexp = re.compile(_LOW_LEVEL_QUOTE + "(.)")
-
-def mask_matches(nick, mask):
-    """Check if a nick matches a mask.
-
-    Returns true if the nick matches, otherwise false.
-    """
-    nick = irc_lower(nick)
-    mask = irc_lower(mask)
-    mask = mask.replace("\\", "\\\\")
-    for ch in ".$|[](){}+":
-        mask = mask.replace(ch, "\\" + ch)
-    mask = mask.replace("?", ".")
-    mask = mask.replace("*", ".*")
-    r = re.compile(mask, re.IGNORECASE)
-    return r.match(nick)
-
-_special = "-[]\\`^{}"
-nick_characters = string.ascii_letters + string.digits + _special
-_ircstring_translation = string.maketrans(string.ascii_uppercase + "[]\\^",
-                                          string.ascii_lowercase + "{}|~")
-
-def irc_lower(s):
-    """Returns a lowercased string.
-
-    The definition of lowercased comes from the IRC specification (RFC
-    1459).
-    """
-    return s.translate(_ircstring_translation)
-
-def _ctcp_dequote(message):
-    """[Internal] Dequote a message according to CTCP specifications.
-
-    The function returns a list where each element can be either a
-    string (normal message) or a tuple of one or two strings (tagged
-    messages).  If a tuple has only one element (ie is a singleton),
-    that element is the tag; otherwise the tuple has two elements: the
-    tag and the data.
-
-    Arguments:
-
-        message -- The message to be decoded.
-    """
-
-    def _low_level_replace(match_obj):
-        ch = match_obj.group(1)
-
-        # If low_level_mapping doesn't have the character as key, we
-        # should just return the character.
-        return _low_level_mapping.get(ch, ch)
-
-    if _LOW_LEVEL_QUOTE in message:
-        # Yup, there was a quote.  Release the dequoter, man!
-        message = _low_level_regexp.sub(_low_level_replace, message)
-
-    if _CTCP_DELIMITER not in message:
-        return [message]
-    else:
-        # Split it into parts.  (Does any IRC client actually *use*
-        # CTCP stacking like this?)
-        chunks = message.split(_CTCP_DELIMITER)
-
-        messages = []
-        i = 0
-        while i < len(chunks)-1:
-            # Add message if it's non-empty.
-            if len(chunks[i]) > 0:
-                messages.append(chunks[i])
-
-            if i < len(chunks)-2:
-                # Aye!  CTCP tagged data ahead!
-                messages.append(tuple(chunks[i+1].split(" ", 1)))
-
-            i = i + 2
-
-        if len(chunks) % 2 == 0:
-            # Hey, a lonely _CTCP_DELIMITER at the end!  This means
-            # that the last chunk, including the delimiter, is a
-            # normal message!  (This is according to the CTCP
-            # specification.)
-            messages.append(_CTCP_DELIMITER + chunks[-1])
-
-        return messages
-
-def is_channel(string):
-    """Check if a string is a channel name.
-
-    Returns true if the argument is a channel name, otherwise false.
-    """
-    return string and string[0] in "#&+!"
-
-def ip_numstr_to_quad(num):
-    """Convert an IP number as an integer given in ASCII
-    representation (e.g. '3232235521') to an IP address string
-    (e.g. '192.168.0.1')."""
-    n = long(num)
-    p = map(str, map(int, [n >> 24 & 0xFF, n >> 16 & 0xFF,
-                           n >> 8 & 0xFF, n & 0xFF]))
-    return ".".join(p)
-
-def ip_quad_to_numstr(quad):
-    """Convert an IP address string (e.g. '192.168.0.1') to an IP
-    number as an integer given in ASCII representation
-    (e.g. '3232235521')."""
-    p = map(long, quad.split("."))
-    s = str((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3])
-    if s[-1] == "L":
-        s = s[:-1]
-    return s
-
-def nm_to_n(s):
-    """Get the nick part of a nickmask.
-
-    (The source of an Event is a nickmask.)
-    """
-    return s.split("!")[0]
-
-def nm_to_uh(s):
-    """Get the userhost part of a nickmask.
-
-    (The source of an Event is a nickmask.)
-    """
-    return s.split("!")[1]
-
-def nm_to_h(s):
-    """Get the host part of a nickmask.
-
-    (The source of an Event is a nickmask.)
-    """
-    return s.split("@")[1]
-
-def nm_to_u(s):
-    """Get the user part of a nickmask.
-
-    (The source of an Event is a nickmask.)
-    """
-    s = s.split("!")[1]
-    return s.split("@")[0]
-
-def parse_nick_modes(mode_string):
-    """Parse a nick mode string.
-
-    The function returns a list of lists with three members: sign,
-    mode and argument.  The sign is \"+\" or \"-\".  The argument is
-    always None.
-
-    Example:
-
-    >>> irclib.parse_nick_modes(\"+ab-c\")
-    [['+', 'a', None], ['+', 'b', None], ['-', 'c', None]]
-    """
-
-    return _parse_modes(mode_string, "")
-
-def parse_channel_modes(mode_string):
-    """Parse a channel mode string.
-
-    The function returns a list of lists with three members: sign,
-    mode and argument.  The sign is \"+\" or \"-\".  The argument is
-    None if mode isn't one of \"b\", \"k\", \"l\", \"v\" or \"o\".
-
-    Example:
-
-    >>> irclib.parse_channel_modes(\"+ab-c foo\")
-    [['+', 'a', None], ['+', 'b', 'foo'], ['-', 'c', None]]
-    """
-
-    return _parse_modes(mode_string, "bklvo")
-
-def _parse_modes(mode_string, unary_modes=""):
-    """[Internal]"""
-    modes = []
-    arg_count = 0
-
-    # State variable.
-    sign = ""
-
-    a = mode_string.split()
-    if len(a) == 0:
-        return []
-    else:
-        mode_part, args = a[0], a[1:]
-
-    if mode_part[0] not in "+-":
-        return []
-    for ch in mode_part:
-        if ch in "+-":
-            sign = ch
-        elif ch == " ":
-            collecting_arguments = 1
-        elif ch in unary_modes:
-            if len(args) >= arg_count + 1:
-                modes.append([sign, ch, args[arg_count]])
-                arg_count = arg_count + 1
-            else:
-                modes.append([sign, ch, None])
-        else:
-            modes.append([sign, ch, None])
-    return modes
-
-def _ping_ponger(connection, event):
-    """[Internal]"""
-    connection.pong(event.target())
-
-# Numeric table mostly stolen from the Perl IRC module (Net::IRC).
-numeric_events = {
-    "001": "welcome",
-    "002": "yourhost",
-    "003": "created",
-    "004": "myinfo",
-    "005": "featurelist",  # XXX
-    "200": "tracelink",
-    "201": "traceconnecting",
-    "202": "tracehandshake",
-    "203": "traceunknown",
-    "204": "traceoperator",
-    "205": "traceuser",
-    "206": "traceserver",
-    "207": "traceservice",
-    "208": "tracenewtype",
-    "209": "traceclass",
-    "210": "tracereconnect",
-    "211": "statslinkinfo",
-    "212": "statscommands",
-    "213": "statscline",
-    "214": "statsnline",
-    "215": "statsiline",
-    "216": "statskline",
-    "217": "statsqline",
-    "218": "statsyline",
-    "219": "endofstats",
-    "221": "umodeis",
-    "231": "serviceinfo",
-    "232": "endofservices",
-    "233": "service",
-    "234": "servlist",
-    "235": "servlistend",
-    "241": "statslline",
-    "242": "statsuptime",
-    "243": "statsoline",
-    "244": "statshline",
-    "250": "luserconns",
-    "251": "luserclient",
-    "252": "luserop",
-    "253": "luserunknown",
-    "254": "luserchannels",
-    "255": "luserme",
-    "256": "adminme",
-    "257": "adminloc1",
-    "258": "adminloc2",
-    "259": "adminemail",
-    "261": "tracelog",
-    "262": "endoftrace",
-    "263": "tryagain",
-    "265": "n_local",
-    "266": "n_global",
-    "300": "none",
-    "301": "away",
-    "302": "userhost",
-    "303": "ison",
-    "305": "unaway",
-    "306": "nowaway",
-    "311": "whoisuser",
-    "312": "whoisserver",
-    "313": "whoisoperator",
-    "314": "whowasuser",
-    "315": "endofwho",
-    "316": "whoischanop",
-    "317": "whoisidle",
-    "318": "endofwhois",
-    "319": "whoischannels",
-    "321": "liststart",
-    "322": "list",
-    "323": "listend",
-    "324": "channelmodeis",
-    "329": "channelcreate",
-    "331": "notopic",
-    "332": "currenttopic",
-    "333": "topicinfo",
-    "341": "inviting",
-    "342": "summoning",
-    "346": "invitelist",
-    "347": "endofinvitelist",
-    "348": "exceptlist",
-    "349": "endofexceptlist",
-    "351": "version",
-    "352": "whoreply",
-    "353": "namreply",
-    "361": "killdone",
-    "362": "closing",
-    "363": "closeend",
-    "364": "links",
-    "365": "endoflinks",
-    "366": "endofnames",
-    "367": "banlist",
-    "368": "endofbanlist",
-    "369": "endofwhowas",
-    "371": "info",
-    "372": "motd",
-    "373": "infostart",
-    "374": "endofinfo",
-    "375": "motdstart",
-    "376": "endofmotd",
-    "377": "motd2",        # 1997-10-16 -- tkil
-    "381": "youreoper",
-    "382": "rehashing",
-    "384": "myportis",
-    "391": "time",
-    "392": "usersstart",
-    "393": "users",
-    "394": "endofusers",
-    "395": "nousers",
-    "401": "nosuchnick",
-    "402": "nosuchserver",
-    "403": "nosuchchannel",
-    "404": "cannotsendtochan",
-    "405": "toomanychannels",
-    "406": "wasnosuchnick",
-    "407": "toomanytargets",
-    "409": "noorigin",
-    "411": "norecipient",
-    "412": "notexttosend",
-    "413": "notoplevel",
-    "414": "wildtoplevel",
-    "421": "unknowncommand",
-    "422": "nomotd",
-    "423": "noadmininfo",
-    "424": "fileerror",
-    "431": "nonicknamegiven",
-    "432": "erroneusnickname", # Thiss iz how its speld in thee RFC.
-    "433": "nicknameinuse",
-    "436": "nickcollision",
-    "437": "unavailresource",  # "Nick temporally unavailable"
-    "441": "usernotinchannel",
-    "442": "notonchannel",
-    "443": "useronchannel",
-    "444": "nologin",
-    "445": "summondisabled",
-    "446": "usersdisabled",
-    "451": "notregistered",
-    "461": "needmoreparams",
-    "462": "alreadyregistered",
-    "463": "nopermforhost",
-    "464": "passwdmismatch",
-    "465": "yourebannedcreep", # I love this one...
-    "466": "youwillbebanned",
-    "467": "keyset",
-    "471": "channelisfull",
-    "472": "unknownmode",
-    "473": "inviteonlychan",
-    "474": "bannedfromchan",
-    "475": "badchannelkey",
-    "476": "badchanmask",
-    "477": "nochanmodes",  # "Channel doesn't support modes"
-    "478": "banlistfull",
-    "481": "noprivileges",
-    "482": "chanoprivsneeded",
-    "483": "cantkillserver",
-    "484": "restricted",   # Connection is restricted
-    "485": "uniqopprivsneeded",
-    "491": "nooperhost",
-    "492": "noservicehost",
-    "501": "umodeunknownflag",
-    "502": "usersdontmatch",
-}
-
-generated_events = [
-    # Generated events
-    "dcc_connect",
-    "dcc_disconnect",
-    "dccmsg",
-    "disconnect",
-    "ctcp",
-    "ctcpreply",
-]
-
-protocol_events = [
-    # IRC protocol events
-    "error",
-    "join",
-    "kick",
-    "mode",
-    "part",
-    "ping",
-    "privmsg",
-    "privnotice",
-    "pubmsg",
-    "pubnotice",
-    "quit",
-    "invite",
-    "pong",
-]
-
-all_events = generated_events + protocol_events + numeric_events.values()
diff --git a/logbot.py b/logbot.py
index b25c9e0..c75c846 100644
--- a/logbot.py
+++ b/logbot.py
@@ -25,7 +25,7 @@
 
 
 __author__ = "Chris Oliver <excid3@gmail.com>"
-__version__ = "0.2.1"
+__version__ = "0.3.0"
 __date__ = "08/11/2009"
 __copyright__ = "Copyright (c) Chris Oliver"
 __license__ = "GPL2"
@@ -33,13 +33,16 @@ __license__ = "GPL2"
 
 import os
 import os.path
-import irclib
+import shutil
 
 from ConfigParser import ConfigParser
 from ftplib import FTP
 from optparse import OptionParser
 from time import strftime
 
+from irclib import nm_to_n
+from ircbot import SingleServerIRCBot
+
 
 html_header = """<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> 
@@ -47,161 +50,99 @@ html_header = """<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
   <head>
     <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
     <title>%s</title>
-    <link href="%s" rel="stylesheet" type="text/css" />
+    <link href="stylesheet.css" rel="stylesheet" type="text/css" />
   </head>
   <body>
   </body>
 </html>
 """
 
+index_header = """<h1>%s</h1><br />"""
+
 
-class LogBot(object):
-    def __init__(self, network, port, channels, owner, nick, password, folder, stylesheet):
-        self.network = network
-        self.port = port
-        self.channels = channels
-        self.owner = owner
-        self.nick = nick
-        self.password = password
+class LogBot(SingleServerIRCBot):
+    def __init__(self, server, port, channels, owners, nickname, password):
+        """Initialize this badboy"""
+        SingleServerIRCBot.__init__(self, [(server, port, password)], 
+                                          nickname, 
+                                          nickname)
+        self.chans = channels
+    
+    def set_format(self, folder, format, stylesheet):
         self.folder = folder
+        self.format = format
         self.stylesheet = stylesheet
         
-    def start(self):
-        # Write logs locally, so we need the folder to exist
-        if not os.path.exists(self.folder):
-            os.mkdir(self.folder)
-        #os.chdir(self.folder)
-
-        # Create an IRC object
-        self.irc = irclib.IRC()
-
-        # Setup the IRC functionality we want to log
-        handlers = {'join': self.handleJoin,
-                    'pubmsg': self.handlePubMessage,
-                    'privmsg': self.handlePrivMessage,
-                    'part': self.handlePart,
-                    'invite': self.handleInvite,
-                    'kick': self.handleKick,
-                    'mode': self.handleMode,
-                    'pubnotice': self.handlePubNotice,
-                    'quit': self.handleQuit}
-        for key, val in handlers.items():
-            self.irc.add_global_handler(key, val)
-
-        # Create a server object, connect and join the channel
-        self.server = self.irc.server()
-        self.server.connect(self.network, self.port, self.nick, ircname=self.nick)
-
-        if self.password:        
-            self.server.privmsg("nickserv", "identify %s" % self.password)
-
-        for channel in self.channels:
-            self.server.join(channel)
-
-        # Jump into an infinte loop
-        self.irc.process_forever()
-    
-            #eventtype -- A string describing the event.
-            #source -- The originator of the event (a nick mask or a server).
-            #target -- The target of the event (a nick or a channel).
-            #arguments 
-            
-    def handleKick(self, connection, event):
-        """Handles kick messages
-        Writes messages to log
-        """
-        # kicker, channel, [person, reason]
-        # event.source(), event.target(), event.arguments()
-        person, reason = event.arguments()
-        self.write(event.target(),
-                   "-!- <span class=\"kick\">%s</span> was kicked from %s by %s [%s]" % \
-                   (person, event.target(), event.source().split("!")[0], reason))
-        
-    def handleMode(self, connection, event):
-        """Handles mode changes
-        Writes messages to log
-        """
-        # person giving ops, #channel, [modes, person]
-        #print event.source(), event.target(), event.arguments()
-        modes, person = event.arguments()
-        self.write(event.target(), 
-    	           "-!- mode/<span class=\"mode\">%s</span> [%s %s] by %s" % \
-		           (event.target(), modes, person, event.source().split("!")[0]))
-        
-    def handlePubNotice(self, connection, event):
-        """Handles public notices
-        Writes messages to log
-        """
-        # user, channel, [msg]
-        #print event.source(), event.target(), event.arguments()
-        self.write(event.target(), 
-                   "<span class=\"notice\">-%s:%s-</span> %s" % \
-                   (event.source().split("!")[0], event.target(), event.arguments()[0]))
-				   
-    def handleQuit(self, connection, event):
-        """Handles quite messages
-        Writes messages to log
-        """
-        # user, channel?, [reason]
-        #print event.source(), event.target(), event.arguments()
-        self.write(None,
-                   "-!- <span class=\"quit\">%s</span> has quit [%s]" % \
-                   (event.source().split("!")[0], event.arguments()[0]))
+    def on_nicknameinuse(self, c, e):
+        """Append an underscore to the nick if it's already in use"""
+        c.nick(c.get_nickname() + "_")
         
-    def handlePrivMessage(self, connection, event):
-        """Handles private messages
-        Used for owners to send instructions to bot
-        """
-        # sender, receiver (me), [msg]
-        print "PRIVATE MESSGAE", event.source(), event.target(), event.arguments()
-        
-    def handleJoin(self, connection, event):
-        """Handles user join messages
-        Writes messages to log
-        """
-        nick = event.source().split("!")
-        try:
-            nickmask = nick[1]
-        except:
-            nickmask = "unknown"
-        nick = nick[0]
-        
-        self.write(event.target(),
-                   "-!- <span class=\"join\">%s</span> (%s) has joined %s" % \
-                   (nick, nickmask, event.target()))
-        
-    def handlePubMessage(self, connection, event):
-        """Handles public messages
-        Writes messages to log
-        """
-        nick = event.source().split("!")[0]
-        self.write(event.target(),
-                   "<span class=\"person\">&lt;%s&gt;</span> %s" % \
-                   (nick, event.arguments()[0]))
-        
-    def handlePart(self, connection, event):
-        """Handles part messages
-        Writes messages to log
-        """
-        nick = event.source().split("!")[0]
-        self.write(event.target(),
-                   "-!- <span class=\"part\">%s</span> has parted %s" % \
-                   (nick, event.target()))
-             
-    def handleInvite(self, connection, event):
-        """Handles invitations from IRC users
-        Only accept invites to join a channel if they are from an owner
-        """
-        nick = event.source().split("!")[0]
+    def on_welcome(self, c, e):
+        """Join the channels once we have made a successful connection"""
+        for channel in self.chans:
+            c.join(channel)
+
+    def on_pubmsg(self, c, e):
+        user = nm_to_n(e.source())
+        message = e.arguments()[0]
+        channel = e.target()
+        self.write(channel, self.format["pubmsg"].replace("%user%", user) \
+                                                 .replace("%message%", message))
+                                         
+    def on_invite(self, c, e):
+        pass
+    
+    def on_join(self, c, e):
+        user = nm_to_n(e.source())
+        host = e.source()
+        channel = e.target()
+        self.write(channel, self.format["join"].replace("%user%", user) \
+                                               .replace("%host%", host) \
+                                               .replace("%channel%", channel))
+    
+    def on_kick(self, c, e):
+        kicker = e.source()
+        channel = e.target()
+        user, reason = e.arguments()
+        self.write(channel, self.format["kick"].replace("%kicker%", kicker) \
+                                               .replace("%channel%", channel) \
+                                               .replace("%user%", user) \
+                                               .replace("%reason%", reason))
+                                 
+    def on_mode(self, c, e):
+        modes, person = e.arguments()
+        channel = e.target()
+        giver = nm_to_n(e.source())
+        self.write(channel, self.format["mode"].replace("%channel%", channel) \
+                                               .replace("%modes%", modes) \
+                                               .replace("%person%", person) \
+                                               .replace("%giver%", giver))
         
-        # Only allow invites from owner(s)
-        if not nick in self.owner:
-            print "Invite from %s denied" % nick
-            return
-            
-        for channel in event.arguments():
-            self.server.join(channel)
+    def on_part(self, c, e):
+        user = nm_to_n(e.source())
+        channel = e.target()
+        self.write(channel, self.format["part"].replace("%user%", user) \
+                                               .replace("%channel%", channel))
+                                 
+    def on_privmsg(self, c, e):
+        pass
+
+    def on_pubnotice(self, c, e):
+        user = nm_to_n(e.source())
+        channel = e.target()
+        message = e.arguments()[0]
+        self.write(channel, self.format["pubnotice"].replace("%user%", user) \
+                                              .replace("%channel%", channel) \
+                                              .replace("%message%", message))
             
+    def on_quit(self, c, e):
+        user = nm_to_n(e.source())
+        reason = e.arguments()[0]
+        channel = e.target()
+        print channel
+        self.write(channel, self.format["quit"].replace("%user%", user) \
+                                               .replace("%reason%", reason))
+
     def write(self, channel, message):
         time = strftime("%H:%M:%S")
         date = strftime("%d-%m-%Y")
@@ -211,28 +152,59 @@ class LogBot(object):
         else:
             # Quits don't have channels
             print "%s %s" % (time, message)
-            channels = self.channels
+            channels = self.chans
+
+        if not os.path.exists(self.folder):
+            # Create the log folder if we need to
+            os.mkdir(self.folder)
+            index = os.path.join(self.folder, "index.html")
+            create_html_file(index, "Logged Channels")
+            append_to_index(index, index_header % "Logged Channels")
+            shutil.copy2(self.stylesheet, self.folder)
 
         for channel in channels:
             path = os.path.abspath(os.path.join(self.folder, channel))
+            
             if not os.path.exists(path):
-                # Create the folder if it doesn't exist
                 os.mkdir(path)
+                
+            if not os.path.exists(os.path.join(path, "stylesheet.css")):
+                shutil.copy2(self.stylesheet, path)
             
+            chan_index = os.path.join(path, "index.html")
             path = os.path.join(path, date+".html")
-            if not os.path.exists(path):
-                # Create the html header
-                f = open(path, "wb")
-                f.write(html_header % (("%s | Logs for %s" % (channel, date)), self.stylesheet))
-                f.close()
-
-            data = open(path, "rb").readlines()[:-2]
-            data.append("<a href=\"#%s\" name=\"%s\" class=\"time\">[%s]</a> %s<br />\n" % (time, time, time, message))
-            data += ["  </body>\n", "</html>\n"]
-            
-            f = open(path, "wb")
-            f.writelines(data)
-            
+            if not os.path.exists(path):                
+                create_html_file(chan_index, "%s | Logs" % channel)
+                append_to_index(chan_index, index_header % "%s | Logs" % channel)
+                
+                append_to_index(index, "<a href=\"%%23%s\">%s</a>" % \
+                                       (channel[1:]+"/index.html", channel))
+                                       
+                create_html_file(path, "%s | Logs for %s" % (channel, date))
+                append_to_index(chan_index, "<a href=\"%s\">%s</a>" % \
+                                            (date+".html", date))
+
+            str = "<a href=\"#%s\" name=\"%s\" class=\"time\">[%s]</a> %s" % \
+                                              (time, time, time, message)
+            append_to_index(path, str)        
+
+
+def create_html_file(path, title):
+    f = open(path, "wb")
+    f.write(html_header % title)
+    f.close()
+
+
+def append_to_index(path, line):
+    data = open(path, "rb").readlines()[:-2]
+    data.append(line + "<br />\n")
+    data += ["  </body>\n", "</html>\n"]
+    
+    f = open(path, "wb")
+    f.writelines(data)
+    f.close()
+
+
 def main(conf):
     """
     Start the bot using a config file.
@@ -242,29 +214,37 @@ def main(conf):
     """
     CONFIG = ConfigParser()
     CONFIG.read(conf)
-    network = CONFIG.get('irc', 'network')
-    port = CONFIG.getint('irc', 'port')
-    channels = CONFIG.get('irc', 'channels').split(',')
-    nick = CONFIG.get('irc', 'nick')
+    
+    # Get the irc network configuration
+    server = CONFIG.get("irc", "server")
+    port = CONFIG.getint("irc", "port")
+    channels = CONFIG.get("irc", "channels").split(",")
+    nick = CONFIG.get("irc", "nick")
     try:
-        password = CONFIG.get('irc', 'password')
+        password = CONFIG.get("irc", "password")
     except:
         password = None
-    owner = CONFIG.get('irc', 'owners').split(',')
-    logs_folder = CONFIG.get('log', 'folder')
-    stylesheet = CONFIG.get('log', 'stylesheet')
+    owner = CONFIG.get("irc", "owners").split(",")
+    
+    # Get the log section
+    folder = CONFIG.get("log", "folder")
+    stylesheet = CONFIG.get("log", "stylesheet")
+    
+    # Get the formation information
+    types = ["join", "kick", "mode", "part", "pubmsg", "pubnotice", "quit"]
+    format = {}
+    for type in types:
+        format[type] = CONFIG.get("format", type)
+        
+    bot = LogBot(server, port, channels, owner, nick, password)
+    bot.set_format(folder, format, stylesheet)
+    bot.start()
 
-    bot = LogBot(network, port, channels, owner, nick, password, logs_folder, stylesheet)
-    try:
-        bot.start()
-    except KeyboardInterrupt:
-        pass
 
-		
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Require a config
     parser = OptionParser()
-    parser.add_option('-c', '--config', dest='conf', help='Config to use')
+    parser.add_option("-c", "--config", dest="conf", help="Config to use")
     (options, args) = parser.parse_args()
 
     if not options.conf or not os.access(options.conf, os.R_OK):
-- 
cgit v1.2.3