'''

if not isinstance(input, str):

if isinstance(input, bytes):

return input.encode('utf-8')

if isinstance(input, unicode):

return input.decode('utf-8')

''' Parse an integer and provide a more human readable error. '''

arg = arg.strip()

try:

return int(arg)

except ValueError:

parsed = json.loads(blob)

if not isinstance(parsed, list):

log('Malformed rules, expected a JSON encoded list of strings, but got a {0}. No rules have been loaded. Please fix the setting manually.'.format(type(parsed)))

return []

for i, entry in enumerate(parsed):

if not isinstance(entry, (str, unicode)):

log('Rule #{0} is not a string but a {1}. No rules have been loaded. Please fix the setting manually.'.format(i, type(entry)))

return []

parsed = json.loads(blob)

if not isinstance(parsed, dict):

log('Malformed helpers, expected a JSON encoded dictionary but got a {0}. No helpers have been loaded. Please fix the setting manually.'.format(type(parsed)))

return {}

for key, value in parsed.items():

if not isinstance(value, (str, unicode)):

log('Helper "{0}" is not a string but a {1}. No helpers have been loaded. Please fix setting manually.'.format(key, type(value)))

return {}

''' The autosort configuration. '''

default_rules = json.dumps([

'${core_first}',

'${info:autosort_order,${info:autosort_escape,${script_or_plugin}},core,*,irc,bitlbee,matrix,slack}',

'${script_or_plugin}',

'${irc_raw_first}',

'${server}',

'${info:autosort_order,${type},server,*,channel,private}',

'${hashless_name}',

'${buffer.full_name}',

])

default_helpers = json.dumps({

'core_first': '${if:${buffer.full_name}!=core.weechat}',

'irc_raw_first': '${if:${buffer.full_name}!=irc.irc_raw}',

'irc_raw_last': '${if:${buffer.full_name}==irc.irc_raw}',

'hashless_name': '${info:autosort_replace,#,,${info:autosort_escape,${buffer.name}}}',

'script_or_plugin': '${if:${script_name}?${script_name}:${plugin}}',

})

default_signal_delay = 5

default_sort_limit = 100

default_signals = 'buffer_opened buffer_merged buffer_unmerged buffer_renamed'

def __init__(self, filename):

''' Initialize the configuration. '''

self.filename = filename

self.config_file = weechat.config_new(self.filename, '', '')

self.sorting_section = None

self.v3_section = None

self.case_sensitive = False

self.rules = []

self.helpers = {}

self.signals = []

self.signal_delay = Config.default_signal_delay,

self.sort_limit = Config.default_sort_limit,

self.sort_on_config = True

self.debug_log = False

self.__case_sensitive = None

self.__rules = None

self.__helpers = None

self.__signals = None

self.__signal_delay = None

self.__sort_limit = None

self.__sort_on_config = None

self.__debug_log = None

if not self.config_file:

log('Failed to initialize configuration file "{0}".'.format(self.filename))

return

self.sorting_section = weechat.config_new_section(self.config_file, 'sorting', False, False, '', '', '', '', '', '', '', '', '', '')

self.v3_section = weechat.config_new_section(self.config_file, 'v3', False, False, '', '', '', '', '', '', '', '', '', '')

if not self.sorting_section:

log('Failed to initialize section "sorting" of configuration file.')

weechat.config_free(self.config_file)

return

self.__case_sensitive = weechat.config_new_option(

self.config_file, self.sorting_section,

'case_sensitive', 'boolean',

'If this option is on, sorting is case sensitive.',

'', 0, 0, 'off', 'off', 0,

'', '', '', '', '', ''

)

weechat.config_new_option(

self.config_file, self.sorting_section,

'rules', 'string',

'Sort rules used by autosort v2.x and below. Not used by autosort anymore.',

'', 0, 0, '', '', 0,

'', '', '', '', '', ''

)

weechat.config_new_option(

self.config_file, self.sorting_section,

'replacements', 'string',

'Replacement patterns used by autosort v2.x and below. Not used by autosort anymore.',

'', 0, 0, '', '', 0,

'', '', '', '', '', ''

)

self.__rules = weechat.config_new_option(

self.config_file, self.v3_section,

'rules', 'string',

'An ordered list of sorting rules encoded as JSON. See /help autosort for commands to manipulate these rules.',

'', 0, 0, Config.default_rules, Config.default_rules, 0,

'', '', '', '', '', ''

)

self.__helpers = weechat.config_new_option(

self.config_file, self.v3_section,

'helpers', 'string',

'A dictionary helper variables to use in the sorting rules, encoded as JSON. See /help autosort for commands to manipulate these helpers.',

'', 0, 0, Config.default_helpers, Config.default_helpers, 0,

'', '', '', '', '', ''

)

self.__signals = weechat.config_new_option(

self.config_file, self.sorting_section,

'signals', 'string',

'A space separated list of signals that will cause autosort to resort your buffer list.',

'', 0, 0, Config.default_signals, Config.default_signals, 0,

'', '', '', '', '', ''

)

self.__signal_delay = weechat.config_new_option(

self.config_file, self.sorting_section,

'signal_delay', 'integer',

'Delay in milliseconds to wait after a signal before sorting the buffer list. This prevents triggering many times if multiple signals arrive in a short time. It can also be needed to wait for buffer localvars to be available.',

'', 0, 1000, str(Config.default_signal_delay), str(Config.default_signal_delay), 0,

'', '', '', '', '', ''

)

self.__sort_limit = weechat.config_new_option(

self.config_file, self.sorting_section,

'sort_limit', 'integer',

'Minimum delay in milliseconds to wait after sorting before signals can trigger a sort again. This is effectively a rate limit on sorting. Keeping signal_delay low while setting this higher can reduce excessive sorting without a long initial delay.',

'', 0, 1000, str(Config.default_sort_limit), str(Config.default_sort_limit), 0,

'', '', '', '', '', ''

)

self.__sort_on_config = weechat.config_new_option(

self.config_file, self.sorting_section,

'sort_on_config_change', 'boolean',

'Decides if the buffer list should be sorted when autosort configuration changes.',

'', 0, 0, 'on', 'on', 0,

'', '', '', '', '', ''

)

self.__debug_log = weechat.config_new_option(

self.config_file, self.sorting_section,

'debug_log', 'boolean',

'If enabled, print more debug messages. Not recommended for normal usage.',

'', 0, 0, 'off', 'off', 0,

'', '', '', '', '', ''

)

if weechat.config_read(self.config_file) != weechat.WEECHAT_RC_OK:

log('Failed to load configuration file.')

if weechat.config_write(self.config_file) != weechat.WEECHAT_RC_OK:

log('Failed to write configuration file.')

self.reload()

def reload(self):

''' Load configuration variables. '''

self.case_sensitive = weechat.config_boolean(self.__case_sensitive)

rules_blob = weechat.config_string(self.__rules)

helpers_blob = weechat.config_string(self.__helpers)

signals_blob = weechat.config_string(self.__signals)

self.rules = decode_rules(rules_blob)

self.helpers = decode_helpers(helpers_blob)

self.signals = signals_blob.split()

self.signal_delay = weechat.config_integer(self.__signal_delay)

self.sort_limit = weechat.config_integer(self.__sort_limit)

self.sort_on_config = weechat.config_boolean(self.__sort_on_config)

self.debug_log = weechat.config_boolean(self.__debug_log)

def save_rules(self, run_callback = True):

''' Save the current rules to the configuration. '''

weechat.config_option_set(self.__rules, json.dumps(self.rules), run_callback)

def save_helpers(self, run_callback = True):

''' Save the current helpers to the configuration. '''

''' Get a list of all the buffers in weechat. '''

hdata = weechat.hdata_get('buffer')

buffer = weechat.hdata_get_list(hdata, "gui_buffers");

result = []

while buffer:

number = weechat.hdata_integer(hdata, buffer, 'number')

result.append((number, buffer))

buffer = weechat.hdata_pointer(hdata, buffer, 'next_buffer')

""" A list of merged buffers, possibly of size 1. """

def __init__(self, number):

super(MergedBuffers, self).__init__()

'''

