/taskcoach/taskcoachlib/thirdparty/Growl.py

"""
A Python module that enables posting notifications to the Growl daemon.
See <http://growl.info/> for more information.
"""
__version__ = "0.7" 
__author__ = "Mark Rowe <bdash@users.sourceforge.net>"
__copyright__ = "(C) 2003 Mark Rowe <bdash@users.sourceforge.net>. Released under the BSD license."
__contributors__ = ["Ingmar J Stein (Growl Team)", 
					"Rui Carmo (http://the.taoofmac.com)",
					"Jeremy Rossi <jeremy@jeremyrossi.com>",
					"Peter Hosey <http://boredzo.org/> (Growl Team)",
				   ]

import _growl
import types
import struct
import hashlib
import socket

GROWL_UDP_PORT=9887
GROWL_PROTOCOL_VERSION=1
GROWL_TYPE_REGISTRATION=0
GROWL_TYPE_NOTIFICATION=1

GROWL_APP_NAME="ApplicationName"
GROWL_APP_ICON="ApplicationIcon"
GROWL_NOTIFICATIONS_DEFAULT="DefaultNotifications"
GROWL_NOTIFICATIONS_ALL="AllNotifications"
GROWL_NOTIFICATIONS_USER_SET="AllowedUserNotifications"

GROWL_NOTIFICATION_NAME="NotificationName"
GROWL_NOTIFICATION_TITLE="NotificationTitle"
GROWL_NOTIFICATION_DESCRIPTION="NotificationDescription"
GROWL_NOTIFICATION_ICON="NotificationIcon"
GROWL_NOTIFICATION_APP_ICON="NotificationAppIcon"
GROWL_NOTIFICATION_PRIORITY="NotificationPriority"
		
GROWL_NOTIFICATION_STICKY="NotificationSticky"

GROWL_APP_REGISTRATION="GrowlApplicationRegistrationNotification"
GROWL_APP_REGISTRATION_CONF="GrowlApplicationRegistrationConfirmationNotification"
GROWL_NOTIFICATION="GrowlNotification"
GROWL_SHUTDOWN="GrowlShutdown"
GROWL_PING="Honey, Mind Taking Out The Trash"
GROWL_PONG="What Do You Want From Me, Woman"
GROWL_IS_READY="Lend Me Some Sugar; I Am Your Neighbor!"

	
growlPriority = {"Very Low":-2,"Moderate":-1,"Normal":0,"High":1,"Emergency":2}

class netgrowl:
	"""Builds a Growl Network Registration packet.
	   Defaults to emulating the command-line growlnotify utility."""

	__notAllowed__ = [GROWL_APP_ICON, GROWL_NOTIFICATION_ICON, GROWL_NOTIFICATION_APP_ICON]

	def __init__(self, hostname, password ):
		self.hostname = hostname
		self.password = password
		self.socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

	def send(self, data):
		self.socket.sendto(data, (self.hostname, GROWL_UDP_PORT))
		
	def PostNotification(self, userInfo):
		if userInfo.has_key(GROWL_NOTIFICATION_PRIORITY):
			priority = userInfo[GROWL_NOTIFICATION_PRIORITY]
		else:
			priority = 0
		if userInfo.has_key(GROWL_NOTIFICATION_STICKY):
			sticky = userInfo[GROWL_NOTIFICATION_STICKY]
		else:
			sticky = False
		data = self.encodeNotify(userInfo[GROWL_APP_NAME],
								 userInfo[GROWL_NOTIFICATION_NAME],
								 userInfo[GROWL_NOTIFICATION_TITLE],
								 userInfo[GROWL_NOTIFICATION_DESCRIPTION],
								 priority,
								 sticky)
		return self.send(data)

	def PostRegistration(self, userInfo):
		data = self.encodeRegistration(userInfo[GROWL_APP_NAME],
									   userInfo[GROWL_NOTIFICATIONS_ALL],
									   userInfo[GROWL_NOTIFICATIONS_DEFAULT])
		return self.send(data)

	def encodeRegistration(self, application, notifications, defaultNotifications):
		data = struct.pack("!BBH",
						   GROWL_PROTOCOL_VERSION,
						   GROWL_TYPE_REGISTRATION,
						   len(application) )
		data += struct.pack("BB",
							len(notifications),
							len(defaultNotifications) )
		data += application
		for i in notifications:
			encoded = i.encode("utf-8")
			data += struct.pack("!H", len(encoded))
			data += encoded
		for i in defaultNotifications:
			data += struct.pack("B", i)
		return self.encodePassword(data)

	def encodeNotify(self, application, notification, title, description,
					 priority = 0, sticky = False):

		application  = application.encode("utf-8")
		notification = notification.encode("utf-8")
		title		= title.encode("utf-8")
		description  = description.encode("utf-8")
		flags = (priority & 0x07) * 2
		if priority < 0: 
			flags |= 0x08
		if sticky: 
			flags = flags | 0x0001
		data = struct.pack("!BBHHHHH",
						   GROWL_PROTOCOL_VERSION,
						   GROWL_TYPE_NOTIFICATION,
						   flags,
						   len(notification),
						   len(title),
						   len(description),
						   len(application) )
		data += notification
		data += title
		data += description
		data += application
		return self.encodePassword(data)

	def encodePassword(self, data):
		checksum = hashlib.md5()
		checksum.update(data)
		if self.password:
		   checksum.update(self.password)
		data += checksum.digest()
		return data

