SGDQ 2015 Markov Chain Chat Simulator

import os
import sys
import time
from datetime import datetime, timezone

def parse_ts(ts_str):
    return datetime.strptime(ts_str, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=timezone.utc).timestamp()

def read_chatlog(chatlog_line):
    try:
        line_split = chatlog_line.split(' ', 1)
        timestamp = parse_ts(line_split[0])
        message = line_split[1].split(": ", 1)
        user = message[0].lower()
        comment = message[1].rstrip("\n")
    except Exception as e:
        return '','',''
    return timestamp, user, comment

class Markov(object):
    def __init__(self, length):
        from collections import defaultdict
        self.length = length
        self._states = defaultdict(set)

    def makeQueue(self):
        from collections import deque
        return deque((None for i in range(self.length)), maxlen = self.length)

    def updateWithMessage(self, message):
        queue = self.makeQueue()

        for token in message:
            self.registerChain(queue, token)
            queue.append(token)

    def registerChain(self, state, token):
        self._states[tuple(state)].add(token)
        #could count occurrences of token to do weighting

    def generateToken(self, state):
        from random import choice
        outputs = self._states[tuple(state)]
        if len(outputs) == 0:
            return None #equates to "end message"
        else:
            return choice(tuple(outputs))

    def generateAllTokens(self):
        queue = self.makeQueue()

        while True:
            token = self.generateToken(queue)

            if token is None:
                return
            else:
                queue.append(token)
                yield token

    def generateMessage(self):
        return "".join(self.generateAllTokens())

def tokenise(message):
    import re
    tokens = re.findall(r"(?:\w+)|(?:\W+)", message)
    tokens.append(None) #denotes the end of the string
    return tokens

def generateMarkov(file, length = 2):
    markov = Markov(length)
    for index, line in enumerate(file):
        timestamp, username, message = read_chatlog(line)
        if username == "":
            continue

        markov.updateWithMessage(tokenise(message))

    return markov

if __name__ == "__main__":
    MARKOV_LENGTH = 4 #take last N tokens into account when generating
    #note that spaces and other punctuation are considered tokens
    CHAT_LINES_TO_GENERATE = 1000

    input_file = open("gamesdonequick.txt", 'r', encoding = "utf-8")
    output_file = open("gdq_markov.txt", "w", encoding = "utf-8")
    markov = generateMarkov(input_file)
    for count in range(CHAT_LINES_TO_GENERATE):
        output_file.write(markov.generateMessage())
        output_file.write("\n")
    output_file.flush()