def __init__(self, handle, parent=None):

global _datadir

self.parent = parent

self.handle = handle

self.convos = {}

self.logpath = _datadir+"logs"

def log(self, handle, msg):

if self.parent.config.time12Format():

time = strftime("[%I:%M")

else:

time = strftime("[%H:%M")

if self.parent.config.showSeconds():

time += strftime(":%S] ")

else:

time += "] "

if handle[0] == '#':

if not self.parent.config.logMemos() & self.parent.config.LOG: return

if not self.parent.config.logMemos() & self.parent.config.STAMP:

time = ""

else:

if not self.parent.config.logPesters() & self.parent.config.LOG: return

if not self.parent.config.logPesters() & self.parent.config.STAMP:

time = ""

if self.parent.isBot(handle): return

#watch out for illegal characters

handle = re.sub(r'[<>:"/\\|?*]', "_", handle)

bbcodemsg = time + convertTags(msg, "bbcode")

html = time + convertTags(msg, "html")+"<br />"

msg = time +convertTags(msg, "text")

modes = {"bbcode": bbcodemsg, "html": html, "text": msg}

if not self.convos.has_key(handle):

time = datetime.now().strftime("%Y-%m-%d.%H.%M")

self.convos[handle] = {}

for (format, t) in modes.iteritems():

if not os.path.exists("%s/%s/%s/%s" % (self.logpath, self.handle, handle, format)):

os.makedirs("%s/%s/%s/%s" % (self.logpath, self.handle, handle, format))

try:

fp = codecs.open("%s/%s/%s/%s/%s.%s.txt" % (self.logpath, self.handle, handle, format, handle, time), encoding='utf-8', mode='a')

except IOError:

errmsg = QtGui.QMessageBox(self)

errmsg.setText("Warning: Pesterchum could not open the log file for %s!" % (handle))

errmsg.setInformativeText("Your log for %s will not be saved because something went wrong. We suggest restarting Pesterchum. Sorry :(" % (handle))

errmsg.show()

continue

self.convos[handle][format] = fp

for (format, t) in modes.iteritems():

f = self.convos[handle][format]

if platform.system() == "Windows":

f.write(t+"\r\n")

else:

f.write(t+"\r\n")

f.flush()

def finish(self, handle):

if not self.convos.has_key(handle):

return

for f in self.convos[handle].values():

f.close()

del self.convos[handle]

def close(self):

for h in self.convos.keys():

for f in self.convos[h].values():

def __init__(self, parent):

self.parent = parent

# Use for bit flag log setting

self.LOG = 1

self.STAMP = 2

# Use for bit flag blink

self.PBLINK = 1

self.MBLINK = 2

# Use for bit flag notfications

self.SIGNIN = 1

self.SIGNOUT = 2

self.NEWMSG = 4

self.NEWCONVO = 8

self.INITIALS = 16

self.filename = _datadir+"pesterchum.js"

with open(self.filename) as fp:

self.config = json.load(fp)

if self.config.has_key("defaultprofile"):

self.userprofile = userProfile(self.config["defaultprofile"])

else:

self.userprofile = None

self.logpath = _datadir+"logs"

if not os.path.exists(self.logpath):

os.makedirs(self.logpath)

try:

with open("%s/groups.js" % (self.logpath), 'r') as fp:

self.groups = json.load(fp)

except (IOError, ValueError):

self.groups = {}

with open("%s/groups.js" % (self.logpath), 'w') as fp:

json.dump(self.groups, fp)

def chums(self):

if not self.config.has_key('chums'):

self.set("chums", [])

return self.config.get('chums', [])

def setChums(self, newchums):

with open(self.filename) as fp:

# what if we have two clients open??

newconfig = json.load(fp)

oldchums = newconfig['chums']

# Time to merge these two! :OOO

for c in list(set(oldchums) - set(newchums)):

newchums.append(c)

self.set("chums", newchums)