class _ImageHook(type):
	def __getattribute__(self, attr):
		global Image
		if Image is self:
			from _growlImage import Image

		return getattr(Image, attr)

class Image(object):
	__metaclass__ = _ImageHook

class _RawImage(object):
	def __init__(self, data):  self.rawImageData = data

class GrowlNotifier(object):
	"""
	A class that abstracts the process of registering and posting
	notifications to the Growl daemon.

	You can either pass `applicationName', `notifications',
	`defaultNotifications' and `applicationIcon' to the constructor
	or you may define them as class-level variables in a sub-class.

	`defaultNotifications' is optional, and defaults to the value of
	`notifications'.  `applicationIcon' is also optional but defaults
	to a pointless icon so is better to be specified.
	"""

	applicationName = 'GrowlNotifier'
	notifications = []
	defaultNotifications = []
	applicationIcon = None
	_notifyMethod = _growl

	def __init__(self, applicationName=None, notifications=None, defaultNotifications=None, applicationIcon=None, hostname=None, password=None):
		if applicationName:
			self.applicationName = applicationName
		assert self.applicationName, 'An application name is required.'

		if notifications:
			self.notifications = list(notifications)
		assert self.notifications, 'A sequence of one or more notification names is required.'

		if defaultNotifications is not None:
			self.defaultNotifications = list(defaultNotifications)
		elif not self.defaultNotifications:
			self.defaultNotifications = list(self.notifications)

		if applicationIcon is not None:
			self.applicationIcon = self._checkIcon(applicationIcon)
		elif self.applicationIcon is not None:
			self.applicationIcon = self._checkIcon(self.applicationIcon)

		if hostname is not None and password is not None:
			self._notifyMethod = netgrowl(hostname, password)
		elif hostname is not None or password is not None:
			raise KeyError, "Hostname and Password are both required for a network notification"

	def _checkIcon(self, data):
		if isinstance(data, str):
			return _RawImage(data)
		else:
			return data

	def register(self):
		if self.applicationIcon is not None:
			self.applicationIcon = self._checkIcon(self.applicationIcon)

		regInfo = {GROWL_APP_NAME: self.applicationName,
				   GROWL_NOTIFICATIONS_ALL: self.notifications,
				   GROWL_NOTIFICATIONS_DEFAULT: self.defaultNotifications,
				   GROWL_APP_ICON:self.applicationIcon,
				  }
		self._notifyMethod.PostRegistration(regInfo)

	def notify(self, noteType, title, description, icon=None, sticky=False, priority=None):
		assert noteType in self.notifications
		notifyInfo = {GROWL_NOTIFICATION_NAME: noteType,
					  GROWL_APP_NAME: self.applicationName,
					  GROWL_NOTIFICATION_TITLE: title,
					  GROWL_NOTIFICATION_DESCRIPTION: description,
					 }
		if sticky:
			notifyInfo[GROWL_NOTIFICATION_STICKY] = 1

		if priority is not None:
			notifyInfo[GROWL_NOTIFICATION_PRIORITY] = priority

		if icon:
			notifyInfo[GROWL_NOTIFICATION_ICON] = self._checkIcon(icon)

		self._notifyMethod.PostNotification(notifyInfo)