'op_command' :'/msg chanserv op $channel $nick',

'autodeop' :'on',

'autodeop_delay' :'180',

'default_banmask' :'host',

'enable_remove' :'off',

'kick_reason' :'',

'enable_multi_kick' :'off',

'display_affected' :'on',

'enable_bar' :'on',

"""Error msg"""

prnt(buffer, '%s%s %s' % (weechat.prefix('error'), script_nick, s))

value = weechat.config_get_plugin('debug')

if value and boolDict[value]:

import traceback

if traceback.sys.exc_type:

trace = traceback.format_exc()

if get_function and callable(get_function):

value = get_function(config, **kwargs)

else:

value = weechat.config_get_plugin(config)

try:

return boolDict[value]

except KeyError:

default = settings[config]

error("Error while fetching config '%s'. Using default value '%s'." %(config, default))

error("'%s' is invalid, allowed: 'on', 'off'" %value)

if get_function and callable(get_function):

value = get_function(config)

else:

value = weechat.config_get_plugin(config)

try:

return int(value)

except ValueError:

default = settings[config]

error("Error while fetching config '%s'. Using default value '%s'." %(config, default))

error("'%s' is not a number." %value)

if get_function and callable(get_function):

value = get_function(config)

else:

value = weechat.config_get_plugin(config)

values = value.lower().split(',')

for value in values:

if value not in valid_banmask:

default = settings[config]

error("Error while fetching config '%s'. Using default value '%s'." %(config, default))

error("'%s' is an invalid value, allowed: %s." %(value, ', '.join(valid_banmask)))

return default

#debug("default banmask: %s" %values)

value = weechat.config_get_plugin(config)

if value:

return value.split(',')

else:

"""Gets config defined for either server or channel."""

value = None

if server and channel:

string = '%s.%s.%s' %(config, server, channel)

value = weechat.config_get_plugin(string)

if server and not value:

string = '%s.%s' %(config, server)

value = weechat.config_get_plugin(string)

if not value:

value = weechat.config_get_plugin(config)

time_hour = 3600

time_day = 86400

time_year = 31536000

if ret is None:

ret = []

if not elapsed:

return ''

if elapsed > time_year:

years, elapsed = elapsed // time_year, elapsed % time_year

ret.append('%s%s' %(years, 'y'))

elif elapsed > time_day:

days, elapsed = elapsed // time_day, elapsed % time_day

ret.append('%s%s' %(days, 'd'))

elif elapsed > time_hour:

hours, elapsed = elapsed // time_hour, elapsed % time_hour

ret.append('%s%s' %(hours, 'h'))

elif elapsed > 60:

mins, elapsed = elapsed // 60, elapsed % 60

ret.append('%s%s' %(mins, 'm'))

else:

secs, elapsed = elapsed, 0

ret.append('%s%s' %(secs, 's'))

if len(ret) >= level or not elapsed:

return ' '.join(ret)

ret = time_elapsed(elapsed, ret, level)

"""Returns whether or not a given string is an IPV4 address."""

import socket

try:

return bool(socket.inet_aton(s))

except socket.error:

"""Use cached regexp object or compile a new one from pattern."""

def getRegexp(pattern, *arg):

try:

regexp = _reCache[pattern]

except KeyError:

s = '^'

for c in pattern:

if c == '*':

s += '.*'

elif c == '?':

s += '.'

elif c in '[{':

s += r'[\[{]'

elif c in ']}':

s += r'[\]}]'

elif c in '|\\':

s += r'[|\\]'

else:

s += re.escape(c)

s += '$'

regexp = re.compile(s, re.I)

_reCache[pattern] = regexp

return f(regexp, *arg)

"""Check if pattern is for match a hostmask and remove ban forward if there's one."""

def checkPattern(pattern, arg):

# XXX this needs a refactor

if is_hostmask(pattern):

# nick!user@host$#channel

if '$' in pattern:

pattern = pattern.partition('$')[0]

if isinstance(arg, list):

