kofoo.py - kofoo in KoFooBot

### This file is part of KoFooBot and is licensed under BSD-license according to the   ###
### LICENSE file in the base directory.                                                ###
### Code in this file is contributed by:                                               ###
###    Krister Svanlund <krister.svanlund gmail.com>                                   ###

import os, sys, getopt
import re
import irclib
import traceback

class KoFooGlobals:
    ### Bot version / module interface version. ###
    bot_version = "0.0.3/3"

    ### For all commands above this level the user has to be identified by nickserv. ###
    bot_id_req_level = 80
    
    bot_command_alias = { }   # Ex. {'tu': 'twitter update'} this will cause the command 'tu update this' to expand to 'twitter update update this'
    
    bot_commands = { "quit":
                         { 'description': "Disconnect and kill the bot",
                           'long help':   """\
Send a notice to all users with level > 100 and then disconnect and kill the bot. If no message specified the default quit message is used.""",
                           'arguments': "[<message>]",
                           'public': False,
                           'level': 100 },
                     "reconnect":
                         { 'description': "Disconnect and reconnect the bot.",
                           'long help':   """\
Send a notice to all users with level > 100 and then disconnect and reconnect the bot.""",
                           'arguments': "[<message>]",
                           'public': False,
                           'level': 100 },
                     "load":
                         { 'description': "Load a module with commands",
                           'long help': """\
Load (or reload, if already loaded) a module from the file kofoo_<modulename>.py. If auto is specified the module will be automatically loaded upon startup.""",
                           'arguments': "[auto] <modulename>",
                           'public': False,
                           'level': 100 },
                     "unload":
                         { 'description': "Unload a module currently loaded",
                           'long help': """\
Unload a module and remove automatically update functions.""",
                           'arguments': "<modulename>",
                           'public': False,
                           'level': 100 },
                     "save":
                         { 'description': "Save settings",
                           'long help': """\
Save all settings to disk.""",
                           'public': False,
                           'level': 100 },
                     "join":
                         { 'description': "Join a channel",
                           'long help': """\
Join a channel and try to identify with nickserv if password is given.""",
                           'public': False,
                           'level': 100},
                     "part":
                         { 'description': "Part from a channel",
                           'long help': """\
Part (leave) a channel.""",
                           'public': False,
                           'level': 100},
                     }
    

class KoFooSettings:
    _unsaved_settings = ["_unsaved_settings",
                         "load_settings",
                         "save_settings",
                         "comments"]
    bot_irc_server    = None   # string
    bot_irc_port      = 0      # int
    bot_nick_name     = None   # string
    bot_nick_password = None   # string
    bot_nick_email    = None   # string
    bot_password      = None   # string
                                
    bot_quit_message  = ""     # string
                                
    bot_channel_list  = { }    # dict { "channel": "chanserv_password" } or list ["channel"]
                                
    bot_user_list     = { }    # dict { "nickname": access_level<int> }

    bot_auto_load_modules = [] # list of string

    bot_public_prefix = '^'    # string

    comments = ""

    def save_settings(self, config_file):
        """Save attributes in settings object to the specified config file."""
        print "Save settings to '%s'." % config_file
        f = open(config_file, 'w')
        ### Write all comments at the top. ###
        f.write(self.comments)
        for key in dir(self):
            config_string = ""
            ### Check if the value is not supposed to be saved.                       ###
            ### Attributes in _unsaved_settings and that starts with _ are not saved. ###
            if key not in self._unsaved_settings and not key[0] == '_':
                value = getattr(self, key)
                ### If the value is a string add ''. ###
                if type(value) == str:
                    config_string = "%s = \"%s\"" % (key, value)
                else:
                    config_string = "%s = %s" % (key, str(value))
                print " <", config_string
            if config_string:
                f.write(config_string+"\n")
        f.close()
    
    def load_settings(self, config_file):
        """Load settings from specified config file into settings object."""
        print "Load settings from '%s'." % config_file
        try:
            config = open(config_file)
        except Exception, e:
            print " + Could not load '%s'." % config_file
            return False
        ### Read the config file and split the lines for parsing. ###
        config_lines = config.read().splitlines()
        loadable_config = ""
        self.comments = ""
        for line in config_lines:
            ### Store a version of the string that has no whitespace in beginning or end. ###
            stripped_line = line.strip()
            ### Split line at # and only use the first part and ignore the commented part. ###
            stripped_line = stripped_line.split(' #', 1)[0]
            if not stripped_line:
                continue
            ### If the string start with # just add it to self.comments so that it can ###
            ### be written back to the config file later on.                           ###
            if stripped_line[0] == "#":
                self.comments += line + "\n"
                continue
            ### if the line is indented it belongs to the previous line. ###
            m = re.match(r'\s+(\S.*)', line)
            if m:
                loadable_config += m.group(1)
            else:
                loadable_config += "\n" + stripped_line
        ### Iterate through the prepeared list and eval each value and assign the result ###
        ### to the correct attribute of the settings object.                             ###
        for line in loadable_config.splitlines():
            ### Split the line into variable and value. ###
            m = re.match(r'(\S+)\s*=\s*(\S.*)', line)
            if m:
                variable = m.group(1)
                value = m.group(2)
                try:
                    setattr(self, variable, eval(value))
                    print " > %s = %s" % (variable, value)
                except Exception, e:
                    print " - Could not load string '%s'. Try to load with right-side as string." % line
                    try:
                        setattr(self, variable, eval("'%s'" % value))
                    except Exception, e:
                        print "   - Could not load with right-side as string."
        print " + Finished loading settings."

