def register_growl(growl_server, growl_password):
""" Register this app with Growl """
error = None
host, port = split_host(growl_server or '')
sys_name = hostname(host)
# Clean up persistent data in GNTP to make re-registration work
GNTPRegister.notifications = []
GNTPRegister.headers = {}
growler = GrowlNotifier(
applicationName='SABnzbd%s' % sys_name,
applicationIcon=get_icon(),
notifications=[Tx(NOTIFICATION[key]) for key in NOTIFY_KEYS],
hostname=host or 'localhost',
port=port or 23053,
password=growl_password or None
)
try:
ret = growler.register()
if ret is None or isinstance(ret, bool):
logging.info('Registered with Growl')
ret = growler
else:
error = 'Cannot register with Growl %s' % str(ret)
logging.debug(error)
del growler
ret = None
except socket.error, err:
error = 'Cannot register with Growl %s' % str(err)
logging.debug(error)
del growler
ret = None
def main():
'''Sets up WeeChat Growl notifications.'''
# Initialize options.
for option, value in SETTINGS.items():
if not weechat.config_is_set_plugin(option):
weechat.config_set_plugin(option, value)
# Initialize Growl.
name = "WeeChat"
hostname = weechat.config_get_plugin('hostname')
password = weechat.config_get_plugin('password')
icon_path = os.path.join(weechat.info_get("weechat_dir", ""),
weechat.config_get_plugin('icon'))
try:
icon = open(icon_path, "rb").read()
except IOError:
weechat.prnt('',
'Weechat-Growl: {0} could not be opened. '.format(icon_path) +
'Please make sure it exists.')
icon = None
notifications = [
'Public',
'Private',
'Action',
'Notice',
'Invite',
'Highlight',
'Server',
'Channel',
'DCC',
'WeeChat'
]
if len(hostname) == 0:
hostname = ''
if len(password) == 0:
password = ''
growl = GrowlNotifier(
applicationName=name,
hostname=hostname,
password=password,
notifications=notifications,
applicationIcon=icon)
try:
growl.register()
except Exception as error:
weechat.prnt('', 'growl: {0}'.format(error))
STATE['growl'] = growl
STATE['icon'] = icon
# Register hooks.
weechat.hook_signal(
'irc_server_connected',
'cb_irc_server_connected',
'')
weechat.hook_signal(
'irc_server_disconnected',
'cb_irc_server_disconnected',
'')
weechat.hook_signal('upgrade_ended', 'cb_upgrade_ended', '')
weechat.hook_print('', '', '', 1, 'cb_process_message', '')
def __init__(self):
self.base_url = 'http://stackoverflow.com/questions/tagged/'
self.get_or_create_database()
self.growl = GrowlNotifier(
applicationName='StackOverflowChecker',
notifications=['new'],
)
self.growl.register()
self.tags = [('django', True), ('python', False)]
self.get_questions()
self.close_connection()
def bark(message, host, password):
growl = GrowlNotifier(applicationName=NAME,
notifications=[NOTIFIER],
defaultNotifications=[NOTIFIER],
hostname=host,
port='23053',
password=password)
growl.register()
growl.notify(
noteType=NOTIFIER,
title=TITLE,
description=message,
icon=ICON_URL,
sticky=False,
priority=1,
)
def register_growl(growl_server, growl_password):
""" Register this app with Growl """
error = None
host, port = split_host(growl_server or '')
sys_name = hostname(host)
# Reduce logging of Growl in Debug/Info mode
logging.getLogger('gntp').setLevel(logging.WARNING)
# Clean up persistent data in GNTP to make re-registration work
GNTPRegister.notifications = []
GNTPRegister.headers = {}
growler = GrowlNotifier(
applicationName='SABnzbd%s' % sys_name,
applicationIcon=get_icon(),
notifications=[Tx(NOTIFICATION[key]) for key in NOTIFY_KEYS],
hostname=host or 'localhost',
port=port or 23053,
password=growl_password or None
)
try:
ret = growler.register()
if ret is None or isinstance(ret, bool):
logging.info('Registered with Growl')
ret = growler
else:
error = 'Cannot register with Growl %s' % str(ret)
logging.debug(error)
del growler
ret = None
except (gntp.errors.NetworkError, gntp.errors.AuthError) as err:
error = 'Cannot register with Growl %s' % str(err)
logging.debug(error)
del growler
ret = None
except:
error = 'Unknown Growl registration error'
logging.debug(error)
logging.info("Traceback: ", exc_info=True)
del growler
ret = None
return ret, error
def growlInit(self):
# addr = (self.config['growl_host'], self.config['growl_port'])
# s = socket(AF_INET,SOCK_DGRAM)
# p = GrowlRegistrationPacket("Deluge", self.config['growl_password'])
# p.addNotification("Download Completed", True)
# p.addNotification("Torrent Added", True)
# s.sendto(p.payload(), addr)
# s.close()
self.growl = GrowlNotifier(
applicationName="Deluge",
notifications=["Torrent Added", "Download Completed"],
defaultNotifications=["Torrent Added"],
hostname=self.config['growl_host'],
password=self.config['growl_password'],
port=self.config['growl_port'],
debug=0)
result = self.growl.register()
def forward(self, packet):
messagetype = packet.info['messagetype']
for label, settings in self.config.items(__name__):
dest, password = settings.split(',')
try:
host, port = dest.split(':')
except ValueError:
host, port = dest, DEFAULTS['port']
passwordHash = self.get('passwordHash', DEFAULTS['passwordHash'])
packet.set_password(password, passwordHash)
logger.info('Forwarding %s to %s:%s', messagetype, host, port)
GrowlNotifier(
hostname=host,
port=port,
)._send(messagetype, packet)
def test_client(config, options):
logging.basicConfig(level=options.verbose)
notifier = GrowlNotifier(hostname=config.get('regrowl.server', 'hostname',
'127.0.0.1'),
port=config.getint('regrowl.server', 'port'),
password=config.get('regrowl.server', 'password'),
notifications=['Test'])
if options.test in ['registration', 'all']:
notifier.register()
if options.test in ['notification', 'all']:
notifier.notify(
noteType='Test',
title='Testing',
description='ReGrowl Test',
)
if options.test in ['subscription', 'all']:
notifier.subscribe(
'TestId',
'TestName',
1337,
)
def main():
(options, message) = ClientParser().parse_args()
logging.basicConfig(level=options.verbose)
if not os.path.exists(DEFAULT_CONFIG):
logging.info('No config read found at %s', DEFAULT_CONFIG)
growl = GrowlNotifier(
applicationName=options.app,
notifications=[options.name],
defaultNotifications=[options.name],
hostname=options.host,
password=options.password,
port=options.port,
)
result = growl.register()
if result is not True:
exit(result)
# This would likely be better placed within the growl notifier
# class but until I make _checkIcon smarter this is "easier"
if options.icon is not None and not options.icon.startswith('http'):
logging.info('Loading image %s', options.icon)
f = open(options.icon)
options.icon = f.read()
f.close()
result = growl.notify(
noteType=options.name,
title=options.title,
description=message,
icon=options.icon,
sticky=options.sticky,
priority=options.priority,
callback=options.callback,
identifier=options.identifier,
)
if result is not True:
exit(result)
def register_growl():
""" Register this app with Growl
"""
error = None
host, port = sabnzbd.misc.split_host(sabnzbd.cfg.growl_server())
if host:
sys_name = '@' + sabnzbd.misc.hostname().lower()
else:
sys_name = ''
# Clean up persistent data in GNTP to make re-registration work
GNTPRegister.notifications = []
GNTPRegister.headers = {}
growler = GrowlNotifier(
applicationName='SABnzbd%s' % sys_name,
applicationIcon=get_icon(host or None),
notifications=[Tx(_NOTIFICATION[key]) for key in _KEYS],
hostname=host or None,
port=port or 23053,
password=sabnzbd.cfg.growl_password() or None)
try:
ret = growler.register()
if ret is None or isinstance(ret, bool):
logging.info('Registered with Growl')
ret = growler
else:
error = 'Cannot register with Growl %s' % str(ret)
logging.debug(error)
del growler
ret = None
except socket.error, err:
error = 'Cannot register with Growl %s' % str(err)
logging.debug(error)
del growler
ret = None
def send_gntp_notification(self):
growl_ips = self.growl_ips
gntp_ips = self.gntp_ips
# don't send to gntp if we can use growl
gntp_ips = [ip for ip in gntp_ips if (ip not in growl_ips)]
for ip in gntp_ips:
growl = GrowlNotifier(
applicationName='Doorbell',
notifications=['doorbell'],
defaultNotifications=['doorbell'],
hostname=ip,
password=self.password,
)
result = growl.register()
if not result:
continue
result = growl.notify(
noteType='doorbell',
title=self.title,
description=self.description,
sticky=True,
)
def setUp(self):
self.growl = GrowlNotifier('GNTP unittest', ['Testing'])
self.growl.register()
self.dir = os.path.dirname(__file__)
self.file = os.path.join(self.dir, 'test_lines.txt')
import sys
# Script Arguments
argv = os.sys.argv
argc = len(argv)
# Stores Pianobar information.
info = {}
# Initalize a new Growl object (localhost does not require a password).
growl = GrowlNotifier(
applicationName=u'Pianobar',
notifications=[
u'Song Start',
u'Song End',
u'Song Love',
u'Song Ban',
u'Song Shelve',
u'Song Bookmark',
u'Artist Bookmark',
u'Program Error',
u'Network Error'])
# Register Pianobar with Growl.
try:
growl.register()
except socket.error:
# Be silent.
pass
# Parse stdin into the dictionary.
for line in sys.stdin:
def setUp(self):
self.growl = GrowlNotifier('GNTP unittest', ['Testing'])
self.growl.register()
def __init__(self, app_name='autocheck'):
self.growl = GrowlNotifier(applicationName=app_name,
notifications=['New Message'],
defaultNotifications=['New Message'])
self.growl.register()
# If we still have an empty title, use the
# first bit of the message as the title
if values.title == '':
values.title = message[:20]
return values, message
if __name__ == "__main__":
(options, message) = ClientParser('~/.gntp').parse_args()
growl = GrowlNotifier(
applicationName=options.app,
notifications=[options.name],
defaultNotifications=[options.name],
hostname=options.host,
password=options.password,
port=options.port,
debug=options.debug,
)
result = growl.register()
if result is not True: exit(result)
result = growl.notify(
noteType=options.name,
title=options.title,
description=message,
icon=options.icon,
sticky=options.sticky,
priority=options.priority,
)
def __init__(self, priority=GrowlPriority.NORMAL, version=2, **kwargs):
"""
Initialize Growl Object
"""
super(NotifyGrowl, self).__init__(title_maxlen=250,
body_maxlen=32768,
image_size=GROWL_IMAGE_XY,
notify_format=NotifyFormat.TEXT,
**kwargs)
# A Global flag that tracks registration
self.is_registered = False
if not self.port:
self.port = GROWL_UDP_PORT
# The Priority of the message
if priority not in GROWL_PRIORITIES:
self.priority = GrowlPriority.NORMAL
else:
self.priority = priority
# Always default the sticky flag to False
self.sticky = False
# Store Version
self.version = version
payload = {
'applicationName': self.app_id,
'notifications': [
GROWL_NOTIFICATION_TYPE,
],
'defaultNotifications': [
GROWL_NOTIFICATION_TYPE,
],
'hostname': self.host,
'port': self.port,
}
if self.password is not None:
payload['password'] = self.password
self.logger.debug('Growl Registration Payload: %s' % str(payload))
self.growl = GrowlNotifier(**payload)
try:
self.growl.register()
# Toggle our flag
self.is_registered = True
self.logger.debug(
'Growl server registration completed successfully.')
except GrowlNetworkError:
self.logger.warning(
'A network error occured sending Growl ' + \
'notification to %s.' % (
self.host,
))
return
except GrowlAuthenticationError:
self.logger.warning(
'An authentication error occured sending Growl ' + \
'notification to %s.' % (
self.host,
))
return
return
# -*- coding: utf-8 -*- # Simple script to test sending UTF8 text with the GrowlNotifier class import logging logging.basicConfig(level=logging.DEBUG) from gntp.notifier import GrowlNotifier import platform growl = GrowlNotifier(notifications=['Testing'],password='******',hostname='ayu') growl.subscribe(platform.node(),platform.node(),12345)