if not buffers: return []

result = {}

for number, buffer in buffers:

if number not in result: result[number] = MergedBuffers(number)

result[number].append(buffer)

for merged in buffers:

for buffer in merged:

name = weechat.hdata_string(hdata, buffer, 'name')

''' Create a sort key function for a list of lists of merged buffers. '''

def key(buffer):

extra_vars = {}

for helper_name, helper in sorted(helpers.items()):

expanded = weechat.string_eval_expression(helper, {"buffer": buffer}, {}, {})

extra_vars[helper_name] = expanded if case_sensitive else casefold(expanded)

result = []

for rule in rules:

expanded = weechat.string_eval_expression(rule, {"buffer": buffer}, extra_vars, {})

result.append(expanded if case_sensitive else casefold(expanded))

return result

buffer_key = buffer_sort_key(rules, helpers, case_sensitive)

def key(merged):

best = None

for buffer in merged:

this = buffer_key(buffer)

if best is None or this < best: best = this

return best

''' Split an argument string in the desired number of arguments. '''

split = args.split(' ', expected - 1)

if (len(split) < expected):

raise HumanReadableError('Expected at least {0} arguments, got {1}.'.format(expected, len(split)))

start = perf_counter()

hdata, buffers = get_buffers()

buffers = merge_buffer_list(buffers)