class KoFoo(irclib.IRC):
    ### A dictionary of nickname and function to do when a user is recognised by nickserv. ###
    # on_user_id_do = { "UserNickname": (callback, arg_tuple) }
    on_user_id_do = {}
    
    ### All on_*_do lists should be a list of callable functions. ###
    # on_event_do    = [ func1, func2, func3 ]
    on_update_do     = [] ### A list of functions to do on update iterations.           ###
    on_pubmsg_do     = [] ### A list of functions to do on public messages in channels. ###
    on_privmsg_do    = [] ### A list of functions to do on private messages to bot.     ###
    on_privnotice_do = [] ### A list of functions to do on private notice to bot.       ###
    on_pubnotice_do  = [] ### A list of functions to do on public notice to channel.    ###
    on_join_part_do  = [] ### A list of functions to do on join/part event.             ###
    on_ctcp_do       = [] ### A list of functions to do on recieved ctcp event.         ###


    ### Currently joined channels. ###
    channel_list = []

    ### List of currently loaded modules. ###
    module_list = []
    ### List of modules not loaded. ###
    found_modules = []
    
    def __init__(self):
        """Initiate the IRC client, load the settings and check if all required settings
           are set. Also add handlers for IRC events."""
        irclib.IRC.__init__(self, config_file)
        self.want_to_quit = False
        self.reconnect_timeout = 0

        try:
            cwd = os.getcwd()
            file_list = os.listdir(cwd)
            for item in file_list:
                print item
                res = re.match("^kofoo_([\S]+).py$", item)
                if res:
                    module_name = res.group(1)
                    self.found_modules.append(module_name)
        except Exception, e:
            print " - Failed to get file list:", str(e)

        self.config_file = config_file

        self.settings = KoFooSettings()
        self.settings.load_settings(self.config_file)

        ### Specify a list of error messages for each reqired non-None setting. ###
        neccessary_settings = [("No irc server set", self.settings.bot_irc_server), 
                               ("No irc port set", self.settings.bot_irc_port), 
                               ("No nickname set for bot", self.settings.bot_nick_name), 
                               ("No password for bot nickname set", self.settings.bot_nick_password),
                               ("No password for bot set", self.settings.bot_password)]
        for desc, opt in neccessary_settings:
            if not opt:
                print "A neccessary setting is not set."
                raise ValueError(desc)

        self.globals = KoFooGlobals()

        self.add_global_handler('welcome', self.on_connected)
        self.add_global_handler('disconnect', self.on_disconnected)
        self.add_global_handler('privmsg', self.on_privmsg)
        self.add_global_handler('privnotice', self.on_privnotice)
        self.add_global_handler('pubmsg', self.on_pubmsg)
        self.add_global_handler('pubnotice', self.on_pubnotice)
        self.add_global_handler('join', self.on_join)
        self.add_global_handler('part', self.on_part)
        self.add_global_handler('kick', self.on_part)
        self.add_global_handler('action', self.on_action)
        self.add_global_handler('ctcp', self.on_ctcp)

    def update(self, server, time_since_last):
        """Iterate through all the update funcs and run them if their timeout limit
           has been reached. Otherwise just adjust their timeout based on time_since_last.
           """
        for update_func in self.on_update_do:
            ### If the update_func somehow has changed into something not callable since ###
            ### it was added, remove it from the list and continue with the next one.    ###
            if not callable(update_func):
                self.on_update_do.remove(update_func)
                print " - Remove update function. Not callable."
                continue
            ### If the update function has a delay variable then check if there is time  ###
            ### left otherwise just execute the function and set the time_left to delay. ###
            if hasattr(update_func, "delay"):
                delay = getattr(update_func, "delay")
                if hasattr(update_func, "time_left"):
                    time_left = getattr(update_func, "time_left")
                    time_left = time_left - time_since_last
                    if time_left <= 0:
                        try:
                            update_func(self, server)
                        except Exception, e:
                            print " - Failed to run update function: %s" % str(e)
                        time_left = delay
                    setattr(update_func, "time_left", time_left)
                else:
                    try:
                        update_func(self, server)
                    except Exception, e:
                        print " - Failed to run update function: %s" % str(e)
                    setattr(update_func, "time_left", delay)
            else:
                try:
                    update_func(self, server)
                except Exception, e:
                    print " - Failed to run update function: %s" % str(e)


    def on_connected(self, server, event):
        """On established connection to the IRC server get the real nickname (it could
           have been changed on connection if the configured one is occupied."""
        print "Connected to %s" % server.get_server_name()
        self.settings.bot_nick_name = server.get_nickname()
        print " + Using nickname '%s'." % self.settings.bot_nick_name
        self.join_channels(server)

        ### Load all auto-loaded modules when connection is established. ###
        if self.settings.bot_auto_load_modules:
            for module in self.settings.bot_auto_load_modules:
                self.load_module(server, module, None)
        else:
            self.settings.bot_auto_load_modules = []

    def on_disconnected(self, server, event):
        """On disconnect."""
        print " !! Disconnected."
        self.reconnect_timeout = 60.0

    def on_privnotice(self, server, event):
        """On a private notice, often used by nickserv, chanserv and other bots."""
        sender = event.source()
        target = event.target()
        if sender:
            sender_nick = irclib.nm_to_n(sender).lower()
        else:
            sender_nick = ""
        arg = event.arguments()[0]
        if sender_nick == "nickserv":
            res = re.match("STATUS (\S*) (\d)", arg)
            if res is not None:
                user = res.group(1)
                status = int(res.group(2), 0)
                if status > 1:
                    print " + User %s has identified with nickserv." % user
                    self.user_confirmed(user)
                else:
                    print " + User %s is not identified with nickserv." %user
                    server.notice(user, "Command failed because you are not identified with nickserv.")
                    if user in self.on_user_id_do:
                        del self.on_user_id_do[user]
                return
        if sender_nick and self.on_privnotice_do:
            for func in self.on_privnotice_do:
                if callable(func):
                    func(self, server, sender, arg)
                else:
                    ### If the function somehow has become a non-callable type. Remove it. ###
                    del self.on_privnotice_do[func]
                    print " - Delete private notice handler."

    def on_pubnotice(self, server, event):
        """On public notice, often from another bot in the channel."""
        sender = event.source()
        target = event.target()
        sender_nick = irclib.nm_to_n(sender).lower()
        arg = event.arguments()[0]
        if self.on_pubnotice_do:
            for func in self.on_pubnotice_do:
                if callable(func):
                    func(self, server, sender, target, arg)
                else:
                    ### If the function somehow has become a non-callable type. Remove it. ###
                    del self.on_pubnotice_do[func]
                    print " - Delete public notice handler."

    def on_privmsg(self, server, event):
        """On a private message, often used by chat users by /query or /msg."""
        sender = event.source()
        target = event.target()
        arg = event.arguments()[0]
        if not self.handle_command(server, sender, target, arg, public=False):
            #print " + Private message from '%s': %s" % (irclib.nm_to_n(sender), arg)
            if self.on_privmsg_do:
                for func in self.on_privmsg_do:
                    if callable(func):
                        func(self, server, sender, arg)
                    else:
                        ### If the function somehow has become a non-callable type. Remove it. ###
                        del self.on_privmsg_do[func]
                        print " - Delete private notice handler."

    def on_pubmsg(self, server, event):
        """On a message in a channel handle commands or send to modules."""
        sender = event.source()
        target = event.target()
        arg = event.arguments()[0]
        command_handled = False
        if not target in self.channel_list:
            print " - Got message from unknown channel %s." % target
        else:
            ### Check if the message starts with bot_public_prefix which is used as a ###
            ### public message prefix. If it is, handle it as a command issued in     ###
            ### public.                                                               ###
            res = re.match('\%s(.*)' % self.settings.bot_public_prefix, arg)
            ### Also check if the string is directed to the bot, this could also be a ###
            ### command. Check for bot_nick_name followed by :, ; or whitespace.      ###
            res2 = re.match('%s[:;,\s]+(.*)' % self.settings.bot_nick_name, arg)
            msg = None
            if res is not None:
                msg = res.group(1)
            elif res2 is not None:
                msg = res2.group(1)
            ### If the command is handled then just return otherwise handle it as a   ###
            ### public string.                                                        ###
            if msg:
                if self.handle_command(server, sender, target, msg, public=True):
                    command_handled = True
            if not command_handled and self.on_pubmsg_do:
                for func in self.on_pubmsg_do:
                    if callable(func):
                        func(self, server, sender, target, arg, action = False)
                    else:
                        ### If the function somehow has become a non-callable type. Remove it. ###
                        del self.on_pubmsg_do[func]
                        print " - Delete public message handler."

    def on_action(self, server, event):
        """On /me or similar, both public and privat."""
        sender = event.source()
        target = event.target()
        arg = event.arguments()[0]
        if target in self.channel_list:
            self.on_pubaction(server, sender, target, arg)
        else:
            self.on_privaction(server, sender, target, arg)

    def on_pubaction(self, server, sender, target, arg):
        for func in self.on_pubmsg_do:
            if callable(func):
                func(self, server, sender, target, arg, True)
            else:
                ### If the function somehow has become a non-callable type. Remove it. ###
                del self.on_pubmsg_do[func]
                print " - Delete public message handler."

    def on_privaction(self, server, sender, target, arg):
        for func in self.on_privmsg_do:
            if callable(func):
                func(self, server, sender, arg, True)
            else:
                ### If the function somehow has become a non-callable type. Remove it. ###
                del self.on_privmsg_do[func]
                print " - Delete public message handler."

    def on_ctcp(self, server, event):
        """On ctcp from other clients."""
        sender = event.source()
        target = event.target()
        arg = event.arguments()[0]
        for func in self.on_ctcp_do:
            if callable(func):
                func(self, server, sender, arg)
            else:
                ### If the function somehow has become a non-callable type. Remove it. ###
                del self.on_ctcp_do[func]
                print " - Delete public message handler."
                
    def user_confirmed(self, user):
        """On returned confirmation from nickserv that a user is identified execute the
           call the user requested."""
        print " + %s has been confirmed by nickserv." % user
        if user in self.on_user_id_do:
            callback, args = self.on_user_id_do[user]
            if callable(callback):
                try:
                    callback(*args)
                except TypeError, e:
                    print " - Callback is not a native function:", str(e)
                    try:
                        callback(self, *args)
                    except Exception, e2:
                        print " - Failed!", str(e2)
            else:
                print " - Callback for %s is not callable." % user
        else:
            print " + Nothing to call for user %s." % user

    def join_channels(self, server):
        """Join channels in bot_channel_list in settings. If a password is specified
           try to claim foundersrights for it otherwise just join and let OPs take care
           of it."""
        if type(self.settings.bot_channel_list) is dict:
            self.settings.bot_channel_list = self.settings.bot_channel_list.keys()
        if type(self.settings.bot_channel_list) is list:
            for channel in self.settings.bot_channel_list:
                server.join(channel)
        else:
            print " - Channel list is not a list."

    def on_join(self, server, event):
        channel = event.target()
        self.channel_list.append(channel)
        if self.on_join_part_do:
            for func in self.on_join_part_do:
                if callable(func):
                    func(self, server, channel, join=True)
                else:
                    ### If the function somehow has become a non-callable type. Remove it. ###
                    del self.on_join_part_do[func]
                    print " - Delete join/part handler."

    def on_part(self, server, event):
        channel = event.target()
        if len(event.arguments()) > 1:
            reason = event.arguments()[1]
        else:
            reason = ""
        sender = irclib.nm_to_n(event.source())
        if reason or sender is self.settings.bot_nick_name:
            print " + Got kicked from %s by %s with reason '%s'." % (channel, sender, reason)
        self.channel_list.remove(channel)
        if self.on_join_part_do:
            for func in self.on_join_part_do:
                if callable(func):
                    func(self, server, channel, join=False)
                else:
                    ### If the function somehow has become a non-callable type. Remove it. ###
                    del self.on_join_part_do[func]
                    print " - Delete join/part handler."

    def respond(self, server, sender, target, arg):
        """If the command was issued in private send respons in private otherwise respond
           in target channel."""
        send_to = irclib.nm_to_n(sender)
        prefix = ""
        if target != self.settings.bot_nick_name:
            prefix = "%s: " % send_to
            send_to = target
        for line in arg.splitlines():
            server.privmsg(send_to, prefix+line)

    def tell_users(self, server, message, level=100, notice=False):
        """Tell all users with a certain level. Optionally a notice to all user of that
           level or higher."""
        if self.settings.bot_user_list:
            for user, user_level in self.settings.bot_user_list.iteritems():
                if user_level >= level:
                    for line in message.splitlines():
                        if notice:
                            server.notice(user, line)
                        else:
                            server.privmsg(user, line)
        else:
            self.settings.bot_user_list = { }

    def get_level(self, user):
        """Get level of a user or the default 0."""
        user_nick = irclib.nm_to_n(user)
        user_level = self.settings.bot_user_list.get(user_nick, 0)
        print " + %s has level %d." % (user_nick, user_level)
        return user_level

    def add_id_action(self, sender, func, args):
        """Add a function to be called on status respons from nickserv."""
        sender_nick = irclib.nm_to_n(sender)
        self.on_user_id_do[sender_nick] = (func, args)
        server.privmsg("nickserv", "STATUS %s" % sender_nick)
    
    def handle_command(self, server, sender, target, arg, public=True):
        """Handle commands either in public or private."""
        try:
            ### If \xc3 is found in the string the string is most likely encoded     ###
            ### UTF-8 otherwise assume it's Latin-1. This is not a really good idea  ###
            ### the bot is supposed to be used by channel using different languages  ###
            ### than english or swedish (maybe other european languages.             ###
            if '\xc3' in arg:
                print " + Convert utf-8 to unicode."
                arg = unicode(arg, "UTF-8")
            else:
                print " + Convert latin-1 to unicode."
                arg = unicode(arg, "Latin-1")
        except:
            print " - Failed to recode string."
        if not arg.strip():
            print " - No arguments."
            return True
        arg_list = arg.split()
        command_name = arg_list[0]
        arg_list = arg_list[1:]
        sender_level = self.get_level(sender)

        ### Strip away everything but nick from sender. ###
        sender = irclib.nm_to_n(sender)

        ### Check if the command is in the global bot alias list. ###
        if command_name in self.globals.bot_command_alias:
            ### If it is, then expand the alias and insert it into the list. ###
            alias_expand = self.globals.bot_command_alias[command_name].split()
            if alias_expand:
                print " + Expanded '%s' to '%s'." % (command_name, ' '.join(alias_expand))
                command_name = alias_expand[0]
                if len(alias_expand) > 1:
                    arg_list = alias_expand[1:] + arg_list

        ### Check if the command is in bot_commands. If it is try to execute it if the ###
        ### user has the rights to do so.                                              ###
        if command_name in self.globals.bot_commands:
            print "Command '%s' has been issued by %s." % (command_name, irclib.nm_to_n(sender))
            command = self.globals.bot_commands[command_name]
            if public and not command['public']:
                self.respond(server, sender, target, "You can't issue this command here.")
                return False
            if sender_level >= command['level']:
                try:
                    print " + Get command function '%s'." % ('do_'+command_name)
                    func = getattr(self, 'do_'+command_name)
                    if command['level'] >= self.globals.bot_id_req_level:
                        self.add_id_action(sender, func, (server, sender, target, arg_list))
                        return True
                    else:
                        try:
                            func(server, sender, target, arg_list)
                            return True
                        except TypeError, e:
                            print " - Callback is not a native function."
                            try:
                                func(self, server, sender, target, arg_list)
                                return True
                            except Exception, e2:
                                print " - Failed!", str(e2)
                                return False
                except AttributeError:
                    self.respond(server, sender, target, "This command is not yet implemented.")
                    print " - Has no method called do_%s." % command_name
                    return False
            else:
                self.respond(server, sender, target, "You are not allowed to issue this command.")
                return False
        else:
            return False

    def reload_module(self, server, module, sender = None):
        """Reload a loaded module."""
        real_module_name = 'kofoo_'+module
        if sender:
            server.privmsg(sender, "Reloading the module '%s'." % module)
        else:
            print "Reloading the module '%s'." % module
        try:
            self.unload_module(server, module, sender)
        except Exception, e:
            print " - Failed to unload module '%s': %s" % (module, str(e))
            return
        try:
            self.load_module(server, module, False, sender)
        except Exception, e:
            print " - Failed to load module '%s': %s" % (module, str(e))
            return

    def unload_module(self, server, module, sender = None):
        """Unload a module in memory and clean up all definitions."""
        real_module_name = 'kofoo_'+module
        print "Unload module '%s'." % real_module_name
        if real_module_name in sys.modules:
            module_object = sys.modules[real_module_name]
            module_attributes = dir(module_object)
            update_module = getattr(module_object, "update_"+module, None)
            module_alias = getattr(module_object, module+"_alias", None)
            module_pubmsg_handler = getattr(module_object, module+"_public_msg_handler", None)
            module_privmsg_handler = getattr(module_object, module+"_private_msg_handler", None)
            module_pubnotice_handler = getattr(module_object, module+"_public_notice_handler", None)
            module_privnotice_handler = getattr(module_object, module+"_private_notice_handler", None)
            module_join_part_handler = getattr(module_object, module+"_join_part_handler", None)
            module_ctcp_handler = getattr(module_object, module+"_ctcp_handler", None)
            module_helpers = getattr(module_object, module+"_helpers", None)
            unload_module = getattr(module_object, "unload_"+module, None)
            module_actions = {}
            if unload_module:
                if not unload_module(self, server, sender):
                    print " - Failed to unload module."
                    if sender:
                        server.privmsg(sender, "Failed to unload module '%s'." % module)
                        raise Exception("Unload module returns False.")
            for module_attribute in module_attributes:
                if module_attribute[:3] == "do_":
                    action_name = module_attribute[3:]
                    if action_name in self.globals.bot_commands:
                        try:
                            del self.globals.bot_commands[action_name]
                            print " + Removed command description for '%s'." % action_name
                        except Exception, e:
                            print " - Failed to remove command description for '%s'." % action_name
                            continue
                    try:
                        if hasattr(self, module_attribute):
                            delattr(self, module_attribute)
                    except Exception, e:
                        print " - Failed to unload '%s'." % module_attribute
                        continue
            if update_module:
                if update_module in self.on_update_do:
                    try:
                        self.on_update_do.remove(update_module)
                        print " + Removed update function."
                    except Exception, e:
                        print " - Failed to remove update function."
            if module_alias:
                for alias in module_alias:
                    try:
                        del self.globals.bot_command_alias[alias]
                        print " + Removed alias '%s'." % alias
                    except Exception, e:
                        print " - Failed to remove alias '%s'." % alias
            if module_pubmsg_handler:
                try:
                    self.on_pubmsg_do.remove(module_pubmsg_handler)
                    print " + Removed public message handler."
                except Exception, e:
                    print " - Failed to remove public message handler: %s" % str(e)
            if module_privmsg_handler:
                try:
                    self.on_privmsg_do.remove(module_privmsg_handler)
                    print " + Removed private message handler."
                except Exception, e:
                    print " - Failed to remove private message handler: %s" % str(e)
            if module_pubnotice_handler:
                try:
                    self.on_pubnotice_do.remove(module_pubnotice_handler)
                    print " + Removed public notice handler."
                except Exception, e:
                    print " - Failed to remove public notice handler: %s" % str(e)
            if module_privnotice_handler:
                try:
                    self.on_privnotice_do.remove(module_privnotice_handler)
                    print " + Removed private notice handler."
                except Exception, e:
                    print " - Failed to remove private notice handler: %s" % str(e)
            if module_join_part_handler:
                try:
                    self.on_join_part_do.remove(module_join_part_handler)
                    print " + Removed join/part handler."
                except Exception, e:
                    print " - Failed to remove join/part handler: %s" % str(e)
            if module_ctcp_handler:
                try:
                    self.on_ctcp_do.remove(module_ctcp_handler)
                    print " + Removed ctcp handler."
                except Exception, e:
                    print " - Failed to remove ctcp handler: %s" % str(e)
            if module_helpers:
                for helper in module_helpers:
                    try:
                        delattr(self, helper)
                        print " + Removed helper '%s'." % helper
                    except Exception, e:
                        print " - Failed to remove helper '%s': %s" % (helper, str(e))
            del module_pubmsg_handler
            del module_privmsg_handler
            del module_pubnotice_handler
            del module_privnotice_handler
            del module_join_part_handler
            del module_ctcp_handler
            del module_object
            del update_module
            del module_alias
            del module_helpers
            del sys.modules[real_module_name]
            self.module_list.remove(module)
        else:
            print " - No such module loaded."
            if sender:
                server.privmsg(sender, "The '%s' module is not loaded." % module)
                
    def load_module(self, server, module, auto = False, sender = None):
        """Try to load a module."""
        real_module_name = 'kofoo_'+module
        print "Load module '%s'." % real_module_name
        if real_module_name in sys.modules:
            self.reload_module(server, module, sender)
            return
        try:
            module_object = __import__(real_module_name, globals(), locals())
        except Exception, e:
            tb = traceback.format_exc()
            print " - Failed to load the module '%s' because %s.\n%s" % (module, str(e), tb)
            if sender:
                server.privmsg(sender, "Failed to load module '%s'.\n%s" % (module, tb))
            return
        module_requires = getattr(module_object, module+"_requires", None)
        if module_requires:
            missing_modules = []
            for requirement in module_requires:
                if not requirement in self.module_list:
                    missing_modules.append(requirement)
            if missing_modules:
                fail_string = "Failed to load module, required module%s not loaded: %s" % (('', 's')[missing_modules==[]], ', '.join(missing_modules))
                print " -", fail_string
                if sender:
                    server.privmsg(sender, fail_string)
                try:
                    del module_requires
                    del sys.modules[real_module_name]
                    del module_object
                    return
                except Exception, e:
                    print " - Could not unload module '%s'." % module
                    return
            else:
                print " + All requirments met."
        init_module = getattr(module_object, "init_"+module, None)
        update_module = getattr(module_object, "update_"+module, None)
        module_settings = getattr(module_object, module+"_settings", None)
        module_alias = getattr(module_object, module+"_alias", None)
        module_pubmsg_handler = getattr(module_object, module+"_public_msg_handler", None)
        module_privmsg_handler = getattr(module_object, module+"_private_msg_handler", None)
        module_pubnotice_handler = getattr(module_object, module+"_public_notice_handler", None)
        module_privnotice_handler = getattr(module_object, module+"_private_notice_handler", None)
        module_join_part_handler = getattr(module_object, module+"_join_part_handler", None)
        module_ctcp_handler = getattr(module_object, module+"_ctcp_handler", None)
        module_helpers = getattr(module_object, module+"_helpers", None)
        module_actions = {}
        module_attributes = dir(module_object)
        for module_attribute in module_attributes:
            if module_attribute[:3] == "do_":
                module_attribute_object = getattr(module_object, module_attribute)
                if callable(module_attribute_object):
                    module_action_description = getattr(module_attribute_object, 'command', None)
                    if not module_action_description:
                        module_action_description = getattr(module_object, module_attribute+'_command', None)
                    if module_action_description:
                        if type(module_action_description) is dict:
                            print " + Added action '%s'." % module_attribute[3:]
                            module_actions[module_attribute[3:]] = module_action_description
                        else:
                            print " - '%s' is of wrong type." % module_attribute
                    else:
                        print " + '%s' has no action description." % module_attribute
                else:
                    print " - '%s' is not callable." % module_attribute
        if module_settings:
            print " + Add settings."
            if type(module_settings) is dict:
                for setting, default in module_settings.iteritems():
                    setting_name = module+"_"+setting
                    if hasattr(self.settings, setting_name):
                        continue
                    else:
                        setattr(self.settings, setting_name, default)
                        print " + Added setting '%s' with default value '%s'." % (setting_name, str(default))
            elif type(module_settings) is list:
                for setting in module_settings:
                    setting_name = module+"_"+setting
                    setattr(self.settings, setting_name, None)
                    print " + Added setting '%s'." % setting_name
            else:
                print " - Module settings are of wrong type."
        if init_module:
            if init_module(self, server, sender):
                print " + Successfully initiated module '%s'." % module
                if sender:
                    server.privmsg(sender, "Successfully loaded module '%s'." % module)
            else:
                print " - Failed to initiate module: '%s'." % module
                if sender:
                    server.privmsg(sender, "Failed to initiate module '%s'." % module)
                try:
                    del module_object
                    del sys.modules[real_module_name]
                    print " - Module '%s' unloaded." % module
                    return
                except Exception, e:
                    print " - Failed to unload unfinished module."
                    return
        if update_module:
            print " + Adding update func for module '%s'." % module
            if not hasattr(update_module, 'delay'):
                delay = getattr(module_object, 'update_%s_delay' % module, None)
                setattr(update_module, 'delay', delay)
            if not hasattr(update_module, 'time_left'):
                time_left = getattr(module_object, 'update_%s_time_left' % module, None)
                setattr(update_module, 'time_left', time_left)
            self.on_update_do.append(update_module)
        if module_actions:
            for command_name, description in module_actions.iteritems():
                print " + Activate action '%s'." % command_name
                command_func_name = "do_"+command_name
                command_func = getattr(module_object, command_func_name, None)
                if command_func:
                    setattr(self, command_func_name, command_func)
                    if type(description) is tuple:
                        description = description[0]
                    self.globals.bot_commands[command_name] = description
                else:
                    print " - Failed to find function '%s'." % command_func_name
        if module_pubmsg_handler:
            if callable(module_pubmsg_handler):
                print " + Added public message handler."
                self.on_pubmsg_do.append(module_pubmsg_handler)
            else:
                print " - Failed to add public message handler. Not callable."
        if module_privmsg_handler:
            if callable(module_privmsg_handler):
                print " + Added private message handler."
                self.on_privmsg_do.append(module_privmsg_handler)
            else:
                print " - Failed to add private message handler. Not callable."
        if module_pubnotice_handler:
            if callable(module_pubnotice_handler):
                print " + Added public notice handler."
                self.on_pubnotice_do.append(module_pubnotice_handler)
            else:
                print " - Failed to add public notice handler. Not callable."
        if module_privnotice_handler:
            if callable(module_privnotice_handler):
                print " + Added private notice handler."
                self.on_privnotice_do.append(module_privnotice_handler)
            else:
                print " - Failed to add private notice handler. Not callable."
        if module_join_part_handler:
            if callable(module_join_part_handler):
                print " + Added join/part handler."
                self.on_join_part_do.append(module_join_part_handler)
            else:
                print " - Failed to add join/part handler. Not callable."
        if module_ctcp_handler:
            if callable(module_ctcp_handler):
                print " + Added ctcp handler."
                self.on_ctcp_do.append(module_ctcp_handler)
            else:
                print " - Failed to add ctcp handler. Not callable."
        if module_alias:
            try:
                self.globals.bot_command_alias.update(module_alias)
            except Exception, e:
                if sender:
                    server.privmsg(sender, "Failed to add alias from '%s'." % module)
        if module_helpers:
            for helper in module_helpers:
                try:
                    if hasattr(self, helper):
                        print " - Bot already has the attribute '%s'." % helper
                    else:
                        helper_object = getattr(module_object, helper)
                        if helper_object:
                            setattr(self, helper, helper_object)
                            print " + Added helper '%s' to bot." % helper
                        else:
                            print " - Module has no such helper '%s'." % helper
                except Exception, e:
                    print " - Failed to add helper '%s': %s" % (helper, str(e))
        if auto:
            if not module in self.settings.bot_auto_load_modules:
                self.settings.bot_auto_load_modules.append(module)
                print " + Added module to autoload."
        self.module_list.append(module)

