I wrote (more of borrowed and molded) an IRC bot in high school and it is a giant piece of crap in terms of code. So recently I condensed it down and decided to redo it all. Here's all of the code, I'll break it down after.

To run it simply

python irc-bot.py <channel> <log.txt>


# Copyright (c) Twisted Matrix Laboratories
# See LICENSE for details.

#Default Imports
import requests

# twisted imports
from twisted.words.protocols import irc  
from twisted.internet import reactor, protocol  
from twisted.python import log

# system imports
import time, sys

#bot settings
nick = "Bot" #Name in chat  
server = "irc.freenode.net" #chat server

class MessageLogger:  
    An independent logger class (because separation of application
    and protocol logic is a good thing).
    def __init__(self, file):
        self.file = file

    def log(self, message):
        """Write a message to the file."""
        timestamp = time.strftime("[%H:%M:%S]", time.localtime(time.time()))
        self.file.write('%s %s\n' % (timestamp, message))

    def close(self):

class LogBot(irc.IRCClient):  
    """A logging IRC bot."""

    nickname = nick

    def connectionMade(self):
        self.logger = MessageLogger(open(self.factory.filename, "a"))
        self.logger.log("[connected at %s]" % 

    def connectionLost(self, reason):
        irc.IRCClient.connectionLost(self, reason)
        self.logger.log("[disconnected at %s]" % 

    # callbacks for events

    def signedOn(self):
        """Called when bot has succesfully signed on to server."""

    def joined(self, channel):
        """This will get called when the bot joins the channel."""
        self.logger.log("[I have joined %s]" % channel)

    def privmsg(self, user, channel, msg):
        """This will get called when the bot receives a message."""
        user = user.split('!', 1)[0]
        self.logger.log("<%s> %s" % (user, msg))

        #Here we only let user "Hunter" run this command
        #which tells the bot to join a channel 
        #Example: ".join #python"
        if user == "Hunter":
            if msg.startswith(".join"):
                joinchannel = msg[6:]

        #Tells the bot to leave the channel, takes no arguments
        if user == "Hunter":
            if msg.startswith(".leave"):
                joinchannel = msg[7:]

        #Commands are structured like .command [args]
        if msg.startswith(".about"):
            msg = "A bot created by Hunter"
            self.msg(channel, msg)
            self.logger.log("<%s> %s" % (self.nickname, msg))

    def action(self, user, channel, msg):
        """This will get called when the bot sees someone do an action."""
        user = user.split('!', 1)[0]
        self.logger.log("* %s %s" % (user, msg))

    # irc callbacks

    def irc_NICK(self, prefix, params):
        """Called when an IRC user changes their nickname."""
        old_nick = prefix.split('!')[0]
        new_nick = params[0]
        self.logger.log("%s is now known as %s" % (old_nick, new_nick))

    # For fun, override the method that determines how a nickname is changed on
    # collisions. The default method appends an underscore.
    def alterCollidedNick(self, nickname):
        Generate an altered version of a nickname that caused a collision in an
        effort to create an unused related name for subsequent registration.
        return nickname + '^'

class LogBotFactory(protocol.ClientFactory):  
    """A factory for LogBots.

    A new protocol instance will be created each time we connect to the server.

    def __init__(self, channel, filename):
        self.channel = channel
        self.filename = filename

    def buildProtocol(self, addr):
        p = LogBot()
        p.factory = self
        return p

    def clientConnectionLost(self, connector, reason):
        """If we get disconnected, reconnect to server."""

    def clientConnectionFailed(self, connector, reason):
        print "connection failed:", reason

if __name__ == '__main__':  
    # initialize logging

    # create factory protocol and application
    f = LogBotFactory(sys.argv[1], sys.argv[2])

    # connect factory to this host and port
    reactor.connectTCP(server, 6667, f)

    # run bot