buffers = sort_buffers(hdata, buffers, config.rules, config.helpers, config.case_sensitive)

apply_buffer_order(buffers)

elapsed = perf_counter() - start

if verbose:

log("Finished sorting buffers in {0:.4f} seconds.".format(elapsed))

else:

hdata, buffers = get_buffers()

buffers = merge_buffer_list(buffers)

# Show evaluation results.

log('Individual evaluation results:')

start = perf_counter()

key = buffer_sort_key(config.rules, config.helpers, config.case_sensitive)

results = []

for merged in buffers:

for buffer in merged:

fullname = weechat.hdata_string(hdata, buffer, 'full_name')

results.append((fullname, key(buffer)))

elapsed = perf_counter() - start

for fullname, result in results:

fullname = ensure_str(fullname)

result = [ensure_str(x) for x in result]

log('{0}: {1}'.format(fullname, result))

log('Computing evaluation results took {0:.4f} seconds.'.format(elapsed))

''' Show the list of sorting rules. '''

output = 'Sorting rules:\n'

for i, rule in enumerate(config.rules):

output += ' {0}: {1}\n'.format(i, rule)

if not len(config.rules):

output += ' No sorting rules configured.\n'

log(output )

''' Add a rule to the rule list. '''

config.rules.append(args)

config.save_rules()

command_rule_list(buffer, command, '')

''' Insert a rule at the desired position in the rule list. '''

index, rule = split_args(args, 2)

index = parse_int(index, 'index')

config.rules.insert(index, rule)

config.save_rules()

command_rule_list(buffer, command, '')

''' Update a rule in the rule list. '''

index, rule = split_args(args, 2)

index = parse_int(index, 'index')

config.rules[index] = rule

config.save_rules()

command_rule_list(buffer, command, '')

''' Delete a rule from the rule list. '''

index = args.strip()

index = parse_int(index, 'index')

config.rules.pop(index)

config.save_rules()

command_rule_list(buffer, command, '')

''' Move a rule to a new position. '''

index_a, index_b = split_args(args, 2)

index_a = parse_int(index_a, 'index')

index_b = parse_int(index_b, 'index')

list_move(config.rules, index_a, index_b)

config.save_rules()

command_rule_list(buffer, command, '')

''' Swap two rules. '''

index_a, index_b = split_args(args, 2)

index_a = parse_int(index_a, 'index')

index_b = parse_int(index_b, 'index')

list_swap(config.rules, index_a, index_b)

config.save_rules()

command_rule_list(buffer, command, '')

''' Show the list of helpers. '''

output = 'Helper variables:\n'

width = max(map(lambda x: len(x) if len(x) <= 30 else 0, config.helpers.keys()))

for name, expression in sorted(config.helpers.items()):

output += ' {0:>{width}}: {1}\n'.format(name, expression, width=width)

if not len(config.helpers):

output += ' No helper variables configured.'

log(output)

''' Add/update a helper to the helper list. '''

name, expression = split_args(args, 2)

config.helpers[name] = expression

config.save_helpers()

command_helper_list(buffer, command, '')

''' Delete a helper from the helper list. '''

name = args.strip()

del config.helpers[name]

config.save_helpers()

command_helper_list(buffer, command, '')

''' Rename a helper to a new position. '''

old_name, new_name = split_args(args, 2)

try:

config.helpers[new_name] = config.helpers[old_name]

del config.helpers[old_name]

except KeyError:

raise HumanReadableError('No such helper: {0}'.format(old_name))

config.save_helpers()

command_helper_list(buffer, command, '')

''' Swap two helpers. '''

a, b = split_args(args, 2)

try:

config.helpers[b], config.helpers[a] = config.helpers[a], config.helpers[b]

except KeyError as e:

raise HumanReadableError('No such helper: {0}'.format(e.args[0]))

config.helpers.swap(index_a, index_b)

config.save_helpers()

command_helper_list(buffer, command, '')

''' Call a subcommand from a dictionary. '''

subcommand, tail = pad(args.split(' ', 1), 2, '')

subcommand = subcommand.strip()

if (subcommand == ''):

child = subcommands.get(' ')

else:

command = command + [subcommand]

child = subcommands.get(subcommand)

if isinstance(child, dict):

return call_command(buffer, command, tail, child)

elif callable(child):

return child(buffer, command, tail)

log('{0}: command not found'.format(' '.join(command)))

global signal_delay_timer

global sort_queued

# If the sort limit timeout is started, we're in the hold-off time after sorting, just queue a sort.

if sort_limit_timer is not None:

if sort_queued:

debug('Signal {0} ignored, sort limit timeout is active and sort is already queued.'.format(signal))

else:

debug('Signal {0} received but sort limit timeout is active, sort is now queued.'.format(signal))

sort_queued = True

return weechat.WEECHAT_RC_OK

# If the signal delay timeout is started, a signal was recently received, so ignore this signal.

if signal_delay_timer is not None:

debug('Signal {0} ignored, signal delay timeout active.'.format(signal))

return weechat.WEECHAT_RC_OK

# Otherwise, start the signal delay timeout.

debug('Signal {0} received, starting signal delay timeout of {1} ms.'.format(signal, config.signal_delay))

weechat.hook_timer(config.signal_delay, 0, 1, "on_signal_delay_timeout", "")

""" Called when the signal_delay_timer triggers. """

global signal_delay_timer

global sort_limit_timer

global sort_queued

signal_delay_timer = None

# If the sort limit timeout was started, we're still in the no-sort period, so just queue a sort.

if sort_limit_timer is not None:

debug('Signal delay timeout expired, but sort limit timeout is active, sort is now queued.')

sort_queued = True

return weechat.WEECHAT_RC_OK

# Time to sort!

debug('Signal delay timeout expired, starting sort.')

do_sort()

# Start the sort limit timeout if not disabled.

if config.sort_limit > 0:

debug('Starting sort limit timeout of {0} ms.'.format(config.sort_limit))

sort_limit_timer = weechat.hook_timer(config.sort_limit, 0, 1, "on_sort_limit_timeout", "")

""" Called when de sort_limit_timer triggers. """

global sort_limit_timer

global sort_queued

# If no signal was received during the timeout, we're done.

if not sort_queued:

debug('Sort limit timeout expired without receiving a signal.')

sort_limit_timer = None

return weechat.WEECHAT_RC_OK

# Otherwise it's time to sort.

debug('Signal received during sort limit timeout, starting queued sort.')

do_sort()

sort_queued = False

# Start the sort limit timeout again if not disabled.

if config.sort_limit > 0:

debug('Starting sort limit timeout of {0} ms.'.format(config.sort_limit))

sort_limit_timer = weechat.hook_timer(config.sort_limit, 0, 1, "on_sort_limit_timeout", "")