arg = [ s for s in arg if is_hostmask(s) ]

elif not is_hostmask(arg):

return ''

rt = f(pattern, arg)

# this doesn't match any mask in args with a channel forward

pattern += '$*'

if isinstance(arg, list):

rt.extend(f(pattern, arg))

elif not rt:

rt = f(pattern, arg)

return rt

return ''

"""'nick!user@host' => 'user'"""

assert is_hostmask(s), "Invalid hostmask: %s" % s

s = s[s.find('!') + 1:s.find('@')]

if trim:

# remove the stuff not part of the username.

if s[0] == '~':

return s[1:]

elif s[:2] in ('i=', 'n='):

return s[2:]

"""'nick!user@host' => 'host'"""

assert is_hostmask(s), "Invalid hostmask: %s" % s

if ' ' in s:

return s[s.find('@') + 1:s.find(' ')]

"""Returns pair (server, channel) or None if buffer isn't an irc channel"""

get_string = weechat.buffer_get_string

if get_string(buffer, 'plugin') == 'irc' \

and get_string(buffer, 'localvar_type') == 'channel':

channel = get_string(buffer, 'localvar_channel')

server = get_string(buffer, 'localvar_server')

def function(*args, **kwargs):

try:

return f(*args, **kwargs)

except Exception as e:

error(e)

"""This function will take a bound method or function and make it a callback."""

# try to create a descriptive and unique name.

func = method.func_name

try:

im_self = method.im_self

try:

inst = im_self.__name__

except AttributeError:

try:

inst = im_self.name

except AttributeError:

raise Exception("Instance of %s has no __name__ attribute" %type(im_self))

cls = type(im_self).__name__

name = '_'.join((cls, inst, func))

except AttributeError:

# not a bound method

name = func

method = catchExceptions(method)

# set our callback

import __main__

setattr(__main__, name, method)

"""I want to always keep debug() calls for this"""

if buffer:

debug("%ssending: %r buffer: %s", COLOR_WHITE, cmd, buffer)

else:

debug("%ssending: %r", COLOR_WHITE, cmd)

"""Class for reading WeeChat's infolists."""

fields = {

'name' :'string',

'option_name' :'string',

'value' :'string',

'host' :'string',

'flags' :'integer',

'prefixes' :'string',

'is_connected':'integer',

'buffer' :'pointer',

}

_use_flags = False

def __init__(self, name, args='', pointer=''):

self.cursor = 0

#debug('Generating infolist %r %r', name, args)

self.pointer = weechat.infolist_get(name, pointer, args)

if self.pointer == '':

raise Exception("Infolist initialising failed (name:'%s' args:'%s')" %(name, args))

def __len__(self):

"""True False evaluation."""

if self.pointer:

return 1

else:

return 0

def __del__(self):

"""Purge infolist if is no longer referenced."""

self.free()

def __getitem__(self, name):

"""Implement the evaluation of self[name]."""

if self._use_flags and name == 'prefixes':

name = 'flags'

value = getattr(weechat, 'infolist_%s' %self.fields[name])(self.pointer, name)

if self._use_flags and name == 'flags':

value = self._flagsAsString(value)

return value

def _flagsAsString(self, n):

s = ''

if n & 32:

s += '+'

if n & 8:

s += '@'

return s

def __iter__(self):

def generator():

while self.next():

yield self

return generator()

def next(self):

self.cursor = weechat.infolist_next(self.pointer)

return self.cursor

def prev(self):

self.cursor = weechat.infolist_prev(self.pointer)

return self.cursor

def reset(self):

"""Moves cursor to beginning of infolist."""

if self.cursor == 1: # only if we aren't in the beginning already

while self.prev():

pass

def free(self):

if self.pointer:

weechat.infolist_free(self.pointer)

try:

return Infolist('irc_nick', '%s,%s' % (server, channel))

except:

"""Class for hook WeeChat commands."""

description, usage, help = "WeeChat command.", "[define usage template]", "detailed help here"

command = ''

