Mac/Contrib/PythonScript/PythonScript.py

"""
Python script a module to comunicate with apple events

v 0.1a2
v.0.2 16 april 1998 


"""
import sys
import getaete
import baetools
import baetypes
import AE
import AppleEvents
import macfs
from types import *
#from aetypes import InstanceType
from aepack import AEDescType

ordinal = {
'every': 'all ',
'first' : 'firs',
'last' : 'last',
'any' : 'any ',
'middle' : 'midd'}


Error = 'PythonScript.Error'


class PsEvents:
	pass


class PsClasses:

	
	def __getattr__(self, name):
		try:
			return DCItem(name, self)
		except:
			pass
		
	def __repr__(self):
		if self.form != 'prop':
			t = type(self.seld)
			if t == StringType:
				self.form = 'name'
			elif baetypes.IsRange(self.seld):
				self.form = 'rang'
			elif baetypes.IsComparison(self.seld) or baetypes.IsLogical(self.seld):
				self.form = 'test'
			elif t == TupleType:
			# Breakout: specify both form and seld in a tuple
			# (if you want ID or rele or somesuch)
				self.form, self.seld = self.seld
			elif t == IntType:
				self.form = 'indx'
			else:
				pass

		if self.seld in ordinal.keys():
			self.seld = baetypes.Ordinal(ordinal[self.seld])
			self.form = 'indx'

		s = "baetypes.ObjectSpecifier(%s, %s, %s" % (`self.want`, `self.form`, `self.seld`)
		if `self.fr`:
			s = s + ", %s)" % `self.fr`
		else:
			s = s + ")"
		return s
		
	def __str__(self):
		return self.want
		
		
def template(self, seld=None, fr=None):
	self.seld = seld
	self.fr = fr
		
def template1(self, which, fr=None):
	self.want = 'prop'
	self.form = 'prop'
	self.fr = fr
	
class DCItem:
	def __init__(self, comp, fr):
		self.compclass = comp
		self.fr = fr
		
	def __call__(self, which=None):
		if which:
			self.compclass = eval('PsClass.%s' % self.compclass)
		else:
			try:
				self.compclass = eval('PsProperties.%s' % self.compclass)
			except AttributeError:
				self.compclass = eval('PsClass.%s' % self.compclass)
		return self.compclass(which, self.fr)

class PsClass:
	pass

class PsProperties:
	pass				


class PsEnumerations:
	pass

			
def PsScript(sig=None, Timeout=0, Ignoring=0):
	elements = {}
	if sig:
		target, sig = Signature(sig)
		pyscript = getaete.Getaete(sig)
	else:
		target, sig = Signature('Pyth')
		pyscript = getaete.Getaete()
	setattr(PyScript, 'timeout', Timeout)
	setattr(PyScript, 'ignoring', Ignoring)
	setattr(PyScript, 'target', target)
	for key, value in pyscript[0].items():
		setattr(PsEvents, key, value)
	for key, value in pyscript[1].items():
		CreateClass(key, 'PsClasses', value)
		for val in value[2]:
			CreateProperty(val[0], 'PsClasses', `val[1]`)
			
		if value[3]:
			for val in value[3]:
				if val[0] not in elements.keys():
					elements[val[0]] = val[1]
				elif len(val[1]) > len(elements[val[0]]):
					elements[val[0]] = val[1]

	for key, value in pyscript[2].items():
		for val in value:
			setattr(PsEnumerations, val[0], val[1])

def CreateClass(newClassName, superClassName, value):
	parentDict = PsClass.__dict__
	exec "class %s(%s): pass" % (newClassName, superClassName) in \
			globals(), parentDict
	newClassObj = parentDict[newClassName]
	newClassObj.__init__ = template
	exec "setattr(newClassObj, 'want', %s)" % `value[0]`
	if value[2] and value[2][0][0] == 'every':
		exec "setattr(newClassObj, 'plur', 1)"

def CreateProperty(newClassName, superClassName, value):
	parentDict = PsProperties.__dict__
	exec "class %s(%s): pass" % (newClassName, superClassName) in \
			globals(), parentDict
	newClassObj = parentDict[newClassName]
	if newClassName == 'Every':
		value = "baetypes.mkOrdinal('every')"
	newClassObj.__init__ = template1
	exec "setattr(newClassObj, 'seld', %s)" % value