def hideOfflineChums(self):

return self.config.get('hideOfflineChums', False)

def defaultprofile(self):

try:

return self.config['defaultprofile']

except KeyError:

return None

def tabs(self):

return self.config.get("tabs", True)

def tabMemos(self):

if not self.config.has_key('tabmemos'):

self.set("tabmemos", self.tabs())

return self.config.get("tabmemos", True)

def showTimeStamps(self):

if not self.config.has_key('showTimeStamps'):

self.set("showTimeStamps", True)

return self.config.get('showTimeStamps', True)

def time12Format(self):

if not self.config.has_key('time12Format'):

self.set("time12Format", True)

return self.config.get('time12Format', True)

def showSeconds(self):

if not self.config.has_key('showSeconds'):

self.set("showSeconds", False)

return self.config.get('showSeconds', False)

def sortMethod(self):

return self.config.get('sortMethod', 0)

def useGroups(self):

return self.config.get('useGroups', False)

def openDefaultGroup(self):

groups = self.getGroups()

for g in groups:

if g[0] == "Chums":

return g[1]

return True

def showEmptyGroups(self):

if not self.config.has_key('emptyGroups'):

self.set("emptyGroups", False)

return self.config.get('emptyGroups', False)

def showOnlineNumbers(self):

if not self.config.has_key('onlineNumbers'):

self.set("onlineNumbers", False)

return self.config.get('onlineNumbers', False)

def logPesters(self):

return self.config.get('logPesters', self.LOG | self.STAMP)

def logMemos(self):

return self.config.get('logMemos', self.LOG)

def disableUserLinks(self):

return not self.config.get('userLinks', True)

def idleTime(self):

return self.config.get('idleTime', 10)

def minimizeAction(self):

return self.config.get('miniAction', 0)

def closeAction(self):

return self.config.get('closeAction', 1)

def opvoiceMessages(self):

return self.config.get('opvMessages', True)

def animations(self):

return self.config.get('animations', True)

def checkForUpdates(self):

u = self.config.get('checkUpdates', 0)

if type(u) == type(bool()):

if u: u = 2

else: u = 3

return u

# Once a day

# Once a week

# Only on start

# Never

def lastUCheck(self):

return self.config.get('lastUCheck', 0)

def checkMSPA(self):

return self.config.get('mspa', False)

def blink(self):

return self.config.get('blink', self.PBLINK | self.MBLINK)

def notify(self):

return self.config.get('notify', True)

def notifyType(self):

return self.config.get('notifyType', "default")

def notifyOptions(self):

return self.config.get('notifyOptions', self.SIGNIN | self.NEWMSG | self.NEWCONVO | self.INITIALS)

def lowBandwidth(self):

return self.config.get('lowBandwidth', False)

def ghostchum(self):

return self.config.get('ghostchum', False)

def addChum(self, chum):

if chum.handle not in self.chums():

with open(self.filename) as fp:

# what if we have two clients open??

newconfig = json.load(fp)

newchums = newconfig['chums'] + [chum.handle]

self.set("chums", newchums)

def removeChum(self, chum):

if type(chum) is PesterProfile:

handle = chum.handle

else:

handle = chum

newchums = [c for c in self.config['chums'] if c != handle]

self.set("chums", newchums)

def getBlocklist(self):

if not self.config.has_key('block'):

self.set('block', [])

return self.config['block']

def addBlocklist(self, handle):

l = self.getBlocklist()

if handle not in l:

l.append(handle)

self.set('block', l)

def delBlocklist(self, handle):

l = self.getBlocklist()

l.pop(l.index(handle))

self.set('block', l)

def getGroups(self):

if not self.groups.has_key('groups'):

self.saveGroups([["Chums", True]])

return self.groups.get('groups', [["Chums", True]])

def addGroup(self, group, open=True):

l = self.getGroups()

exists = False

for g in l:

if g[0] == group:

exists = True

break

if not exists:

l.append([group,open])

l.sort()

self.saveGroups(l)

def delGroup(self, group):

l = self.getGroups()

i = 0

for g in l:

if g[0] == group: break

i = i+1

l.pop(i)

l.sort()

self.saveGroups(l)

def expandGroup(self, group, open=True):

l = self.getGroups()

for g in l:

if g[0] == group:

g[1] = open

break

self.saveGroups(l)

def saveGroups(self, groups):

self.groups['groups'] = groups

try:

jsonoutput = json.dumps(self.groups)

except ValueError as e:

raise e

with open("%s/groups.js" % (self.logpath), 'w') as fp:

fp.write(jsonoutput)

def server(self):

if hasattr(self.parent, 'serverOverride'):

return self.parent.serverOverride

return self.config.get('server', 'irc.mindfang.org')

def port(self):

if hasattr(self.parent, 'portOverride'):

return self.parent.portOverride

return self.config.get('port', '6667')

def soundOn(self):

if not self.config.has_key('soundon'):

self.set('soundon', True)

return self.config['soundon']

def chatSound(self):

return self.config.get('chatSound', True)

def memoSound(self):

return self.config.get('memoSound', True)

def memoPing(self):

return self.config.get('pingSound', True)

def nameSound(self):

return self.config.get('nameSound', True)

def volume(self):

return self.config.get('volume', 100)

def trayMessage(self):

return self.config.get('traymsg', True)

def set(self, item, setting):

self.config[item] = setting

try:

jsonoutput = json.dumps(self.config)

except ValueError as e:

raise e

with open(self.filename, 'w') as fp:

fp.write(jsonoutput)

def availableThemes(self):

themes = []

# Load user themes.

for dirname, dirnames, filenames in os.walk(_datadir+'themes'):

for d in dirnames:

themes.append(d)

# Also load embedded themes.

if _datadir:

for dirname, dirnames, filenames in os.walk('themes'):

for d in dirnames:

if d not in themes:

themes.append(d)

themes.sort()

return themes

def availableProfiles(self):

profs = []

profileloc = _datadir+'profiles'

for dirname, dirnames, filenames in os.walk(profileloc):

for filename in filenames:

l = len(filename)

if filename[l-3:l] == ".js":

profs.append(filename[0:l-3])

profs.sort()

def __init__(self, user):

self.profiledir = _datadir+"profiles"

if type(user) is PesterProfile:

self.chat = user

self.userprofile = {"handle":user.handle,

"color": unicode(user.color.name()),

"quirks": [],

"theme": "pesterchum"}

self.theme = pesterTheme("pesterchum")

self.chat.mood = Mood(self.theme["main/defaultmood"])

self.lastmood = self.chat.mood.value()

self.quirks = pesterQuirks([])

self.randoms = False

initials = self.chat.initials()

if len(initials) >= 2:

initials = (initials, "%s%s" % (initials[0].lower(), initials[1]), "%s%s" % (initials[0], initials[1].lower()))

self.mentions = [r"\b(%s)\b" % ("|".join(initials))]

else:

self.mentions = []

self.autojoins = []

else:

with open("%s/%s.js" % (self.profiledir, user)) as fp:

self.userprofile = json.load(fp)

try:

self.theme = pesterTheme(self.userprofile["theme"])

except ValueError:

self.theme = pesterTheme("pesterchum")

self.lastmood = self.userprofile.get('lastmood', self.theme["main/defaultmood"])

self.chat = PesterProfile(self.userprofile["handle"],

QtGui.QColor(self.userprofile["color"]),

Mood(self.lastmood))

self.quirks = pesterQuirks(self.userprofile["quirks"])

if "randoms" not in self.userprofile:

self.userprofile["randoms"] = False

self.randoms = self.userprofile["randoms"]

if "mentions" not in self.userprofile:

initials = self.chat.initials()

if len(initials) >= 2:

initials = (initials, "%s%s" % (initials[0].lower(), initials[1]), "%s%s" % (initials[0], initials[1].lower()))

self.userprofile["mentions"] = [r"\b(%s)\b" % ("|".join(initials))]

else:

self.userprofile["mentions"] = []

self.mentions = self.userprofile["mentions"]

if "autojoins" not in self.userprofile:

self.userprofile["autojoins"] = []

self.autojoins = self.userprofile["autojoins"]

try:

with open(_datadir+"passwd.js") as fp:

self.passwd = json.load(fp)

except:

self.passwd = {}

self.autoidentify = False

self.nickservpass = ""

if self.chat.handle in self.passwd:

self.autoidentify = self.passwd[self.chat.handle]["auto"]

self.nickservpass = self.passwd[self.chat.handle]["pw"]

def setMood(self, mood):

self.chat.mood = mood

def setTheme(self, theme):

self.theme = theme

self.userprofile["theme"] = theme.name

self.save()

def setColor(self, color):

self.chat.color = color

self.userprofile["color"] = unicode(color.name())

self.save()

def setQuirks(self, quirks):

self.quirks = quirks

self.userprofile["quirks"] = self.quirks.plainList()

self.save()

def getRandom(self):

return self.randoms

def setRandom(self, random):

self.randoms = random

self.userprofile["randoms"] = random

self.save()

def getMentions(self):

return self.mentions

def setMentions(self, mentions):

try:

for (i,m) in enumerate(mentions):

re.compile(m)

except re.error, e:

logging.error("#%s Not a valid regular expression: %s" % (i, e))

else:

self.mentions = mentions

self.userprofile["mentions"] = mentions

self.save()

def getLastMood(self):

return self.lastmood

def setLastMood(self, mood):

self.lastmood = mood.value()

self.userprofile["lastmood"] = self.lastmood

self.save()

def getTheme(self):

return self.theme

def getAutoIdentify(self):

return self.autoidentify

def setAutoIdentify(self, b):

self.autoidentify = b

if self.chat.handle not in self.passwd:

self.passwd[self.chat.handle] = {}

self.passwd[self.chat.handle]["auto"] = b

self.saveNickServPass()

def getNickServPass(self):

return self.nickservpass

def setNickServPass(self, pw):

self.nickservpass = pw

if self.chat.handle not in self.passwd:

self.passwd[self.chat.handle] = {}

self.passwd[self.chat.handle]["pw"] = pw

self.saveNickServPass()

def getAutoJoins(self):

return self.autojoins

def setAutoJoins(self, autojoins):

self.autojoins = autojoins

self.userprofile["autojoins"] = self.autojoins

self.save()

def save(self):

handle = self.chat.handle

if handle[0:12] == "pesterClient":

# dont save temp profiles

return

try:

jsonoutput = json.dumps(self.userprofile)

except ValueError as e:

raise e

with open("%s/%s.js" % (self.profiledir, handle), 'w') as fp:

fp.write(jsonoutput)

def saveNickServPass(self):

# remove profiles with no passwords

for h,t in self.passwd.items():

if "auto" not in t and ("pw" not in t or t["pw"] == ""):

del self.passwd[h]

try:

jsonoutput = json.dumps(self.passwd, indent=4)

except ValueError as e:

raise e

with open(_datadir+"passwd.js", 'w') as fp:

fp.write(jsonoutput)

@staticmethod

def newUserProfile(chatprofile):

if os.path.exists("%s/%s.js" % (_datadir+"profiles", chatprofile.handle)):

newprofile = userProfile(chatprofile.handle)

else:

newprofile = userProfile(chatprofile)

newprofile.save()

def __init__(self):

self.logpath = _datadir+"logs"

if not os.path.exists(self.logpath):

os.makedirs(self.logpath)

try:

with open("%s/chums.js" % (self.logpath), 'r') as fp:

chumdict = json.load(fp)

except (IOError, ValueError):

# karxi: This code feels awfully familiar....

chumdict = {}

with open("%s/chums.js" % (self.logpath), 'w') as fp:

json.dump(chumdict, fp)

u = []

for (handle, c) in chumdict.iteritems():

options = dict()

if 'group' in c:

options['group'] = c['group']

if 'notes' in c:

options['notes'] = c['notes']

if 'color' not in c:

c['color'] = "#000000"

if 'mood' not in c:

c['mood'] = "offline"

u.append((handle, PesterProfile(handle, color=QtGui.QColor(c['color']), mood=Mood(c['mood']), **options)))

converted = dict(u)

self.update(converted)

def save(self):

try:

with open("%s/chums.js" % (self.logpath), 'w') as fp:

chumdict = dict([p.plaindict() for p in self.itervalues()])

json.dump(chumdict, fp)

except Exception as e:

raise e

def getColor(self, handle, default=None):

if not self.has_key(handle):

return default

else:

return self[handle].color

def setColor(self, handle, color):

if self.has_key(handle):

self[handle].color = color

else:

self[handle] = PesterProfile(handle, color)

def getGroup(self, handle, default="Chums"):

if not self.has_key(handle):

return default

else:

return self[handle].group

def setGroup(self, handle, theGroup):

if self.has_key(handle):

self[handle].group = theGroup

else:

self[handle] = PesterProfile(handle, group=theGroup)

self.save()

def getNotes(self, handle, default=""):

if not self.has_key(handle):

return default

else:

return self[handle].notes

def setNotes(self, handle, notes):

if self.has_key(handle):

self[handle].notes = notes

else:

self[handle] = PesterProfile(handle, notes=notes)

self.save()

def __setitem__(self, key, val):

dict.__setitem__(self, key, val)

def __init__(self, name, default=False):

possiblepaths = (_datadir+"themes/%s" % (name),

"themes/%s" % (name),

_datadir+"themes/pesterchum",

"themes/pesterchum")

self.path = "themes/pesterchum"

for p in possiblepaths:

if os.path.exists(p):

self.path = p

break

self.name = name

try:

with open(self.path+"/style.js") as fp:

theme = json.load(fp, object_hook=self.pathHook)

except IOError:

theme = json.loads("{}")

self.update(theme)

if self.has_key("inherits"):

self.inheritedTheme = pesterTheme(self["inherits"])

if not default:

self.defaultTheme = pesterTheme("pesterchum", default=True)

def __getitem__(self, key):

keys = key.split("/")

try:

v = super(pesterTheme, self).__getitem__(keys.pop(0))

except KeyError as e:

if hasattr(self, 'inheritedTheme'):

return self.inheritedTheme[key]

elif hasattr(self, 'defaultTheme'):

return self.defaultTheme[key]

else:

raise e

for k in keys:

try:

v = v[k]

except KeyError as e:

if hasattr(self, 'inheritedTheme'):

return self.inheritedTheme[key]

elif hasattr(self, 'defaultTheme'):

return self.defaultTheme[key]

else:

raise e

return v

def pathHook(self, d):

for (k, v) in d.iteritems():

if isinstance(v, unicode):

s = Template(v)

d[k] = s.safe_substitute(path=self.path)

return d

def get(self, key, default):

keys = key.split("/")

try:

v = super(pesterTheme, self).__getitem__(keys.pop(0))

for k in keys:

v = v[k]

return default if v is None else v

except KeyError:

if hasattr(self, 'inheritedTheme'):

return self.inheritedTheme.get(key, default)

else:

return default

def has_key(self, key):

keys = key.split("/")

try:

v = super(pesterTheme, self).__getitem__(keys.pop(0))

for k in keys:

v = v[k]

return (v is not None)

except KeyError:

if hasattr(self, 'inheritedTheme'):

return self.inheritedTheme.has_key(key)

else: