import sys
from inspect import isclass, getmembers
from re import match
from Logging import LogFile
from Configuration import ConfigFile
log = LogFile("PluginManager")
class PluginManager:
__services__={}
__plugins__={}
__hooks__=[] # list of (function, pluginname, functionname)
AutoLoadDeps = False
def hasPlugin(self,plug):
log.debug("hasPlugin %s"%plug)
return self.__plugins__.has_key(plug)
def checkRequirements(self,cls):
log.debug("Check requirements",cls)
req = getattr(cls,"sbreq",None)
if not req:#no requirements, no problem!
log.debug("No requirements.")
return True
for r in req:
for s in r:
if self.__services__.has_key(s):
import urllib
import urllib2
import lxml.html
try:
import simplejson
is_json = True
except:
is_json = False
from Hook import bindFunction
from Logging import LogFile
log = LogFile("GoogleService")
GOOGLE_SEARCH_URL = "http://www.google.com/dictionary/json?callback=dict_api.callbacks.id100&sl=en&tl=en&restrict=pr%2Cde&client=te&"
HEADERS = {'User-Agent': "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.1.5)"}
class Google:
def _buildResponse(self, url, is_json=False):
log.debug("Build request", url, is_json)
request = urllib2.Request(url, None, HEADERS)
response = urllib2.urlopen(request)
if is_json:
response = response.read()
# FIXME: simplejson doesn't like the callback, I think
response = simplejson.load(response)
if not 'responseData' in response:
log.warning("Json response was empty")
return # no data, pointless
return response['responseData']
return response
import threading
from types import GeneratorType
from Util import call
from time import sleep
from Logging import LogFile
pdLog = LogFile("PluginDispatcher")
pdwtLog = LogFile("PluginDispatcherWorkerThread")
class PluginDispatcherWorkerThread(threading.Thread):
running = True
produce = None
consume = None
def run(self):
pdwtLog.debug("Worker thread started.")
while True:
while self.produce == None or self.consume == None:
pdwtLog.debug("Waiting on producer and consumer",
"P:" + str(self.produce),
"C:" + str(self.consume))
sleep(1)
if self.produce and self.consume:
pdwtLog.debug("Producer and consumer set.",
"P:" + str(self.produce),
"C:" + str(self.consume))
func, args = self.produce()
pdwtLog.debug("Produced", func, args)
import time
import random
import re
import urllib
from Hook import *
from Logging import LogFile
from collections import Counter
log = LogFile("Numbers")
def solve(game):
url = "http://djce.org.uk/countdown?n=" + "&n=".join(map(
str, game[0])) + "&t=" + str(game[1])
return urllib.urlopen(url).read().split("\n</pre>")[0].split("\n")[-1]
def chooseNumbers(numLarge):
log.debug("Choose numbers called, {}".format(numLarge))
if 0 > numLarge or numLarge > 4:
return None
large = [25, 50, 75, 100]
small = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10]
random.shuffle(large)
random.shuffle(small)
numbers = large[:numLarge] + small[:6 - numLarge]
return numbers, random.randint(100, 900)
def factor(n):
if n == 1: return [1]
if n & 1 == 0:
import sys
import traceback
from Configuration import ConfigFile
from Logging import LogFile
from twisted.words.protocols import irc
from twisted.internet import protocol, reactor
#these events get given to plugins to give back to the the ircconnector
log = LogFile("IRCConnector")
log.debug("Connector imported")
class IRCConnectorEvents:
def __init__(self):
pass
def join(self, channel, key=None):
return "join", channel, key
def part(self, channel, message=None):
return "part", channel, messages
def kick(self, channel, user, message=None):
return "kick", channel, user, message
def topic(self, channel, message=None):
return "topic", channel, message
def say(self, channel, message, length=None):
return "say", channel, message, 1024
def msg(self, user, message, length=None):
except ImportError:
import pickle
def save(obj, filename):
pickle.dump(obj, open(filename, "w"))
return obj
def load(filename):
if not os.path.exists(filename):
save(dict(), filename)
return pickle.load(open(filename, "r"))
log = LogFile("Gifts")
gifts_file = "GiftsStore.pkl"
gifts = load(gifts_file)
pluralized_file = "PluralizedStore.pkl"
pluralized = load(pluralized_file)
def map_plural(singular, plural):
global pluralized
global gifts
if plural in pluralized.keys():
if plural in pluralized.values():
if singular != plural:
from Hook import *
from Logging import LogFile
import shelve
import urllib2
import json
log = LogFile("Weather")
KEY = "90911f1ab7b29950"
def getResponse(command):
url = "http://api.wunderground.com/api/%s/%s.json"%(KEY,urllib2.quote(command))
log.debug("getResponse",url)
f = urllib2.urlopen(url)
json_string = f.read()
response = json.loads(json_string)
return response
class Weather:
@bindFunction(message="^!w (?P<location>.*)$")
def currentWeather(self,response,target,location):
weather = getResponse("conditions/q/%s"%location)
log.debug(weather.keys())
if weather["response"].has_key("results"):
yield response.say(target,"I found multiple results for "\
+location+". Please specify the state (or use zip instead)")
states = [str(entry["state"]) for entry in weather["response"]["results"]]
yield response.say(target,"Stats found: (%s)"%", ".join(states))
"""Useful tools for opening and reading pages."""
from urllib2 import Request, build_opener, urlopen, URLError, HTTPError
import sys
from Logging import LogFile
log = LogFile("URLUtils")
class URLUtils(object):
USER_AGENT = ('User-agent',
'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT')
def open_url(self, url):
"""Simply open and return page contents mimicking a browser."""
request = Request(url, None)
opener = build_opener()
opener.add_headers = [self.USER_AGENT]
try:
response = opener.open(request)
except HTTPError, e:
log.exception("There server couldn't fulfill the request.",
"Error: %s" % e.code, "URL: %s" % url)
except URLError, e:
log.exception("Failed to reach a server.", "Error: %s" % e.code,
"URL: %s" % url)
from Hook import *
import time
import urllib
from Logging import LogFile
log = LogFile("Mtgox")
keys = ["low", "buy", "avg", "sell", "high"]
class Mtgox:
streamSize = [0] * 5
lastData = [0] * 5
@dedicated(delay=10)
def ded(self, response):
d = dict(
eval(
urllib.urlopen("https://mtgox.com/api/0/data/ticker.php").read(
)))["ticker"]
d = {k: round(d[k], 3) for k in keys}
vals = map(d.get, keys)
log.dict(d, "Ticker data")
diffs = map(lambda (x, y): x - y, zip(vals, self.lastData))
self.lastData = vals
change = filter(lambda x: x, diffs) != []
log.debug(diffs, self.lastData, change, self.streamSize)
if not change:
log.debug("No change in ticker. Waiting 10 seconds")
return
from Hook import *
from Logging import LogFile
try:
import cPickle as pickle
log.debug("Using cPickle")
except:
import pickle
log.debug("Using pickle")
log = LogFile("Alias")
storeFile = "AliasStore.pkl"
aliases = {}
def saveAliases():
global aliases
log.debug("Saving aliases.")
try:
pickle.dump(aliases,file(storeFile,"w"))
except:
log.exception("Failed to save aliases.")
def loadAliases():
global aliases
log.debug("Loading aliases.")
try:
aliases = pickle.load(file(storeFile))
print "Aliases 1:",aliases
return True
from Hook import *
parser = None
from Logging import LogFile
log = LogFile("Alarm")
import time
import datetime
storeFile = "AlarmStore.pkl"
parseStrings = [
"%m/%d", "%m/%d/%y", "%m/%d/%y %H:%M:%S", "%m/%d/%y %h:%M:%S %p"
]
def backupParse(s):
global parseStrings
for fmt in parseStrings:
try:
return datetime.datetime.strptime(s, fmt)
except:
pass
return None
try:
import parsedatetime.parsedatetime as pdt
import parsedatetime.parsedatetime_consts as pdc
c = pdc.Constants()
p = pdt.Calendar(c)
parser = lambda s: datetime.datetime(*p.parse(s)[0][:6])
log.debug("Using parsedatetime")
except:
from Hook import bindFunction, requires, prefers
from Logging import LogFile
log = LogFile("GD")
log.debug("Log start")
import sys
@requires("Google")
@prefers("Colors")
class Google_Define:
@bindFunction(message="!gd (?P<term>[a-zA-Z ]+) ?(?P<definition>\d*)")
def g_define(self, term, response, target, colorize, gdefine, definition):
log.debug("g_define", term, response, target, colorize, gdefine,
definition)
d = gdefine(term.strip().replace(' ', '+'), definition)
if colorize:
return response.msg(
target,
colorize("<{C3}Google Define{}: %s [{B}%s{} of %s]>" % d))
else:
return response.msg(target, "<Google Define: %s [%s of %s]>" % d)
from Hook import bindFunction
from Logging import LogFile
log = LogFile("Security_Service")
class Security:
sessions = {}
def __init__(self):
log.debug("Security service created.")
def onEvent(self, event): # a plugin wants access to our stuff!
log.debug("onEvent")
event["loggedIn"] = self.isLoggedIn
#only give the the ability to check if a nick is logged in.
def logIn(self, nick, pswd): # plugin will make call back to here
log.debug("logIn", nick, self.sessions)
ses = self.sessions.get(nick, {"pswd": pswd})
if pswd == ses["pswd"]:
ses["LoggedIn"] = True
else:
return False
self.sessions[nick] = ses
return True
def logOut(self, nick):
log.debug("logOut", nick, self.sessions)
ses = self.sessions.get(nick, {})
ses["LoggedIn"] = False
from Hook import *
parser = None
from Logging import LogFile
log = LogFile("Seen")
import datetime
storeFile = "SeenStore.pkl"
try:
import cPickle as pickle
log.debug("Using cPickle")
except:
import pickle
log.debug("Using pickle.")
def now():
return datetime.datetime.now().strftime("%H:%M:%S")
def saveState(state):
try:
pickle.dump(state, file(storeFile, "w"))
except:
log.exception("Failed to store pickle.")
def loadState():
try:
return pickle.load(file(storeFile))
except:
log.exception("Failed to load pickle")
from Hook import bindFunction, prefers
from Logging import LogFile
import re
log = LogFile("Sed")
msgHistory = [""] * 20
sedRegex = "(?P<delim>[^a-zA-Z])(?P<search>.*?)\\1(?P<replace>.*?)\\1(?P<flags>.*?)(?P<extras>(?:\\1.*)|)$"
replacementColors = [4, 7, 3, 10, 6]
def applySed(searchRE, replace, flags, message, colorNum=0):
log.debug("applySed:", searchRE.pattern, replace, flags, message, colorNum)
if "c" in flags:
colorNum %= len(replacementColors)
replace = "{C%i}%s{}" % (replacementColors[colorNum], replace)
if "g" in flags:
out = searchRE.sub(replace, message, 0) #all
else:
out = searchRE.sub(replace, message, 1) #once
return out
def findMatch(searchRE):
global msgHistory
for msg in msgHistory:
if searchRE.search(msg):
log.debug("Found match", msg)
return msg