# Unhook all signals and hook the new ones.

for hook in hooks:

weechat.unhook(hook)

for signal in config.signals:

hooks.append(weechat.hook_signal(signal, 'on_signal', ''))

if config.sort_on_config:

debug('Sorting because configuration changed.')

''' Called whenever the configuration changes. '''

config.reload()

apply_config()

if not args: return '', None

result = ''

escaped = False

for i, c in enumerate(args):

if not escaped:

if c == '\\':

escaped = True

continue

elif c == ',':

return result, args[i+1:]

result += c

escaped = False

result = []

i = 0

while max is None or i < max:

i += 1

arg, args = parse_arg(args)

if arg is None: break

result.append(arg)

if args is None: break

result = ''

for c in arguments:

if c == '\\':

result += '\\\\'

elif c == ',':

result += '\\,'

else:

result +=c

arguments, rest = parse_args(arguments, 3)

if rest or len(arguments) < 3:

log('usage: ${{info:{0},old,new,text}}'.format(name))

return ''

old, new, text = arguments

arguments, rest = parse_args(arguments)

if len(arguments) < 1:

log('usage: ${{info:{0},value,first,second,third,...}}'.format(name))

return ''

value = arguments[0]

keys = arguments[1:]

if not keys: return '0'

# Find the value in the keys (or '*' if we can't find it)

result = list_find(keys, value)

if result is None: result = list_find(keys, '*')

if result is None: result = len(keys)

# Pad result with leading zero to make sure string sorting works.

width = int(math.log10(len(keys))) + 1

''' Called when the autosort command is invoked. '''

try:

return call_command(buffer, ['/autosort'], args, {

' ': command_sort,

'sort': command_sort,

'debug': command_debug,

'rules': {

' ': command_rule_list,

'list': command_rule_list,

'add': command_rule_add,

'insert': command_rule_insert,

'update': command_rule_update,

'delete': command_rule_delete,

'move': command_rule_move,

'swap': command_rule_swap,

},

'helpers': {

' ': command_helper_list,

'list': command_helper_list,

'set': command_helper_set,

'delete': command_helper_delete,

'rename': command_helper_rename,

'swap': command_helper_swap,

},

})

except HumanReadableError as e:

log(e)

if len(words) == 0:

add_completions(completion, ['add', 'delete', 'insert', 'list', 'move', 'swap', 'update'])

if len(words) == 1 and words[0] in ('delete', 'insert', 'move', 'swap', 'update'):

add_completions(completion, map(str, range(len(config.rules))))

if len(words) == 2 and words[0] in ('move', 'swap'):

add_completions(completion, map(str, range(len(config.rules))))

if len(words) == 2 and words[0] in ('update'):

try:

add_completions(completion, [config.rules[int(words[1])]])

except KeyError: pass

except ValueError: pass

else:

add_completions(completion, [''])

if len(words) == 0:

add_completions(completion, ['delete', 'list', 'rename', 'set', 'swap'])

elif len(words) == 1 and words[0] in ('delete', 'rename', 'set', 'swap'):

add_completions(completion, sorted(config.helpers.keys()))

elif len(words) == 2 and words[0] == 'swap':

add_completions(completion, sorted(config.helpers.keys()))

elif len(words) == 2 and words[0] == 'rename':

add_completions(completion, sorted(config.helpers.keys()))

elif len(words) == 2 and words[0] == 'set':

try:

add_completions(completion, [config.helpers[words[1]]])

except KeyError: pass

cmdline = weechat.buffer_get_string(buffer, "input")

cursor = weechat.buffer_get_integer(buffer, "input_pos")

prefix = cmdline[:cursor]

words = prefix.split()[1:]

# If the current word isn't finished yet,

# ignore it for coming up with completion suggestions.

if prefix[-1] != ' ': words = words[:-1]

if len(words) == 0:

add_completions(completion, ['debug', 'helpers', 'rules', 'sort'])

elif words[0] == 'rules':

return autosort_complete_rules(words[1:], completion)

elif words[0] == 'helpers':

return autosort_complete_helpers(words[1:], completion)