#
# This is where command declaration begins!
#

    def do_quit(self, server, sender, target, args):
        """ [Native Command]"""
        print "Unload all modules."
        for module in self.module_list:
            self.unload_module(server, module, sender)
        self.want_to_quit = True
        alt_quit_msg = ' '.join(args)
        self.tell_users(server, "'Quit' issued by %s." % irclib.nm_to_n(sender), level=100, notice=True)
        if alt_quit_msg:
            self.disconnect_all("Quit '%s'." % alt_quit_msg)
        else:
            self.disconnect_all(self.settings.bot_quit_message)
        print "Disconnect and kill."

    def do_reconnect(self, server, sender, target, args):
        """ [Native Command]"""
        self.want_to_quit = False
        self.reconnect_timeout = 10.0
        self.tell_users(server, "'Reconnect' issued by %s." % irclib.nm_to_n(sender), level=100, notice=True)
        self.disconnect_all("Reconnecting '%s'." % ' '.join(args))
        print "Disconnect and reconnect."

    def do_load(self, server, sender, target, args):
        """ [Native Command]"""
        auto_load = False
        if args and args[0] == "auto":
            auto_load = True
            args = args[1:]
        for module in args:
            self.load_module(server, module, auto_load, irclib.nm_to_n(sender))

    def do_unload(self, server, sender, target, args):
        """ [Native Command]"""
        for module in args:
            self.unload_module(server, module, irclib.nm_to_n(sender))
            self.respond(server, sender, target, "Unloaded '%s'." % module)

    def do_save(self, server, sender, target, args):
        """ [Native Command]"""
        self.settings.save_settings(self.config_file)
        self.respond(server, sender, target, "Saved current configuration.")

    def do_join(self, server, sender, target, args):
        """ [Native Command]"""
        if args:
            for channel in args:
                server.join(channel)

    def do_part(self, server, sender, target, args):
        """ [Native Command]"""
        if args:
            server.send_raw("PART %s" % ", ".join(args))

