mixster

#!/usr/bin/python
import sys, socket, time, threading, random, MySQLdb

class ERR:
    NOCON = -1
    NODAT = -2
    NOHAN = -3

class IRCCon:
    data = []
    connected = False

class Message:
    nick = ''
    real = ''
    host = ''
    param = []
    trail = []

    def __init__(self, data):
        print "<<" + data

        if data[0] == ":":
            data = data[1:]
            t = data.find(" ")
            prefix = data[:t]
            data = data[t+1:]
            temp = prefix.partition("@")
            self.host = temp[2]
            temp = temp[0].partition("!")
            self.nick, self.real = temp[0], temp[2]
        else:
            self.nick, self.real, self.host = "", "", ""

        pe = data.find(" :")
        if pe != -1:
            self.trail = data[pe + 2:].split(" ")
            self.param = data[:pe].split(" ")
        else:
            self.trail = []
            self.param = data.split(" ")


class IRCReader(threading.Thread):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    con = IRCCon()

    def __init__(self, server, nick, port=6667, real=None, passw=None, auth="ABC123"):
        self.sock.connect((server, port))
        self.con.connected = True
        self.nick = nick
        self.auth = auth

        if passw != None:
            self.send("PASS " + passw)
        if real == None:
            real = nick

        self.send("NICK " + nick)
        self.send("USER " + nick + " 0 0 :" + real)

        self.act = {
        "CTCP" : lambda x: self.send("PRIVMSG " + x.nick + " :" + chr(1) + " ".join(x.trail[1:]) + chr(1)),
        "QUIT": lambda x: self.send("QUIT :" + " ".join(x.trail[1:])),
        "RAW": lambda x: self.send(" ".join(x.trail[1:]))
        }

        self.ntc = {}

        self.ctcp = {
        "PING": lambda x: self.send("NOTICE " + x.nick + " :" + chr(1) + "PING " + " ".join(x.trail[1:]) + chr(1)),
        "VERSION": lambda x: self.send("NOTICE " + x.nick + " :" + chr(1) + "VERSION Python Markov Chain Chatbot v3.0" + chr(1)),
        "TIME": lambda x: self.send("NOTICE " + x.nick + " :" + chr(1) + "TIME " + time.strftime("%a %b %d %H:%M:%S %Y") + chr(1))
        }

        self.cmd = {
        "PING": lambda x: self.send("PONG " + x.trail[0]),
        "NOTICE": lambda x: self.ntc.get(x.trail[0].upper(), lambda x: ERR.NOHAN)(x),
        "PRIVMSG": self.checkPrivmsg,
        "ERROR": lambda x: self.setClosed()
        }

        threading.Thread.__init__(self)

    def run(self):
        while self.con.connected:
            data = self.sock.recv(512)
            while data[-2:] != "\r\n":
                data += self.sock.recv(64)
            data = data.split("\r\n")

            for line in data:
                tmp = self.parse(line)
                if tmp == ERR.NODAT:
                    continue
                res = self.handle(tmp)
                if res == ERR.NOHAN:
                    self.con.data.append(tmp)

        self.sock.close()

    def setClosed(self):
        self.con.connected = False

    def parse(self, data):
        if len(data) == 0:
            return ERR.NODAT

        tmp = Message(data)

        print "(" + ",".join([tmp.nick, tmp.real, tmp.host]) + ")::" + "|".join(tmp.param) + "[" + str(len(tmp.param)) + "]::" + " ".join(tmp.trail)

        return tmp


    def checkPrivmsg(self, data):
        if len(data.trail) == 0:
            return ERR.NOHAN

        elif data.param[1] == self.nick:
            if data.trail[0].startswith(chr(1)) and data.trail[-1].endswith(chr(1)):
                data.trail[0] = data.trail[0].lstrip(chr(1))
                data.trail[-1] = data.trail[-1].rstrip(chr(1))
                return self.ctcp.get(data.trail[0].upper(), lambda x: ERR.NOHAN)(data)
            elif ((len(data.trail) > 1) and (data.trail[0] == self.auth)):
                del data.trail[0]
                return self.act.get(data.trail[0].upper(), lambda x: ERR.NOHAN)(data)
            else:
                return ERR.NOHAN
        else:
            return ERR.NOHAN


    def handle(self, data):
        return self.cmd.get(data.param[0].upper(), lambda x: ERR.NOHAN)(data)

    def send(self, data):
        if not self.con.connected:
            return ERR.NOCON

        print ">>" + data
        sent = self.sock.send(data + "\n")
        data = data[sent:]
        while (len(data) != 0) and (self.con.connected):
            sent = self.sock.send(data + "\n")
            data = data[sent:]

        return 0

    def formatPriv(self, data, text):
        if self.nick == data.param[1]:
            return "PRIVMSG " + data.nick + " :" + text
        else:
            return "PRIVMSG " + data.param[1] + " :" + text


