'clear_buffer' : 'off',

'log_filter' : '',

'go_to_buffer' : 'on',

'max_lines' : '4000',

'show_summary' : 'on',

'size_limit' : '2048',

'default_tail_head' : '10',

'timeout_secs' : '300',

"""

def __setitem__(self, key, value):

assert isinstance(value, list)

if key not in self:

dict.__setitem__(self, key, value)

else:

dict.__getitem__(self, key).extend(value)

def get_matches_count(self):

"""Return the sum of total matches stored."""

if dict.__len__(self):

return sum(map(lambda L: L.matches_count, self.itervalues()))

else:

return 0

def __len__(self):

"""Return the sum of total lines stored."""

if dict.__len__(self):

return sum(map(len, self.itervalues()))

else:

return 0

def __str__(self):

"""Returns buffer count or buffer name if there's just one stored."""

n = len(self.keys())

if n == 1:

return self.keys()[0]

elif n > 1:

return '%s logs' %n

else:

return ''

def items(self):

"""Returns a list of items sorted by line count."""

items = dict.items(self)

items.sort(key=lambda i: len(i[1]))

return items

def items_count(self):

"""Returns a list of items sorted by match count."""

items = dict.items(self)

items.sort(key=lambda i: i[1].matches_count)

return items

def strip_separator(self):

for L in self.itervalues():

L.strip_separator()

def get_last_lines(self, n):

total_lines = len(self)

#debug('total: %s n: %s' %(total_lines, n))

if n >= total_lines:

# nothing to do

return

for k, v in reversed(self.items()):

l = len(v)

if n > 0:

if l > n:

del v[:l-n]

v.stripped_lines = l-n

n -= l

else:

del v[:]

"""Class for list of matches, since sometimes I need to add lines that aren't matches, I need an

_sep = '...'

def __init__(self, *args):

list.__init__(self, *args)

self.matches_count = 0

self.stripped_lines = 0

def append(self, item):

"""Append lines, can be a string or a list with strings."""

if isinstance(item, str):

list.append(self, item)

else:

self.extend(item)

def append_separator(self):

"""adds a separator into the list, makes sure it doen't add two together."""

s = self._sep

if (self and self[-1] != s) or not self:

self.append(s)

def onlyUniq(self):

s = set(self)

del self[:]

self.extend(s)

def count_match(self, item=None):

if item is None or isinstance(item, str):

self.matches_count += 1

else:

self.matches_count += len(item)

def strip_separator(self):

"""removes separators if there are first or/and last in the list."""

if self:

s = self._sep

if self[0] == s:

del self[0]

if self[-1] == s:

try:

return os.stat(f).st_size

except OSError:

power = 0

while size > 1024:

power += 1

size /= 1024.0

"""Returns coloured nick, with coloured mode if any."""

if not nick: return ''

wcolor = weechat.color

config_string = lambda s : weechat.config_string(weechat.config_get(s))

config_int = lambda s : weechat.config_integer(weechat.config_get(s))

# prefix and suffix

prefix = config_string('irc.look.nick_prefix')

suffix = config_string('irc.look.nick_suffix')

prefix_c = suffix_c = wcolor(config_string('weechat.color.chat_delimiters'))

if nick[0] == prefix:

nick = nick[1:]

else:

prefix = prefix_c = ''

if nick[-1] == suffix:

nick = nick[:-1]

suffix = wcolor(color_delimiter) + suffix

else:

suffix = suffix_c = ''

# nick mode

modes = '@!+%'

if nick[0] in modes:

mode, nick = nick[0], nick[1:]

mode_color = wcolor(config_string('weechat.color.nicklist_prefix%d' \

%(modes.find(mode) + 1)))

else:

mode = mode_color = ''

# nick color

nick_color = ''

if nick:

nick_color = weechat.info_get('irc_nick_color', nick)

if not nick_color:

# probably we're in WeeChat 0.3.0

#debug('no irc_nick_color')

color_nicks_number = config_int('weechat.look.color_nicks_number')

idx = (sum(map(ord, nick))%color_nicks_number) + 1

nick_color = wcolor(config_string('weechat.color.chat_nick_color%02d' %idx))

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)

value = weechat.config_get_plugin(config)

try:

return int(value)

except ValueError:

if value == '' and allow_empty_string:

return value

default = settings[config]

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

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

filter = weechat.config_get_plugin('log_filter')

if filter:

return filter.split(',')

else:

home = weechat.config_string(weechat.config_get('logger.file.path'))

home = home.replace('%h', weechat.info_get('weechat_dir', ''))

home = path.abspath(path.expanduser(home))

"""Strips home dir from the begging of the log path, this makes them sorter."""

if not dir:

global home_dir

dir = home_dir

l = len(dir)

if s[:l] == dir:

return s[l:]