def Signature(signature):
	if type(signature) == AEDescType:
		target = signature
	elif type(signature) == InstanceType and hasattr(signature, '__aepack__'):
		target = signature.__aepack__()
	elif type(signature) == StringType:
		if len(signature) == 4:
			target = AE.AECreateDesc(AppleEvents.typeApplSignature, signature)
			target_signature = signature
		else:
			#This should ready be made persistant, so PythonScript 'remembered' where applications were
			fss, ok = macfs.PromptGetFile('Find the aplication %s' % signature, 'APPL')
			if ok:
				target_signature = fss.GetCreatorType()[0]
				target = AE.AECreateDesc(AppleEvents.typeApplSignature, target_signature)
	else:
		raise TypeError, "signature should be 4-char string or AEDesc"
	return target, target_signature

		

		
class PyScript(PsEvents):
	def __init__(self, name, obj=None,  **args):
		desc, code, subcode, rply, message, keywds = name
#		print 'code', code
#		print 'subcode', subcode
#		print 'rply', rply
#		print 'message', message
#		print 'keywds', keywds
#		print 'name', name
#		print 'obj', obj
#		print 'args', args
		self.code = code
		self.subcode = subcode
		self.attributes ={}
		self.arguments = {}
		if keywds:
			self.arguments = self.keyargs(keywds, args)
		self.arguments['----'] = self.keyfms(message[0], obj)

		##XXXX Eudora needs this XXXX##
		if self.arguments['----'] == None:
			del self.arguments['----']
#		print 'arguments', self.arguments
		if self.ignoring or rply[0] == 'null':
			self.send_flags = AppleEvents.kAENoReply
		else:
			self.send_flags = AppleEvents.kAEWaitReply
		self.send_priority = AppleEvents.kAENormalPriority	
		if self.timeout:
			self.send_timeout = self.timeout
		else:
			self.send_timeout = AppleEvents.kAEDefaultTimeout


	def keyargs(self, ats, args):
#		print 'keyargs', ats, args
		output = {}
		for arg in args.keys():
			for at in ats:
				if at[0] == arg:
					output[at[1]] = self.keyfms(at[2][0], args[arg])
		return output
				
	def keyfms(self, key, value):
#		print 'keyfms', 'key', key, `value`
		if key == 'obj ' or key == 'insl':
			return eval(`value`)
		elif key == 'TEXT':
			return value
		elif key == 'null':
			return 
		elif key == 'bool':
			return baetypes.mkboolean(value)
		elif key == 'type':
			try:
				val = eval('PsClass.%s()' % value)
				return baetypes.mktype(str(val))
			except:
				return baetypes.mktype(value)
		else:
			print "I don't know what to put here -- script.keyargs"
			print key, `value`
			sys.exit[1]
		
	def newevent(self, code, subcode, parameters = {}, attributes = {}):
		"""Create a complete structure for an apple event"""
#		print code, subcode, parameters, attributes
		event = AE.AECreateAppleEvent(code, subcode, self.target,
			  	  AppleEvents.kAutoGenerateReturnID, AppleEvents.kAnyTransactionID)
		baetools.packevent(event, parameters, attributes)
		return event
		
	def sendevent(self, event):
		"""Send a pre-created appleevent, await the reply and unpack it"""
		
		reply = event.AESend(self.send_flags, self.send_priority,
							  self.send_timeout)
		parameters, attributes = baetools.unpackevent(reply)
		return reply, parameters, attributes
		
	def send(self, code, subcode, parameters = {}, attributes = {}):
		"""Send an appleevent given code/subcode/pars/attrs and unpack the reply"""
#		print code, subcode, parameters, attributes
		return self.sendevent(self.newevent(code, subcode, parameters, attributes))
		
	def __str__(self):
		_reply, _arguments, _attributes = self.send(self.code, self.subcode, self.arguments, self.attributes)

		if _arguments.has_key('errn'):
			raise baetools.Error, baetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return str(_arguments['----'])
		else:
			return 

	
	
def test():
	Simp = 'Hermit:Applications:SimpleText'
	PsScript('MACS', Timeout=60*60*3)
#	PsScript('CSOm', Timeout=60*60*3)
#	PsScript('', Timeout=60*60*3)
#	PyScript('macsoup')
	ev = PsEvents
	ps = PsClass
#	print PsProperties.__dict__
#	y = script(ev.Open, File('Hermit:Desktop Folder:Lincolnshire Imp'), using=Application_file(Simp))
#	print baetypes.NProperty('prop', 'prop', 'pnam',  baetypes.ObjectSpecifier('cdis', 'indx', 1, None))
#	y = PyScript(ev.Get, Disk("Hermit").Folder(7).File(1).Name())
#	y = PyScript(ev.Get, Disk("Hermit").Size(), As='Integer')
#	y = PyScript(ev.Get, ps.Desktopobject(1).Startup_disk())
#	y = PyScript(ev.Get, Mailbox(1).File(), as='TEXT')
#	print 'y', y, type(y)

if __name__ == '__main__':
	test()
#	sys.exit(1)