completion = ''

def __init__(self):

assert self.command, "No command defined"

self.__name__ = self.command

self._pointer = ''

self._callback = ''

def __call__(self, *args):

return self.callback(*args)

def callback(self, data, buffer, args):

"""Called by WeeChat when /command is used."""

self.data, self.buffer, self.args = data, buffer, args

debug("%s[%s] data: \"%s\" buffer: \"%s\" args: \"%s\"", COLOR_DARKGRAY,

self.command,

data,

buffer,

args)

try:

self.parser(args) # argument parsing

except ArgumentError as e:

error('Argument error, %s' %e)

except NoArguments:

pass

else:

self.execute()

return WEECHAT_RC_OK

def parser(self, args):

"""Argument parsing, override if needed."""

pass

def execute(self):

"""This method is called when the command is run, override this."""

pass

def hook(self):

assert not self._pointer, \

"There's already a hook pointer, unhook first (%s)" %self.command

self._callback = callback(self.callback)

pointer = weechat.hook_command(self.command,

self.description,

self.usage,

self.help,

self.completion,

self._callback, '')

if pointer == '':

raise Exception("hook_command failed: %s %s" % (SCRIPT_NAME, self.command))

self._pointer = pointer

def unhook(self):

if self._pointer:

weechat.unhook(self._pointer)

self._pointer = ''

def __init__(self, name, hidden=False, items=''):

self.name = name

self.hidden = hidden

self._pointer = ''

self._items = items

def new(self):

assert not self._pointer, "Bar %s already created" % self.name

pointer = weechat.bar_search(self.name)

if not pointer:

pointer = weechat.bar_new(self.name, boolDict[self.hidden], '0', 'window',

'active', 'bottom', 'horizontal', 'vertical',

'0', '1', 'default', 'cyan', 'blue', 'off',

self._items)

if not pointer:

raise Exception("bar_new failed: %s %s" % (SCRIPT_NAME, self.name))

self._pointer = pointer

def getPointer(self):

return weechat.bar_search(self.name)

def show(self):

pointer = self.getPointer()

if pointer and self.hidden:

weechat.bar_set(pointer, 'hidden', 'off')

self.hidden = False

return pointer

def hide(self):

pointer = self.getPointer()

if pointer and not self.hidden:

weechat.bar_set(pointer, 'hidden', 'on')

self.hidden = True

def remove(self):

pointer = self.getPointer()

if pointer:

weechat.bar_remove(pointer)

self._pointer = ''

def __len__(self):

"""True False evaluation."""

if self.getPointer():

return 1

else:

_timer_hook = ''

popup_mode = False

def popup(self, delay=10):

if self.show():

if self._timer_hook:

weechat.unhook(self._timer_hook)

self._timer_hook = weechat.hook_timer(delay * 1000, 0, 1, callback(self._timer), '')

def _timer(self, data, counter):

self.hide()

self._timer_hook = ''

"""Keeps variables and objects of a specific buffer."""

def __init__(self, buffer):

self['buffer'] = buffer

self['irc'] = IrcCommands(buffer)

self['autodeop'] = True

self['deopHook'] = self.opHook = self.opTimeout = None

self['server'] = weechat.buffer_get_string(buffer, 'localvar_server')

self['channel'] = weechat.buffer_get_string(buffer, 'localvar_channel')

self['nick'] = weechat.info_get('irc_nick', self.server)

def __getattr__(self, k):

return self[k]

def __setattr__(self, k, v):

debug(' -- buffer[%s] %s ... %s => %s', self.buffer, k, self.get(k), v)

"""Keeps track of BuffersVariables instances in chanop."""

buffer = ''

_buffer = {} # must be shared across instances

def __getattr__(self, k):

return self._buffer[self.buffer][k]

def setup(self, buffer):

self.buffer = buffer

if buffer not in self._buffer:

self._buffer[buffer] = BufferVariables(buffer)

else:

# update nick, it might have changed.

self.vars.nick = weechat.info_get('irc_nick', self.vars.server)

