Limnoria/plugins/FunDB.py
2004-09-23 16:18:41 +00:00

442 lines
16 KiB
Python
Executable File

###
# Copyright (c) 2002-2004, Jeremiah Fincher
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice,
# this list of conditions, and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions, and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the author of this software nor the name of
# contributors to this software may be used to endorse or promote products
# derived from this software without specific prior written consent.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###
"""
Provides fun commands that require a database to operate.
"""
__revision__ = "$Id$"
import supybot.plugins as plugins
import re
import csv
import sets
import random
import itertools
import supybot.dbi as dbi
import supybot.conf as conf
import supybot.ircdb as ircdb
import supybot.utils as utils
import supybot.world as world
import supybot.ircmsgs as ircmsgs
import supybot.ircutils as ircutils
import supybot.privmsgs as privmsgs
import supybot.registry as registry
import supybot.callbacks as callbacks
class FunDBRecord(object):
__metaclass__ = dbi.Record
__fields__ = [
'by',
'text',
]
class DbiFunDBDB(object):
class FunDBDB(dbi.DB):
Record = FunDBRecord
def __init__(self, filename):
self.dbs = ircutils.IrcDict()
self.filename = filename
def close(self):
for type in self.dbs.itervalues():
for db in type.itervalues():
db.close()
def _getDb(self, channel, type):
type = type.lower()
if channel not in self.dbs:
self.dbs[channel] = {}
if type not in self.dbs[channel]:
filename = self.filename.replace('FunDB', type.capitalize())
filename = plugins.makeChannelFilename(filename, channel)
self.dbs[channel][type] = self.FunDBDB(filename)
return self.dbs[channel][type]
def get(self, channel, type, id):
db = self._getDb(channel, type)
return db.get(id)
def add(self, channel, type, text, by):
db = self._getDb(channel, type)
return db.add(db.Record(by=by, text=text))
def remove(self, channel, type, id):
db = self._getDb(channel, type)
db.remove(id)
def change(self, channel, type, id, f):
db = self._getDb(channel, type)
record = db.get(id)
record.text = f(record.text)
db.set(id, record)
def random(self, channel, type):
db = self._getDb(channel, type)
return db.random()
def size(self, channel, type):
db = self._getDb(channel, type)
return itertools.ilen(db)
def search(self, channel, type, p):
db = self._getDb(channel, type)
return db.select(p)
FunDBDB = plugins.DB('FunDB',
{'flat': DbiFunDBDB})
conf.registerPlugin('FunDB')
conf.registerChannelValue(conf.supybot.plugins.FunDB, 'showIds',
registry.Boolean(True, """Determines whether the bot will show the id of an
insult/praise/lart."""))
class FunDB(callbacks.Privmsg):
"""
Contains the 'fun' commands that require a database. Currently includes
commands for larting, praising, and insulting.
"""
_types = ('insult', 'lart', 'praise')
def __init__(self):
self.__parent = super(FunDB, self)
self.__parent.__init__()
self.db = FunDBDB()
def die(self):
self.db.close()
self.__parent.die()
def _getBy(self, by):
try:
return ircdb.users.getUser(int(by)).name
except ValueError:
return by
def _validType(self, irc, type, error=True):
lowerTypes = [t.lower() for t in self._types]
if type.lower() not in lowerTypes:
if error:
irc.error('%r is not a valid type. Valid types include %s.' %
(type, utils.commaAndify(self._types)))
return False
else:
return True
def _validId(self, irc, id, error=True):
try:
return int(id)
except ValueError:
if error:
irc.error('The <id> argument must be an integer.')
return None
def _isRegistered(self, irc, msg):
try:
return ircdb.users.getUserId(msg.prefix)
except KeyError:
irc.errorNotRegistered()
return None
def add(self, irc, msg, args):
"""[<channel>] <lart|insult|praise> <text>
Adds another record to the data referred to in the first argument. For
commands that will later respond with an ACTION (lart and praise), $who
should be in the message to show who should be larted or praised. I.e.
'fundb add lart slices $who in half with a free AOL cd' would make the
bot, when it used that lart against, say, jemfinch, to say '/me slices
jemfinch in half with a free AOL cd' <channel> is only necessary if
the message isn't sent in the channel itself.
"""
channel = privmsgs.getChannel(msg, args)
(type, s) = privmsgs.getArgs(args, required=2)
type = type.lower()
userId = self._isRegistered(irc, msg)
if not userId:
return
if not self._validType(irc, type):
return
if type == "lart" or type == "praise":
if '$who' not in s:
irc.error('There must be a $who in the lart/praise somewhere')
return
id = self.db.add(channel, type, s, userId)
irc.replySuccess('(%s #%s added)' % (type, id))
def remove(self, irc, msg, args):
"""[<channel>] <lart|insult|praise> <id>
Removes the data, referred to in the first argument, with the id
number <id> from the database. <channel> is only necessary if the
message isn't sent in the channel itself.
"""
channel = privmsgs.getChannel(msg, args)
(type, id) = privmsgs.getArgs(args, required=2)
if not self._isRegistered(irc, msg):
return
if not self._validType(irc, type):
return
id = self._validId(irc, id)
if id is None:
return
try:
self.db.remove(channel, type, id)
irc.replySuccess()
except KeyError:
irc.error('There is no %s with that id.' % type)
def search(self, irc, msg, args):
"""[<channel>] <lart|insult|praise> <text>
Searches the database specified for <text>, and returns the records
with matching ids as well as a snippet of the text of each record.
"""
channel = privmsgs.getChannel(msg, args)
(type, text) = privmsgs.getArgs(args, required=2)
if not self._validType(irc, type):
return
def p(record):
return text in record.text
results = self.db.search(channel, type, p)
L = ['#%s: %s' % (record.id, utils.ellipsisify(record.text, 50)) \
for record in results]
if not L:
irc.error('There is no %s containing that text.' % type)
else:
irc.reply(utils.commaAndify(L))
def change(self, irc, msg, args):
"""[<channel>] <lart|insult|praise> <id> <regexp>
Changes the data, referred to in the first argument, with the id
number <id> according to the regular expression <regexp>. <id> is the
zero-based index into the db; <regexp> is a regular expression of the
form s/regexp/replacement/flags. <channel> is only necessary if the
message isn't sent in the channel itself.
"""
channel = privmsgs.getChannel(msg, args)
(type, id, regexp) = privmsgs.getArgs(args, required=3)
if not self._validType(irc, type):
return
id = self._validId(irc, id)
if id is None:
return
if not self._isRegistered(irc, msg):
return
try:
replacer = utils.perlReToReplacer(regexp)
except ValueError, e:
irc.error('That regexp wasn\'t valid: %s.' % e.args[0])
return
except re.error, e:
irc.error(utils.exnToString(e))
return
try:
self.db.change(channel, type, id, replacer)
irc.replySuccess()
except KeyError:
irc.error('There is no %s with that id.' % type)
def stats(self, irc, msg, args):
"""[<channel>] <lart|insult|praise>
Returns the number of records, of the type specified, currently in
the database. <channel> is only necessary if the message isn't sent
in the channel itself.
"""
channel = privmsgs.getChannel(msg, args)
type = privmsgs.getArgs(args)
if not self._validType(irc, type):
return
total = self.db.size(channel, type)
irc.reply('There %s currently %s in my database.' %
(utils.be(total), utils.nItems(type, total)))
def get(self, irc, msg, args):
"""[<channel>] <lart|insult|praise> <id>
Gets the record with id <id> from the type specified. <channel> is
only necessary if the message isn't sent in the channel itself.
"""
channel = privmsgs.getChannel(msg, args)
(type, id) = privmsgs.getArgs(args, required=2)
if not self._validType(irc, type):
return
id = self._validId(irc, id)
if id is None:
return
try:
x = self.db.get(channel, type, id)
irc.reply(x.text)
except KeyError:
irc.error('There is no %s with that id.' % type)
def info(self, irc, msg, args):
"""[<channel>] <lart|insult|praise> <id>
Gets the info for the record with id <id> from the type specified.
<channel> is only necessary if the message isn't sent in the channel
itself.
"""
channel = privmsgs.getChannel(msg, args)
(type, id) = privmsgs.getArgs(args, required=2)
if not self._validType(irc, type):
return
id = self._validId(irc, id)
if id is None:
return
try:
x = self.db.get(channel, type, id)
reply = '%s #%s: %r; Created by %s.' % (type, x.id, x.text,
self._getBy(x.by))
irc.reply(reply)
except KeyError:
irc.error('There is no %s with that id.' % type)
def _formatResponse(self, s, id, channel):
if self.registryValue('showIds', channel):
return '%s (#%s)' % (s, id)
else:
return s
_meRe = re.compile(r'\bme\b', re.I)
_myRe = re.compile(r'\bmy\b', re.I)
def _replaceFirstPerson(self, s, nick):
s = self._meRe.sub(nick, s)
s = self._myRe.sub('%s\'s' % nick, s)
return s
def insult(self, irc, msg, args):
"""[<channel>] <nick>
Insults <nick>. <channel> is only necessary if the message isn't
sent in the channel itself.
"""
channel = privmsgs.getChannel(msg, args)
nick = privmsgs.getArgs(args)
if not nick:
raise callbacks.ArgumentError
insult = self.db.random(channel, 'insult')
if insult is None:
irc.error('There are currently no available insults.')
else:
nick = self._replaceFirstPerson(nick, msg.nick)
s = '%s: %s' % (nick, insult.text.replace('$who', nick))
irc.reply(self._formatResponse(s, insult.id, channel),
prefixName=False)
def lart(self, irc, msg, args):
"""[<channel>] [<id>] <text> [for <reason>]
Uses a lart on <text> (giving the reason, if offered). Will use lart
number <id> from the database when <id> is given. <channel> is only
necessary if the message isn't sent in the channel itself.
"""
channel = privmsgs.getChannel(msg, args)
(id, nick) = privmsgs.getArgs(args, optional=1)
id = self._validId(irc, id, error=False)
if id is None:
nick = privmsgs.getArgs(args)
nick = nick.rstrip('.')
if not nick:
raise callbacks.ArgumentError
if ircutils.strEqual(nick, irc.nick):
nick = msg.nick
try:
(nick, reason) = itertools.imap(' '.join,
utils.itersplit('for'.__eq__, nick.split(), 1))
except ValueError:
reason = ''
if id:
try:
lart = self.db.get(channel, 'lart', id)
except KeyError:
irc.error('There is no such lart.')
return
else:
lart = self.db.random(channel, 'lart')
if lart is None:
irc.error('There are currently no available larts.')
else:
nick = self._replaceFirstPerson(nick, msg.nick)
reason = self._replaceFirstPerson(reason, msg.nick)
s = lart.text.replace('$who', nick)
if reason:
s = '%s for %s' % (s, reason)
s = s.rstrip('.')
irc.reply(self._formatResponse(s, lart.id, channel), action=True)
def praise(self, irc, msg, args):
"""[<channel>] [<id>] <text> [for <reason>]
Uses a praise on <text> (giving the reason, if offered). Will use
praise number <id> from the database when <id> is given.
<channel> is only necessary if the message isn't sent in the channel
itself.
"""
channel = privmsgs.getChannel(msg, args)
(id, nick) = privmsgs.getArgs(args, optional=1)
id = self._validId(irc, id, error=False)
if id is None:
nick = privmsgs.getArgs(args)
nick = nick.rstrip('.')
if not nick:
raise callbacks.ArgumentError
try:
(nick, reason) = itertools.imap(' '.join,
utils.itersplit('for'.__eq__, nick.split(), 1))
except ValueError:
reason = ''
if id:
try:
praise = self.db.get(channel, 'praise', id)
except KeyError:
irc.error('There is no such praise.')
return
else:
praise = self.db.random(channel, 'praise')
if praise is None:
irc.error('There are currently no available praises.')
else:
nick = self._replaceFirstPerson(nick, msg.nick)
reason = self._replaceFirstPerson(reason, msg.nick)
s = praise.text.replace('$who', nick)
if reason:
s = '%s for %s' % (s, reason)
s = s.rstrip('.')
irc.reply(self._formatResponse(s, praise.id, channel), action=True)
Class = FunDB
# vim:set shiftwidth=4 tabstop=8 expandtab textwidth=78: