# -*- coding: utf-8 -*- # # Project: weechat-notify-send # Homepage: https://github.com/s3rvac/weechat-notify-send # Description: Sends highlight and message notifications through notify-send. # Requires libnotify. # License: MIT (see below) # # Copyright (c) 2015 by Petr Zemek and contributors # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. # from __future__ import print_function import os import re import subprocess import sys import time # Ensure that we are running under WeeChat. try: import weechat except ImportError: sys.exit('This script has to run under WeeChat (https://weechat.org/).') # Name of the script. SCRIPT_NAME = 'notify_send' # Author of the script. SCRIPT_AUTHOR = 's3rvac' # Version of the script. SCRIPT_VERSION = '0.11 (dev)' # License under which the script is distributed. SCRIPT_LICENSE = 'MIT' # Description of the script. SCRIPT_DESC = 'Sends highlight and message notifications through notify-send.' # Name of a function to be called when the script is unloaded. SCRIPT_SHUTDOWN_FUNC = '' # Used character set (utf-8 by default). SCRIPT_CHARSET = '' # Script options. OPTIONS = { 'notify_on_highlights': ( 'on', 'Send notifications on highlights.' ), 'notify_on_privmsgs': ( 'on', 'Send notifications on private messages.' ), 'notify_on_filtered_messages': ( 'off', 'Send notifications also on filtered (hidden) messages.' ), 'notify_when_away': ( 'on', 'Send also notifications when away.' ), 'notify_for_current_buffer': ( 'on', 'Send also notifications for the currently active buffer.' ), 'notify_on_all_messages_in_current_buffer': ( 'off', 'Send a notification on all messages in the currently active buffer.' ), 'notify_on_all_messages_in_buffers': ( '', 'A comma-separated list of buffers for which you want to receive ' 'notifications on all messages that appear in them.' ), 'notify_on_all_messages_in_buffers_that_match': ( '', 'A comma-separated list of regex patterns of buffers for which you ' 'want to receive notifications on all messages that appear in them.' ), 'notify_on_messages_that_match': ( '', 'A comma-separated list of regex patterns that you want to receive ' 'notifications on when message matches.' ), 'min_notification_delay': ( '500', 'A minimal delay between successive notifications from the same ' 'buffer (in milliseconds; set to 0 to show all notifications).' ), 'ignore_messages_tagged_with': ( ','.join([ 'notify_none', # Buffer with line is not added to hotlist 'irc_join', # Joined IRC 'irc_quit', # Quit IRC 'irc_part', # Parted a channel 'irc_status', # Status messages 'irc_nick_back', # A nick is back on server 'irc_401', # No such nick/channel 'irc_402', # No such server ]), 'A comma-separated list of message tags for which no notifications ' 'should be shown.' ), 'ignore_buffers': ( '', 'A comma-separated list of buffers from which no notifications should ' 'be shown.' ), 'ignore_buffers_starting_with': ( '', 'A comma-separated list of buffer prefixes from which no ' 'notifications should be shown.' ), 'ignore_nicks': ( '-,--,-->', 'A comma-separated list of nicks from which no notifications should ' 'be shown.' ), 'ignore_nicks_starting_with': ( '', 'A comma-separated list of nick prefixes from which no ' 'notifications should be shown.' ), 'hide_messages_in_buffers_that_match': ( '', 'A comma-separated list of regex patterns for names of buffers from ' 'which you want to receive notifications without messages.' ), 'nick_separator': ( ': ', 'A separator between a nick and a message.' ), 'escape_html': ( 'on', "Escapes the '<', '>', and '&' characters in notification messages." ), 'max_length': ( '72', 'Maximal length of a notification (0 means no limit).' ), 'ellipsis': ( '[..]', 'Ellipsis to be used for notifications that are too long.' ), 'icon': ( '/usr/share/icons/hicolor/32x32/apps/weechat.png', 'Path to an icon to be shown in notifications.' ), 'desktop_entry': ( 'weechat', 'Name of the desktop entry for WeeChat.' ), 'timeout': ( '5000', 'Time after which the notification disappears (in milliseconds; ' 'set to 0 to disable).' ), 'transient': ( 'on', 'When a notification expires or is dismissed, remove it from the ' 'notification bar.' ), 'urgency': ( 'normal', 'Urgency (low, normal, critical).' ) } class Notification(object): """A representation of a notification.""" def __init__(self, source, message, icon, desktop_entry, timeout, transient, urgency): self.source = source self.message = message self.icon = icon self.desktop_entry = desktop_entry self.timeout = timeout self.transient = transient self.urgency = urgency def default_value_of(option): """Returns the default value of the given option.""" return OPTIONS[option][0] def add_default_value_to(description, default_value): """Adds the given default value to the given option description.""" # All descriptions end with a period, so do not add another period. return '{} Default: {}.'.format( description, default_value if default_value else '""' ) def nick_that_sent_message(tags, prefix): """Returns a nick that sent the message based on the given data passed to the callback. """ # 'tags' is a comma-separated list of tags that WeeChat passed to the # callback. It should contain a tag of the following form: nick_XYZ, where # XYZ is the nick that sent the message. for tag in tags: if tag.startswith('nick_'): return tag[5:] # There is no nick in the tags, so check the prefix as a fallback. # 'prefix' (str) is the prefix of the printed line with the message. # Usually (but not always), it is a nick with an optional mode (e.g. on # IRC, @ denotes an operator and + denotes a user with voice). We have to # remove the mode (if any) before returning the nick. # Strip also a space as some protocols (e.g. Matrix) may start prefixes # with a space. It probably means that the nick has no mode set. if prefix.startswith(('~', '&', '@', '%', '+', '-', ' ')): return prefix[1:] return prefix def parse_tags(tags): """Parses the given "list" of tags (str) from WeeChat into a list.""" return tags.split(',') def message_printed_callback(data, buffer, date, tags, is_displayed, is_highlight, prefix, message): """A callback when a message is printed.""" is_displayed = int(is_displayed) is_highlight = int(is_highlight) tags = parse_tags(tags) nick = nick_that_sent_message(tags, prefix) if notification_should_be_sent(buffer, tags, nick, is_displayed, is_highlight, message): notification = prepare_notification(buffer, nick, message) send_notification(notification) return weechat.WEECHAT_RC_OK def notification_should_be_sent(buffer, tags, nick, is_displayed, is_highlight, message): """Should a notification be sent?""" if notification_should_be_sent_disregarding_time(buffer, tags, nick, is_displayed, is_highlight, message): # The following function should be called only when the notification # should be sent (it updates the last notification time). if not is_below_min_notification_delay(buffer): return True return False def notification_should_be_sent_disregarding_time(buffer, tags, nick, is_displayed, is_highlight, message): """Should a notification be sent when not considering time?""" if not nick: # A nick is required to form a correct notification source/message. return False if i_am_author_of_message(buffer, nick): return False if not is_displayed: if not notify_on_filtered_messages(): return False if is_away(buffer): if not notify_when_away(): return False if ignore_notifications_from_messages_tagged_with(tags): return False if ignore_notifications_from_nick(nick): return False if ignore_notifications_from_buffer(buffer): return False if buffer == weechat.current_buffer(): if not notify_for_current_buffer(): return False elif notify_on_all_messages_in_current_buffer(): return True if is_private_message(buffer): return notify_on_private_messages() if is_highlight: return notify_on_highlights() if notify_on_messages_that_match(message): return True if notify_on_all_messages_in_buffer(buffer): return True return False def is_below_min_notification_delay(buffer): """Is a notification in the given buffer below the minimal delay between successive notifications from the same buffer? When called, this function updates the time of the last notification. """ # We store the time of the last notification in a buffer-local variable to # make it persistent over the lifetime of this script. LAST_NOTIFICATION_TIME_VAR = 'notify_send_last_notification_time' last_notification_time = buffer_get_float( buffer, 'localvar_' + LAST_NOTIFICATION_TIME_VAR ) min_notification_delay = weechat.config_get_plugin('min_notification_delay') # min_notification_delay is in milliseconds (str). To compare it with # last_notification_time (float in seconds), we have to convert it to # seconds (float). min_notification_delay = float(min_notification_delay) / 1000 current_time = time.time() # We have to update the last notification time before returning the result. buffer_set_float( buffer, 'localvar_set_' + LAST_NOTIFICATION_TIME_VAR, current_time ) return (min_notification_delay > 0 and current_time - last_notification_time < min_notification_delay) def buffer_get_float(buffer, property): """A variant of weechat.buffer_get_x() for floats. This variant is needed because WeeChat supports only buffer_get_string() and buffer_get_int(). """ value = weechat.buffer_get_string(buffer, property) return float(value) if value else 0.0 def buffer_set_float(buffer, property, value): """A variant of weechat.buffer_set() for floats. This variant is needed because WeeChat supports only integers and strings. """ weechat.buffer_set(buffer, property, str(value)) def names_for_buffer(buffer): """Returns a list of all names for the given buffer.""" # The 'buffer' parameter passed to our callback is actually the buffer's ID # (e.g. '0x2719cf0'). We have to check its name (e.g. 'freenode.#weechat') # and short name (e.g. '#weechat') because these are what users specify in # their configs. buffer_names = [] full_name = weechat.buffer_get_string(buffer, 'name') if full_name: buffer_names.append(full_name) short_name = weechat.buffer_get_string(buffer, 'short_name') if short_name: buffer_names.append(short_name) # Consider >channel and #channel to be equal buffer names. The reason # is that the https://github.com/rawdigits/wee-slack script replaces # '#' with '>' to indicate that someone in the buffer is typing. This # fixes the behavior of several configuration options (e.g. # 'notify_on_all_messages_in_buffers') when weechat_notify_send is used # together with the wee_slack script. # # Note that this is only needed to be done for the short name. Indeed, # the full name always stays unchanged. if short_name.startswith('>'): buffer_names.append('#' + short_name[1:]) return buffer_names def notify_for_current_buffer(): """Should we also send notifications for the current buffer?""" return weechat.config_get_plugin('notify_for_current_buffer') == 'on' def notify_on_all_messages_in_current_buffer(): """Should we send a notication on all messages in the current buffer?""" return weechat.config_get_plugin('notify_on_all_messages_in_current_buffer') == 'on' def notify_on_highlights(): """Should we send notifications on highlights?""" return weechat.config_get_plugin('notify_on_highlights') == 'on' def notify_on_private_messages(): """Should we send notifications on private messages?""" return weechat.config_get_plugin('notify_on_privmsgs') == 'on' def notify_on_filtered_messages(): """Should we also send notifications for filtered (hidden) messages?""" return weechat.config_get_plugin('notify_on_filtered_messages') == 'on' def notify_when_away(): """Should we also send notifications when away?""" return weechat.config_get_plugin('notify_when_away') == 'on' def is_away(buffer): """Is the user away?""" return weechat.buffer_get_string(buffer, 'localvar_away') != '' def is_private_message(buffer): """Has a private message been sent?""" return weechat.buffer_get_string(buffer, 'localvar_type') == 'private' def i_am_author_of_message(buffer, nick): """Am I (the current WeeChat user) the author of the message?""" return weechat.buffer_get_string(buffer, 'localvar_nick') == nick def split_option_value(option, separator=','): """Splits the value of the given plugin option by the given separator and returns the result in a list. """ values = weechat.config_get_plugin(option) if not values: # When there are no values, return the empty list instead of ['']. return [] return [value.strip() for value in values.split(separator)] def ignore_notifications_from_messages_tagged_with(tags): """Should notifications be ignored for a message tagged with the given tags? """ ignored_tags = split_option_value('ignore_messages_tagged_with') for ignored_tag in ignored_tags: for tag in tags: if tag == ignored_tag: return True return False def ignore_notifications_from_buffer(buffer): """Should notifications from the given buffer be ignored?""" buffer_names = names_for_buffer(buffer) for buffer_name in buffer_names: if buffer_name and buffer_name in ignored_buffers(): return True for buffer_name in buffer_names: for prefix in ignored_buffer_prefixes(): if prefix and buffer_name.startswith(prefix): return True return False def ignored_buffers(): """A generator of buffers from which notifications should be ignored.""" for buffer in split_option_value('ignore_buffers'): yield buffer def ignored_buffer_prefixes(): """A generator of buffer prefixes from which notifications should be ignored. """ for prefix in split_option_value('ignore_buffers_starting_with'): yield prefix def ignore_notifications_from_nick(nick): """Should notifications from the given nick be ignored?""" if nick in ignored_nicks(): return True for prefix in ignored_nick_prefixes(): if prefix and nick.startswith(prefix): return True return False def ignored_nicks(): """A generator of nicks from which notifications should be ignored.""" for nick in split_option_value('ignore_nicks'): yield nick def ignored_nick_prefixes(): """A generator of nick prefixes from which notifications should be ignored. """ for prefix in split_option_value('ignore_nicks_starting_with'): yield prefix def notify_on_messages_that_match(message): """Should we send a notification for the given message, provided it matches any of the requested patterns? """ message_patterns = split_option_value('notify_on_messages_that_match') for pattern in message_patterns: if re.search(pattern, message): return True return False def buffers_to_notify_on_all_messages(): """A generator of buffer names in which the user wants to be notified for all messages. """ for buffer in split_option_value('notify_on_all_messages_in_buffers'): yield buffer def buffer_patterns_to_notify_on_all_messages(): """A generator of buffer-name patterns in which the user wants to be notifier for all messages. """ for pattern in split_option_value('notify_on_all_messages_in_buffers_that_match'): yield pattern def notify_on_all_messages_in_buffer(buffer): """Does the user want to be notified for all messages in the given buffer? """ buffer_names = names_for_buffer(buffer) # Option notify_on_all_messages_in_buffers: for buf in buffers_to_notify_on_all_messages(): if buf in buffer_names: return True # Option notify_on_all_messages_in_buffers_that_match: for pattern in buffer_patterns_to_notify_on_all_messages(): for buf in buffer_names: if re.search(pattern, buf): return True return False def buffer_patterns_to_hide_messages(): """A generator of buffer-name patterns in which the user wants to hide messages. """ for pattern in split_option_value('hide_messages_in_buffers_that_match'): yield pattern def hide_message_in_buffer(buffer): """Should messages in the given buffer be hidden?""" buffer_names = names_for_buffer(buffer) for pattern in buffer_patterns_to_hide_messages(): for buf in buffer_names: if re.search(pattern, buf): return True return False def prepare_notification(buffer, nick, message): """Prepares a notification from the given data.""" if is_private_message(buffer): source = nick else: source = (weechat.buffer_get_string(buffer, 'short_name') or weechat.buffer_get_string(buffer, 'name')) message = nick + nick_separator() + message if hide_message_in_buffer(buffer): message = '' max_length = int(weechat.config_get_plugin('max_length')) if max_length > 0: ellipsis = weechat.config_get_plugin('ellipsis') message = shorten_message(message, max_length, ellipsis) if weechat.config_get_plugin('escape_html') == 'on': message = escape_html(message) message = escape_slashes(message) icon = weechat.config_get_plugin('icon') desktop_entry = weechat.config_get_plugin('desktop_entry') timeout = weechat.config_get_plugin('timeout') transient = should_notifications_be_transient() urgency = weechat.config_get_plugin('urgency') return Notification(source, message, icon, desktop_entry, timeout, transient, urgency) def should_notifications_be_transient(): """Should the sent notifications be transient, i.e. should they be removed from the notification bar once they expire or are dismissed? """ return weechat.config_get_plugin('transient') == 'on' def nick_separator(): """Returns a nick separator to be used.""" separator = weechat.config_get_plugin('nick_separator') return separator if separator else default_value_of('nick_separator') def shorten_message(message, max_length, ellipsis): """Shortens the message to at most max_length characters by using the given ellipsis. """ # In Python 2, we need to decode the message and ellipsis into Unicode to # correctly (1) detect their length and (2) shorten the message. Failing to # do that could make the shortened message invalid and cause notify-send to # fail. For example, when we have bytes, we cannot guarantee that we do not # split the message inside of a multibyte character. if sys.version_info.major == 2: try: message = message.decode('utf-8') ellipsis = ellipsis.decode('utf-8') except UnicodeDecodeError: # Either (or both) of the two cannot be decoded. Continue in a # best-effort manner. pass message = shorten_unicode_message(message, max_length, ellipsis) if sys.version_info.major == 2: if not isinstance(message, str): message = message.encode('utf-8') return message def shorten_unicode_message(message, max_length, ellipsis): """An internal specialized version of shorten_message() when the both the message and ellipsis are str (in Python 3) or unicode (in Python 2). """ if max_length <= 0 or len(message) <= max_length: # Nothing to shorten. return message if len(ellipsis) >= max_length: # We cannot include any part of the message. return ellipsis[:max_length] return message[:max_length - len(ellipsis)] + ellipsis def escape_html(message): """Escapes HTML characters in the given message.""" # Only the following characters need to be escaped # (https://wiki.ubuntu.com/NotificationDevelopmentGuidelines). message = message.replace('&', '&') message = message.replace('<', '<') message = message.replace('>', '>') return message def escape_slashes(message): """Escapes slashes in the given message.""" # We need to escape backslashes to prevent notify-send from interpreting # them, e.g. we do not want to print a newline when the message contains # '\n'. return message.replace('\\', r'\\') def send_notification(notification): """Sends the given notification to the user.""" notify_cmd = ['notify-send', '--app-name', 'weechat'] if notification.icon: notify_cmd += ['--icon', notification.icon] if notification.desktop_entry: notify_cmd += ['--hint', 'string:desktop-entry:{}'.format(notification.desktop_entry)] if notification.timeout: notify_cmd += ['--expire-time', str(notification.timeout)] if notification.transient: notify_cmd += ['--hint', 'int:transient:1'] if notification.urgency: notify_cmd += ['--urgency', notification.urgency] # The "im.received" category means "A received instant message # notification". notify_cmd += ['--category', 'im.received'] # We need to add '--' before the source and message to ensure that # notify-send considers the remaining parameters as the source and the # message. This prevents errors when a source or message starts with '--'. notify_cmd += [ '--', # notify-send fails with "No summary specified." when no source is # specified, so ensure that there is always a non-empty source. notification.source or '-', notification.message ] # Prevent notify-send from messing up the WeeChat screen when occasionally # emitting assertion messages by redirecting the output to /dev/null (users # would need to run /redraw to fix the screen). # In Python < 3.3, there is no subprocess.DEVNULL, so we have to use a # workaround. with open(os.devnull, 'wb') as devnull: try: subprocess.check_call( notify_cmd, stderr=subprocess.STDOUT, stdout=devnull, ) except Exception as ex: error_message = '{} (reason: {!r}). {}'.format( 'Failed to send the notification via notify-send', '{}: {}'.format(ex.__class__.__name__, ex), 'Ensure that you have notify-send installed in your system.', ) print(error_message, file=sys.stderr) if __name__ == '__main__': # Registration. weechat.register( SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, SCRIPT_SHUTDOWN_FUNC, SCRIPT_CHARSET ) # Initialization. for option, (default_value, description) in OPTIONS.items(): description = add_default_value_to(description, default_value) weechat.config_set_desc_plugin(option, description) if not weechat.config_is_set_plugin(option): weechat.config_set_plugin(option, default_value) # Catch all messages on all buffers and strip colors from them before # passing them into the callback. weechat.hook_print('', '', '', 1, 'message_printed_callback', '')