"""

 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)