@property

def vars(self):

return self._buffer[self.buffer]

def varsOf(self, buffer):

return self._buffer[buffer]

def replace_vars(self, s):

try:

return weechat.buffer_string_replace_local_var(self.buffer, s)

except AttributeError:

if '$channel' in s:

s = s.replace('$channel', self.channel)

if '$nick' in s:

s = s.replace('$nick', self.nick)

if '$server' in s:

s = s.replace('$server', self.server)

return s

def get_config(self, config):

#debug('config: %s' %config)

return get_config_specific(config, self.server, self.channel)

def get_config_boolean(self, config):

return get_config_boolean(config, self.get_config)

def get_config_int(self, config):

command = None

args = ()

wait = 0

def __init__(self, cmd=None, args=(), wait=0):

if cmd: self.command = cmd

if args: self.args = args

if wait: self.wait = wait

def payload(self):

cmd = self.command

if cmd[0] != '/':

cmd = '/' + cmd

if self.args:

cmd += ' ' + ' '.join(self.args)

if self.wait:

cmd = '/wait %s ' %self.wait + cmd

return cmd

def register(self, buffer):

self.buffer = buffer

def __call__(self):

cmd = self.payload()

if cmd:

self.send(cmd)

def send(self, cmd):

weechat_command(self.buffer, cmd)

def __repr__(self):

"""Class that manages and sends the script's commands to WeeChat."""

# Special message classes

class OpMessage(Message):

def send(self, cmd):

if self.irc.checkOp():

# nothing to do

return

self.irc.interrupt = True

Message.send(self, cmd)

def modeOpCallback(buffer, signal, signal_data):

vars = self.varsOf(buffer)

data = 'MODE %s +o %s' % (vars.channel, vars.nick)

signal = signal_data.split(None, 1)[1]

if signal == data:

debug('GOT OP')

# add this channel to our watchlist

config = 'watchlist.%s' % vars.server

channels = CaseInsensibleSet(get_config_list(config))

if vars.channel not in channels:

channels.add(vars.channel)

value = ','.join(channels)

weechat.config_set_plugin(config, value)

weechat.unhook(vars.opHook)

weechat.unhook(vars.opTimeout)

vars.opTimeout = vars.opHook = None

vars.irc.interrupt = False

vars.irc.run()

return WEECHAT_RC_OK

def timeoutCallback(buffer, count):

vars = self.varsOf(buffer)

error("Couldn't get op in '%s', purging command queue..." % vars.channel)

weechat.unhook(vars.opHook)

if vars.deopHook:

weechat.unhook(vars.deopHook)

vars.deopHook = None

vars.opTimeout = vars.opHook = None

vars.irc.interrupt = False

vars.irc.clear()

return WEECHAT_RC_OK

# wait for a while before timing out.

self.vars.opTimeout = weechat.hook_timer(30*1000, 0, 1, callback(timeoutCallback),

self.buffer)

self.vars.opHook = weechat.hook_signal('%s,irc_in2_MODE' %self.server,

callback(modeOpCallback), self.buffer)

class UserhostMessage(Message):

def send(self, cmd):

self.irc.interrupt = True

Message.send(self, cmd)

def msgCallback(buffer, modifier, modifier_data, string):

vars = self.varsOf(buffer)

if vars.server != modifier_data:

return string

nick, host = string.rsplit(None, 1)[1].split('=')

nick, host = nick.strip(':*'), host[1:]

hostmask = '%s!%s' % (nick, host)

debug('USERHOST: %s %s', nick, hostmask)

userCache.remember(modifier_data, nick, hostmask)

weechat.unhook(vars.msgHook)

weechat.unhook(vars.msgTimeout)

vars.msgTimeout = vars.msgHook = None

vars.irc.interrupt = False

vars.irc.run()

return ''

def timeoutCallback(buffer, count):

vars = self.varsOf(buffer)

weechat.unhook(vars.msgHook)

vars.msgTimeout = vars.msgHook = None