#
# This is where command declaration ends!
#

def usage():
    print """\
KoFooBot usage:
  python kofoo.py [--config=<config-file>] [--help]

  Short  Long      Argument    Description
   -c    --config  <filename>  Choose what file to load configuration from.
   -h    --help                Show this help."""

if __name__ == '__main__':
    config_file = "config.cfg"
    if sys.argv:
        try:
            opts, args = getopt.getopt(sys.argv[1:], 'hc:', ['help', 'config='])
        except getopt.GetoptError, e:
            print str(e)
            usage()
            sys.exit(2)
        for opt, arg in opts:
            if opt in ('--help', '-h'):
                usage()
                sys.exit(0)
            elif opt in ('--config', '-c'):
                config_file = arg
        
    irc = KoFoo()
    reconnected = 1
    while not irc.want_to_quit:
        import time
        server = irc.server()
        server.connect(irc.settings.bot_irc_server, irc.settings.bot_irc_port, irc.settings.bot_nick_name)
        if not server.is_connected():
            reconnected += 1
        try:
            now = time.time()
            last = now
            last_update = time.time()
            while server.is_connected():
                if (time.time() - last_update) > 10.0:
                    last_update = time.time()
                now = time.time()
                irc.update(server, now-last)
                irc.process_once(0.2)
                last = now
        except KeyboardInterrupt:
            irc.want_to_quit = True
            irc.disconnect_all("Interrupted")
            print "Keyboard interruption captured."
        if irc.reconnect_timeout > 0 and not irc.want_to_quit:
            print "Wait for reconnection '%.2f'." % (irc.reconnect_timeout*reconnected)
            time.sleep(irc.reconnect_timeout*reconnected)
            reconnected -= 1
            if reconnected < 0:
                reconnected = 0
    irc.settings.save_settings(irc.config_file)
    print "Connection closed."
    
Gitorious
