weechat: add chanop, notify and whois_on_query

3 files changed, 3482 insertions, 0 deletions

diff --git a/weechat/python/chanop.py b/weechat/python/chanop.py
new file mode 100644
index 0000000..848837e
--- /dev/null
+++ b/weechat/python/chanop.py
@@ -0,0 +1,3236 @@
+# -*- coding: utf-8 -*-
+###
+# Copyright (c) 2009-2013 by Elián Hanisch <lambdae2@gmail.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+###
+
+###
+#   Helper script for IRC Channel Operators
+#
+#   Inspired by auto_bleh.pl (irssi) and chanserv.py (xchat) scripts.
+#
+#   Networks like Freenode and some channels encourage operators to not stay
+#   permanently with +o privileges and only use it when needed. This script
+#   works along those lines, requesting op, kick/ban/etc and deop
+#   automatically with a single command.
+#   Still this script is very configurable and its behaviour can be configured
+#   in a per server or per channel basis so it can fit most needs without
+#   changing its code.
+#
+#   Features several completions for ban/quiet masks and a memory for channel
+#   masks and users (so users that parted are still bannable by nick).
+#
+#
+#   Commands (see detailed help with /help in WeeChat):
+#   *      /oop: Request or give op.
+#   *    /odeop: Drop or remove op.
+#   *    /okick: Kick user (or users).
+#   *     /oban: Apply ban mask.
+#   *   /ounban: Remove ban mask.
+#   *   /oquiet: Apply quiet mask.
+#   * /ounquiet: Remove quiet mask.
+#   * /obankick: Ban and kick user (or users)
+#   *   /otopic: Change channel topic
+#   *    /omode: Change channel modes
+#   *    /olist: List cached masks (bans or quiets)
+#   *   /ovoice: Give voice to user
+#   * /odevoice: Remove voice from user
+#
+#
+#   Settings:
+#   Most configs (unless noted otherwise) can be defined for a server or a
+#   channel in particular, so it is possible to request op in different
+#   networks, stay always op'ed in one channel while
+#   auto-deop in another.
+#
+#   For define an option for a specific server use:
+#   /set plugins.var.python.chanop.<option>.<server> "value"
+#   For define it in a specific channel use:
+#   /set plugins.var.python.chanop.<option>.<server>.<#channel> "value"
+#
+#   * plugins.var.python.chanop.op_command:
+#     Here you define the command the script must run for request op, normally
+#     is a /msg to a bot, like chanserv in freenode or Q in quakenet.
+#     It accepts the special vars $server, $channel and $nick
+#
+#     By default it ask op to chanserv, if your network doesn't use chanserv,
+#     then you must change it.
+#
+#     Examples:
+#     /set plugins.var.python.chanop.op_command
+#          "/msg chanserv op $channel $nick"
+#     (globally for all servers, like freenode and oftc)
+#     /set plugins.var.python.chanop.op_command.quakenet
+#          "/msg q op $channel $nick"
+#     (for quakenet only)
+#
+#   * plugins.var.python.chanop.autodeop:
+#     Enables auto-deop'ing after using any of the ban or kick commands.
+#     Note that if you got op manually (like with /oop) then the script won't
+#     deop you.
+#     Valid values: 'on', 'off' Default: 'on'
+#
+#   * plugins.var.python.chanop.autodeop_delay:
+#     Time it must pass (without using any commands) before auto-deop, in
+#     seconds. Using zero causes to deop immediately.
+#     Default: 180
+#
+#   * plugins.var.python.chanop.default_banmask:
+#     List of keywords separated by comas. Defines default banmask, when using
+#     /oban, /obankick or /oquiet
+#     You can use several keywords for build a banmask, each keyword defines how
+#     the banmask will be generated for a given hostmask, see /help oban.
+#     Valid keywords are: nick, user, host and exact.
+#     Default: 'host'
+#
+#     Examples:
+#     /set plugins.var.python.chanop.default_banmask host
+#     (bans with *!*@host)
+#     /set plugins.var.python.chanop.default_banmask host,user
+#     (bans with *!user@host)
+#
+#   * plugins.var.python.chanop.kick_reason:
+#     Default kick reason if none was given in the command.
+#
+#   * plugins.var.python.chanop.enable_remove:
+#     If enabled, it will use "/quote remove" command instead of /kick, enable
+#     it only in networks that support it, like freenode.
+#     Valid values: 'on', 'off' Default: 'off'
+#
+#     Example:
+#     /set plugins.var.python.chanop.enable_remove.freenode on
+#
+#   * plugins.var.python.chanop.display_affected:
+#     Whenever a new ban is set, chanop will show the users affected by it.
+#     This is intended for help operators to see if their ban is too wide or
+#     point out clones in the channel.
+#     Valid values: 'on', 'off' Default: 'off'
+#
+#
+#   The following configs are global and can't be defined per server or channel.
+#
+#   * plugins.var.python.chanop.enable_multi_kick:
+#     Enables kicking multiple users with /okick command.
+#     Be careful with this as you can kick somebody by accident if
+#     you're not careful when writting the kick reason.
+#
+#     This also applies to /obankick command, multiple bankicks would be enabled.
+#     Valid values: 'on', 'off' Default: 'off'
+#
+#   * plugins.var.python.chanop.enable_bar:
+#     This will enable a pop-up bar for displaying chanop messages that would
+#     otherwise be printed in the buffer. This bar also shows in realtime the
+#     users affected by a ban you're about to set.
+#     Valid values: 'on', 'off' Default: 'on'
+#
+#
+#   The following configs are defined per server and are updated by the script only.
+#
+#   * plugins.var.python.chanop.watchlist:
+#     Indicates to chanop which channels should watch and keep track of users and
+#     masks. This config is automatically updated when you use any command that needs
+#     op, so manual setting shouldn't be needed.
+#
+#   * plugins.var.python.chanop.isupport:
+#     Only used in WeeChat versions prior to 0.3.3 which lacked support for
+#     irc_005 messages. These aren't meant to be set manually.
+#
+#
+#   Completions:
+#     Chanop has several completions, documented here. Some aren't used by chanop
+#     itself, but can be used in aliases with custom completions.
+#     Examples:
+#     apply exemptions with mask autocompletion
+#     /alias -completion %(chanop_ban_mask) exemption /mode $channel +e
+#     if you use grep.py script, grep with host autocompletion, for look clones.
+#     /alias -completion %(chanop_hosts) ogrep /grep
+#
+#   * chanop_unban_mask (used in /ounban)
+#     Autocompletes with banmasks set in current channel, requesting them if needed.
+#     Supports patterns for autocomplete several masks: *<tab> for all bans, or
+#     *192.168*<tab> for bans with '192.168' string.
+#
+#   * chanop_unquiet (used in /ounquiet)
+#     Same as chanop_unban_mask, but with masks for q channel mode.
+#
+#   * chanop_ban_mask (used in /oban and /oquiet)
+#     Given a partial IRC hostmask, it will try to complete with hostmasks of current
+#     users: *!*@192<tab> will try to complete with matching users, like
+#     *!*@192.168.0.1
+#
+#   * chanop_nicks (used in most commands)
+#     Autocompletes nicks, same as WeeChat's completer, but using chanop's user
+#     cache, so nicks from users that parted the channel will be still be completed.
+#
+#   * chanop_users (not used by chanop)
+#     Same as chanop_nicks, but with the usename part of the hostmask.
+#
+#   * chanop_hosts (not used by chanop)
+#     Same as chanop_nicks, but with the host part of the hostmask (includes previously used
+#     hostnames).
+#
+#
+#   TODO
+#   * use dedicated config file like in urlgrab.py?
+#   * ban expire time
+#   * save ban.mask and ban.hostmask across reloads
+#   * allow to override quiet command (for quiet with ChanServ)
+#   * freenode:
+#    - support for bans with channel forward
+#    - support for extbans (?)
+#   * Sort completions by user activity
+#
+#
+#   History:
+#   2013-05-24
+#   version 0.3.1: bug fixes
+#   * fix exceptions while fetching bans with /mode
+#   * fix crash with /olist command in networks that don't support +q channel masks.
+#
+#   2013-04-14
+#   version 0.3:
+#   * cycle between different banmasks in /oban /oquiet commands.
+#   * added pop-up bar for show information.
+#   * save ban mask information (date and operator)
+#   * remove workarounds for < 0.3.2 weechat versions
+#   * python 3.0 compatibility (not tested)
+#
+#   2013-01-02
+#   version 0.2.7: bug fixes:
+#   * fix /obankick, don't deop before kicking.
+#
+#   2011-09-18
+#   version 0.2.6: bug fixes:
+#   * update script to work with freenode's new quiet messages.
+#   * /omode wouldn't work with several modes.
+#
+#   2011-05-31
+#   version 0.2.5: bug fixes:
+#   * /omode -o nick wouldn't work due to the deopNow switch.
+#   * unban_completer could fetch the same masks several times.
+#   * removing ban forwards falied when using exact mask.
+#   * user nick wasn't updated in every call.
+#
+#   2011-02-02
+#   version 0.2.4: fix python 2.5 compatibility
+#
+#   2011-01-09
+#   version 0.2.3: bug fixes.
+#
+#   2010-12-23
+#   version 0.2.2: bug fixes.
+#
+#   2010-10-28
+#   version 0.2.1: refactoring mostly
+#   * deop_command option removed
+#   * removed --webchat switch, freenode's updates made it superfluous.
+#   * if WeeChat doesn't know a hostmask, use /userhost or /who if needed.
+#   * /oban and /oquiet without arguments show ban/quiet list.
+#   * most commands allows '-o' option, that forces immediate deop (without configured delay).
+#   * updated for WeeChat 0.3.4 (irc_nick infolist changes)
+#
+#   2010-09-20
+#   version 0.2: major update
+#   * fixed quiets for ircd-seven (freenode)
+#   * implemented user and mask cache.
+#   * added commands:
+#     - /ovoice /odevoice for de/voice users.
+#     - /omode for change channel modes.
+#     - /olist for list bans/quiets on cache.
+#   * changed /omute and /ounmute commands to /oquiet and /ounquiet, as q masks
+#     is refered as a quiet rather than a mute.
+#   * autocompletions:
+#     - for bans set on a channel.
+#     - for make new bans.
+#     - for nicks/usernames/hostnames.
+#   * /okban renamed to /obankick. This is because /okban is too similar to
+#     /okick and bankicking somebody due to tab fail was too easy.
+#   * added display_affected feature.
+#   * added --webchat ban option.
+#   * config options removed:
+#     - merge_bans: superseded by isupport methods.
+#     - enable_mute: superseded by isupport methods.
+#     - invert_kickban_order: now is fixed to "ban, then kick"
+#   * Use WeeChat isupport infos.
+#   * /oop and /odeop can op/deop other users.
+#
+#   2009-11-9
+#   version 0.1.1: fixes
+#   * script renamed to 'chanop' because it was causing conflicts with python
+#     'operator' module
+#   * added /otopic command
+#
+#   2009-10-31
+#   version 0.1: Initial release
+###
+
+WEECHAT_VERSION = (0x30200, '0.3.2')
+
+SCRIPT_NAME    = "chanop"
+SCRIPT_AUTHOR  = "Elián Hanisch <lambdae2@gmail.com>"
+SCRIPT_VERSION = "0.3.1"
+SCRIPT_LICENSE = "GPL3"
+SCRIPT_DESC    = "Helper script for IRC Channel Operators"
+
+# default settings
+settings = {
+'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',
+}
+
+try:
+    import weechat
+    from weechat import WEECHAT_RC_OK, prnt
+    import_ok = True
+except ImportError:
+    print("This script must be run under WeeChat.")
+    print("Get WeeChat now at: http://www.weechat.org/")
+    import_ok = False
+
+import os
+import re
+import time
+import string
+import getopt
+from collections import defaultdict
+from shelve import DbfilenameShelf as Shelf
+
+chars = string.maketrans('', '')
+
+# -----------------------------------------------------------------------------
+# Messages
+
+script_nick = SCRIPT_NAME
+def error(s, buffer=''):
+    """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()
+            prnt('', trace)
+
+def say(s, buffer=''):
+    """normal msg"""
+    prnt(buffer, '%s\t%s' %(script_nick, s))
+
+def _no_debug(*args):
+    pass
+
+debug = _no_debug
+
+# -----------------------------------------------------------------------------
+# Config
+
+# TODO Need to refactor all this too
+
+boolDict = {'on':True, 'off':False, True:'on', False:'off'}
+def get_config_boolean(config, get_function=None, **kwargs):
+    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)
+        return boolDict[default]
+
+def get_config_int(config, get_function=None):
+    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)
+        return int(default)
+
+valid_banmask = set(('nick', 'user', 'host', 'exact'))
+def get_config_banmask(config='default_banmask', get_function=None):
+    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)
+    return values
+
+def get_config_list(config):
+    value = weechat.config_get_plugin(config)
+    if value:
+        return value.split(',')
+    else:
+        return []
+
+def get_config_specific(config, server='', channel=''):
+    """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)
+    return value
+
+# -----------------------------------------------------------------------------
+# Utils
+
+now = lambda: int(time.time())
+
+def time_elapsed(elapsed, ret=None, level=2):
+    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)
+    return ret
+
+# -----------------------------------------------------------------------------
+# IRC utils
+
+_hostmaskRe = re.compile(r':?\S+!\S+@\S+') # poor but good enough
+def is_hostmask(s):
+    """Returns whether or not the string s starts with something like a hostmask."""
+    return _hostmaskRe.match(s) is not None
+
+def is_ip(s):
+    """Returns whether or not a given string is an IPV4 address."""
+    import socket
+    try:
+        return bool(socket.inet_aton(s))
+    except socket.error:
+        return False
+
+_reCache = {}
+def cachedPattern(f):
+    """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)
+    return getRegexp
+
+def hostmaskPattern(f):
+    """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 ''
+    return checkPattern
+
+match_string = lambda r, s: r.match(s) is not None
+match_list = lambda r, L: [ s for s in L if r.match(s) is not None ]
+
+pattern_match = cachedPattern(match_string)
+pattern_match_list = cachedPattern(match_list)
+hostmask_match = hostmaskPattern(pattern_match)
+hostmask_match_list = hostmaskPattern(pattern_match_list)
+
+def get_nick(s):
+    """':nick!user@host' => 'nick'"""
+    return weechat.info_get('irc_nick_from_host', s)
+
+def get_user(s, trim=False):
+    """'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:]
+    return s
+
+def get_host(s):
+    """'nick!user@host' => 'host'"""
+    assert is_hostmask(s), "Invalid hostmask: %s" % s
+    if ' ' in s:
+        return s[s.find('@') + 1:s.find(' ')]
+    return s[s.find('@') + 1:]
+
+def is_channel(s):
+    return weechat.info_get('irc_is_channel', s)
+
+def is_nick(s):
+    return weechat.info_get('irc_is_nick', s)
+
+def irc_buffer(buffer):
+    """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')
+        return (server, channel)
+
+# -----------------------------------------------------------------------------
+# WeeChat classes
+
+class InvalidIRCBuffer(Exception):
+    pass
+
+def catchExceptions(f):
+    def function(*args, **kwargs):
+        try:
+            return f(*args, **kwargs)
+        except Exception as e:
+            error(e)
+    return function
+
+def callback(method):
+    """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)
+    return name
+
+def weechat_command(buffer, cmd):
+    """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)
+    weechat.command(buffer, cmd)
+
+class Infolist(object):
+    """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)
+            self.pointer = ''
+
+def nick_infolist(server, channel):
+    try:
+        return Infolist('irc_nick', '%s,%s' % (server, channel))
+    except:
+        raise InvalidIRCBuffer('%s.%s' % (server, channel))
+
+class NoArguments(Exception):
+    pass
+
+class ArgumentError(Exception):
+    pass
+
+class Command(object):
+    """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 = ''
+            self._callback = ''
+
+class Bar(object):
+    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:
+            return 0
+
+class PopupBar(Bar):
+    _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 = ''
+        return WEECHAT_RC_OK
+
+# -----------------------------------------------------------------------------
+# Per buffer variables
+
+class BufferVariables(dict):
+    """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)
+        self[k] = v
+
+class ChanopBuffers(object):
+    """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):
+        return get_config_int(config, self.get_config)
+
+# -----------------------------------------------------------------------------
+# IRC messages queue
+
+class Message(ChanopBuffers):
+    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):
+        return '<Message(%s, %s)>' %(self.command, self.args)
+
+class IrcCommands(ChanopBuffers):
+    """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
+                vars.irc.interrupt = False
+                vars.irc.clear()
+                return WEECHAT_RC_OK
+
+            # wait for a while before timing out.
+            self.vars.msgTimeout = \
+                weechat.hook_timer(30*1000, 0, 1, callback(timeoutCallback), self.buffer)
+
+            self.vars.msgHook = weechat.hook_modifier('irc_in_302',
+                    callback(msgCallback), self.buffer)
+
+
+    class ModeMessage(Message):
+        command = 'mode'
+        def __init__(self, char=None, args=None, **kwargs):
+            self.chars = [ char ]
+            self.charargs = [ args ]
+            self.args = (char, args)
+            Message.__init__(self, **kwargs)
+
+        def payload(self):
+            args = []
+            modeChar = []
+            prefix = ''
+            for m, a in zip(self.chars, self.charargs):
+                if a:
+                    if callable(a):
+                        a = a()
+                        if not a:
+                            continue
+                    args.append(a)
+                if m[0] != prefix:
+                    prefix = m[0]
+                    modeChar.append(prefix)
+                modeChar.append(m[1])
+            args.insert(0, ''.join(modeChar))
+            if args:
+                self.args = args
+                return Message.payload(self)
+
+
+    class DeopMessage(ModeMessage):
+        def send(self, cmd):
+            if self.irc.checkOp():
+                Message.send(self, cmd)
+
+    # IrcCommands methods
+    def __init__(self, buffer):
+        self.interrupt = False
+        self.commands = []
+        self.buffer = buffer
+
+    def checkOp(self):
+        infolist = nick_infolist(self.server, self.channel)
+        while infolist.next():
+            if infolist['name'] == self.nick:
+                return '@' in infolist['prefixes']
+        return False
+
+    def Op(self):
+        if self.opHook and self.opTimeout:
+            # already send command, wait for timeout
+            return
+
+        value = self.replace_vars(self.get_config('op_command'))
+        if not value:
+            raise Exception("No command defined for get op.")
+        msg = self.OpMessage(value)
+        self.queue(msg, insert=True)
+
+    def Deop(self):
+        msg = self.DeopMessage('-o', self.nick)
+        self.queue(msg)
+
+    def Mode(self, mode, args=None, wait=0):
+        msg = self.ModeMessage(mode, args, wait=wait)
+        self.queue(msg)
+
+    def Kick(self, nick, reason=None, wait=0):
+        if not reason:
+            reason = self.get_config('kick_reason')
+        if self.get_config_boolean('enable_remove'):
+            cmd = '/quote remove %s %s :%s' %(self.channel, nick, reason)
+            msg = Message(cmd, wait=wait)
+        else:
+            msg = Message('kick', (nick, reason), wait=wait)
+        self.queue(msg)
+
+    def Voice(self, nick):
+        self.Mode('+v', nick)
+
+    def Devoice(self, nick):
+        self.Mode('-v', nick)
+
+    def Userhost(self, nick):
+        msg = self.UserhostMessage('USERHOST', (nick, ))
+        self.queue(msg, insert=True) # USERHOST should be sent first
+
+    def queue(self, message, insert=False):
+        debug('queuing: %s', message)
+        # merge /modes
+        if self.commands and message.command == 'mode':
+            max_modes = supported_maxmodes(self.server)
+            msg = self.commands[-1]
+            if msg.command == 'mode' and len(msg.chars) < max_modes:
+                msg.chars.append(message.chars[0])
+                msg.charargs.append(message.charargs[0])
+                return
+        if insert:
+            self.commands.insert(0, message)
+        else:
+            self.commands.append(message)
+
+    # it happened once and it wasn't pretty
+    def safe_check(f):
+        def abort_if_too_many_commands(self):
+            if len(self.commands) > 10:
+                error("Limit of 10 commands in queue reached, aborting.")
+                self.clear()
+            else:
+                f(self)
+        return abort_if_too_many_commands
+
+    @safe_check
+    def run(self):
+        while self.commands and not self.interrupt:
+            msg = self.commands.pop(0)
+            msg.register(self.buffer)
+            msg()
+            if self.interrupt:
+                #debug("Interrupting queue")
+                break
+
+    def clear(self):
+        debug('clear queue (%s messages)', len(self.commands))
+        self.commands = []
+
+    def __repr__(self):
+        return '<IrcCommands(%s)>' % ', '.join(map(repr, self.commands))
+
+# -----------------------------------------------------------------------------
+# User/Mask classes
+
+_rfc1459trans = string.maketrans(string.ascii_uppercase + r'\[]',
+                                 string.ascii_lowercase + r'|{}')
+def IRClower(s):
+    return s.translate(_rfc1459trans)
+
+class CaseInsensibleString(str):
+    def __init__(self, s=''):
+        self.lowered = IRClower(s)
+
+    lower    = lambda self: self.lowered
+    translate = lambda self, trans: self.lowered
+    __eq__   = lambda self, s: self.lowered == IRClower(s)
+    __ne__   = lambda self, s: not self == s
+    __hash__ = lambda self: hash(self.lowered)
+
+def caseInsensibleKey(k):
+    if isinstance(k, str):
+        return CaseInsensibleString(k)
+    elif isinstance(k, tuple):
+        return tuple(map(caseInsensibleKey, k))
+    return k
+
+class CaseInsensibleDict(dict):
+    key = staticmethod(caseInsensibleKey)
+
+    def __init__(self, **kwargs):
+        for k, v in kwargs.items():
+            self[k] = v
+
+    def __setitem__(self, k, v):
+        dict.__setitem__(self, self.key(k), v)
+
+    def __getitem__(self, k):
+        return dict.__getitem__(self, self.key(k))
+
+    def __delitem__(self, k):
+        dict.__delitem__(self, self.key(k))
+
+    def __contains__(self, k):
+        return dict.__contains__(self, self.key(k))
+
+    def pop(self, k):
+        return dict.pop(self, self.key(k))
+
+class CaseInsensibleDefaultDict(defaultdict, CaseInsensibleDict):
+    pass
+
+class CaseInsensibleSet(set):
+    normalize = staticmethod(caseInsensibleKey)
+
+    def __init__(self, iterable=()):
+        iterable = map(self.normalize, iterable)
+        set.__init__(self, iterable)
+
+    def __contains__(self, v):
+        return set.__contains__(self, self.normalize(v))
+
+    def update(self, L):
+        set.update(self, map(self.normalize, L))
+
+    def add(self, v):
+        set.add(self, self.normalize(v))
+
+    def remove(self, v):
+        set.remove(self, self.normalize(v))
+
+class ChannelWatchlistSet(CaseInsensibleSet):
+    _updated = False
+    def __contains__(self, v):
+        if not self._updated:
+            self.__updateFromConfig()
+        return CaseInsensibleSet.__contains__(self, v)
+
+    def __updateFromConfig(self):
+        self._updated = True
+        infolist = Infolist('option', 'plugins.var.python.%s.watchlist.*' %SCRIPT_NAME)
+        n = len('python.%s.watchlist.' %SCRIPT_NAME)
+        while infolist.next():
+            name = infolist['option_name']
+            value = infolist['value']
+            server = name[n:]
+            if value:
+                channels = value.split(',')
+            else:
+                channels = []
+            self.update([ (server, channel) for channel in channels ])
+
+chanopChannels = ChannelWatchlistSet()
+
+class ServerChannelDict(CaseInsensibleDict):
+    def getChannels(self, server, item=None):
+        """Return a list of channels that match server and has item if given"""
+        if item:
+            return [ chan for serv, chan in self if serv == server and item in self[serv, chan] ]
+        else:
+            return [ chan for serv, chan in self if serv == server ]
+
+    def purge(self):
+        for key in self.keys():
+            if key not in chanopChannels:
+                debug('removing %s mask list, not in watchlist.', key)
+                del self[key]
+        for data in self.values():
+            data.purge()
+
+# -----------------------------------------------------------------------------
+# Channel Modes (bans)
+
+class MaskObject(object):
+    def __init__(self, mask, hostmask=[], operator='', date=0, expires=0):
+        self.mask = mask
+        self.operator = operator
+        if date:
+            date = int(date)
+        else:
+            date = now()
+        self.date = date
+        if isinstance(hostmask, str):
+            hostmask = [ hostmask ]
+        self.hostmask = hostmask
+        self.expires = int(expires)
+
+    def serialize(self):
+        data = ';'.join([ self.operator,
+                          str(self.date),
+                          str(self.expires),
+                          ','.join(self.hostmask) ])
+        return data
+
+    def deserialize(self, data):
+        op, date, expires, hostmasks = data.split(';')
+        assert op and date, "Error reading chanmask option %s, missing operator or date" % self.mask
+        if not is_hostmask(op):
+            raise Exception('Error reading chanmask option %s, invalid usermask %r' \
+                            % (self.mask, op))
+
+        self.operator = op
+        try:
+            self.date = int(date)
+        except ValueError:
+            self.date = int(time.mktime(time.strptime(date,'%Y-%m-%d %H:%M:%S')))
+        if expires:
+            self.expires = int(expires)
+        else:
+            self.expires = 0
+        if hostmasks:
+            hostmasks = hostmasks.split(',')
+            if not all(map(is_hostmask, hostmasks)):
+                raise Exception('Error reading chanmask option %s, a hostmask is invalid: %s' \
+                                % (self.mask, hostmasks))
+
+            self.hostmask = hostmasks
+
+    def __repr__(self):
+        return "<MaskObject(%s)>" % self.mask
+
+class MaskList(CaseInsensibleDict):
+    """Single list of masks"""
+    def __init__(self, server, channel):
+        self.synced = 0
+
+    def add(self, mask, **kwargs):
+        if mask in self:
+            # mask exists, update it
+            ban = self[mask]
+            for attr, value in kwargs.items():
+                if value and not getattr(ban, attr):
+                    setattr(ban, attr, value)
+        else:
+            ban = self[mask] = MaskObject(mask, **kwargs)
+        return ban
+
+#    def searchByNick(self, nick):
+#        try:
+#            hostmask = userCache.getHostmask(nick, self.server, self.channel)
+#            return self.searchByHostmask(hostmask)
+#        except KeyError:
+#            return []
+
+    def search(self, pattern, reverseMatch=False):
+        if reverseMatch:
+            L = [ mask for mask in self if hostmask_match(mask, pattern) ]
+        else:
+            L = pattern_match_list(pattern, self.keys())
+        return L
+
+    def purge(self):
+        pass
+
+class MaskCache(ServerChannelDict):
+    """Keeps a cache of masks for different channels."""
+    def add(self, server, channel, mask, **kwargs):
+        """Adds a ban to (server, channel) banlist."""
+        key = (server, channel)
+        if key not in self:
+            self[key] = MaskList(*key)
+        ban = self[key].add(mask, **kwargs)
+        return ban
+
+    def remove(self, server, channel, mask=None):#, hostmask=None):
+        key = (server, channel)
+        try:
+            if mask is None:
+                del self[key]
+            else:
+                del self[key][mask]
+                #debug("removing ban: %s" %banmask)
+        except KeyError:
+            pass
+
+class ChanopCache(Shelf):
+    def __init__(self, filename):
+        path = os.path.join(weechat.info_get('weechat_dir', ''), filename)
+        Shelf.__init__(self, path, writeback=True)
+
+class ModeCache(ChanopCache):
+    """class for store channel modes lists."""
+    def __init__(self, filename):
+        ChanopCache.__init__(self, filename)
+        self.modes = set()
+        self.map = CaseInsensibleDict()
+
+        # reset all sync timers
+        for cache in self.values():
+            for masklist in cache.values():
+                masklist.synced = 0
+
+    def registerMode(self, mode, *args):
+        if mode not in self:
+            cache = MaskCache()
+            self[mode] = cache
+
+        if mode not in self.modes:
+            self.modes.add(mode)
+
+        self.map[mode] = mode
+        for name in args:
+            self.map[name] = mode
+
+    def __getitem__(self, mode):
+        try:
+            return ChanopCache.__getitem__(self, mode)
+        except KeyError:
+            return ChanopCache.__getitem__(self, self.map[mode])
+
+    def add(self, server, channel, mode, mask, **kwargs):
+        assert mode in self.modes
+        self[mode].add(server, channel, mask, **kwargs)
+
+    def remove(self, server, channel, mode, mask):
+        self[mode].remove(server, channel, mask)
+
+    def purge(self):
+        for cache in self.values():
+            cache.purge()
+
+class MaskSync(object):
+    """Class for fetch and sync bans of any channel and mode."""
+    __name__ = ''
+    _hide_msg = False
+
+    _hook_mask = ''
+    _hook_end = ''
+
+    # freenode new signals for list quiet messages
+    _hook_quiet_mask = ''
+    _hook_quiet_end = ''
+
+    # sync queue stuff
+    queue = []
+    _maskbuffer = CaseInsensibleDefaultDict(list)
+    _callback = CaseInsensibleDict()
+
+    def hook(self):
+        # 367 - ban mask
+        # 368 - end of ban list
+        # 728 - quiet mask
+        # 729 - end of quiet list
+        self.unhook()
+        self._hook_mask = \
+                weechat.hook_modifier('irc_in_367', callback(self._maskCallback), '')
+        self._hook_end = \
+                weechat.hook_modifier('irc_in_368', callback(self._endCallback), '')
+        self._hook_quiet_mask = \
+                weechat.hook_modifier('irc_in_728', callback(self._maskCallback), '')
+        self._hook_quiet_end = \
+                weechat.hook_modifier('irc_in_729', callback(self._endCallback), '')
+
+    def unhook(self):
+        for hook in ('_hook_mask',
+                     '_hook_end',
+                     '_hook_quiet_mask',
+                     '_hook_quiet_end'):
+            attr = getattr(self, hook)
+            if attr:
+                weechat.unhook(attr)
+                setattr(self, hook, '')
+
+    def fetch(self, server, channel, mode, callback=None):
+        """Fetches masks for a given server and channel."""
+        buffer = weechat.buffer_search('irc', 'server.%s' %server)
+        if not buffer or not weechat.info_get('irc_is_channel', channel):
+            # invalid server or channel
+            return
+
+        # check modes
+        if mode not in supported_modes(server):
+            return
+        maskCache = modeCache[mode]
+        key = (server, channel)
+        # check the last time we did this
+        try:
+            masklist = maskCache[key]
+            if (now() - masklist.synced) < 60:
+                # don't fetch again
+                return
+        except KeyError:
+            pass
+
+        if not self.queue:
+            self.queue.append((server, channel, mode))
+            self._fetch(server, channel, mode)
+        elif (server, channel, mode) not in self.queue:
+            self.queue.append((server, channel, mode))
+
+        if callback:
+            self._callback[server, channel] = callback
+
+    def _fetch(self, server, channel, mode):
+        buffer = weechat.buffer_search('irc', 'server.%s' %server)
+        if not buffer:
+            return
+        cmd = '/mode %s %s' %(channel, mode)
+        self._hide_msg = True
+        weechat_command(buffer, cmd)
+
+    def _maskCallback(self, data, modifier, modifier_data, string):
+        """callback for store a single mask."""
+        #debug("MASK %s: %s %s", modifier, modifier_data, string)
+        args = string.split()
+        if self.queue:
+            server, channel, _ = self.queue[0]
+        else:
+            server, channel = modifier_data, args[3]
+
+        if modifier == 'irc_in_367':
+            try:
+                mask, op, date = args[4:]
+            except IndexError:
+                mask = args[4]
+                op = date = None
+        elif modifier == 'irc_in_728':
+            mask, op, date = args[5:]
+
+        # store temporally until "end list" msg
+        self._maskbuffer[server, channel].append((mask, op, date))
+        if self._hide_msg:
+            string = ''
+        return string
+
+    def _endCallback(self, data, modifier, modifier_data, string):
+        """callback for end of channel's mask list."""
+        #debug("MASK END %s: %s %s", modifier, modifier_data, string)
+        if self.queue:
+            server, channel, mode = self.queue.pop(0)
+        else:
+            args = string.split()
+            server, channel = modifier_data, args[3]
+            if modifier == 'irc_in_368':
+                mode = args[7]
+            elif modifier == 'irc_in_729':
+                mode = args[4]
+            else:
+                return string
+
+        maskCache = modeCache[mode]
+
+        # delete old masks in cache
+        if (server, channel) in maskCache:
+            masklist = maskCache[server, channel]
+            banmasks = [ L[0] for L in self._maskbuffer[server, channel] ]
+            for mask in masklist.keys():
+                if mask not in banmasks:
+                    del masklist[mask]
+
+        for banmask, op, date in self._maskbuffer[server, channel]:
+            maskCache.add(server, channel, banmask, operator=op, date=date)
+        del self._maskbuffer[server, channel]
+        try:
+            maskList = maskCache[server, channel]
+        except KeyError:
+            maskList = maskCache[server, channel] = MaskList(server, channel)
+        maskList.synced = now()
+
+        # run hooked functions if any
+        if (server, channel) in self._callback:
+            self._callback[server, channel]()
+            del self._callback[server, channel]
+
+        if self._hide_msg:
+            string = ''
+        if self.queue:
+            next = self.queue[0]
+            self._fetch(*next)
+        else:
+            assert not self._maskbuffer, "mask buffer not empty: %s" % self._maskbuffer.keys()
+            self._hide_msg = False
+        return string
+
+maskSync = MaskSync()
+
+# -----------------------------------------------------------------------------
+# User cache
+
+class UserObject(object):
+    def __init__(self, nick, hostmask=None):
+        self.nick = nick
+        if hostmask:
+            self._hostmask = [ hostmask ]
+        else:
+            self._hostmask = []
+        self.seen = now()
+        self._channels = 0
+
+    @property
+    def hostmask(self):
+        try:
+            return self._hostmask[-1]
+        except IndexError:
+            return ''
+
+    def update(self, hostmask=None):
+        if hostmask and hostmask != self.hostmask:
+            if hostmask in self._hostmask:
+                del self._hostmask[self._hostmask.index(hostmask)]
+            self._hostmask.append(hostmask)
+        self.seen = now()
+
+    def __len__(self):
+        return len(self.hostmask)
+
+    def __repr__(self):
+        return '<UserObject(%s)>' %(self.hostmask or self.nick)
+
+class ServerUserList(CaseInsensibleDict):
+    def __init__(self, server):
+        self.server = server
+        buffer = weechat.buffer_search('irc', 'server.%s' %server)
+        self.irc = IrcCommands(buffer)
+        self._purge_time = 3600*4 # 4 hours
+
+    def getHostmask(self, nick):
+        user = self[nick]
+        return user.hostmask
+
+    def purge(self):
+        """Purge old nicks"""
+        n = now()
+        for nick, user in self.items():
+            if user._channels < 1 and (n - user.seen) > self._purge_time:
+                #debug('purging old user: %s' % nick)
+                del self[nick]
+
+class UserList(ServerUserList):
+    def __init__(self, server, channel):
+        self.server = server
+        self.channel = channel
+        self._purge_list = CaseInsensibleDict()
+        self._purge_time = 3600*2 # 2 hours
+
+    def __setitem__(self, nick, user):
+        #debug('%s %s: join, %s', self.server, self.channel, nick)
+        if nick not in self:
+            user._channels += 1
+        if nick in self._purge_list:
+            #debug(' - removed from purge list')
+            del self._purge_list[nick]
+        ServerUserList.__setitem__(self, nick, user)
+
+    def part(self, nick):
+        try:
+            #debug('%s %s: part, %s', self.server, self.channel, nick)
+            user = self[nick]
+            self._purge_list[nick] = user
+        except KeyError:
+            pass
+
+    def values(self):
+        if not all(ServerUserList.values(self)):
+            userCache.who(self.server, self.channel)
+        return sorted(ServerUserList.values(self), key=lambda x:x.seen, reverse=True)
+
+    def hostmasks(self, sorted=False, all=False):
+        if sorted:
+            users = self.values()
+        else:
+            users = ServerUserList.values(self)
+        if all:
+            # return all known hostmasks
+            return [ hostmask for user in users for hostmask in user._hostmask ]
+        else:
+            # only current hostmasks
+            return [ user.hostmask for user in users if user._hostmask ]
+
+    def nicks(self, *args, **kwargs):
+#        if not all(self.itervalues()):
+#            userCache.who(self.server, self.channel)
+        L = list(self.items())
+        L.sort(key=lambda x:x[1].seen)
+        return reversed([x[0] for x in L])
+
+    def getHostmask(self, nick):
+        try:
+            user = self[nick]
+        except KeyError:
+            user = userCache[self.server][nick]
+        return user.hostmask
+
+    def purge(self):
+        """Purge old nicks"""
+        n = now()
+        for nick, user in self._purge_list.items():
+            if (n - user.seen) > self._purge_time:
+                #debug('%s %s: forgeting about %s', self.server, self.channel, nick)
+                user._channels -= 1
+                try:
+                    del self._purge_list[nick]
+                    del self[nick]
+                except KeyError:
+                    pass
+
+class UserCache(ServerChannelDict):
+    __name__ = ''
+    servercache = CaseInsensibleDict()
+    _hook_who = _hook_who_end = None
+    _channels = CaseInsensibleSet()
+
+    def generateCache(self, server, channel):
+        debug('* building cache: %s %s', server, channel)
+        users = UserList(server, channel)
+        try:
+            infolist = nick_infolist(server, channel)
+        except:
+            # better to fail silently
+            #debug('invalid buffer')
+            return users
+
+        while infolist.next():
+            nick = infolist['name']
+            host = infolist['host']
+            if host:
+                hostmask = '%s!%s' %(nick, host)
+            else:
+                hostmask = ''
+            user = self.remember(server, nick, hostmask)
+            users[nick] = user
+        self[server, channel] = users
+        debug("new cache of %s users", len(users))
+        return users
+
+    def remember(self, server, nick, hostmask):
+        cache = self[server]
+        try:
+            user = cache[nick]
+            if hostmask:
+                user.update(hostmask)
+        except KeyError:
+            #debug("%s: new user %s %s", server, nick, hostmask)
+            user = UserObject(nick, hostmask)
+            cache[nick] = user
+        return user
+
+    def __getitem__(self, k):
+        if isinstance(k, tuple):
+            try:
+                return ServerChannelDict.__getitem__(self, k)
+            except KeyError:
+                return self.generateCache(*k)
+        elif isinstance(k, str):
+            try:
+                return self.servercache[k]
+            except KeyError:
+                cache = self.servercache[k] = ServerUserList(k)
+                return cache
+
+    def __delitem__(self, k):
+        # when we delete a channel, we need to reduce user._channels count
+        # so they can be purged later.
+        #debug('forgeting about %s', k)
+        for user in self[k].values():
+            user._channels -= 1
+        ServerChannelDict.__delitem__(self, k)
+
+    def getHostmask(self, nick, server, channel=None):
+        """Returns hostmask of nick."""
+        if channel:
+            return self[server, channel].getHostmask(nick)
+        return self[server].getHostmask(nick)
+
+    def who(self, server, channel):
+        if self._hook_who:
+            return
+
+        if (server, channel) in self._channels:
+            return
+
+        self._channels.add((server, channel))
+
+        key = ('%s.%s' %(server, channel)).lower()
+        self._hook_who = weechat.hook_modifier(
+                'irc_in_352', callback(self._whoCallback), key)
+        self._hook_who_end = weechat.hook_modifier(
+                'irc_in_315', callback(self._endWhoCallback), key)
+
+        buffer = weechat.buffer_search('irc', 'server.%s' %server)
+        weechat_command(buffer, '/who %s' % channel)
+
+    def _whoCallback(self, data, modifier, modifier_data, string):
+        #debug('%s %s %s', modifier, modifier_data, string)
+        args = string.split()
+        server, channel = modifier_data, args[3]
+        key = ('%s.%s' %(server, channel)).lower()
+        if key != data:
+            return string
+
+        nick, user, host = args[7], args[4], args[5]
+        hostmask = '%s!%s@%s' %(nick, user, host)
+        debug('WHO: %s', hostmask)
+        self.remember(server, nick, hostmask)
+        return ''
+
+    def _endWhoCallback(self, data, modifier, modifier_data, string):
+        args = string.split()
+        server, channel = modifier_data, args[3]
+        key = ('%s.%s' %(server, channel)).lower()
+        if key != data:
+            return string
+
+        debug('WHO: end.')
+        weechat.unhook(self._hook_who)
+        weechat.unhook(self._hook_who_end)
+        self._hook_who = self._hook_who_end = None
+        return ''
+
+    def purge(self):
+        ServerChannelDict.purge(self)
+        for cache in self.servercache.values():
+            cache.purge()
+
+userCache = UserCache()
+
+# -----------------------------------------------------------------------------
+# Chanop Command Classes
+
+# Base classes for chanop commands
+class CommandChanop(Command, ChanopBuffers):
+    """Base class for our commands, with config and general functions."""
+    infolist = None
+
+    def parser(self, args):
+        if not args:
+            weechat_command('', '/help %s' % self.command)
+            raise NoArguments
+        self.setup(self.buffer)
+
+    def execute(self):
+        self.users = userCache[self.server, self.channel]
+        try:
+            self.execute_chanop()   # call our command and queue messages for WeeChat
+            self.irc.run()          # run queued messages
+        except InvalidIRCBuffer as e:
+            error('Not in a IRC channel (%s)' % e)
+            self.irc.clear()
+        self.infolist = None    # free irc_nick infolist
+
+    def execute_chanop(self):
+        pass
+
+    def nick_infolist(self):
+        # reuse the same infolist instead of creating it many times
+        if not self.infolist:
+            self.infolist = nick_infolist(self.server, self.channel)
+        else:
+            self.infolist.reset()
+        return self.infolist
+
+    def has_op(self, nick):
+        nicks = self.nick_infolist()
+        while nicks.next():
+            if nicks['name'] == nick:
+                return '@' in nicks['prefixes']
+
+    def has_voice(self, nick):
+        nicks = self.nick_infolist()
+        while nicks.next():
+            if nicks['name'] == nick:
+                return '+' in nicks['prefixes']
+
+    def isUser(self, nick):
+        return nick in self.users
+
+    def inChannel(self, nick):
+        return CaseInsensibleString(nick) in [ nick['name'] for nick in self.nick_infolist() ]
+
+    def getHostmask(self, name):
+        try:
+            hostmask = self.users.getHostmask(name)
+            if not hostmask:
+                self.irc.Userhost(name)
+                user = userCache[self.server][name]
+                return lambda: user.hostmask or user.nick
+            return hostmask
+        except KeyError:
+            pass
+
+    def set_mode(self, *nicks):
+        mode = self.prefix + self.mode
+        for nick in nicks:
+            self.irc.Mode(mode, nick)
+
+class CommandWithOp(CommandChanop):
+    """Base class for all the commands that requires op status for work."""
+    _enable_deopNow = True
+    deop_delay = 0
+
+    def __init__(self, *args, **kwargs):
+        CommandChanop.__init__(self, *args, **kwargs)
+        # update help so it adds --deop option
+        if self._enable_deopNow:
+            if self.usage:
+                self.usage += " "
+            if self.help:
+                self.help += "\n"
+            self.usage += "[--deop]"
+            self.help += " -o --deop: Forces deop immediately, without configured delay"\
+                         " (option must be the last argument)."
+
+    def setup(self, buffer):
+        self.deopNow = False
+        CommandChanop.setup(self, buffer)
+
+    def parser(self, args):
+        CommandChanop.parser(self, args)
+        args = args.split()
+        if self._enable_deopNow and args[-1] in ('-o', '--deop'):
+            self.deopNow = True
+            del args[-1]
+            self.args = ' '.join(args)
+        if not self.args:
+            raise NoArguments
+
+    def execute_chanop(self, *args):
+        self.execute_op(*args)
+
+        if not self.irc.commands:
+            # nothing in queue, no reason to op.
+            return
+
+        self.irc.Op()
+        if (self.autodeop and self.get_config_boolean('autodeop')) or self.deopNow:
+            if self.deopNow:
+                delay = self.deop_delay
+            else:
+                delay = self.get_config_int('autodeop_delay')
+            if delay > 0:
+                if self.deopHook:
+                    weechat.unhook(self.deopHook)
+                self.vars.deopHook = weechat.hook_timer(delay * 1000, 0, 1,
+                        callback(self.deopCallback), self.buffer)
+            elif self.irc.commands: # only Deop if there are msgs in queue
+                self.irc.Deop()
+
+    def execute_op(self, *args):
+        """Commands in this method will be run with op privileges."""
+        pass
+
+    def deopCallback(self, buffer, count):
+        #debug('deop %s', buffer)
+        vars = self.varsOf(buffer)
+        if vars.autodeop:
+            if vars.irc.commands:
+                # there are commands in queue yet, wait some more
+                vars.deopHook = weechat.hook_timer(1000, 0, 1,
+                        callback(self.deopCallback), buffer)
+                return WEECHAT_RC_OK
+            else:
+                vars.irc.Deop()
+                vars.irc.run()
+        vars.deopHook = None
+        return WEECHAT_RC_OK
+
+# Chanop commands
+class Op(CommandChanop):
+    description, usage = "Request operator privileges or give it to users.", "[nick [nick ... ]]",
+    help = \
+    "The command used for ask op is defined globally in plugins.var.python.%(name)s.op_command\n"\
+    "It can be defined per server or per channel in:\n"\
+    " plugins.var.python.%(name)s.op_command.<server>\n"\
+    " plugins.var.python.%(name)s.op_command.<server>.<#channel>\n"\
+    "\n"\
+    "After using this command, you won't be autodeoped." %{'name':SCRIPT_NAME}
+    command = 'oop'
+    completion = '%(nicks)'
+
+    prefix = '+'
+    mode = 'o'
+
+    def parser(self, args):
+        # dont show /help if no args
+        self.setup(self.buffer)
+
+    def execute_chanop(self):
+        self.irc.Op()
+        # /oop was used, we assume that the user wants
+        # to stay opped permanently
+        self.vars.autodeop = False
+        if self.args:
+            for nick in self.args.split():
+                if self.inChannel(nick) and not self.has_op(nick):
+                    self.set_mode(nick)
+
+class Deop(Op, CommandWithOp):
+    description, usage, help = \
+    "Removes operator privileges from yourself or users.", "[nick [nick ... ]]", ""
+    command = 'odeop'
+    completion = '%(nicks)'
+
+    prefix = '-'
+    _enable_deopNow = False
+
+    def execute_chanop(self):
+        if self.args:
+            nicks = []
+            for nick in self.args.split():
+                if self.inChannel(nick) and self.has_op(nick):
+                    nicks.append(nick)
+            if nicks:
+                CommandWithOp.execute_chanop(self, nicks)
+        else:
+            self.vars.autodeop = True
+            if self.has_op(self.nick):
+                self.irc.Deop()
+
+    def execute_op(self, nicks):
+        self.set_mode(*nicks)
+
+class Kick(CommandWithOp):
+    description, usage = "Kick nick.", "<nick> [<reason>]"
+    help = \
+    "On freenode, you can set this command to use /remove instead of /kick, users"\
+    " will see it as if the user parted and it can bypass autojoin-on-kick scripts."\
+    " See plugins.var.python.%s.enable_remove config option." %SCRIPT_NAME
+    command = 'okick'
+    completion = '%(nicks)'
+
+    def execute_op(self):
+        nick, s, reason = self.args.partition(' ')
+        if self.inChannel(nick):
+            self.irc.Kick(nick, reason)
+        else:
+            say("Nick not in %s (%s)" % (self.channel, nick), self.buffer)
+            self.irc.clear()
+
+class MultiKick(Kick):
+    description = "Kick one or more nicks."
+    usage = "<nick> [<nick> ... ] [:] [<reason>]"
+    help = Kick.help + "\n\n"\
+    "Note: Is not needed, but use ':' as a separator between nicks and "\
+    "the reason. Otherwise, if there's a nick in the channel matching the "\
+    "first word in reason it will be kicked."
+    completion = '%(nicks)|%*'
+
+    def execute_op(self):
+        args = self.args.split()
+        nicks = []
+        nicks_parted = []
+        #debug('multikick: %s' %str(args))
+        while(args):
+            nick = args[0]
+            if nick[0] == ':' or not self.isUser(nick):
+                break
+            nick = args.pop(0)
+            if self.inChannel(nick):
+                nicks.append(nick)
+            else:
+                nicks_parted.append(nick)
+
+        #debug('multikick: %s, %s' %(nicks, args))
+        reason = ' '.join(args).lstrip(':')
+        if nicks_parted:
+            say("Nick(s) not in %s (%s)" % (self.channel, ', '.join(nicks_parted)), self.buffer)
+        elif not nicks:
+            say("Unknown nick (%s)" % nick, self.buffer)
+        if nicks:
+            for nick in nicks:
+                self.irc.Kick(nick, reason)
+        else:
+            self.irc.clear()
+
+ban_help = \
+"Mask options:\n"\
+" -h  --host: Match hostname (*!*@host)\n"\
+" -n  --nick: Match nick     (nick!*@*)\n"\
+" -u  --user: Match username (*!user@*)\n"\
+" -e --exact: Use exact hostmask.\n"\
+"\n"\
+"If no mask options are supplied, configured defaults are used.\n"\
+"\n"\
+"Completer:\n"\
+"%(script)s will attempt to guess a complete banmask from current\n"\
+"users when using <tab> in an incomplete banmask. Using <tab> in a\n"\
+"complete banmask will generate variations of it. \n"\
+"\n"\
+"Examples:\n"\
+" /%(cmd)s somebody --user --host\n"\
+"   will ban with *!user@hostname mask.\n"\
+" /%(cmd)s nick!*@<tab>\n"\
+"   will autocomple with 'nick!*@host'.\n"\
+" /%(cmd)s nick!*@*<tab>\n"\
+"   will cycle through different banmask variations for the same user.\n"
+
+class Ban(CommandWithOp):
+    description = "Ban user or hostmask."
+    usage = \
+    "<nick|mask> [<nick|mask> ... ] [ [--host] [--user] [--nick] | --exact ]"
+    command = 'oban'
+    help = ban_help % {'script': SCRIPT_NAME, 'cmd': command}
+    completion = '%(chanop_nicks)|%(chanop_ban_mask)|%*'
+
+    banmask = []
+    mode = 'b'
+    prefix = '+'
+
+    def __init__(self):
+        self.maskCache = modeCache[self.mode]
+        CommandWithOp.__init__(self)
+
+    def parser(self, args):
+        if not args:
+            showBans.callback(self.data, self.buffer, self.mode)
+            raise NoArguments
+        CommandWithOp.parser(self, args)
+        self._parser(self.args)
+
+    def _parser(self, args):
+        args = args.split()
+        try:
+            (opts, args) = getopt.gnu_getopt(args, 'hune', ('host', 'user', 'nick', 'exact'))
+        except getopt.GetoptError as e:
+            raise ArgumentError(e)
+        self.banmask = []
+        for k, v in opts:
+            if k in ('-h', '--host'):
+                self.banmask.append('host')
+            elif k in ('-u', '--user'):
+                self.banmask.append('user')
+            elif k in ('-n', '--nick'):
+                self.banmask.append('nick')
+            elif k in ('-e', '--exact'):
+                self.banmask = ['exact']
+                break
+        if not self.banmask:
+            self.banmask = self.get_default_banmask()
+        self.args = ' '.join(args)
+
+    def get_default_banmask(self):
+        return get_config_banmask(get_function=self.get_config)
+
+    def make_banmask(self, hostmask):
+        assert self.banmask
+        template = self.banmask
+
+        def banmask(s):
+            if not is_hostmask(s):
+                return s
+            if 'exact' in template:
+                return s
+            nick = user = host = '*'
+            if 'nick' in template:
+                nick = get_nick(s)
+            if 'user' in template:
+                user = get_user(s)
+            if 'host' in template:
+                host = get_host(s)
+                # check for freenode's webchat, and use a better mask.
+                if host.startswith('gateway/web/freenode'):
+                    ip = host.partition('.')[2]
+                    if is_ip(ip):
+                        host = '*%s' % ip
+            s = '%s!%s@%s' %(nick, user, host)
+            assert is_hostmask(s), "Invalid hostmask: %s" % s
+            return s
+
+        if callable(hostmask):
+            return lambda: banmask(hostmask())
+        return banmask(hostmask)
+
+    def execute_op(self):
+        args = self.args.split()
+        banmasks = []
+        for arg in args:
+            if is_nick(arg):
+                hostmask = self.getHostmask(arg)
+                if not hostmask:
+                    say("Unknown nick (%s)" % arg, self.buffer)
+                    continue
+                mask = self.make_banmask(hostmask)
+                if self.has_voice(arg):
+                    self.irc.Devoice(arg)
+            else:
+                # probably an extban
+                mask = arg
+            banmasks.append(mask)
+        banmasks = set(banmasks) # remove duplicates
+        self.ban(*banmasks)
+
+    def mode_is_supported(self):
+        return self.mode in supported_modes(self.server)
+
+    def ban(self, *banmasks, **kwargs):
+        if self.mode != 'b' and not self.mode_is_supported():
+            error("%s doesn't seem to support channel mode '%s', using regular ban." %(self.server,
+                self.mode))
+            mode = 'b'
+        else:
+            mode = self.mode
+        mode = self.prefix + mode
+        for mask in banmasks:
+            self.irc.Mode(mode, mask, **kwargs)
+
+class UnBan(Ban):
+    description, usage = "Remove bans.", "<nick|mask> [<nick|mask> ... ]"
+    command = 'ounban'
+    help = \
+    "Autocompletion will use channel's bans, patterns allowed for autocomplete multiple"\
+    " bans.\n"\
+    "\n"\
+    "Example:\n"\
+    "/%(cmd)s *192.168*<tab>\n"\
+    "  Will autocomplete with all bans matching *192.168*" %{'cmd':command}
+    completion = '%(chanop_unban_mask)|%(chanop_nicks)|%*'
+    prefix = '-'
+
+    def search_masks(self, hostmask, **kwargs):
+        try:
+            masklist = self.maskCache[self.server, self.channel]
+        except KeyError:
+            return []
+
+        if callable(hostmask):
+            def banmask():
+                L = masklist.search(hostmask(), **kwargs)
+                if L: return L[0]
+
+            return [ banmask ]
+        return masklist.search(hostmask, **kwargs)
+
+    def execute_op(self):
+        args = self.args.split()
+        banmasks = []
+        for arg in args:
+            if is_hostmask(arg):
+                banmasks.extend(self.search_masks(arg))
+            elif is_nick(arg):
+                hostmask = self.getHostmask(arg)
+                if hostmask:
+                    banmasks.extend(self.search_masks(hostmask, reverseMatch=True))
+                else:
+                    # nick unknown to chanop
+                    say("Unknown nick (%s)" % arg, self.buffer)
+            else:
+                banmasks.append(arg)
+        self.ban(*banmasks)
+
+class Quiet(Ban):
+    description = "Silence user or hostmask."
+    command = 'oquiet'
+    help = "This command is only for networks that support channel mode 'q'.\n\n" \
+            + ban_help % {'script': SCRIPT_NAME, 'cmd': command}
+    completion = '%(chanop_nicks)|%(chanop_ban_mask)|%*'
+
+    mode = 'q'
+
+class UnQuiet(UnBan):
+    command = 'ounquiet'
+    description = "Remove quiets."
+    help = "Works exactly like /ounban, but only for quiets. See /help ounban"
+    completion = '%(chanop_unquiet_mask)|%(chanop_nicks)|%*'
+
+    mode = 'q'
+
+class BanKick(Ban, Kick):
+    description = "Bankicks nick."
+    usage = "<nick> [<reason>] [ [--host] [--user] [--nick] | --exact ]"
+    help = "Combines /oban and /okick commands. See /help oban and /help okick."
+    command = 'obankick'
+    completion = '%(chanop_nicks)'
+    deop_delay = 2
+
+    def execute_op(self):
+        nick, s, reason = self.args.partition(' ')
+        if not self.isUser(nick):
+            say("Unknown nick (%s)" % nick, self.buffer)
+            self.irc.clear()
+            return
+
+        hostmask = self.getHostmask(nick)
+        # we already checked that nick is valid, so hostmask shouldn't be None
+        banmask = self.make_banmask(hostmask)
+        self.ban(banmask)
+        if self.inChannel(nick):
+            self.irc.Kick(nick, reason, wait=1)
+
+class MultiBanKick(BanKick):
+    description = "Bankicks one or more nicks."
+    usage = \
+    "<nick> [<nick> ... ] [:] [<reason>] [ [--host)] [--user] [--nick] | --exact ]"
+    completion = '%(chanop_nicks)|%*'
+
+    def execute_op(self):
+        args = self.args.split()
+        nicks = []
+        while(args):
+            nick = args[0]
+            if nick[0] == ':' or not self.isUser(nick):
+                break
+            nicks.append(args.pop(0))
+        reason = ' '.join(args).lstrip(':')
+        if not nicks:
+            say("Unknown nick (%s)" % nick, self.buffer)
+            self.irc.clear()
+            return
+
+        for nick in nicks:
+            hostmask = self.getHostmask(nick)
+            banmask = self.make_banmask(hostmask)
+            self.ban(banmask)
+
+        self.deop_delay = 1
+        for nick in nicks:
+            if self.inChannel(nick):
+                self.deop_delay += 1
+                self.irc.Kick(nick, reason, wait=1)
+
+class Topic(CommandWithOp):
+    description, usage = "Changes channel topic.", "[-delete | topic]"
+    help = "Clear topic if '-delete' is the new topic."
+    command = 'otopic'
+    completion = '%(irc_channel_topic)||-delete'
+
+    def execute_op(self):
+        self.irc.queue(Message('/topic %s' %self.args))
+
+class Voice(CommandWithOp):
+    description, usage, help = "Gives voice to somebody.", "nick [nick ... ]", ""
+    command = 'ovoice'
+    completion = '%(nicks)|%*'
+
+    prefix = '+'
+    mode = 'v'
+
+    def execute_op(self):
+        for nick in self.args.split():
+            if self.inChannel(nick) and not self.has_voice(nick):
+                self.set_mode(nick)
+
+class DeVoice(Voice):
+    description = "Removes voice from somebody."
+    command = 'odevoice'
+
+    prefix = '-'
+
+    def has_voice(self, nick):
+        return not Voice.has_voice(self, nick)
+
+class Mode(CommandWithOp):
+    description, usage, help = "Changes channel modes.", "<channel modes>", ""
+    command = 'omode'
+
+    def execute_op(self):
+        args = self.args.split()
+        modes = args.pop(0)
+        L = []
+        p = ''
+        for c in modes:
+            if c in '+-':
+                p = c
+            elif args:
+                L.append((p + c, args.pop(0)))
+            else:
+                L.append((p + c, None))
+        if not L:
+            return
+
+        for mode, arg in L:
+            self.irc.Mode(mode, arg)
+
+class ShowBans(CommandChanop):
+    description, usage, help = "Lists bans or quiets of a channel.", "(bans|quiets) [channel]", ""
+    command = 'olist'
+    completion = 'bans|quiets %(irc_server_channels)'
+    showbuffer = ''
+
+    padding = 40
+
+    def parser(self, args):
+        server = weechat.buffer_get_string(self.buffer, 'localvar_server')
+        channel = weechat.buffer_get_string(self.buffer, 'localvar_channel')
+        if server:
+            self.server = server
+        if channel:
+            self.channel = channel
+        type, _, args = args.partition(' ')
+        if not type:
+            raise ValueError('missing argument')
+        try:
+            mode = modeCache.map[type]
+        except KeyError:
+            raise ValueError('incorrect argument')
+
+        self.mode = mode
+        # fix self.type so is "readable" (ie, 'bans' instead of 'b')
+        if mode == 'b':
+            self.type = 'bans'
+        elif mode == 'q':
+            self.type = 'quiets'
+        args = args.strip()
+        if args:
+            self.channel = args
+
+    def get_buffer(self):
+        if self.showbuffer:
+            return self.showbuffer
+
+        buffer = weechat.buffer_search('python', SCRIPT_NAME)
+        if not buffer:
+            buffer = weechat.buffer_new(SCRIPT_NAME, '', '', '', '')
+            weechat.buffer_set(buffer, 'localvar_set_no_log', '1')
+            weechat.buffer_set(buffer, 'time_for_each_line', '0')
+        self.showbuffer = buffer
+        return buffer
+
+    def prnt(self, s):
+        weechat.prnt(self.get_buffer(), s)
+
+    def prnt_ban(self, banmask, op, when, hostmask=None):
+        padding = self.padding - len(banmask)
+        if padding < 0:
+            padding = 0
+        self.prnt('%s%s%s %sset by %s%s%s %s' %(color_mask,
+                                                banmask,
+                                                color_reset,
+                                                '.'*padding,
+                                                color_chat_nick,
+                                                op,
+                                                color_reset,
+                                                self.formatTime(when)))
+        if hostmask:
+            hostmasks = ' '.join(hostmask)
+            self.prnt('  %s%s' % (color_chat_host, hostmasks))
+
+    def clear(self):
+        b = self.get_buffer()
+        weechat.buffer_clear(b)
+        weechat.buffer_set(b, 'display', '1')
+        weechat.buffer_set(b, 'title', '%s' %SCRIPT_NAME)
+
+    def set_title(self, s):
+        weechat.buffer_set(self.get_buffer(), 'title', s)
+
+    def formatTime(self, t):
+        t = now() - int(t)
+        elapsed = time_elapsed(t, level=3)
+        return '%s ago' %elapsed
+
+    def execute(self):
+        self.showbuffer = ''
+        if self.mode not in supported_modes(self.server):
+            self.clear()
+            self.prnt("\n%sNetwork '%s' doesn't support %s" % (color_channel,
+                                                               self.server,
+                                                               self.type))
+            return
+
+        maskCache = modeCache[self.mode]
+        key = (self.server, self.channel)
+        try:
+            masklist = maskCache[key]
+        except KeyError:
+            if not (weechat.info_get('irc_is_channel', key[1]) and self.server):
+                error("Command /%s must be used in an IRC buffer." % self.command)
+                return
+
+            masklist = None
+        self.clear()
+        mask_count = 0
+        if masklist:
+            mask_count = len(masklist)
+            self.prnt('\n%s[%s %s]' %(color_channel, key[0], key[1]))
+            masks = [ m for m in masklist.values() ]
+            masks.sort(key=lambda x: x.date)
+            for ban in masks:
+                op = self.server
+                if ban.operator:
+                    try:
+                        op = get_nick(ban.operator)
+                    except:
+                        pass
+                self.prnt_ban(ban.mask, op, ban.date, ban.hostmask)
+        else:
+            self.prnt('No known %s for %s.%s' %(self.type, key[0], key[1]))
+        if masklist is None or not masklist.synced:
+            self.prnt("\n%sList not synced, please wait ..." %color_channel)
+            maskSync.fetch(key[0], key[1], self.mode, lambda: self.execute())
+        self.set_title('List of %s known by chanop in %s.%s (total: %s)' %(self.type,
+                                                                           key[0],
+                                                                           key[1],
+                                                                           mask_count))
+
+# -----------------------------------------------------------------------------
+# Script callbacks
+
+# Decorators
+def signal_parse(f):
+    @catchExceptions
+    def decorator(data, signal, signal_data):
+        server = signal[:signal.find(',')]
+        channel = signal_data.split()[2]
+        if channel[0] == ':':
+            channel = channel[1:]
+        if (server, channel) not in chanopChannels:
+            # signals only processed for channels in watchlist
+            return WEECHAT_RC_OK
+        nick = get_nick(signal_data)
+        hostmask = signal_data[1:signal_data.find(' ')]
+        #debug('%s %s', signal, signal_data)
+        return f(server, channel, nick, hostmask, signal_data)
+    decorator.func_name = f.func_name
+    return decorator
+
+def signal_parse_no_channel(f):
+    @catchExceptions
+    def decorator(data, signal, signal_data):
+        server = signal[:signal.find(',')]
+        nick = get_nick(signal_data)
+        channels = userCache.getChannels(server, nick)
+        if channels:
+            hostmask = signal_data[1:signal_data.find(' ')]
+            #debug('%s %s', signal, signal_data)
+            return f(server, channels, nick, hostmask, signal_data)
+        return WEECHAT_RC_OK
+    decorator.func_name = f.func_name
+    return decorator
+
+isupport = {}
+def get_isupport_value(server, feature):
+    #debug('isupport %s %s', server, feature)
+    try:
+        return isupport[server][feature]
+    except KeyError:
+        if not server:
+            return ''
+        elif server not in isupport:
+            isupport[server] = {}
+        v = weechat.info_get('irc_server_isupport_value', '%s,%s' %(server, feature.upper()))
+        if v:
+            isupport[server][feature] = v
+        else:
+            # old api
+            v = weechat.config_get_plugin('isupport.%s.%s' %(server, feature))
+            if not v:
+                # lets do a /VERSION (it should be done only once.)
+                if '/VERSION' in isupport[server]:
+                    return ''
+                buffer = weechat.buffer_search('irc', 'server.%s' %server)
+                weechat_command(buffer, '/VERSION')
+                isupport[server]['/VERSION'] = True
+        return v
+
+_supported_modes = set('bq') # the script only support b,q masks
+def supported_modes(server):
+    """Returns modes supported by server."""
+    modes = get_isupport_value(server, 'chanmodes')
+    if not modes:
+        return 'b'
+    modes = modes.partition(',')[0] # we only care about the first type
+    modes = ''.join(_supported_modes.intersection(modes))
+    return modes
+
+def supported_maxmodes(server):
+    """Returns max modes number supported by server."""
+    max = get_isupport_value(server, 'modes')
+    try:
+        max = int(max)
+        if max <= 0:
+            max = 1
+    except ValueError:
+        return 1
+    return max
+
+def isupport_cb(data, signal, signal_data):
+    """Callback used for catch isupport msg if current version of WeeChat doesn't
+    support it."""
+    data = signal_data.split(' ', 3)[-1]
+    data, s, s = data.rpartition(' :')
+    data = data.split()
+    server = signal.partition(',')[0]
+    d = {}
+    #debug(data)
+    for s in data:
+        if '=' in s:
+            k, v = s.split('=')
+        else:
+            k, v = s, True
+        k = k.lower()
+        if k in ('chanmodes', 'modes', 'prefix'):
+            config = 'isupport.%s.%s' %(server, k)
+            weechat.config_set_plugin(config, v)
+            d[k] = v
+    isupport[server] = d
+    return WEECHAT_RC_OK
+
+def print_affected_users(buffer, *hostmasks):
+    """Print a list of users, max 8 hostmasks"""
+    def format_user(hostmask):
+        nick, host = hostmask.split('!', 1)
+        return '%s%s%s(%s%s%s)' %(color_chat_nick,
+                                  nick,
+                                  color_delimiter,
+                                  color_chat_host,
+                                  host,
+                                  color_delimiter)
+
+    max = 8
+    count = len(hostmasks)
+    if count > max:
+        hostmasks = hostmasks[:max]
+    say('Affects (%s): %s%s' %(count, ' '.join(map(format_user,
+        hostmasks)), count > max and ' %s...' %color_reset or ''), buffer=buffer)
+
+# Masks list tracking
+@signal_parse
+def mode_cb(server, channel, nick, opHostmask, signal_data):
+    """Keep the banmask list updated when somebody changes modes"""
+    #:m4v!~znc@unaffiliated/m4v MODE #test -bo+v asd!*@* m4v dude
+    pair = signal_data.split(' ', 4)[3:]
+    if len(pair) != 2:
+        # modes without argument, not interesting.
+        return WEECHAT_RC_OK
+    modes, args = pair
+
+    # check if there are interesting modes
+    servermodes = supported_modes(server)
+    s = modes.translate(chars, '+-') # remove + and -
+    if not set(servermodes).intersection(s):
+        return WEECHAT_RC_OK
+
+    # check if channel is in watchlist
+    key = (server, channel)
+    allkeys = CaseInsensibleSet()
+    for maskCache in modeCache.values():
+        allkeys.update(maskCache)
+        if key not in allkeys and key not in chanopChannels:
+            # from a channel we're not tracking
+            return WEECHAT_RC_OK
+
+    prefix = get_isupport_value(server, 'prefix')
+    chanmodes = get_isupport_value(server, 'chanmodes')
+    if not prefix or not chanmodes:
+        # we don't have ISUPPORT data, can't continue
+        return WEECHAT_RC_OK
+
+    # split chanmodes into tuples like ('+', 'b', 'asd!*@*')
+    action = ''
+    chanmode_list = []
+    args = args.split()
+
+    # user channel mode, such as +v or +o, get only the letters and not the prefixes
+    usermodes = ''.join(map(lambda c: c.isalpha() and c or '', prefix))
+    chanmodes = chanmodes.split(',')
+    # modes not supported by script, like +e +I
+    notsupported = chanmodes[0].translate(chars, servermodes)
+    modes_with_args = chanmodes[1] + usermodes + notsupported
+    modes_with_args_when_set = chanmodes[2]
+    for c in modes:
+        if c in '+-':
+            action = c
+        elif c in servermodes:
+            chanmode_list.append((action, c, args.pop(0)))
+        elif c in modes_with_args:
+            del args[0]
+        elif c in modes_with_args_when_set and action == '+':
+            del args[0]
+
+    affected_users = []
+    # update masks
+    for action, mode, mask in chanmode_list:
+        debug('MODE: %s%s %s %s', action, mode, mask, opHostmask)
+        if action == '+':
+            hostmask = hostmask_match_list(mask, userCache[key].hostmasks())
+            if hostmask:
+                affected_users.extend(hostmask)
+            if mask != '*!*@*':
+                # sending this signal with a *!*@* is annoying
+                weechat.hook_signal_send("%s,chanop_mode_%s" % (server, mode),
+                                         weechat.WEECHAT_HOOK_SIGNAL_STRING,
+                                         "%s %s %s %s" % (opHostmask, channel,
+                                                          mask, ','.join(hostmask)))
+            modeCache.add(server, channel, mode, mask, operator=opHostmask, hostmask=hostmask)
+        elif action == '-':
+            modeCache.remove(server, channel, mode, mask)
+
+    if affected_users and get_config_boolean('display_affected',
+            get_function=get_config_specific, server=server, channel=channel):
+        buffer = weechat.buffer_search('irc', '%s.%s' %key)
+        print_affected_users(buffer, *set(affected_users))
+    return WEECHAT_RC_OK
+
+# User cache
+@signal_parse
+def join_cb(server, channel, nick, hostmask, signal_data):
+    if weechat.info_get('irc_nick', server) == nick:
+        # we're joining the channel, the cache is no longer valid
+        #userCache.generateCache(server, channel)
+        try:
+            del userCache[server, channel]
+        except KeyError:
+            pass
+        return WEECHAT_RC_OK
+    user = userCache.remember(server, nick, hostmask)
+    userCache[server, channel][nick] = user
+    return WEECHAT_RC_OK
+
+@signal_parse
+def part_cb(server, channel, nick, hostmask, signal_data):
+    userCache.remember(server, nick, hostmask)
+    userCache[server, channel].part(nick)
+    return WEECHAT_RC_OK
+
+@signal_parse_no_channel
+def quit_cb(server, channels, nick, hostmask, signal_data):
+    userCache.remember(server, nick, hostmask)
+    for channel in channels:
+        userCache[server, channel].part(nick)
+    return WEECHAT_RC_OK
+
+@signal_parse_no_channel
+def nick_cb(server, channels, oldNick, oldHostmask, signal_data):
+    newNick = signal_data[signal_data.rfind(' ') + 2:]
+    newHostmask = '%s!%s' % (newNick, oldHostmask[oldHostmask.find('!') + 1:])
+    userCache.remember(server, oldNick, oldHostmask)
+    user = userCache.remember(server, newNick, newHostmask)
+    for channel in channels:
+        userCache[server, channel].part(oldNick)
+        userCache[server, channel][newNick] = user
+    return WEECHAT_RC_OK
+
+# Garbage collector
+def garbage_collector_cb(data, counter):
+    """This takes care of purging users and masks from channels not in watchlist, and
+    expired users that parted.
+    """
+    debug('* flushing caches')
+    modeCache.purge()
+    userCache.purge()
+
+    if weechat.config_get_plugin('debug'):
+        # extra check that everything is right.
+        for serv, chan in userCache:
+            for nick in [ nick['name'] for nick in nick_infolist(serv, chan) ]:
+                if nick not in userCache[serv, chan]:
+                    error('User cache out of sync, unknown nick. (%s - %s.%s)' % (nick, serv, chan))
+
+    return WEECHAT_RC_OK
+
+# -----------------------------------------------------------------------------
+# Config callbacks
+
+def enable_multi_kick_conf_cb(data, config, value):
+    global cmd_kick, cmd_bankick
+    cmd_kick.unhook()
+    cmd_bankick.unhook()
+    if boolDict[value]:
+        cmd_kick = MultiKick()
+        cmd_bankick = MultiBanKick()
+    else:
+        cmd_kick = Kick()
+        cmd_bankick = BanKick()
+    cmd_kick.hook()
+    cmd_bankick.hook()
+    return WEECHAT_RC_OK
+
+def update_chanop_watchlist_cb(data, config, value):
+    #debug('CONFIG: %s' %(' '.join((data, config, value))))
+    server = config[config.rfind('.')+1:]
+    if value:
+        L = value.split(',')
+    else:
+        L = []
+    for serv, chan in list(chanopChannels):
+        if serv == server:
+            chanopChannels.remove((serv, chan))
+    chanopChannels.update([ (server, channel) for channel in L ])
+    return WEECHAT_RC_OK
+
+def enable_bar_cb(data, config, value):
+    if boolDict[value]:
+        chanop_bar.new()
+        weechat.bar_item_new('chanop_ban_matches', 'item_ban_matches_cb', '')
+        weechat.bar_item_new('chanop_status', 'item_status_cb', '')
+        weechat.hook_modifier('input_text_content', 'input_content_cb', '')
+    else:
+        chanop_bar.remove()
+    return WEECHAT_RC_OK
+
+def enable_debug_cb(data, config, value):
+    global debug
+    if value and boolDict[value]:
+        try:
+            # custom debug module I use, allows me to inspect script's objects.
+            import pybuffer
+            debug = pybuffer.debugBuffer(globals(), '%s_debug' % SCRIPT_NAME)
+            weechat.buffer_set(debug._getBuffer(), 'localvar_set_no_log', '0')
+        except:
+            def debug(s, *args):
+                if not isinstance(s, str):
+                    s = str(s)
+                if args:
+                    s = s % args
+                prnt('', '%s\t%s' % (script_nick, s))
+    else:
+        try:
+            if hasattr(debug, 'close'):
+                debug.close()
+        except NameError:
+            pass
+
+        debug = _no_debug
+
+    return WEECHAT_RC_OK
+
+# -----------------------------------------------------------------------------
+# Completers
+
+def cmpl_get_irc_users(f):
+    """Check if completion is done in a irc channel, and pass the buffer's user list."""
+    @catchExceptions
+    def decorator(data, completion_item, buffer, completion):
+        key = irc_buffer(buffer)
+        if not key:
+            return WEECHAT_RC_OK
+        users = userCache[key]
+        return f(users, data, completion_item, buffer, completion)
+    return decorator
+
+def unban_mask_cmpl(mode, completion_item, buffer, completion):
+    """Completion for applied banmasks, for commands like /ounban /ounquiet"""
+    maskCache = modeCache[mode]
+    key = irc_buffer(buffer)
+    if not key:
+        return WEECHAT_RC_OK
+    server, channel = key
+
+    def cmpl_unban(masklist):
+        input = weechat.buffer_get_string(buffer, 'input')
+        if input[-1] != ' ':
+            input, _, pattern = input.rpartition(' ')
+        else:
+            pattern = ''
+        #debug('%s %s', repr(input), repr(pattern))
+        if pattern and not is_nick(pattern): # FIXME nick completer interferes.
+                                             # NOTE masklist no longer accepts nicks.
+            L = masklist.search(pattern)
+            #debug('unban pattern %s => %s', pattern, L)
+            if L:
+                input = '%s %s ' % (input, ' '.join(L))
+                weechat.buffer_set(buffer, 'input', input)
+                weechat.buffer_set(buffer, 'input_pos', str(len(input)))
+                return
+        elif not masklist:
+            return
+        for mask in masklist.keys():
+            #debug('unban mask: %s', mask)
+            weechat.hook_completion_list_add(completion, mask, 0, weechat.WEECHAT_LIST_POS_END)
+
+    if key not in maskCache or not maskCache[key].synced:
+        # do completion after fetching marks
+        if not maskSync.queue:
+            def callback():
+                masklist = maskCache[key]
+                if chanop_bar:
+                    global chanop_bar_status
+                    if masklist:
+                        chanop_bar_status = 'Got %s +%s masks.' % (len(masklist), mode)
+                    else:
+                        chanop_bar_status = 'No +%s masks found.' % mode
+                    chanop_bar.popup()
+                    weechat.bar_item_update('chanop_status')
+                else:
+                    if masklist:
+                        say('Got %s +%s masks.' % (len(masklist), mode), buffer)
+                    else:
+                       say('No +%s masks found.' % mode, buffer)
+                cmpl_unban(masklist)
+
+            maskSync.fetch(server, channel, mode, callback)
+            if chanop_bar:
+                global chanop_bar_status
+                chanop_bar_status = 'Fetching +%s masks in %s, please wait...' %(mode, channel)
+                weechat.bar_item_update('chanop_status')
+                chanop_bar.popup()
+            else:
+                say('Fetching +%s masks in %s, please wait...' %(mode, channel), buffer)
+    else:
+        # mask list is up to date, do completion
+        cmpl_unban(maskCache[key])
+    return WEECHAT_RC_OK
+
+banmask_cmpl_list = []
+@cmpl_get_irc_users
+def ban_mask_cmpl(users, data, completion_item, buffer, completion):
+    """Completion for banmasks, for commands like /oban /oquiet"""
+    input = weechat.buffer_get_string(buffer, 'input')
+    if input[-1] == ' ':
+        # no pattern, return
+        return WEECHAT_RC_OK
+
+    input, _, pattern = input.rpartition(' ')
+
+    global banmask_cmpl_list
+    if is_hostmask(pattern):
+        if not banmask_cmpl_list:
+            maskList = pattern_match_list(pattern, users.hostmasks(sorted=True, all=True))
+            if maskList:
+                banmask_cmpl_list = [ pattern ]
+
+            def add(mask):
+                if mask not in banmask_cmpl_list:
+                    banmask_cmpl_list.append(mask)
+
+            for mask in maskList:
+                #debug('ban_mask_cmpl: Generating variations for %s', mask)
+                host = get_host(mask)
+                add('*!*@%s' % host)
+                add('%s!*@%s' % (get_nick(mask), host))
+                if host.startswith('gateway/web/freenode'):
+                    ip = host.partition('.')[2]
+                    if is_ip(ip):
+                        add('*!*@*%s' % ip)
+                elif is_ip(host):
+                    user = get_user(mask)
+                    iprange = host.rsplit('.', 2)[0]
+                    add('*!%s@%s.*' % (user, iprange))
+                    add('*!*@%s.*' % iprange)
+            #debug('ban_mask_cmpl: variations: %s', banmask_cmpl_list)
+
+        if pattern in banmask_cmpl_list:
+            i = banmask_cmpl_list.index(pattern) + 1
+            if i == len(banmask_cmpl_list):
+                i = 0
+            mask = banmask_cmpl_list[i]
+            input = '%s %s' % (input, mask)
+            weechat.buffer_set(buffer, 'input', input)
+            weechat.buffer_set(buffer, 'input_pos', str(len(input)))
+            return WEECHAT_RC_OK
+
+    banmask_cmpl_list = []
+
+    if pattern[-1] != '*':
+        search_pattern = pattern + '*'
+    else:
+        search_pattern = pattern
+
+    if '@' in pattern:
+        # complete *!*@hostname
+        prefix = pattern[:pattern.find('@')]
+        make_mask = lambda mask: '%s@%s' %(prefix, mask[mask.find('@') + 1:])
+        get_list = users.hostmasks
+    elif '!' in pattern:
+        # complete *!username@*
+        prefix = pattern[:pattern.find('!')]
+        make_mask = lambda mask: '%s!%s@*' %(prefix, mask[mask.find('!') + 1:mask.find('@')])
+        get_list = users.hostmasks
+    else:
+        # complete nick!*@*
+        make_mask = lambda mask: '%s!*@*' %mask
+        get_list = users.nicks
+
+    for mask in pattern_match_list(search_pattern, get_list(sorted=True, all=True)):
+        mask = make_mask(mask)
+        weechat.hook_completion_list_add(completion, mask, 0, weechat.WEECHAT_LIST_POS_END)
+    return WEECHAT_RC_OK
+
+# Completions for nick, user and host parts of a usermask
+@cmpl_get_irc_users
+def nicks_cmpl(users, data, completion_item, buffer, completion):
+    for nick in users.nicks():
+        weechat.hook_completion_list_add(completion, nick, 0, weechat.WEECHAT_LIST_POS_END)
+    return WEECHAT_RC_OK
+
+@cmpl_get_irc_users
+def hosts_cmpl(users, data, completion_item, buffer, completion):
+    for hostmask in users.hostmasks(sorted=True, all=True):
+        weechat.hook_completion_list_add(completion, get_host(hostmask), 0,
+                weechat.WEECHAT_LIST_POS_SORT)
+    return WEECHAT_RC_OK
+
+@cmpl_get_irc_users
+def users_cmpl(users, data, completion_item, buffer, completion):
+    for hostmask in users.hostmasks(sorted=True, all=True):
+        user = get_user(hostmask)
+        weechat.hook_completion_list_add(completion, user, 0, weechat.WEECHAT_LIST_POS_END)
+    return WEECHAT_RC_OK
+
+# info hooks
+def info_hostmask_from_nick(data, info_name, arguments):
+    #debug('INFO: %s %s', info_name, arguments)
+    args = arguments.split(',')
+    channel = None
+    try:
+        nick, server, channel = args
+    except ValueError:
+        try:
+            nick, server = args
+        except ValueError:
+            return ''
+    try:
+        hostmask = userCache.getHostmask(nick, server, channel)
+    except KeyError:
+        return ''
+    return hostmask
+
+def info_pattern_match(data, info_name, arguments):
+    #debug('INFO: %s %s', info_name, arguments)
+    pattern, string = arguments.split(',')
+    if pattern_match(pattern, string):
+        return '1'
+    return ''
+
+# -----------------------------------------------------------------------------
+# Chanop bar callbacks
+
+chanop_bar_current_buffer = ''
+
+@catchExceptions
+def item_ban_matches_cb(data, item, window):
+    #debug('ban matches item: %s %s', item, window)
+    global chanop_bar_current_buffer
+    buffer = chanop_bar_current_buffer
+    if not buffer:
+        return ''
+
+    input = weechat.buffer_get_string(buffer, 'input')
+    if not input:
+        return ''
+
+    command, _, content = input.partition(' ')
+
+    if command[1:] not in ('oban', 'oquiet'):
+        return ''
+
+    def format(s):
+        return '%s affects: %s' % (command, s)
+
+    channel = weechat.buffer_get_string(buffer, 'localvar_channel')
+    if not channel or not is_channel(channel):
+        return format('(not an IRC channel)')
+
+    server = weechat.buffer_get_string(buffer, 'localvar_server')
+    users = userCache[server, channel]
+    content = content.split()
+    masks = [ mask for mask in content if is_hostmask(mask) or is_nick(mask) ]
+    if not masks:
+        return format('(no valid user mask or nick)')
+
+    #debug('ban matches item: %s', masks)
+
+    affected = []
+    hostmasks = users.hostmasks(all=True)
+    for mask in masks:
+        if is_hostmask(mask):
+            affected.extend(hostmask_match_list(mask, hostmasks))
+        elif mask in users:
+            affected.append(mask)
+    #debug('ban matches item: %s', affected)
+
+    if not affected:
+        return format('(nobody)')
+
+    L = set([ get_nick(h) for h in affected ])
+    return format('(%s) %s' % (len(L), ' '.join(L)))
+
+chanop_bar_status = ''
+def item_status_cb(data, item, window):
+    global chanop_bar_status
+    if chanop_bar_status:
+        return "%s[%s%s%s]%s %s" % (COLOR_BAR_DELIM,
+                                    COLOR_BAR_FG,
+                                    SCRIPT_NAME,
+                                    COLOR_BAR_DELIM,
+                                    color_reset,
+                                    chanop_bar_status)
+    else:
+        return "%s[%s%s%s]" % (COLOR_BAR_DELIM,
+                               COLOR_BAR_FG,
+                               SCRIPT_NAME,
+                               COLOR_BAR_DELIM)
+
+@catchExceptions
+def input_content_cb(data, modifier, modifier_data, string):
+    #debug('input_content_cb: %s %s %r', modifier, modifier_data, string)
+    global chanop_bar_current_buffer, chanop_bar_status
+    if not chanop_bar:
+        return string
+
+    if string and not weechat.string_input_for_buffer(string):
+        command, _, content = string.partition(' ')
+        content = content.strip()
+        if content and command[1:] in ('oban', 'oquiet'):
+            chanop_bar.show()
+            chanop_bar_current_buffer = modifier_data
+            weechat.bar_item_update('chanop_ban_matches')
+            if chanop_bar_status:
+                chanop_bar_status = ''
+                weechat.bar_item_update('chanop_bar_status')
+            return string
+
+    if not chanop_bar._timer_hook:
+        chanop_bar.hide()
+    return string
+
+# -----------------------------------------------------------------------------
+# Main
+
+def unload_chanop():
+    if chanop_bar:
+        # we don't remove it, so custom options configs aren't lost
+        chanop_bar.hide()
+    bar_item = weechat.bar_item_search('chanop_ban_matches')
+    if bar_item:
+        weechat.bar_item_remove(bar_item)
+    return WEECHAT_RC_OK
+
+# Register script
+if __name__ == '__main__' and import_ok and \
+        weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE,
+        SCRIPT_DESC, 'unload_chanop', ''):
+
+    # colors
+    color_delimiter = weechat.color('chat_delimiters')
+    color_chat_nick = weechat.color('chat_nick')
+    color_chat_host = weechat.color('chat_host')
+    color_mask      = weechat.color('white')
+    color_channel   = weechat.color('lightred')
+    color_reset     = weechat.color('reset')
+    COLOR_WHITE     = weechat.color('white')
+    COLOR_DARKGRAY  = weechat.color('darkgray')
+    COLOR_BAR_DELIM = weechat.color('bar_delim')
+    COLOR_BAR_FG    = weechat.color('bar_fg')
+
+    # pretty [chanop]
+    script_nick = '%s[%s%s%s]%s' %(color_delimiter,
+                                   color_chat_nick,
+                                   SCRIPT_NAME,
+                                   color_delimiter,
+                                   color_reset)
+
+    # -------------------------------------------------------------------------
+    # Debug
+
+    enable_debug_cb('', '', weechat.config_get_plugin('debug'))
+    weechat.hook_config('plugins.var.python.%s.debug' % SCRIPT_NAME, 'enable_debug_cb', '')
+
+    # -------------------------------------------------------------------------
+    # Init
+
+    # check weechat version
+    try:
+        version = int(weechat.info_get('version_number', ''))
+    except:
+        version = 0
+    if version < WEECHAT_VERSION[0]:
+        error("This version of WeeChat isn't supported. Use %s or later." % WEECHAT_VERSION[1])
+        raise Exception('unsupported weechat version')
+    if version < 0x30300: # prior to 0.3.3 didn't have support for ISUPPORT msg
+        error('WeeChat < 0.3.3: using ISUPPORT workaround.')
+        weechat.hook_signal('*,irc_in_005', 'isupport_cb', '')
+    if version < 0x30400: # irc_nick flags changed in 0.3.4
+        error('WeeChat < 0.3.4: using irc_nick infolist workaround.')
+        Infolist._use_flags = True
+
+    for opt, val in settings.items():
+        if not weechat.config_is_set_plugin(opt):
+            weechat.config_set_plugin(opt, val)
+
+    modeCache = ModeCache('chanop_mode_cache.dat')
+    modeCache.registerMode('b', 'ban', 'bans')
+    modeCache.registerMode('q', 'quiet', 'quiets')
+
+    # -------------------------------------------------------------------------
+    # remove old chanmask config and save them in shelf
+
+    prefix = 'python.%s.chanmask' % SCRIPT_NAME
+    infolist = Infolist('option', 'plugins.var.%s.*' % prefix)
+    n = len(prefix)
+    while infolist.next():
+        option = infolist['option_name'][n + 1:]
+        server, channel, mode, mask = option.split('.', 3)
+        if mode in modeCache:
+            cache = modeCache[mode]
+            if (server, channel) in cache:
+                masklist = cache[server, channel]
+            else:
+                masklist = cache[server, channel] = MaskList(server, channel)
+        if mask in masklist:
+            masklist[mask].deserialize(infolist['value'])
+        else:
+            obj = masklist[mask] = MaskObject(mask)
+            obj.deserialize(infolist['value'])
+        weechat.config_unset_plugin('chanmask.%s.%s.%s.%s' \
+                % (server, channel, mode, mask))
+    del infolist
+
+    # hook /oop /odeop
+    Op().hook()
+    Deop().hook()
+    # hook /okick /obankick
+    if get_config_boolean('enable_multi_kick'):
+        cmd_kick = MultiKick()
+        cmd_bankick = MultiBanKick()
+    else:
+        cmd_kick = Kick()
+        cmd_bankick = BanKick()
+    cmd_kick.hook()
+    cmd_bankick.hook()
+    # hook /oban /ounban /olist
+    Ban().hook()
+    UnBan().hook()
+    showBans = ShowBans()
+    showBans.hook()
+    # hook /oquiet /ounquiet
+    Quiet().hook()
+    UnQuiet().hook()
+    # hook /otopic /omode /ovoive /odevoice
+    Topic().hook()
+    Mode().hook()
+    Voice().hook()
+    DeVoice().hook()
+
+    maskSync.hook()
+
+    weechat.hook_config('plugins.var.python.%s.enable_multi_kick' % SCRIPT_NAME,
+            'enable_multi_kick_conf_cb', '')
+    weechat.hook_config('plugins.var.python.%s.watchlist.*' % SCRIPT_NAME,
+            'update_chanop_watchlist_cb', '')
+    weechat.hook_config('plugins.var.python.%s.enable_bar' % SCRIPT_NAME,
+            'enable_bar_cb', '')
+
+    weechat.hook_completion('chanop_unban_mask', 'channelmode b masks', 'unban_mask_cmpl', 'b')
+    weechat.hook_completion('chanop_unquiet_mask', 'channelmode q masks', 'unban_mask_cmpl', 'q')
+    weechat.hook_completion('chanop_ban_mask', 'completes partial mask', 'ban_mask_cmpl', '')
+    weechat.hook_completion('chanop_nicks', 'nicks in cache', 'nicks_cmpl', '')
+    weechat.hook_completion('chanop_users', 'usernames in cache', 'users_cmpl', '')
+    weechat.hook_completion('chanop_hosts', 'hostnames in cache', 'hosts_cmpl', '')
+
+    weechat.hook_signal('*,irc_in_join', 'join_cb', '')
+    weechat.hook_signal('*,irc_in_part', 'part_cb', '')
+    weechat.hook_signal('*,irc_in_quit', 'quit_cb', '')
+    weechat.hook_signal('*,irc_in_nick', 'nick_cb', '')
+    weechat.hook_signal('*,irc_in_mode', 'mode_cb', '')
+
+    # run our cleaner function every 30 min.
+    weechat.hook_timer(1000 * 60 * 30, 0, 0, 'garbage_collector_cb', '')
+
+    chanop_bar = PopupBar('chanop_bar', hidden=True,
+            items='chanop_status,chanop_ban_matches')
+    if get_config_boolean('enable_bar'):
+        chanop_bar.new()
+        weechat.bar_item_new('chanop_ban_matches', 'item_ban_matches_cb', '')
+        weechat.bar_item_new('chanop_status', 'item_status_cb', '')
+        weechat.hook_modifier('input_text_content', 'input_content_cb', '')
+    else:
+        chanop_bar.remove()
+
+    weechat.hook_info("chanop_hostmask_from_nick",
+            "Returns nick's hostmask if is known. Returns '' otherwise.",
+            "nick,server[,channel]", "info_hostmask_from_nick", "")
+    weechat.hook_info("chanop_pattern_match",
+            "Test if pattern matches text, is case insensible with IRC case rules.",
+            "pattern,text", "info_pattern_match", "")
+
+
+# vim:set shiftwidth=4 tabstop=4 softtabstop=4 expandtab textwidth=100:
diff --git a/weechat/python/notify.py b/weechat/python/notify.py
new file mode 100644
index 0000000..7c583f4
--- /dev/null
+++ b/weechat/python/notify.py
@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+# Author: lavaramano <lavaramano AT gmail DOT com>
+# Improved by: BaSh - <bash.lnx AT gmail DOT com>
+# Ported to Weechat 0.3.0 by: Sharn - <sharntehnub AT gmail DOT com)
+# This Plugin Calls the libnotify bindings via python when somebody says your nickname, sends you a query, etc.
+# To make it work, you may need to download: python-notify2 (and libnotify - libgtk)
+# Requires Weechat 0.3.0
+# Released under GNU GPL v2
+# 2014-05-10, Sébastien Helleu <flashcode@flashtux.org>
+#     version 0.0.8: change hook_print callback argument type of
+#                    displayed/highlight (WeeChat >= 1.0)
+# 2013-11-17, spline <http://github.com/reticulatingspline>
+#     version 0.0.7: Fix up prnt statement in previous edition.
+#     add in option to not notify on messages starting with prefix like *
+#     this is to stop getting notifications if user is connected via ZNC
+#     where you command ZNC via irc and all its targets start with '*'.
+# 2013-11-16, spline <http://github.com/reticulatingspline>
+#     version 0.0.6: Convert from pynotify to notify2 (pynotify is being retired)
+#     clean up .show() so it's in a try/except block so we don't get errors in console
+#     we also add in an option to disable notifications when away.
+#     improve privmsg highlight so if we /msg someone but not in current buffer, it won't notify.
+# 2010-02-20, Aron Griffis <agriffis@n01se.net>
+#     version 0.0.5: Add nick_separator, don't call show_notification twice on
+#     privmsg, fix spelling s/nofify/notify/, use nick as "summary" for privmsg
+#     notification, fit in 80 columns, tweak vim modeline.
+# 2010-01-24, David Rubin <davidrub+weechat@gmail.com>
+#     version 0.0.4.2 Fixed issue with self notifications when used with out "smart_notification"
+# 2010-01-19, Didier Roche <didrocks@ubuntu.com>
+#     version 0.0.4.1: add private message sender name
+# 2010-01-19, Didier Roche <didrocks@ubuntu.com>
+#     version 0.0.4: add smart notification:
+#     be notified only if you're not in the current channel/pv window (off by default)
+# 2009-06-16, kba <unixprog@gmail.com.org>:
+#     version 0.0.3: added config options for icon and urgency
+# 2009-05-02, FlashCode <flashcode@flashtux.org>:
+#     version 0.0.2.1: sync with last API changes
+
+# script variables
+SCRIPT_NAME = "notify"
+SCRIPT_AUTHOR = "lavaramano"
+SCRIPT_VERSION = "0.0.8"
+SCRIPT_LICENSE = "GPL"
+SCRIPT_DESC = "notify: A real time notification system for weechat"
+
+# make sure we're run under weechat.
+import_ok = True
+try:
+    import weechat
+except ImportError:
+    print "This script must be run under WeeChat."
+    print "Get WeeChat now at: http://www.weechat.org/"
+    import_ok = False
+# make sure we have notify2.
+try:
+    import notify2
+except ImportError, message:
+    print "Missing package(s) for %s: %s" % (SCRIPT_NAME, message)
+    print "You must have notify2 installed."
+    import_ok = False
+
+# script options
+settings = {
+    "show_hilights"             : "on",
+    "show_priv_msg"             : "on",
+    "notify_when_away"          : "off",
+    "nick_separator"            : ": ",
+    "ignore_nicks_startwith"    : "*",
+    "icon"                      : "/usr/share/pixmaps/weechat.xpm",
+    "urgency"                   : "normal",
+    "smart_notification"        : "off"
+}
+
+urgencies = {
+    "low"      : notify2.URGENCY_LOW,
+    "critical" : notify2.URGENCY_CRITICAL,
+    "normal"   : notify2.URGENCY_NORMAL,
+}
+
+# Functions
+def notify_show(data, bufferp, uber_empty, tagsn, isdisplayed, ishilight, prefix, message):
+    """Sends highlighted message to be printed on notification"""
+    # string for show_notification return
+    snreturn = None
+    # smart_notification
+    if (weechat.config_get_plugin('smart_notification') == "on" and bufferp == weechat.current_buffer()):
+        pass
+    # are we away and want highlights? check: w.infolist_integer(infolist, 'is_away')
+    elif (weechat.config_get_plugin('notify_when_away') == "off" and weechat.buffer_get_string(bufferp, 'localvar_away')):
+        pass
+    elif (weechat.buffer_get_string(bufferp, "localvar_type") == "private" and weechat.config_get_plugin('show_priv_msg') == "on"):
+        # should we ignore messages from something like ZNC with * prefix?
+        ignprefix = weechat.config_get_plugin('ignore_nicks_startwith')
+        if ignprefix != '' and prefix.startswith(ignprefix):  # if not empty..
+            pass
+        # if im sending a message to someone, don't pop up a notification.
+        elif weechat.buffer_get_string(bufferp, "localvar_nick") != prefix:
+            snreturn = show_notification(prefix, message)
+    elif (int(ishilight) and weechat.config_get_plugin('show_hilights') == "on"):
+        buffer = (weechat.buffer_get_string(bufferp, "short_name") or weechat.buffer_get_string(bufferp, "name"))
+        snreturn = show_notification(buffer, prefix + weechat.config_get_plugin('nick_separator') + message)
+    # check to see if we had an error showing notification and return to user
+    if snreturn:
+        weechat.prnt(bufferp, snreturn)
+    return weechat.WEECHAT_RC_OK
+
+def show_notification(chan, message):
+    """Our handler to print highlighted messages"""
+
+    notify2.init("weechat")
+    wn = notify2.Notification(chan, message, weechat.config_get_plugin('icon'))
+    wn.set_urgency(urgencies[weechat.config_get_plugin('urgency')] or notify2.URGENCY_NORMAL)
+    # now try to show notification
+    try:
+        wn.show()
+        return None
+    except Exception, e:
+        return "Exception trying to show notification: {0}".format(e)
+
+if __name__ == "__main__":
+    if import_ok and weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, "", ""):
+        # Init everything
+        for option, default_value in settings.items():
+            if weechat.config_get_plugin(option) == "":
+                weechat.config_set_plugin(option, default_value)
+        # Hook privmsg/hilights
+        weechat.hook_print("", "irc_privmsg", "", 1, "notify_show", "")
+        # w.hook_info('%s_buffer' %SCRIPT_NAME, '', '', 'info_hook_cb', '')
+
+# vim:set shiftwidth=4 tabstop=4 softtabstop=4 expandtab textwidth=250:
diff --git a/weechat/python/whois_on_query.py b/weechat/python/whois_on_query.py
new file mode 100644
index 0000000..4721437
--- /dev/null
+++ b/weechat/python/whois_on_query.py
@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009-2012 Sebastien Helleu <flashcode@flashtux.org>
+# Copyright (C) 2011 Elián Hanisch <lambdae2@gmail.com>
+# Copyright (C) 2011 ArZa <arza@arza.us>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+#
+# Send "whois" on nick when receiving (or opening) new IRC query.
+# (this script requires WeeChat 0.3.2 or newer)
+#
+# History:
+#
+# 2012-01-03, Sebastien Helleu <flashcode@flashtux.org>:
+#     version 0.6: make script compatible with Python 3.x
+# 2011-10-17, Sebastien Helleu <flashcode@flashtux.org>:
+#     version 0.5: add option "self_query" to do whois on self query,
+#       add help for options (WeeChat >= 0.3.5)
+# 2011-07-06, ArZa <arza@arza.us>:
+#     version 0.4: fix target buffer for command
+# 2011-05-31, Elián Hanisch <lambdae2@gmail.com>:
+#     version 0.3: depends on WeeChat 0.3.2
+#       use irc_is_nick instead of irc_is_channel.
+#       only /whois when somebody opens a query with you.
+# 2009-05-02, Sebastien Helleu <flashcode@flashtux.org>:
+#     version 0.2: sync with last API changes
+# 2009-02-08, Sebastien Helleu <flashcode@flashtux.org>:
+#     version 0.1: initial release
+#
+
+try:
+    import weechat
+    from weechat import WEECHAT_RC_OK, prnt
+    import_ok = True
+except ImportError:
+    print('This script must be run under WeeChat.')
+    print('Get WeeChat now at: http://www.weechat.org/')
+    import_ok = False
+
+SCRIPT_NAME    = 'whois_on_query'
+SCRIPT_AUTHOR  = 'Sebastien Helleu <flashcode@flashtux.org>'
+SCRIPT_VERSION = '0.6'
+SCRIPT_LICENSE = 'GPL3'
+SCRIPT_DESC    = 'Whois on query'
+
+# script options
+woq_settings_default = {
+    'command'   : ('/whois $nick $nick', 'the command sent to do the whois ($nick is repladed by nick)'),
+    'self_query': ('off', 'if on, send whois for self queries'),
+}
+
+irc_pv_hook = ''
+
+def unhook_irc_pv():
+    """Remove irc_pv hook."""
+    global irc_pv_hook
+    if irc_pv_hook:
+        weechat.unhook(irc_pv_hook)
+    irc_pv_hook = ''
+
+def exec_command(buffer, nick):
+    """Execute the whois command."""
+    command = weechat.config_get_plugin('command').replace('$nick', nick)
+    weechat.command(buffer, command)
+
+def signal_irc_pv_opened(data, signal, signal_data):
+    """Callback for signal 'irc_pv_opened'."""
+    global irc_pv_hook
+    if weechat.buffer_get_string(signal_data, 'plugin') == 'irc':
+        nick = weechat.buffer_get_string(signal_data, 'localvar_channel')
+        if weechat.info_get('irc_is_nick', nick) == '1':
+            unhook_irc_pv()
+            if weechat.config_get_plugin('self_query') == 'on':
+                exec_command(signal_data, nick)
+            else:
+                # query open, wait for a msg to come (query was open by user) or if we send a msg out
+                # (query was open by us)
+                server = weechat.buffer_get_string(signal_data, 'localvar_server')
+                irc_pv_hook = weechat.hook_signal('irc_pv', 'signal_irc_pv',
+                                                  '%s,%s' % (signal_data, nick))
+    return weechat.WEECHAT_RC_OK
+
+def signal_irc_pv(data, signal, signal_data):
+    """Callback for signal 'irc_pv'."""
+    buffer, nick = data.split(',')
+    if signal_data.startswith(':' + nick + '!'):
+        # ok, run command
+        exec_command(buffer, nick)
+    unhook_irc_pv()
+    return weechat.WEECHAT_RC_OK
+
+if __name__ == '__main__' and import_ok:
+    if weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE,
+                        SCRIPT_DESC, '', ''):
+        # set default settings
+        version = weechat.info_get('version_number', '') or 0
+        for option, value in woq_settings_default.items():
+            if not weechat.config_is_set_plugin(option):
+                weechat.config_set_plugin(option, value[0])
+            if int(version) >= 0x00030500:
+                weechat.config_set_desc_plugin(option, '%s (default: "%s")' % (value[1], value[0]))
+
+        # hook signal 'irc_pv_opened'
+        weechat.hook_signal('irc_pv_opened', 'signal_irc_pv_opened', '')