Pointything/modules/Logging.py Pointything/modules/Markov.py Pointything/modules/Test.py Pointything/modules/db.py @@ -1,4 +1,5 @@ # -*- coding: utf-8 -*- +r"""Various constraints for use in a sql schema""" class Constraint: def __init__(self, str): self.str = str @@ -22,15 +23,18 @@ class PrimaryKey(Constraint): Constraint.__init__(self, "primary key") class ForeignKey(Constraint): + """A foreign key constraint. Requires an list of actions, which may be empty.""" def __init__(self, other, *actions): Constraint.__init__(self, "references") self.other = other self.actions = actions def __repr__(self): - return "references %s.%s %s"%(self.other.table.name, self.other.name, reduce((lambda x,y:str(x)+" "+str(y)), self.actions)) + return "references %s(%s) %s"%(self.other.table.name, self.other.name, reduce((lambda x,y:str(x)+" "+str(y)), self.actions)) class ForeignKeyAction: + """An action to perform on event, which may be one of "UPDATE", "DELETE", + or anything else supported by the underlying sql layer. The action is what to be done, such as "CASCADE" or "SET DEFAULT".""" def __init__(self, event, action): self.event = event self.action = action Database/Constraints.py @@ -1,32 +1,50 @@ # -*- coding: utf-8 -*- +r"""Field types +""" +import Constraints + class BaseField: def __init__(self, type, name): self.name = name self.constraints = [] self.type = type self.table = None + self.foreignTables = [] - def addConstraint(self, type): - self.constraints.append(type) + def addConstraint(self, c): + """Applies a constraint to the field""" + if isinstance(c, Constraints.ForeignKey): + self.foreignTables.append(c.other.table) + self.constraints.append(c) return self def __repr__(self): - return "%s %s %s"%(self.name, self.type, reduce((lambda x,y:repr(x)+" "+repr(y)),self.constraints, "")) + constraints = "" + if len(self.constraints)>0: + constraints = [] + for c in self.constraints: + constraints.append(repr(c)) + return "%s %s %s"%(self.name, self.type, " ".join(constraints)) def __str__(self): return self.name def cast(self, data): + """Converts data into the field's native format""" pass class Text(BaseField): def __init__(self, name): BaseField.__init__(self, 'text', name) def cast(self, data): - return int(data) + if data == None: + return "" + return str(data) class Integer(BaseField): def __init__(self, name): BaseField.__init__(self, 'integer', name) def cast(self, data): + if data == None: + return 0 return int(data) \ No newline at end of file Database/Fields.py @@ -1,4 +1,5 @@ # -*- coding: utf-8 -*- +from Fields import BaseField class MatchBase: def __init__(self, operand, field, value): self.field = field @@ -7,7 +8,32 @@ class MatchBase: def __str__(self): return str(self.field) + self.op + str(self.field.cast(self.value)) + + def __repr__(self): + return str(self.field) + self.op + "?" class Equals(MatchBase): + RIGHT = 1 + LEFT = 2 def __init__(self, field, value): - MatchBase.__init__(self, '==', field, value) \ No newline at end of file + if isinstance(field, BaseField): + self.direction = Equals.RIGHT + self.field = field + self.value = value + else: + self.direction = Equals.LEFT + self.field = value + self.value = field + MatchBase.__init__(self, '==', self.field, self.value) + + def __repr__(self): + if self.direction==Equals.RIGHT: + return str(self.field) + self.op + "?" + else: + return "?" + self.op + str(self.field) + + def __str__(self): + if self.direction==Equals.RIGHT: + return str(self.field) + self.op + str(self.field.cast(self.value)) + else: + return str(self.field.cast(self.value)) + self.op + str(self.field) \ No newline at end of file Database/Matches.py @@ -1,79 +1,221 @@ # -*- coding: utf-8 -*- +r"""An object-oriented database abstraction layer. + +The Database module is meant to provide an easy way to essentially +write your database's schema right into your python code. It is best explained with an example: + +import Database +class UserTable(Database.Table): + def __init__(self): + Database.Table.__init__(self, "users") + self.addField(Database.Fields.Integer("user_id").addConstraint(Database.Constraints.PrimaryKey()).addConstraint(Database.Constraints.AutoIncrement())) + self.addField(Database.Fields.Text("login")) + self.addField(Database.Fields.Text("password")) + +print repr(UserTable()) + +The output of this is valid SQL you can pass right into your favorite +sql engine's query() function. + +More advanced SQL is possible as well: + +from Database import * + +class MarkovWordTable(Table): + def __init__(self): + Table.__init__(self, "markov_words") + self.addField( + Fields.Integer("wid") + .addConstraint(Constraints.PrimaryKey()) + .addConstraint(Constraints.AutoIncrement()) + .addConstraint(Constraints.ForeignKey(MarkovLinkTable().field("from"), + ( + Constraints.ForeignKeyAction("delete", "cascade") + ) + )) + .addConstraint(Constraints.ForeignKey(MarkovLinkTable().field("to"), + ( + Constraints.ForeignKeyAction("delete", "cascade") + ) + )) + ) + self.addField(Fields.Text("word")) + +This creates a table named "markov_words" with two fields. The integer "wid" field +is a primary key with autoincrement and two foreign keys. The keys exist in the Link table +and are set to cascade on delete. + +Querying with a table object is remarkably simple as well: + +tbl = UserTable() +u = tbl.select(tbl.fields(), (Database.Matches.Equals(tbl["user_id"], id),)) + +This essentially evaluates to "SELECT * FROM users WHERE user_id == $id" + +""" + import sqlite3 import logging import Fields, Constraints, Matches '''Using repr() on a database object returns valid SQL.''' -instance = None - -def instance(): - if (instance == None): - instance = Database() - return instance - class Table: + """Represents a table in a sql database""" def __init__(self, name): self.log = logging.getLogger("Pointything.Database.%s"%name) - self.db = Database() self.name = name self._fields = {} + self.schemaReady = False + self.depends = [] + self.db = Database() + self.db.addTable(self) + def create(self): + if self.schemaReady: + return + else: + for d in self.depends: + d.create() + self.db.createTable(self) + self.schemaReady = True + + def addDependency(self, other): + self.depends.append(other) + def addField(self, field): + """Adds a field to the table's schema""" field.table = self self._fields.update({field.name: field}) + for d in field.foreignTables: + self.addDependency(d) + self.schemaReady = False return field def field(self, name): + """Returns the named field""" return self._fields[name] def fields(self): + """Returns all registered fields""" return self._fields.values() def __getitem__(self, name): + """Returns the named field""" return self.field(name) def select(self, *args, **kwargs): + """See Database.select for usage.""" return self.db.select(self, *args, **kwargs) + def insert(self, *args, **kwargs): + """See Database.insert for usage.""" + return self.db.insert(self, *args, **kwargs) + + def update(self, *args, **kwargs): + return self.db.update(self, *args, **kwargs) + + def __str__(self): + return self.name + def __repr__(self): - sql = "create table %s"%self.name - sql += " ( "+reduce((lambda x,y:repr(x)+", "+repr(y.schema())), self._fields.values())+" )" + """Creates the CREATE TABLE ... sql""" + sql = "create table if not exists %s"%self.name + fields = [] + for f in self._fields.values(): + fields.append(repr(f)) + sql += " ( "+(", ".join(fields))+" )" return sql class Database: + """Represents a database connection""" connection = None + alltables = {} def __init__(self): self.log = logging.getLogger("Pointything.Database") self.log.debug("Connecting to database") if Database.connection == None: Database.connection = sqlite3.connect("/home/trever/Projects/Pointything5/database") Database.connection.row_factory = sqlite3.Row + + def tables(self): + return Database.alltables + + def table(self, name): + return Database.alltables[name] + def addTable(self, table): + Database.alltables[table.name] = table def createTable(self, table): - c = self.db().cursor() + """Executes the table's CREATE sql""" + self.log.debug("Creating table: %s"%(repr(table))) try: - c.execute(table.schema()) - self.db().commit() - self.log.info("Created table %s"%(table.name)) - except sqlite3.OperationlError: - self.db().rollback() - return false - return true - - def db(self): + self.query(repr(table)) + #self.log.info("Created table %s"%(table.name)) + except sqlite3.OperationalError: + self.__db().rollback() + return False + return True + + def __db(self): return Database.connection def query(self, q, *args): - self.log.debug("Running query %s (%s)", q, args) - c = self.db().cursor() - c.execute(q, args) - self.db().commit() + """Runs a raw query on the database connection. If you have to use this, its a bug.""" + self.log.debug("Running query %s %% %s", q, args) + c = self.__db().cursor() + try: + c.execute(q, args) + except Exception, msg: + self.log.error("Exception during SQL: %s", msg) + raise msg return c def select(self, table, fields, matches): - sql = "select %s from %s where %s"%(reduce(lambda x,y:str(x)+", "+str(y), fields), table.name, reduce(lambda x,y:str(x)+" "+str(y), matches)) - c = self.db().cursor() - c.execute(sql) - return c \ No newline at end of file + """Runs a SELECT <fields> FROM <table> WHERE <matches>""" + table.create() + compares = [] + values = [] + for f in matches: + compares.append(repr(f)) + values.append(str(f.field.cast(f.value))) + #TODO: ANDs and ORs + sql = "select %s from %s where %s"%(reduce(lambda x,y:str(x)+", "+str(y), fields), table.name, " AND ".join(compares)) + return self.query(sql, *values) + + def insert(self, table, **fields): + """Runs INSERT INTO <table> <fields> VALUES <values> + Pass in a set of keyword arguments of field=value.""" + table.create() + parsedValues = [] + fieldNames = [] + for fieldName,value in fields.iteritems(): + field = table.field(fieldName) + parsedValues.append(field.cast(value)) + fieldNames.append(fieldName) + sql = "insert into %s (%s) values (%s)"%(table.name, reduce(lambda x,y:str(x)+", "+str(y), fieldNames), ','.join(['?']*len(parsedValues))) + return self.query(sql, *parsedValues) + + def update(self, table, conditions, **values): + """Runs UPDATE <table> <values> WHERE <conditions> + Pass in a set of keyword arguments of field=newValue + """ + table.create() + parsedValues = [] + fieldNames = [] + for fieldName,value in values.iteritems(): + field = table.field(fieldName) + parsedValues.append(field.cast(value)) + fieldNames.append(fieldName+"=?") + + compares = [] + values = [] + for f in conditions: + compares.append(repr(f)) + values.append(str(f.field.cast(f.value))) + + sql = "update %s set %s where %s"%(table.name, ", ".join(fieldNames) , " AND ".join(compares)) + queryValues = parsedValues+values + #sql = "update %s set (%s) where (%s)"%(table.name, reduce(lambda x,y:str(x)+", "+str(y), fieldNames), ','.join(['?']*len(parsedValues))) + return self.query(sql, *queryValues) \ No newline at end of file Database/__init__.py @@ -1,14 +1,21 @@ # -*- coding: utf-8 -*- +r"""Interface for the user subsystem authorization and management. + +Normal extensions shouldn't be concerned with this module. +""" import Database class UserTable(Database.Table): + """Contains users""" def __init__(self): Database.Table.__init__(self, "users") self.addField(Database.Fields.Integer("user_id").addConstraint(Database.Constraints.PrimaryKey()).addConstraint(Database.Constraints.AutoIncrement())) self.addField(Database.Fields.Text("login")) self.addField(Database.Fields.Text("password")) + self.insert(login="Trever", password="Hi") class User: + """A representation of a Pointything user. Users that exist in the database are considered "valid".""" def __init__(self, id): tbl = UserTable() u = tbl.select(tbl.fields(), (Database.Matches.Equals(tbl["user_id"], id),)) @@ -26,10 +33,11 @@ class User: @staticmethod def login(login, password): + """Returns a valid user if the credentials are correct, and an invalid one otherwise.""" tbl = UserTable() u = tbl.select((tbl["user_id"],), (Database.Matches.Equals(tbl["login"], login), Database.Matches.Equals(tbl["password"], password))) u = u.fetchone() if u == None: return User(0) else: - return User(u['user_id']) \ No newline at end of file + return User(u['user_id']) Pointything/Auth.py @@ -1,11 +1,56 @@ # -*- coding: utf-8 -*- +r"""Classes for dealing with extensions, Pointything actions, and the passing of data between actions""" from functools import wraps import logging +import sys +import imp + +__all__ = ["Extension", "Output", "Action", "InputHandler"] class Extension: - extension_name = "" + """The heart of Pointything's extensibility. + + Extension classes are meant to be loaded, unloaded, and reloaded on the fly with minimal hassle. + Normaly, __init__() and __del__() would be used to handle the loading and unloading. However, + /reloading/ an extension adds another level of complexity. It isn't enough to simply create + a new instance of an Extension and delete the old, because the state of an extension might want + to be preserved between reloads. The following set of methods were designed to handle this: + + * init - Called when the extension is first seen + * unloaded - Called when the extension is last seen + * reloading - Called on the new instance when it is about to replace the old one + * disposed - Called on the old instance after it has been supplanted by the new instance. + + For every Extension, __init__ and __del__ get handled apropriately on a per-instance basis. + For simple extensions that don't need to keep a state over Pointything's lifetime, that is + all they need. However, what if you are writing an extension that needs to keep a set of + memos in memory? Using only __init__, your internal memo variables would be wiped at every + extension reload. This is where these magic functions come in. To transfer the memo list + between module reloads, this memo module would need to implement the reloading method: + + def reloading(self, old): + self.memoList = old.memoList + + And your old memo list is now stored in the new extension instance. + + The init and unloaded methods work in a similar fashion. When an extension is first seen in Python, + it gets instantiated (which calls __init__), then init is called. Between then and the end of + the extension's life, reloads may happen (which use reloading/disposed), and finally unloaded is called. + + Extensions always get unloaded when the main loop exits, however they may also be unloaded on-demand. + + Each Extension contains a set of actions (decorated with Action) that may be called by + Pointything's users. Simply marking it with @Action tags it for inclusion in the default + implementation of userMethods. + + Actions get added to pointything with two names. The first is the actionName, the second is of the form + repr(extension)+"."+actionName. + + Other extensions may register actions with the same short names, but they may not claim another + action's full name. + """ def __init__(self, bot): - self.log = logging.getLogger("Pointything.extensions.%s"%(self.__class__.extension_name)) + self.log = logging.getLogger("Pointything.extensions.%s"%repr(self)) def __getattribute__(self, name): for m in self.userMethods(): @@ -15,6 +60,7 @@ class Extension: return getattr(self, name) def userMethods(self): + """Must return a list of available methods""" ret = [] for m in dir(self): m = getattr(self, m) @@ -22,10 +68,35 @@ class Extension: ret.append(m) return ret + def init(self): + """Called when the extension is first created""" + def unloaded(self): + """Called when the extension is unloaded""" + pass + + def reloading(self, oldInstance): + """Called when the extension has been replaced with a new instance""" + pass + + def disposed(self, newInstance): + """Called when the old extension has been replaced with the new one.""" pass + + def readBanter(self, input, user): + """Called to handle text recieved that isn't a command""" + pass + + def __str__(self): + """Returns the user-friendly name of the extension""" + return repr(self) + + def __repr__(self): + """Returns the internal representation of the extension. Overriding this is not recommended.""" + return self.__class__.__name__ def Action(name=None): + """Methods decorated with this become tagged for inclusion in the default implementation of Extension.userMethods() and have their return value automatically wrapped inside an Output object.""" if type(name)==str: def wrapper(func): @wraps(func) @@ -42,13 +113,14 @@ def Action(name=None): return outputWrap class Output(list): + """Standardized object for passing data between actions""" def __init__(self, input=None, user=None, bot=None, delimiter=None): if delimiter == None: self.delimiter = " " self.bot = bot self.user = user list.__init__(self) - if type(input)==str or type(input) == unicode: + if type(input)==str or type(input) == unicode or type(input) == int: self.append(input) elif input != None: if isinstance(input,Output): @@ -68,11 +140,79 @@ class Output(list): return "" def do(self, command, out, user): + """For chaining commands""" pass class InputHandler(Extension): + """Describes an extension that can handle input streams""" def parse(self, bot, stream): + """Called when select() on a stream (from InputHandler.streams) notifies that it has data ready to be read.""" pass def streams(self): - pass \ No newline at end of file + """Must return a list of file-like objects that eventually make their way to select() in the main event loop""" + pass + +class ExtensionControl(Extension): + '''Extension to control the extensions. Thats deep, man.''' + def __str__(self): + return "Extension Management" + def __init__(self, bot): + Extension.__init__(self, bot) + extPath = "/home/trever/Projects/Pointything5/Pointything/modules" + self.log.debug("Looking for extensions in %s",extPath) + sys.path.append(extPath) + + @Action + def loadModule(self, input, modName): + """Load a module""" + self.log.info("Loading module %s",modName) + self.log.debug("Looking for module %s", modName) + (file, path, desc) = imp.find_module(modName) + self.log.debug("Found in %s", path) + mod = imp.load_module(modName, file, path, desc) + foundExtensions = [] + for item in dir(mod): + ext = getattr(mod, item) + if type(ext) == type(Extension) and issubclass(ext, Extension) and ext != Extension and ext != InputHandler: + self.log.debug("Found extension %s", ext) + foundExtensions.append(ext) + input.bot.extendWith(ext) + self.log.info("Loaded %s with extensions: %s", modName, map(lambda x:x.__name__,foundExtensions)) + return "Loading complete. Found extensions: %s"%(foundExtensions) + + @Action + def details(self, input, extName): + """Give details about a module""" + ext = input.bot.grabExtension(extName) + details = {} + details["Name"] = str(ext) + details["Desc"] = ext.__doc__ + details["Class"] = repr(ext) + return details + + @Action + def unload(self, input, extName): + """Unload a module by name""" + self.log.info("Unloading extension %s", extName) + input.bot.unloadExtension(input.bot.grabExtension(extName)) + return "Unloaded extension" + + @Action + def functions(self, input, module=None): + """Returns a list of all functions declared by all loaded extensions""" + ret = [] + if module!=None: + for i in input.bot.extensions[module].userMethods(): + ret.append(i.action_name) + else: + ret = input.bot.commands + return ret + + @Action + def extensions(self, bot): + """Lists all loaded extensions""" + ret = [] + for m in input.bot.extensions: + ret.append(m) + return ret \ No newline at end of file Pointything/Extensions.py @@ -1,69 +1,12 @@ # -*- coding: utf-8 -*- -import imp +r"""Pointything, The Famous Whatshisface""" from Extensions import * -import sys +from Extensions import ExtensionControl import select import logging import __builtin__ import traceback - -class ExtensionControl(Extension): - '''Extension to control the extensions. Thats deep, man.''' - extension_name = "extensionControl" - def __init__(self, bot): - Extension.__init__(self, bot) - extPath = "/home/trever/Projects/Pointything5/Pointything/modules" - self.log.debug("Looking for extensions in %s",extPath) - sys.path.append(extPath) - - @Action - def loadModule(self, input, modName): - self.log.info("Loading module %s",modName) - self.log.debug("Looking for module %s", modName) - (file, path, desc) = imp.find_module(modName) - self.log.debug("Found in %s", path) - mod = imp.load_module(modName, file, path, desc) - foundExtensions = [] - for item in dir(mod): - ext = getattr(mod, item) - if type(ext) == type(Extension) and issubclass(ext, Extension) and ext != Extension and ext != InputHandler: - self.log.debug("Found extension %s", ext.extension_name) - foundExtensions.append(ext.extension_name) - input.bot.extendWith(ext) - self.log.info("Loaded %s with extensions: %s", modName, foundExtensions) - return "Loading complete. Found extensions: %s"%(foundExtensions) - - @Action - def details(self, input, extName): - ext = input.bot.grabExtension(extName) - details = {} - details["Name"] = ext.extension_name - details["Desc"] = ext.__doc__ - details["Class"] = str(ext) - return details - - @Action - def unload(self, input, extName): - self.log.info("Unloading extension %s", extName) - input.bot.unloadExtension(input.bot.grabExtension(extName)) - return "Unloaded extension" - - @Action - def functions(self, input, module=None): - ret = [] - if module!=None: - for i in input.bot.extensions[module].userMethods(): - ret.append(i.action_name) - else: - ret = input.bot.commands - return ret - - @Action - def extensions(self, bot): - ret = [] - for m in input.bot.extensions: - ret.append(m) - return ret +import sys class Pointything: def __init__(self): @@ -74,6 +17,7 @@ class Pointything: self.extendWith(ExtensionControl) def do(self, command, input, user=None): + """'Does' a command. The heart of Pointything.""" input = Output(input, user, self) if command in self.commands: command = self.commands[command] @@ -89,7 +33,12 @@ class Pointything: out.do = doWrapper return out + def readBanter(self, input, user=None): + for ext in self.extensions.values(): + ext.readBanter(input, user) + def run(self): + """Begins the main loop""" self.log.info("Entering main loop.") while True: streamToListener = {} @@ -116,38 +65,58 @@ class Pointything: self.cleanup() def cleanup(self): + """Performs some end-of-life maintenence, including unloading modules and closing inputs.""" self.log.debug("Cleaning up modules...") extList = self.extensions.copy() for m in extList: self.unloadExtension(self.extensions[m]) def extendWith(self, ext): + """Loads an instance of ext + + ext is _NOT_ an instance of an Extension class. It is the class itself. + Extensions must be initialized properly by Pointything to work right. + + """ log = logging.getLogger("Pointything.extensions") - log.info("Loading extension %s", ext.extension_name) + log.debug("Creating new instance of extension %s", ext) extInstance = ext(self) - #self.unloadExtension(ext) - self.extensions[ext.extension_name]=extInstance + try: + old = self.grabExtension(repr(extInstance)) + except: + old = None + if old == None: + log.info("Loading extension %s (%s)", repr(extInstance), extInstance) + extInstance.init() + else: + log.info("Reloading extension %s (%s)", repr(extInstance), extInstance) + extInstance.reloading(old) + old.disposed(extInstance) + del old + self.extensions[repr(extInstance)]=extInstance for cmd in extInstance.userMethods(): - self.commands[ext.extension_name+"."+cmd.action_name] = cmd + self.commands[repr(extInstance)+"."+cmd.action_name] = cmd self.commands[cmd.action_name] = cmd if isinstance(extInstance, InputHandler): - log.info("Attaching %s as input", ext.extension_name) + log.info("Attaching %s as input", extInstance) self.inputs.append(extInstance) def grabExtension(self, extName): + """Returns the extension with the given name""" return self.extensions[extName] def unloadExtension(self, ext): + """Unloads the extension""" log = logging.getLogger("Pointything.extensions") if ext in self.extensions.values(): - log.info("Unloading extension %s", ext.extension_name) + log.info("Unloading extension %s (%s)", repr(ext), ext) for cmd in ext.userMethods(): - log.debug("Unregistering commands %s, %s", cmd.action_name, ext.extension_name+"."+cmd.action_name) + log.debug("Unregistering commands %s, %s", cmd.action_name, repr(ext)+"."+cmd.action_name) if self.commands[cmd.action_name] == cmd: del self.commands[cmd.action_name] - del self.commands[ext.extension_name+"."+cmd.action_name] - del self.extensions[ext.extension_name] + del self.commands[repr(ext)+"."+cmd.action_name] + del self.extensions[repr(ext)] if ext in self.inputs: - log.info("Detatching input %s", ext.extension_name) + log.info("Detatching input %s", ext) self.inputs.remove(ext) ext.unloaded() \ No newline at end of file Pointything/__init__.py @@ -3,7 +3,6 @@ from Pointything.Extensions import * import random class EightBall(Extension): - extension_name="8ball" ANSWERS=[ "As I see it, yes", Pointything/modules/Games.py @@ -1,9 +1,8 @@ # -*- coding: utf-8 -*- from Pointything.Extensions import * -class HelpExtension(Extension): - extension_name="help" +class Help(Extension): @Action def help(self, bot, *args): - return "Ok" \ No newline at end of file + return "Ok" Pointything/modules/Help.py @@ -2,7 +2,7 @@ import irclib irclib.DEBUG = 1 class IRCInput(InputHandler): - extension_name="IRC" + def __init__(self, bot): InputHandler.__init__(self, bot) self.bot = bot @@ -37,6 +37,7 @@ class IRCInput(InputHandler): elif first.startswith("~"): args[0] = args[0][1:] else: + self.bot.readBanter(event.arguments()[0]) return try: server.privmsg(event.target(),str(self.bot.do(*args))) @@ -51,4 +52,4 @@ class IRCInput(InputHandler): server.privmsg(irclib.nm_to_n(event.source()),str(msg)) def streams(self): - return self.ircSockets \ No newline at end of file + return self.ircSockets Pointything/modules/IRC.py @@ -2,7 +2,6 @@ from Pointything.Extensions import * class StringTransform(Extension): - extension_name = "strings" @Action("concat") def concat(self, bot, *args, **kwargs): @@ -20,4 +19,4 @@ class StringTransform(Extension): for i in args: input.append(i) input.reverse() - return input \ No newline at end of file + return input Pointything/modules/StringTransform.py @@ -6,6 +6,21 @@ import threading import traceback import sys import atexit +import logging + +class TelnetLogHandler(logging.Handler): + def __init__(self, handler): + logging.Handler.__init__(self) + self.handler = handler + + def emit(self, record): + for c in self.handler.clients: + try: + c.send(self.format(record)+"\n") + except socket.error: + pass + except: + self.handleError(record) class TelnetListener(threading.Thread): def __init__(self, handler): @@ -13,9 +28,16 @@ class TelnetListener(threading.Thread): self.running = False self.handler = handler self.daemon = True - self.handler.log.info("Listening on *:16161") self.server = socket.socket() - self.server.bind(("0.0.0.0", 16161)) + bound = False + port = 16161 + while not bound: + try: + self.server.bind(("0.0.0.0", port)) + bound = True + except socket.error: + port+=1 + self.handler.log.info("Listening on *:%s", port) self.server.listen(1) def run(self): @@ -36,19 +58,34 @@ class TelnetListener(threading.Thread): self.running = False class TelnetInput(InputHandler): - extension_name="Telnet" def __init__(self, bot): InputHandler.__init__(self, bot) self.clients = [] self.buffers = {} + self.listenThread = None + self.logHandler = None + + def __str__(self): + return "Telnet Interface" + + def init(self): self.listenThread = TelnetListener(self) self.listenThread.start() - + self.logHandler = TelnetLogHandler(self) + logging.root.addHandler(self.logHandler) + def unloaded(self): self.stopListener(); + listenThread = None for s in self.clients: s.close() + def reloading(self, old): + self.listenThread = old.listenThread + self.clients = old.clients + self.buffers = old.buffers + self.logHandler = old.logHandler + def stopListener(self): self.log.info("Shutting down listener thread...") self.listenThread.kill() @@ -69,8 +106,11 @@ class TelnetInput(InputHandler): command = args[0] input = Output(args[1:], User(1)) try: + #bot.readBanter(line) ret = bot.do(command, input) stream.send(str(ret)+"\n") + except NotImplementedError: + stream.send("Unknown command: %s\n"%command) except: exceptionType, exceptionValue, exceptionTraceback = sys.exc_info() out = traceback.format_exception(exceptionType, exceptionValue, exceptionTraceback) @@ -78,4 +118,4 @@ class TelnetInput(InputHandler): stream.send(line) def streams(self): - return self.clients \ No newline at end of file + return self.clients Pointything/modules/Telnet.py @@ -6,8 +6,10 @@ import logging if __name__ == "__main__": logging.basicConfig(level=logging.DEBUG) + logging.getLogger("Pointything.Database").setLevel(logging.INFO) pthang = Pointything.Pointything() pthang.do("loadModule", "Telnet") + pthang.do("loadModule", "Markov") try: pthang.run() except KeyboardInterrupt: main.py 1d331a8b2bf5740f9ef47b0ef95cb86fc70ff72e Trever Fischer wm161@wm161.net http://github.com/workman161/pointything/commit/6d5dc331effad7c300534e465e20b2d028e4a6d4 6d5dc331effad7c300534e465e20b2d028e4a6d4 2009-01-14T23:37:40-08:00 2009-01-14T23:37:40-08:00 * Lots of documentation * Changed module API (again) to use repr() and str() for machine and user-friendly names * Finished more chunks of the database API * New Modules: Logging, db, Test, Markov * New Extensions: LogControl, Database, Testing, Markov * Forwarded logging output to all telnet sessions c870ac9096cab9365c94586dac5a98a6fac01a72 Trever Fischer wm161@wm161.net