class IRCProcessor:
    def __init__(self, server, nick, port=6667, real=None, passw=None, auth="ABC123"):
        self.reader = IRCReader(server, nick, port, real, passw, auth)
        self.con = self.reader.con
        self.send = self.reader.send
        self.formatPriv = self.reader.formatPriv
        self.reader.start()

        self.ntc = {}

        self.act = {
        "REPLY": lambda x: self.send(self.formatPriv(x, generateReply(x.trail[1:]))),
        "PING" : lambda x: self.send(self.formatPriv(x, "pong!"))
        }

        self.cmd = {
        "NOTICE": lambda x: self.ntc.get(x.trail[0].upper(), lambda x: ERR.NOHAN)(x),
        "PRIVMSG": self.checkPrivmsg
        }

    def read(self):
        if len(self.con.data) == 0:
            return ERR.NODAT
        return self.con.data.pop(0)

    def handle(self, data):
        return self.cmd.get(data.param[0].upper(), lambda x: ERR.NOHAN)(data)

    def checkPrivmsg(self, data):
        if len(data.trail) == 0:
            return ERR.NOHAN

        if data.trail[0].startswith(self.reader.nick):
            if len(data.trail[0]) != len(self.reader.nick):
                if data.trail[0][len(self.reader.nick)+1:].isalnum():
                    return ERR.NOHAN

            del data.trail[0]
        elif data.param[1] == self.reader.nick:
            pass
        else:
            return ERR.NOHAN


        return self.act.get(data.trail[0].upper(), lambda x: ERR.NOHAN)(data)


def generateReply(seed):
    t = time.clock()

    db = MySQLdb.connect("localhost", "user", "pass", "wordsdb")
    c = db.cursor()

    if type(seed) == type(list()):
        if len(seed) == 0:
            c.execute("SELECT wid FROM sentences WHERE sentences.pid=0 ORDER BY rand() LIMIT 1")
            inp = c.fetchone()
            c.execute("SELECT word FROM words WHERE id=%s", (inp[0],))
            inp = c.fetchone()
            seed = inp[0]
        else:
            seed = random.choice(seed)

    inp = seed.lower()
    sentence = [inp]

    c.execute("SELECT id FROM words WHERE word=%s", (inp, ))
    inp = c.fetchone()

    if inp != None:
        pid = [inp[0]]

        c.execute("SELECT curw.word, curw.id FROM words curw, sentences curs, sentences pres WHERE pres.wid=%s AND curs.pid=pres.id AND curw.id=curs.wid ORDER BY rand() LIMIT 1", (pid[0], ))
        inp = c.fetchone()

        if inp != None:
            sentence.append(inp[0])
            pid.append(inp[1])

    while inp != None:
        c.execute("SELECT curw.word, curw.id FROM words curw, sentences curs, sentences pres, sentences pres2 WHERE pres.wid=%s AND pres2.wid=%s AND curs.pid=pres.id AND pres.pid=pres2.id AND curw.id=curs.wid ORDER BY RAND() LIMIT 1", (pid[-1], pid[-2], ))

        inp = c.fetchone()
        if inp != None:
            sentence.append(inp[0])
            pid.append(inp[1])

    t = time.clock() - t
    if t > 0:
        print "generateReply() took " + str(t) + " seconds to produce a sentence of " + str(len(sentence)) + " words (" + str((len(sentence) - 1) / t) + " wps)"
    else:
        print "generateReply() took " + str(t) + " seconds to produce a sentence of " + str(len(sentence)) + " words"

    return " ".join(sentence)


random.seed()
irccon = IRCProcessor("irc.rizon.net", "sillybot", auth="ABC123")
irccon.send("JOIN #mixster")
while irccon.con.connected:
    inp = irccon.read()
    if inp != ERR.NODAT:
        irccon.handle(inp)
    else:
        time.sleep(0.025)
print "Terminating!"