"""Error msg"""

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

if weechat.config_get_plugin('debug'):

import traceback

if traceback.sys.exc_type:

trace = traceback.format_exc()

"""Returns a list of files in 'dir' and its subdirs."""

global cache_dir

from os import walk

from fnmatch import fnmatch

#debug('dir_list: listing in %s' %dir)

key = (dir, include_dir)

try:

return cache_dir[key]

except KeyError:

pass

filter_list = filter_list or get_config_log_filter()

dir_len = len(dir)

if filter_list:

def filter(file):

file = file[dir_len:] # pattern shouldn't match home dir

for pattern in filter_list:

if fnmatch(file, pattern):

return filter_excludes

return not filter_excludes

else:

filter = lambda f : not filter_excludes

file_list = []

extend = file_list.extend

join = path.join

def walk_path():

for basedir, subdirs, files in walk(dir):

#if include_dir:

# subdirs = map(lambda s : join(s, ''), subdirs)

# files.extend(subdirs)

files_path = map(lambda f : join(basedir, f), files)

files_path = [ file for file in files_path if not filter(file) ]

extend(files_path)

walk_path()

cache_dir[key] = file_list

#debug('dir_list: got %s' %str(file_list))

"""Returns the first log whose path matches 'pattern',

if not pattern: return []

#debug('get_file_by_filename: searching for %s.' %pattern)

# do envvar expandsion and check file

file = path.expanduser(pattern)

file = path.expandvars(file)

if path.isfile(file):

return [file]

# lets see if there's a matching log

global home_dir

file = path.join(home_dir, pattern)

if path.isfile(file):

return [file]

else:

from fnmatch import fnmatch

file = []

file_list = dir_list(home_dir)

n = len(home_dir)

for log in file_list:

basename = log[n:]

if fnmatch(basename, pattern):

file.append(log)

#debug('get_file_by_filename: got %s.' %file)

if not all and file:

file.sort()

return [ file[-1] ]

"""Given buffer pointer, finds log's path or returns None."""

#debug('get_file_by_buffer: searching for %s' %buffer)

infolist = weechat.infolist_get('logger_buffer', '', '')

if not infolist: return

try:

while weechat.infolist_next(infolist):

pointer = weechat.infolist_pointer(infolist, 'buffer')

if pointer == buffer:

file = weechat.infolist_string(infolist, 'log_filename')

if weechat.infolist_integer(infolist, 'log_enabled'):

#debug('get_file_by_buffer: got %s' %file)

return file

#else:

# debug('get_file_by_buffer: got %s but log not enabled' %file)

finally:

#debug('infolist gets freed')

"""Given a buffer name, returns its log path or None. buffer_name should be in 'server.#channel'

#debug('get_file_by_name: searching for %s' %buffer_name)

# common mask options

config_masks = ('logger.mask.irc', 'logger.file.mask')

# since there's no buffer pointer, we try to replace some local vars in mask, like $channel and

# $server, then replace the local vars left with '*', and use it as a mask for get the path with

# get_file_by_pattern

for config in config_masks:

mask = weechat.config_string(weechat.config_get(config))

#debug('get_file_by_name: mask: %s' %mask)

if '$name' in mask:

mask = mask.replace('$name', buffer_name)

elif '$channel' in mask or '$server' in mask:

if '.' in buffer_name and \

'#' not in buffer_name[:buffer_name.find('.')]: # the dot isn't part of the channel name

# ^ I'm asuming channel starts with #, i'm lazy.

server, channel = buffer_name.split('.', 1)

else:

server, channel = '*', buffer_name

if '$channel' in mask:

mask = mask.replace('$channel', channel)

if '$server' in mask:

mask = mask.replace('$server', server)

# change the unreplaced vars by '*'

from string import letters

if '%' in mask:

# vars for time formatting

mask = mask.replace('%', '$')

if '$' in mask:

masks = mask.split('$')

masks = map(lambda s: s.lstrip(letters), masks)

mask = '*'.join(masks)

if mask[0] != '*':

mask = '*' + mask

#debug('get_file_by_name: using mask %s' %mask)

file = get_file_by_pattern(mask)

#debug('get_file_by_name: got file %s' %file)

if file:

return file

"""Given a buffer name returns its buffer pointer or None."""

#debug('get_buffer_by_name: searching for %s' %buffer_name)

pointer = weechat.buffer_search('', buffer_name)

if not pointer:

try:

infolist = weechat.infolist_get('buffer', '', '')

while weechat.infolist_next(infolist):

short_name = weechat.infolist_string(infolist, 'short_name')

name = weechat.infolist_string(infolist, 'name')

if buffer_name in (short_name, name):

#debug('get_buffer_by_name: found %s' %name)

pointer = weechat.buffer_search('', name)

return pointer

finally:

weechat.infolist_free(infolist)

#debug('get_buffer_by_name: got %s' %pointer)

"""Returns list with pointers of all open buffers."""

buffers = []

infolist = weechat.infolist_get('buffer', '', '')

while weechat.infolist_next(infolist):

buffers.append(weechat.infolist_pointer(infolist, 'pointer'))

weechat.infolist_free(infolist)

grep_buffer = weechat.buffer_search('python', SCRIPT_NAME)

if grep_buffer and grep_buffer in buffers:

# remove it from list

del buffers[buffers.index(grep_buffer)]

"""Returns a compiled regexp."""

if pattern in ('.', '.*', '.?', '.+'):

# because I don't need to use a regexp if we're going to match all lines

return None

# matching takes a lot more time if pattern starts or ends with .* and it isn't needed.

if pattern[:2] == '.*':

pattern = pattern[2:]

if pattern[-2:] == '.*':

pattern = pattern[:-2]

try:

if not matchcase:

regexp = re.compile(pattern, re.IGNORECASE)

else:

regexp = re.compile(pattern)

except Exception, e:

raise Exception, 'Bad pattern, %s' %e

"""Checks 's' with a regexp and returns it if is a match."""

if not regexp:

return s

elif exact:

matchlist = regexp.findall(s)

if matchlist:

if isinstance(matchlist[0], tuple):

# join tuples (when there's more than one match group in regexp)

return [ ' '.join(t) for t in matchlist ]

return matchlist

elif hilight:

matchlist = regexp.findall(s)

if matchlist:

if isinstance(matchlist[0], tuple):

# flatten matchlist

matchlist = [ item for L in matchlist for item in L if item ]

matchlist = list(set(matchlist)) # remove duplicates if any

# apply hilight

color_hilight, color_reset = hilight.split(',', 1)

for m in matchlist:

s = s.replace(m, '%s%s%s' % (color_hilight, m, color_reset))

return s

# no need for findall() here

elif regexp.search(s):

"""Return a list of lines that match 'regexp' in 'file', if no regexp returns all lines."""

if count:

tail = head = after_context = before_context = False

hilight = ''

elif exact:

before_context = after_context = False

hilight = ''

elif invert:

hilight = ''

#debug(' '.join(map(str, (file, head, tail, after_context, before_context))))

lines = linesList()

# define these locally as it makes the loop run slightly faster

append = lines.append

count_match = lines.count_match

separator = lines.append_separator

if invert:

def check(s):

if check_string(s, regexp, hilight, exact):

return None

else:

return s

else:

check = lambda s: check_string(s, regexp, hilight, exact)

try:

file_object = open(file, 'r')

except IOError:

# file doesn't exist

return lines

if tail or before_context:

# for these options, I need to seek in the file, but is slower and uses a good deal of

# memory if the log is too big, so we do this *only* for these options.

file_lines = file_object.readlines()

if tail:

# instead of searching in the whole file and later pick the last few lines, we

# reverse the log, search until count reached and reverse it again, that way is a lot

# faster

file_lines.reverse()

# don't invert context switches

before_context, after_context = after_context, before_context

if before_context:

before_context_range = range(1, before_context + 1)

before_context_range.reverse()

limit = tail or head

line_idx = 0

while line_idx < len(file_lines):

line = file_lines[line_idx]

line = check(line)

if line:

if before_context:

separator()

trimmed = False

for id in before_context_range:

try:

context_line = file_lines[line_idx - id]

if check(context_line):

# match in before context, that means we appended these same lines in a

# previous match, so we delete them merging both paragraphs

if not trimmed:

del lines[id - before_context - 1:]

trimmed = True

else:

append(context_line)

except IndexError:

pass

append(line)

count_match(line)

if after_context:

id, offset = 0, 0

while id < after_context + offset:

id += 1

try:

context_line = file_lines[line_idx + id]

_context_line = check(context_line)

if _context_line:

offset = id

context_line = _context_line # so match is hilighted with --hilight

count_match()

append(context_line)

except IndexError:

pass

separator()

line_idx += id

if limit and lines.matches_count >= limit:

break

line_idx += 1

if tail:

lines.reverse()

else:

# do a normal grep

limit = head

for line in file_object:

line = check(line)

if line:

count or append(line)

count_match(line)

if after_context:

id, offset = 0, 0

while id < after_context + offset:

id += 1

try:

context_line = file_object.next()

_context_line = check(context_line)

if _context_line:

offset = id

context_line = _context_line

count_match()

count or append(context_line)

except StopIteration:

pass

separator()

if limit and lines.matches_count >= limit:

break

file_object.close()

invert):

"""Return a list of lines that match 'regexp' in 'buffer', if no regexp returns all lines."""

lines = linesList()

if count:

tail = head = after_context = before_context = False

hilight = ''

elif exact:

before_context = after_context = False

#debug(' '.join(map(str, (tail, head, after_context, before_context, count, exact, hilight))))

# Using /grep in grep's buffer can lead to some funny effects

# We should take measures if that's the case

def make_get_line_funcion():

"""Returns a function for get lines from the infolist, depending if the buffer is grep's or

string_remove_color = weechat.string_remove_color

infolist_string = weechat.infolist_string

grep_buffer = weechat.buffer_search('python', SCRIPT_NAME)

if grep_buffer and buffer == grep_buffer:

def function(infolist):

prefix = infolist_string(infolist, 'prefix')

message = infolist_string(infolist, 'message')

if prefix: # only our messages have prefix, ignore it

return None

return message

else:

infolist_time = weechat.infolist_time

def function(infolist):

prefix = string_remove_color(infolist_string(infolist, 'prefix'), '')

message = string_remove_color(infolist_string(infolist, 'message'), '')

date = infolist_time(infolist, 'date')

# since WeeChat 2.2, infolist_time returns a long integer

# instead of a string

if not isinstance(date, str):

date = time.strftime('%F %T', time.localtime(int(date)))

return '%s\t%s\t%s' %(date, prefix, message)

return function

get_line = make_get_line_funcion()

infolist = weechat.infolist_get('buffer_lines', buffer, '')

if tail:

# like with grep_file() if we need the last few matching lines, we move the cursor to

# the end and search backwards

infolist_next = weechat.infolist_prev

infolist_prev = weechat.infolist_next

else:

infolist_next = weechat.infolist_next

infolist_prev = weechat.infolist_prev

limit = head or tail

# define these locally as it makes the loop run slightly faster

append = lines.append

count_match = lines.count_match

separator = lines.append_separator

if invert:

def check(s):

if check_string(s, regexp, hilight, exact):

return None

else:

return s

else:

check = lambda s: check_string(s, regexp, hilight, exact)

if before_context:

before_context_range = range(1, before_context + 1)

before_context_range.reverse()

while infolist_next(infolist):

line = get_line(infolist)

if line is None: continue

line = check(line)

if line:

if before_context:

separator()

trimmed = False

for id in before_context_range:

if not infolist_prev(infolist):

trimmed = True

for id in before_context_range:

context_line = get_line(infolist)

if check(context_line):

if not trimmed:

del lines[id - before_context - 1:]

trimmed = True

else:

append(context_line)

infolist_next(infolist)

count or append(line)

count_match(line)

if after_context:

id, offset = 0, 0

while id < after_context + offset:

id += 1

if infolist_next(infolist):

context_line = get_line(infolist)

_context_line = check(context_line)

if _context_line:

context_line = _context_line

offset = id

count_match()

append(context_line)

else:

# in the main loop infolist_next will start again an cause an infinite loop

# this will avoid it

infolist_next = lambda x: 0

separator()

if limit and lines.matches_count >= limit:

break

weechat.infolist_free(infolist)

if tail:

lines.reverse()

"""

global pattern, matchcase, number, count, exact, hilight, invert

global tail, head, after_context, before_context

global search_in_files, search_in_buffers, matched_lines, home_dir

global time_start

matched_lines = linesDict()

#debug('buffers:%s \nlogs:%s' %(search_in_buffers, search_in_files))

time_start = now()

# buffers

if search_in_buffers:

regexp = make_regexp(pattern, matchcase)

for buffer in search_in_buffers:

buffer_name = weechat.buffer_get_string(buffer, 'name')

matched_lines[buffer_name] = grep_buffer(buffer, head, tail, after_context,

before_context, count, regexp, hilight, exact, invert)

# logs

if search_in_files:

size_limit = get_config_int('size_limit', allow_empty_string=True)

background = False

if size_limit or size_limit == 0:

size = sum(map(get_size, search_in_files))

if size > size_limit * 1024:

background = True

elif size_limit == '':

background = False

regexp = make_regexp(pattern, matchcase)

global grep_options, log_pairs

grep_options = (head, tail, after_context, before_context,

count, regexp, hilight, exact, invert)

log_pairs = [(strip_home(log), log) for log in search_in_files]

if not background:

# run grep normally

for log_name, log in log_pairs:

matched_lines[log_name] = grep_file(log, *grep_options)

buffer_update()

else:

global hook_file_grep, grep_stdout, grep_stderr, pattern_tmpl

grep_stdout = grep_stderr = ''

hook_file_grep = weechat.hook_process(

'func:grep_process',

get_config_int('timeout_secs') * 1000,

'grep_process_cb',

''

)

if hook_file_grep:

buffer_create("Searching for '%s' in %s worth of data..." % (

pattern_tmpl,

human_readable_size(size)

))

else:

result = {}