# plugs/url.py # # from gozerbot.generic import handle_exception, rlog, convertpickle from gozerbot.callbacks import callbacks from gozerbot.commands import cmnds from gozerbot.plughelp import plughelp from gozerbot.examples import examples from gozerbot.datadir import datadir from gozerbot.persist.persiststate import PlugState import re, os plughelp.add('url', 'maintain searchable logs of urls') def upgrade(): convertpickle(datadir + os.sep + 'old' + os.sep + 'url', \ datadir + os.sep + 'plugs' + os.sep + 'url' + os.sep + 'state') re_url_match = re.compile(u'((?:http|https)://\S+)') state = None def init(): global state state = PlugState() state.define('urls', {}) return 1
__gendoclast__ = ['part', ] # gozerbot imports from gozerbot.callbacks import callbacks from gozerbot.fleet import fleet from gozerbot.partyline import partyline from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp from gozerbot.tests import tests import gozerbot.threads.thr as thr # basic imports import Queue, sets plughelp.add('irc', 'irc related commands') ignorenicks = [] def handle_broadcast(bot, ievent): """ broadcast txt to all joined channels. """ if not ievent.rest: ievent.missing('<txt>') return fleet.broadcast(ievent.rest) partyline.say_broadcast(ievent.rest) cmnds.add('broadcast', handle_broadcast, 'OPER')
from gozerbot.generic import handle_exception, rlog, strtotime, striptime, \ jsonstring from gozerbot.utils.lazydict import LazyDict from gozerbot.persist.persist import Persist from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.utils.nextid import nextid from gozerbot.fleet import fleet from gozerbot.datadir import datadir from gozerbot.plughelp import plughelp from gozerbot.aliases import aliases from gozerbot.periodical import periodical from gozerbot.tests import tests import time, os, shutil plughelp.add('alarm', 'remind the user with given txt at a certain time') ## UPGRADE PART def upgrade(): pass ## END UPGRARE PART class Alarmitem(LazyDict): """ item holding alarm data """ def __init__(self, botname='default', i=0, nick="", ttime=time.time(), txt="", \ printto=None, d={}): if not d:
# gozerbot/plugs/inform.py # # """ prepend nick: to the output of a command. """ # gozerbot imports from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plugins import plugins from gozerbot.plughelp import plughelp from gozerbot.tests import tests plughelp.add('inform', 'inform <nick> the output of a command') def handle_inform(bot, ievent): """ prepend nick: to the output of command to another user """ if ievent.msg: ievent.reply('inform can only be used in a channel') return try: nick, cmnd = ievent.rest.split(' ', 1) except ValueError: ievent.missing('<nick> <command>') return ievent.txt = cmnd result = plugins.cmnd(bot, ievent) if not result:
# # """ eight ball """ __copyright__ = 'this file is in the public domain' __revision__ = '$Id: m8b.py 1120 2006-12-30 12:00:00Z deck $' from gozerbot.generic import handle_exception from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp from gozerbot.tests import tests import re, random plughelp.add('8b', 'Ask the magic 8 ball') balltxt=[ "Signs point to yes.", "Yes.", "Most likely.", "Without a doubt.", "Yes - definitely.", "As I see it, yes.", "You may rely on it.", "Outlook good.", "It is certain.", "It is decidedly so.", "Reply hazy, try again.", "Better not tell you now.", "Ask again later.",
for z in j: karma.setwhodown(i, z) for i, j in k.whoup.iteritems(): for z in j: karma.setwhoup(i, z) except Exception, ex: rlog(10, 'karma', 'failed to upgrade: %s' % str(ex)) return rlog(10, 'karma', 'upgraded %s karma items' % str(teller)) # END UPGRADE PART plughelp.add( 'karma', 'maintain karma of items .. use ++ to raise karma by 1 \ or use -- to lower by 1 .. reason might be given after a "#"') class KarmaDb(object): """ karma object """ def save(self): pass def size(self): """ return number of items """ s = create_session() count = s.query(sa.func.count(Karma.item)).first()[0] return count @trans
# # """ ignore users. """ __copyright__ = 'this file is in the public domain' # gozerbot imports from gozerbot.commands import cmnds from gozerbot.generic import getwho from gozerbot.examples import examples from gozerbot.plughelp import plughelp from gozerbot.ignore import addignore, delignore, ignore from gozerbot.tests import tests from gozerbot.users import users plughelp.add('ignore', 'ignore users for a certain time') def handle_ignore(bot, ievent): """ ignore nick for number of seconds. """ try: (nick, nrseconds) = ievent.args nrseconds = int(nrseconds) except ValueError: ievent.missing('<nick> <seconds>') return userhost = getwho(bot, nick) if not userhost:
# plugs/tel.py # # """ telefone codes """ __copyright__ = 'this file is in the public domain' from gozerbot.generic import geturl, striphtml, splittxt from gozerbot.commands import cmnds from gozerbot.aliases import aliases from gozerbot.examples import examples from gozerbot.plughelp import plughelp import re, random plughelp.add('tel', 'show country telephone codes') codes = [ ("213", "ALGERIA", "DZ"), ("102", "ANTIGUA BARBUDA", ""), ("54", "ARGENTINA", "AR"), ("374", "ARMENIA", "AM"), ("297", "ARUBA", "AW"), ("61", "AUSTRALIA", "AU"), ("43", "AUSTRIA", "AT"), ("994", "AZERBAIJAN", "AZ"), ("103", "BAHAMAS", "BS"), ("104", "BARBADOS", "BB"), ("375", "BELARUS", "BY"), ("32", "BELGIUM", "BE"), ("105", "BERMUDA", "BM"),
# plugs/dns.py # # __copyright__ = 'this file is in the public domain' from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp import copy import re import socket plughelp.add('dns', 'do ip or host lookup') _re_hexip = re.compile('^[\da-f]{8}$', re.I) def handle_hostname(bot, ievent): """ hostname <ipnr> .. get hostname of ip number""" try: item = ievent.args[0] except IndexError: ievent.missing('<ipnr>') return try: hostname = socket.gethostbyaddr(item) ievent.reply(hostname[0]) except: ievent.reply("can't match " + str(item)) cmnds.add('host', handle_hostname, 'USER')
# # Sorting """ sort bot results. """ __author__ = "Wijnand 'maze' Modderman <http://tehmaze.com>" __license__ = "BSD" from gozerbot.commands import cmnds from gozerbot.generic import waitforqueue from gozerbot.plughelp import plughelp from gozerbot.examples import examples from gozerbot.tests import tests import optparse plughelp.add('sort', ' sort elements (of a pipeline)') class SortError(Exception): pass class SortOptionParser(optparse.OptionParser): def __init__(self): optparse.OptionParser.__init__(self) self.add_option('-f', '--ignore-case', help='fold lower case to upper case characters', default=False, action='store_true', dest='ignorecase') self.add_option('-n', '--numeric-sort', default=False, help='compare according to string numerical value', action='store_true', dest='numeric') self.add_option('-r', '--reverse', default=False, help='reverse the result of comparisons', action='store_true', dest='reverse')
from gozerbot.generic import rlog, geturl, striphtml, jsonstring from gozerbot.persist.persist import PlugPersist from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.callbacks import callbacks, jcallbacks from gozerbot.plughelp import plughelp from gozerbot.plugins import plugins from gozerbot.threads.thr import start_new_thread from gozerbot.utils.statdict import Statdict from gozerbot.utils.limlist import Limlist from os.path import join as _j import time, re, random, types from gozerbot.persist.persistconfig import PersistConfig plughelp.add('markov', 'Gozerbot speaking madness') cfg = PersistConfig() cfg.define('enable', []) cfg.define('command', 1) cfg.define('onjoin', []) def enabled(botname, channel): if jsonstring([botname, channel]) in cfg['enable']: return True # Markers (is Marker the correct name for this?) class Marker: pass class BeginMarker(Marker): pass class EndMarker(Marker): pass class NickMarker(Marker): pass
__author__ = "Wijnand 'tehmaze' Modderman - http://tehmaze.com" __license__ = 'BSD' __depending__ = ['rss', ] from gozerbot.aliases import aliases from gozerbot.callbacks import callbacks from gozerbot.commands import cmnds from gozerbot.generic import striphtml, useragent, rlog from gozerbot.plughelp import plughelp from gozerbot.examples import examples import urllib import urllib2 import urlparse import re plughelp.add('tinyurl', 'the tinyurl url provides a tiny url for the url \ provided as argument or the last url in the log') re_url_match = re.compile(u'((?:http|https)://\S+)') urlcache = {} def valid_url(url): """ check if url is valid """ if not re_url_match.search(url): return False parts = urlparse.urlparse(url) cleanurl = '%s://%s' % (parts[0], parts[1]) if parts[2]: cleanurl = '%s%s' % (cleanurl, parts[2]) if parts[3]: cleanurl = '%s;%s' % (cleanurl, parts[3]) if parts[4]:
# plugs/drinks.py # # from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp import os, string, random plughelp.add('drinks', 'serve coffee/tea or beer') coffee = [] tea = [] beer = [] def init(): global coffee global tea global beer for i in coffeetxt.split('\n'): if i: coffee.append(i.strip()) for i in teatxt.split('\n'): if i: tea.append(i.strip()) for i in beertxt.split('\n'): if i: beer.append(i.strip()) return 1
from gozerbot.generic import useragent, waitforqueue from gozerbot.plughelp import plughelp from gozerbot.persist.persistconfig import PersistConfig import copy import optparse import urllib import urllib2 cfg = PersistConfig() cfg.define('url', 'http://www.paste-it.net/ajax/pit/') cfg.define('expiry', 604800) cfg.define('items', 50) cfg.define('waitforqueue', 50) cfg.define('useragent', 'paste-it.net command line client (Compatible; %s)' % ' '.join(config['version'].split()[0:2])) plughelp.add('pit', 'http://www.paste-it.net paste functionality') class PitOptionParser(optparse.OptionParser): def __init__(self, ievent): optparse.OptionParser.__init__(self) self.ievent = ievent self.ievent.stop = False self.formatter = optparse.IndentedHelpFormatter(0, 24, None, 1) self.formatter.set_parser(self) # no wai! def exit(self, status=0, msg=None): pass def error(self, msg): if msg:
# """ negative grep. """ __copyright__ = 'this file is in the public domain' # gozerbot imports from gozerbot.tests import tests from gozerbot.examples import examples from gozerbot.commands import cmnds from gozerbot.generic import waitforqueue from gozerbot.plughelp import plughelp # basic imports import getopt, re plughelp.add('not', 'the not command is a negative grep used in pipelines') def handle_not(bot, ievent): """ negative grep. """ if not ievent.inqueue: ievent.reply('use not in a pipeline') return if not ievent.rest: ievent.reply('not <txt>') return try: (options, rest) = getopt.getopt(ievent.args, 'r')
__license__ = "BSD" # gozerbot imports from gozerbot.aliases import aliases from gozerbot.commands import cmnds from gozerbot.periodical import periodical, at from gozerbot.plugins import plugins from gozerbot.examples import examples from gozerbot.plughelp import plughelp from gozerbot.generic import uniqlist from gozerbot.tests import tests # basic imports import copy, datetime, time, types plughelp.add('job', 'job management') def size(): """ show nr of running jobs. """ return len(periodical.jobs) def handle_job(bot, ievent): """ show data of <jobid>. """ if not ievent.args or not ievent.args[0].isdigit(): ievent.reply('<job id>') return
# IP subnet calculator # (c) 2007 Wijnand 'tehmaze' Modderman - http://tehmaze.com # BSD License from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp plughelp.add('ipcalc', 'ip calculator') # IP subnet calculator # (C) 2007 Wijnand 'tehmaze' Modderman - http://tehmaze.com # BSD License # # ABOUT # This module allows you to perform network calculations. # # CHANGELOG # 2007-10-26: Added IPv6 support, as well as a lot of other functions, # refactored the calculations. # 2007-10-25: Initial writeup, because I could not find any other workable # implementation. # # TODO # * add CLI parser # # REFERENCES # * http://www.estoile.com/links/ipv6.pdf # * http://www.iana.org/assignments/ipv4-address-space # * http://www.iana.org/assignments/multicast-addresses
# gozerplugs/plugs/powernick.py # # """ relay log messages to nicks joined on the partyline (DCC CHAT) """ from gozerbot.callbacks import callbacks from gozerbot.persist.persiststate import PlugState from gozerbot.commands import cmnds from gozerbot.users import users from gozerbot.examples import examples from gozerbot.partyline import partyline from gozerbot.plughelp import plughelp import gozerbot.generic plughelp.add('powernick', 'plugin used to monitor log messages') state = PlugState() state.define('nicks', {}) # username is key def logcallback(level, description, txt): global state for nick in state['nicks'].values(): partyline.say_nick(nick, "[%s] %s" % (description, txt)) def init(): if not logcallback in gozerbot.utils.log.logcallbacks: gozerbot.utils.log.logcallbacks.append(logcallback) def shutdown():
from gozerbot.fleet import fleet from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.datadir import datadir from gozerbot.utils.dol import Dol from gozerbot.compat.pdod import Pdod from gozerbot.compat.pdol import Pdol from gozerbot.plughelp import plughelp from gozerbot.periodical import periodical from gozerbot.aliases import aliasset from gozerbot.users import users import feedparser import gozerbot.threads.thr as thr import time, os, types, thread, socket, xml plughelp.add('rss', 'manage rss feeds') savelist = [] def txtindicts(result, d): """ return lowlevel values in (nested) dicts """ for j in d.values(): if type(j) == types.DictType: txtindicts(result, j) else: result.append(j) def checkfordate(data, date): for item in data:
# """ code related commands. """ __copyright__ = 'this file is in the public domain' # gozerbot imports from gozerbot.redispatcher import rebefore, reafter from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.generic import exceptionlist from gozerbot.plugins import plugins from gozerbot.aliases import aliasset from gozerbot.plughelp import plughelp from gozerbot.tests import tests plughelp.add('code', 'the code plugin provides code related commands') def handle_showexceptions(bot, ievent): """ show exception list. """ ievent.reply(str(exceptionlist)) cmnds.add('code-exceptions', handle_showexceptions, 'OPER') examples.add('code-exceptions', 'show exception list', 'code-exceptions') aliasset('exceptions', 'code-exceptions') tests.add('code-exceptions') def handle_funcnames(bot, ievent):
# plugs/underauth.py # # """Handle non-ident connection on undernet""" __copyright__ = 'this file is in the public domain' __author__ = '*****@*****.**' from gozerbot.callbacks import callbacks from gozerbot.plughelp import plughelp plughelp.add('underauth', 'provide callbacks that registers the bot with the \ undernet network') def pre_underauth_cb(bot, ievent): """ Only respond to the message like: NOTICE AUTH :*** Your ident is disabled or broken, to continue to connect you must type /QUOTE PASS 16188 """ args = ievent.arguments try: return (args[0] == u'AUTH' and args[-3] == u'/QUOTE' and args[-2] == u'PASS') except Exception, ex: return 0 def underauth_cb(bot, ievent):
# plugs/grab.py """ quotes grab plugin """ __copyright__ = 'this file is in the public domain' __depend__ = ['quote', ] from gozerbot.config import config from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.aliases import aliases from gozerbot.plughelp import plughelp from gozerplugs.quote import quotes plughelp.add('grab', 'grab the last quote of an user') def handle_quotegrab(bot, ievent): """ grab the last last from the given user """ try: from gozerplugs.seen import seen assert(seen) except (ImportError, AssertionError, NameError): ievent.reply("seen plugin not enabled") return if not quotes: ievent.reply('quotes plugin not enabled') return if not ievent.args: ievent.reply('missing <user> argument') return nick = ievent.args[0].lower()
""" allow all user in a channel to have permissions. permission that use userstate information can not be used, for that the users must be meeted to the bot. """ __copyright__ = 'this file is in the public domain' # gozerbot imports from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp from gozerbot.utils.log import rlog from gozerbot.tests import tests plughelp.add('chanperm', 'manage channel permissions') def handle_chanperm(bot, ievent): """ show channel permissions. """ chan = ievent.channel.lower() try: p = bot.channels[chan]['perms'] except (KeyError, TypeError): ievent.reply("channel %s has no permissions set" % chan) return if p: ievent.reply('permissions of channel %s: ' % chan, p, dot=True)
'log-off', ] __depending__ = ['mail', 'markov'] from gozerbot.generic import rlog, handle_exception, elapsedstring, dmy, \ hourmin, lockdec, strtotime from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.callbacks import callbacks, jcallbacks from gozerbot.plughelp import plughelp from gozerbot.monitor import saymonitor, jabbermonitor from gozerbot.aliases import aliases, aliasdel from gozerbot.users import users import glob, re, thread, pickle, os, mmap, time plughelp.add('log', 'logs related commands') # check if logs dir exists if not create it if not os.path.isdir('logs'): os.mkdir('logs') loglock = thread.allocate_lock() locked = lockdec(loglock) class Logs(object): """ hold handles to log files (per channel) """ def __init__(self, logdir): self.logdir = logdir self.maps = {} self.files = {}
# # __copyright__ = 'this file is in the public domain' from gozerbot.generic import geturl, striphtml, splittxt, handle_exception, \ fromenc from gozerbot.commands import cmnds from gozerbot.aliases import aliases from gozerbot.examples import examples from gozerbot.utils.rsslist import rsslist from gozerbot.plughelp import plughelp from urllib import quote import re plughelp.add('wowwiki', 'query wowwiki') wikire = re.compile('start content(.*?)end content', re.M) def getwikidata(url, ievent): """ fetch wiki data """ try: result = fromenc(geturl(url)) except IOError, ex: try: errno = ex[0] except IndexError: handle_exception(ievent=ievent) return ievent.reply('invalid option') return
# # # """ eight ball """ __copyright__ = 'this file is in the public domain' __revision__ = '$Id: m8b.py 1120 2006-12-30 12:00:00Z deck $' from gozerbot.generic import handle_exception from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp from gozerbot.tests import tests import re, random plughelp.add('8b', 'Ask the magic 8 ball') balltxt = [ "Signs point to yes.", "Yes.", "Most likely.", "Without a doubt.", "Yes - definitely.", "As I see it, yes.", "You may rely on it.", "Outlook good.", "It is certain.", "It is decidedly so.", "Reply hazy, try again.", "Better not tell you now.", "Ask again later.", "Concentrate and ask again.", "Cannot predict now.", "My sources say no.", "Very doubtful.", "My reply is no.", "Outlook not so good.", "Don't count on it." ] def handle_8b(bot, ievent): ievent.reply(random.choice(balltxt))
# gozerplugs/lart.py # # from gozerbot.commands import cmnds from gozerbot.persist.persistconfig import PersistConfig from gozerbot.aliases import aliasset from gozerbot.examples import examples from gozerbot.plughelp import plughelp import random plughelp.add("lart", "do the lart") cfg = PersistConfig() cfg.define("lartlist", []) def handle_lart(bot, ievent): try: who = ievent.args[0] except IndexError: ievent.missing("<who>") return try: txt = random.choice(cfg.get("lartlist")) except IndexError: ievent.reply('lart list is empty .. use lart-add to add entries .. use "<who>" as a nick holder') return txt = txt.replace("<who>", who) bot.action(ievent.channel, txt)
# # """ do voice on join """ __copyright__ = "this file is in the public domain" from gozerbot.commands import cmnds from gozerbot.callbacks import callbacks from gozerbot.examples import examples from gozerbot.plughelp import plughelp from gozerbot.tests import tests plughelp.add( "autovoice", "enable auto voicing of people join .. commands \ work for the channels the commands are given in", ) def preautovoice(bot, ievent): """ precondition on auto-op .. we must be op """ if ievent.channel in bot.state["opchan"]: return 1 def cbautovoice(bot, ievent): """ autovoice callback """ chandata = 0 try: chandata = bot.channels[ievent.channel]["autovoice"]
__author__ = 'Landon Fowles' from gozerbot.generic import geturl, waitforuser, getwho, rlog from gozerbot.commands import cmnds from gozerbot.datadir import datadir from gozerbot.persist.persist import Persist from gozerbot.users import users from gozerbot.plughelp import plughelp from gozerbot.examples import examples from gozerbot.persist.persiststate import UserState from gozerbot.aliases import aliasset import time from xml.dom import minidom from urllib import urlencode plughelp.add('weather', 'show weather by zipcode/city name') def handle_weather(bot, ievent): """ show weather using Google's weather API """ userhost = "" loc = "" try: nick = ievent.options['--u'] if nick: userhost = getwho(bot, nick) if not userhost: ievent.reply("can't determine username for %s" % nick) return else: try: name = users.getname(userhost)
from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp import os, string, random plughelp.add('dope', 'for all the junkies out there') joint = ''' purple haze white widow silver haze mango haze krystal mossad mexican haze northern lights master kush california orange bud b-52 binnenkweek mix skunk jamaican jack herrer tafrolt pakistaan primero red libanon hija super hija afghaan zwarte afghaan
# plugs/googletalk.py # # """ enable the bot to log into google chat. """ __copyright__ = 'this file is in the public domain' # gozerbot imports from gozerbot.callbacks import jcallbacks from gozerbot.generic import rlog from gozerbot.config import config from gozerbot.plughelp import plughelp plughelp.add('googletalk', 'the google talk plugin make it possible to link \ to the googletalk servers .. google changes the JID of the bot so this \ plugin detects this and sets the bots JID .. for this to work the bot must \ be in a googletalk users buddieslist') def googletalktest(bot, msg): """ check if presence callbacks should fire. """ if not 'google' in bot.host: return 0 if "vcard-temp:x:update" in str(msg): newjid = msg.getAttrs()['to'] if bot.me != str(newjid): if bot.me in str(newjid): return 1
import time import re # Third Party Imports # Local Imports from gozerbot.callbacks import callbacks from gozerbot.commands import cmnds from gozerbot.datadir import datadir from gozerbot.persist.pdod import Pdod from gozerbot.persist.persistconfig import PersistConfig from gozerbot.plughelp import plughelp from gozerbot.examples import examples from gozerbot.redispatcher import rebefore plughelp.add('sed', 'Perform substitution on last message spoken') cfg = PersistConfig() cfg.define('cmd_req', 0) sed_expression = r'^s([/|#.:;])(.*?)\1(.*?)\1?([gi]*)$' sedre = re.compile(sed_expression) class LastLine(Pdod): def __init__(self): self.datadir = os.path.join(datadir, 'plugs', 'sed') Pdod.__init__(self, os.path.join(self.datadir, 'sed.data')) if not self.data: self.data = {} def handle_sed(self, bot, ievent):
from gozerbot.generic import getwho, rlog from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.aliases import aliases from gozerbot.callbacks import callbacks from gozerbot.plughelp import plughelp import Queue import time plughelp.add('kickban', 'channel ban list management') bans = {} cachetime = 300 timeout = 10 def handle_367(bot, ievent): rlog(10, '367', str(ievent)) channel = ievent.arguments[1].lower() if not bot.name in bans or not channel in bans[bot.name]: return # not requested by this plugin bans[bot.name][channel].append(ievent.txt.split()[0]) def handle_mode(bot, ievent): rlog(10, 'mode', str(ievent)) # [18 Jan 2008 13:41:29] (mode) cmnd=MODE [email protected] postfix=#eth0-test +b *!*@je.moeder.ook arguments=[u'#eth0-test', u'+b', u'*!*@je.moeder.ook'] nick=maze user=wijnand [email protected] channel=#eth0-test txt= command= args=[] rest= speed=5 options={} def get_bans(bot, channel): # :ironforge.sorcery.net 367 basla #eth0 *!*@71174af5.e1d1a3cf.net.hmsk [email protected] 1200657224
# plugs/mailexceptions.py # # """ mail exceptions in backlog """ __copyright__ = 'this file is in the public domain' from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.generic import exceptionlist from gozerbot.plughelp import plughelp import smtplib plughelp.add('mailexceptions', 'mail list of occured exceptions to \ [email protected]') def handle_mailexceptions(bot, ievent): """ mailexceptions [<email>] .. mail exceptions in log """ if not len(exceptionlist): ievent.reply("no exceptions available") return try: mailto = ievent.args[0] except IndexError: mailto = '*****@*****.**' try: mailserver = mailto.split('@')[1] except IndexError: ievent.reply("can't determine mailserver from %s" % mailto) return
# plugs/echo.py # # """ simple echo command """ __copyright__ = 'this file is in the public domain' from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp plughelp.add('echo', 'simply write back what you tell it') def handle_echo(bot, ievent): """ say back what is being said """ ievent.reply(ievent.rest) cmnds.add('echo', handle_echo, 'USER') examples.add('echo', "echo Hello World!", 'echo')
__copyright__ = 'this file is in the public domain' from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.users import users from gozerbot.redispatcher import rebefore, reafter from gozerbot.aliases import aliases from gozerbot.callbacks import callbacks from gozerbot.plugins import plugins from gozerbot.fleet import fleet from gozerbot.plughelp import plughelp from gozerbot.tests import tests plughelp.add( 'size', 'the size command shows the sizes of plugins that \ provide a size() plugin command and the sizes of some basic structures') def handle_size(bot, ievent): """ size .. show size of core datastructures """ txtlist = [] txtlist.append("fleet: %s" % fleet.size()) txtlist.append("users: %s" % users.size()) txtlist.append("cmnds: %s" % cmnds.size()) txtlist.append("callbacks: %s" % callbacks.size()) txtlist.append("rebefore: %s" % rebefore.size()) txtlist.append("reafter: %s" % reafter.size()) txtlist.append("aliases: %s" % len(aliases.data)) txtlist.append("examples: %s" % examples.size()) plugsizes = plugins.plugsizes()
# plugs/tell.py # # """ send the output of a command to <nick>. """ from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plugins import plugins from gozerbot.plughelp import plughelp from gozerbot.tests import tests plughelp.add('tell', 'the tell command sends the output of a command to \ another user') def handle_tell(bot, ievent): """ send output of command to another user """ if ievent.msg: ievent.reply('tell can only be used in a channel') return try: nick, cmnd = ievent.rest.split(' ', 1) except ValueError: ievent.missing('<nick> <command>') return ievent.txt = cmnd #if not plugins.woulddispatch(bot, ievent): # ievent.reply("can't execute %s" % cmnd) # return result = plugins.cmnd(bot, ievent) if not result:
# # __copyright__ = 'this file is in the public domain' from gozerbot.generic import geturl, striphtml, splittxt, handle_exception, \ fromenc from gozerbot.commands import cmnds from gozerbot.aliases import aliases from gozerbot.examples import examples from gozerbot.utils.rsslist import rsslist from gozerbot.plughelp import plughelp from urllib import quote import re plughelp.add('wikipedia', 'query wikipedia') wikire = re.compile('start content(.*?)end content', re.M) def searchwiki(txt, lang='en'): for i in txt.split(): if i.startswith('-'): if len(i) != 3: continue else: lang = i[1:] continue txt = txt.replace("-%s" % lang, '') txt = txt.strip().capitalize() what = txt.strip().replace(' ', '_') url = 'http://%s.wikipedia.org/wiki/Special:Export/%s' % (lang, \
# gozerplugs/beats.py # # """ internet time .beats """ __copyright__ = 'this file is in the public domain' from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp from gozerbot.plughelp import plughelp from gozerbot.tests import tests import time, math plughelp.add('beats', 'show internet time') def handle_beats(bot, ievent): """ beats .. show current internet time """ beats = ((time.time() + 3600) % 86400) / 86.4 beats = int(math.floor(beats)) ievent.reply('@' + str(beats)) cmnds.add('beats', handle_beats, 'USER') examples.add('beats', 'show current internet time', 'beats') tests.add('beats' , '@')
# # __copyright__ = 'this file is in the public domain' from gozerbot.generic import elapsedstring, getwho, jsonstring from gozerbot.commands import cmnds from gozerbot.callbacks import callbacks, jcallbacks from gozerbot.examples import examples from gozerbot.datadir import datadir from gozerbot.persist.persist import PlugPersist from gozerbot.plughelp import plughelp from gozerbot.aliases import aliases import time, os plughelp.add('idle', 'show how long a user or channel has been idle') idle = PlugPersist('idle.data') if not idle.data: idle.data = {} def shutdown(): idle.save() def preidle(bot, ievent): """ idle precondition aka check if it is not a command """ if ievent.usercmnd: return 0 else:
# gozerplugs/buzz.py # # __author__ = 'unknown' from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp plughelp.add('buzz', 'create a buzz word') from random import randint verb = [ "implement", "utilize", "integrate", "streamline", "optimize", "evolve", "transform", "embrace", "enable", "orchestrate", "leverage", "reinvent", "aggregate", "architect", "enhance", "incentivize", "morph", "empower", "envisioneer", "monetize", "harness", "facilitate", "seize", "disintermediate", "synergize", "strategize", "deploy", "brand", "grow", "brand", "grow", "target", "syndicate", "synthesize", "deliver", "mesh", "incubate", "engage", "maximize", "benchmark", "expedite", "reintermediate", "expedite", "reintermediate", "whiteboard", "visualize", "repurpose", "innovate", "scale", "unleash", "drive", "extend", "engineer", "revolutionize", "generate", "exploit", "transition", "e-enable", "iterate", "cultivate", "matrix", "productize", "redefine", "recontextualize" ] adj = [ "clicks-and-mortar", "value-added", "vertical", "proactive", "robust",
import time import re # Third Party Imports # Local Imports from gozerbot.callbacks import callbacks from gozerbot.commands import cmnds from gozerbot.datadir import datadir from gozerbot.persist.pdod import Pdod from gozerbot.persist.persistconfig import PersistConfig from gozerbot.plughelp import plughelp from gozerbot.examples import examples from gozerbot.redispatcher import rebefore plughelp.add('sed', 'Perform substitution on last message spoken') cfg = PersistConfig() cfg.define('cmd_req', 0) sed_expression = r'^s([/|#.:;])(.*?)\1(.*?)\1?([gi]*)$' sedre = re.compile(sed_expression) class LastLine(Pdod): def __init__(self): self.datadir = os.path.join(datadir, 'plugs', 'sed') Pdod.__init__(self, os.path.join(self.datadir, 'sed.data')) if not self.data: self.data = {} def handle_sed(self, bot, ievent): """ Perform substitution """
""" do the timebomb dance. """ __copyright__ = 'BSD' __author__ = 'clone at magtar.org' from gozerbot.generic import getwho from gozerbot.commands import cmnds from gozerbot.plughelp import plughelp from gozerbot.persist.persist import PlugPersist from gozerbot.aliases import aliasset from time import sleep, time from random import randint, shuffle plughelp.add('timebomb', 'blow your buddies to smithereens !timebomb <victim>') plughelp.add('cut', 'try to defuse a bomb placed with !timebomb by cutting a wire i.e. !cut blue') # define plugpersist outside localscope, you only want to initiate it once. bomb = PlugPersist('bomb') bomb.data = [] def timebomb(bot, ievent): # check if we have ops if ievent.channel not in bot.state['opchan']: bot.action(ievent.channel, "bends over and farts in %s's general direction." % ievent.nick) return # check if we are already running a bomb if bomb.data: bot.action(ievent.channel ,"points at the bulge in %s's pants." % bomb.data[0]) return
import json import requests from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp from gozerbot.tests import tests # add help plughelp.add('asn', 'lookup ASN via peeringdb') def handle_asn(bot, ievent): asnumber_in = "" try: what = ievent.args[0] except IndexError: ievent.missing("<asn>"); return try: asnumber_in = what url = "https://stat.ripe.net/data/as-overview/data.json?resource=" + asnumber_in resp = requests.get(url=url) pdb_json = json.loads(resp.text) network_name = pdb_json['data'][0]['holder'] resultstring = "AS Number: %s has name: %s" % (asnumber_in, network_name) ievent.reply(resultstring) except Exception, ex: ievent.reply("Invalid ASN") ; return cmnds.add('asn', handle_asn, 'USER') examples.add('asn', 'Lookup as number on ripestat', 'asn 8315') tests.add('asn 8315') ### In elkaar gerost door phreak ergens in 2020.
# Idea not so loosely based on [email protected]'s eggdrop timebomb """ do the timebomb dance. """ __copyright__ = 'BSD' __author__ = 'clone at magtar.org' from gozerbot.generic import getwho from gozerbot.commands import cmnds from gozerbot.plughelp import plughelp from gozerbot.persist.persist import PlugPersist from gozerbot.aliases import aliasset from time import sleep, time from random import randint, shuffle plughelp.add('timebomb', 'blow your buddies to smithereens !timebomb <victim>') plughelp.add( 'cut', 'try to defuse a bomb placed with !timebomb by cutting a wire i.e. !cut blue' ) # define plugpersist outside localscope, you only want to initiate it once. bomb = PlugPersist('bomb') bomb.data = [] def timebomb(bot, ievent): # check if we have ops if ievent.channel not in bot.state['opchan']: bot.action( ievent.channel,
__copyright__ = 'this file is in the public domain' from gozerbot.generic import rlog from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.callbacks import callbacks from gozerbot.users import users from gozerbot.plugins import plugins from gozerbot.datadir import datadir from gozerbot.persist.persist import PlugPersist from gozerbot.plughelp import plughelp from gozerbot.tests import tests import time, os plughelp.add('away', "keep notice of who's away") lasttime = [] # use datadir/away as pickle file awaydict = PlugPersist('away.data') # see if data attribute is set otherwise init it if not awaydict.data: awaydict.data = {} if not awaydict.data.has_key('enable'): awaydict.data['enable'] = 0 awaydict.save() def init(): """ init plugin """
for item, descrlist in oldinfo.data.iteritems(): for descr in descrlist: info.add(item, descr, 'none', 0) teller += 1 except IOError, ex: if "No such file" in str(ex): rlog(10, 'infoitem', 'nothing to upgrade') except Exception, ex: rlog(10, 'infoitem', "can't upgrade: %s" % str(ex)) return rlog(10, 'infoitem', 'upgraded %s infoitems' % str(teller)) return teller import thread, os, time plughelp.add('infoitem', 'also known as factoids .. info can be retrieved \ by keyword or searched') infolock = thread.allocate_lock() # create lock descriptor locked = lockdec(infolock) class InfoitemsDb(object): """ information items """ @trans def add(self, session, item, description, userhost, ttime): """ add an item """ item = item.lower() result = 0
""" __copyright__ = 'this file is in the public domain' __gendocfirst__ = ['pt-add', ] __gendoclast__ = ['pt-del', ] from gozerbot.utils.generic import convertpickle from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.users import users from gozerbot.datadir import datadir from gozerbot.persist.persist import PlugPersist from gozerbot.plughelp import plughelp plughelp.add('projecttracker', 'track hours spent working on projects') ## UPGRADE PART def upgrade(): convertpickle(datadir + os.sep + 'old' + os.sep + 'pt-projects', \ datadir + os.sep + 'plugs' + os.sep + 'projecttracker' + os.sep + 'pt-projects') convertpickle(datadir + os.sep + 'old' + os.sep + 'pt-contrib', \ datadir + os.sep + 'plugs' + os.sep + 'projecttracker' + os.sep + 'pt-contrib') ## END UPGRADE PART import os projects = PlugPersist('pt-projects') contrib = PlugPersist('pt-contrib')
# plugs/drinks.py # # from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.plughelp import plughelp import os, string, random plughelp.add('drinks', 'serve coffee/tea or beer') coffee = [] tea = [] beer = [] def init(): global coffee global tea global beer for i in coffeetxt.split('\n'): if i: coffee.append(i.strip()) for i in teatxt.split('\n'): if i: tea.append(i.strip()) for i in beertxt.split('\n'): if i: beer.append(i.strip()) return 1 def handle_coffee(bot, ievent):
# # I included the Twitter API, because I had to fix some minor issues. These # issues have been reported so maybe the API part will be removed from this # plugin at a later stadium. import os from gozerbot.commands import cmnds from gozerbot.datadir import datadir from gozerbot.examples import examples from gozerbot.persist.pdol import Pdol from gozerbot.plughelp import plughelp from gozerbot.utils.textutils import html_unescape from gozerbot.utils.generic import waitforqueue from gozerbot.plughelp import plughelp plughelp.add('twitter', 'do the twitter') __version__ = '0.2' # # twitter-py stuff # # Twitter API # (c) DeWitt Clinton <*****@*****.**> # Apache License 2.0 import base64 import md5 import os import sys import tempfile
from gozerbot.examples import examples from gozerbot.generic import geturl, posturl, waitforqueue from gozerbot.plughelp import plughelp # compatibility check (since r1701) try: from gozerbot.textutils import html_unescape except ImportError: import htmllib def html_unescape(s): p = htmllib.HTMLParser(None) p.save_bgn() p.feed(s) return p.save_end() plughelp.add('translate', 'translate between languages') class TranslateLanguageException(Exception): pass class TranslateLoginException(Exception): pass class Translate: lang = ['English/Spanish', 'English/French', 'English/German', 'English/Italian', 'English/Dutch', 'English/Portuguese', 'English/Russian', 'English/Norwegian', 'English/SimplifiedChinese', 'English/TraditionalChinese', 'English/Japanese', 'Spanish/English', 'French/English', 'German/English', 'Italian/English', 'Dutch/English', 'Portuguese/English', 'Russian/English', 'Japanese/English'] re_username = re.compile('<input type="hidden" name="username" value="([^"]+)" />', re.I | re.M) re_password = re.compile('<input type="hidden" name="password" value="([^"]+)" />', re.I | re.M) def translate(self, lang_from, lang_to, text): # fix case stuff
from gozerbot.utils.generic import convertpickle, jsonstring from gozerbot.commands import cmnds from gozerbot.examples import examples from gozerbot.callbacks import callbacks, jcallbacks from gozerbot.fleet import fleet from gozerbot.monitor import saymonitor, jabbermonitor from gozerbot.datadir import datadir from gozerbot.persist.pdol import Pdol from gozerbot.plughelp import plughelp from gozerbot.ignore import shouldignore from gozerbot.generic import rlog from gozerbot.threads.thr import start_new_thread import time, os plughelp.add('relay', 'relay between fleet bots or channels') ## UPGRADE PART def upgrade(): convertpickle(datadir + os.sep + 'old' + os.sep + 'relay', \ datadir + os.sep + 'plugs' + os.sep + 'relay' + os.sep + 'relay') class Relay(Pdol): """ relay is implemented as a pickled dict of lists """ def check(self, botname, channel, txt, fromm=None): """ check if we relay on (botname, channel) .. if so do output """ channel = channel.lower() indexstring = jsonstring((botname, channel))