Erik van Blokland's CaptureAE.

2 files changed, 367 insertions, 0 deletions

diff --git a/Mac/Contrib/AECaptureParser/AECaptureParser.py b/Mac/Contrib/AECaptureParser/AECaptureParser.py
new file mode 100644
index 0000000..25a0237
--- /dev/null
+++ b/Mac/Contrib/AECaptureParser/AECaptureParser.py
@@ -0,0 +1,362 @@
+'''
+AECaptureParser makes a brave attempt to convert the text output
+of the very handy Lasso Capture AE control panel
+into close-enough executable python code.
+
+In a roundabout way AECaptureParser offers the way to write lines of AppleScript
+and convert them to python code. Once Pythonised, the code can be made prettier,
+and it can run without Capture or Script Editor being open.
+
+You need Lasso Capture AE from Blueworld:
+ftp://ftp.blueworld.com/Lasso251/LassoCaptureAE.hqx
+
+Lasso Capture AE prints structured ascii representations in a small window.
+As these transcripts can be very complex, cut and paste to AECaptureParser, it parses and writes
+python code that will, when executed, cause the same events to happen.
+It's been tested with some household variety events, I'm sure there will be tons that
+don't work.
+
+All objects are converted to standard aetypes.ObjectSpecifier instances.
+
+How to use:
+	1. Start the Capture window
+	2. Cause the desired appleevent to happen
+		- by writing a line of applescript in Script Editor and running it (!)
+		- by recording some action in Script Editor and running it
+	3. Find the events in Capture:
+		- make sure you get the appropriate events, cull if necessary
+		- sometimes Capture barfs, just quit and start Capture again, run events again
+		- AECaptureParser can process multiple events - it will just make more code.
+	4. Copy and paste in this script and execute
+	5. It will print python code that, when executed recreates the events.
+
+Example:
+	For instance the following line of AppleScript in Script Editor
+			tell application "Finder"
+				return application processes
+			end tell
+	will result in the following transcript:
+			[event: target="Finder", class=core, id=getd]
+			'----':obj {form:indx, want:type(pcap), seld:abso(«616C6C20»), from:'null'()}
+			[/event]
+	Feed a string with this (and perhaps more) events to AECaptureParser
+	
+Some mysteries:
+	* 	what is '&subj' - it is sent in an activate event:	&subj:'null'()
+		The activate event works when this is left out. A possibility?
+	*	needs to deal with embedded aliasses
+
+
+'''
+__version__ = '0.002'
+__author__ = 'evb'
+
+
+import string 
+
+opentag = '{'
+closetag = '}'
+
+
+
+import aetools
+import aetypes
+
+class eventtalker(aetools.TalkTo):
+	pass
+
+def processes():
+	'''Helper function to get the list of current processes and their creators
+	This code was mostly written by AECaptureParser! It ain't pretty, but that's not python's fault!'''
+	talker = eventtalker('MACS')
+	_arguments = {}
+	_attributes = {}
+	p = []
+	names = []
+	creators = []
+	results = []
+	# first get the list of process names
+	_arguments['----'] = aetypes.ObjectSpecifier(want=aetypes.Type('pcap'),
+			form="indx", seld=aetypes.Unknown('abso', "all "), fr=None)
+	_reply, _arguments, _attributes = talker.send('core', 'getd', _arguments, _attributes)
+	if _arguments.has_key('errn'):
+		raise aetools.Error, aetools.decodeerror(_arguments)
+	if _arguments.has_key('----'):
+		p = _arguments['----']
+	for proc in p:
+		names.append(proc.seld)
+	# then get the list of process creators
+	_arguments = {}
+	_attributes = {}
+	AEobject_00 = aetypes.ObjectSpecifier(want=aetypes.Type('pcap'), form="indx", seld=aetypes.Unknown('abso', "all "), fr=None)
+	AEobject_01 = aetypes.ObjectSpecifier(want=aetypes.Type('prop'), form="prop", seld=aetypes.Type('fcrt'), fr=AEobject_00)
+	_arguments['----'] = AEobject_01
+	_reply, _arguments, _attributes = talker.send('core', 'getd', _arguments, _attributes)
+	if _arguments.has_key('errn'):
+		raise aetools.Error, aetools.decodeerror(_arguments)
+	if _arguments.has_key('----'):
+		p = _arguments['----']
+	for proc in p:
+		creators.append(proc.type)
+	# then put the lists together
+	for i in range(len(names)):
+		results.append((names[i], creators[i]))
+	return results
+
+		
+class AECaptureParser:
+	'''convert a captured appleevent-description into executable python code'''
+	def __init__(self, aetext):
+		self.aetext = aetext
+		self.events = []
+		self.arguments = {}
+		self.objectindex = 0
+		self.varindex = 0
+		self.currentevent =  {'variables':{}, 'arguments':{}, 'objects':{}}
+		self.parse()
+	
+	def parse(self):
+		self.lines = string.split(self.aetext, '\n')
+		for l in self.lines:
+			if l[:7] == '[event:':
+				self.eventheader(l)
+			elif l[:7] == '[/event':
+				if len(self.currentevent)<>0:
+					self.events.append(self.currentevent)
+					self.currentevent = {'variables':{}, 'arguments':{}, 'objects':{}}
+					self.objectindex = 0
+			else:
+				self.line(l)
+	
+	def line(self, value):
+		'''interpret literals, variables, lists etc.'''
+		# stuff in [  ], l ists
+		varstart = string.find(value, '[')
+		varstop = string.find(value, ']')
+		if varstart <> -1 and varstop <> -1 and varstop>varstart:
+			variable = value[varstart:varstop+1]
+			name = 'aevar_'+string.zfill(self.varindex, 2)
+			self.currentevent['variables'][name] = variable
+			value = value[:varstart]+name+value[varstop+1:]
+			self.varindex = self.varindex + 1
+		# stuff in «  »
+		# these are 'ordinal' descriptors of 4 letter codes, so translate
+		varstart = string.find(value, '«')
+		varstop = string.find(value, '»')
+		if varstart <> -1 and varstop <> -1 and varstop>varstart:
+			variable = value[varstart+1:varstop]
+			t = ''
+			for i in range(0, len(variable), 2):
+				c = eval('0x'+variable[i : i+2])
+				t = t + chr(c)
+			
+			name = 'aevar_'+string.zfill(self.varindex, 2)
+			self.currentevent['variables'][name] = '"' + t + '"'
+			value = value[:varstart]+name+value[varstop+1:]
+			self.varindex = self.varindex + 1
+		pos = string.find(value, ':')
+		if pos==-1:return
+		ok = 1
+		while ok <> None:
+			value, ok = self.parseobject(value)
+		self.currentevent['arguments'].update(self.splitparts(value, ':'))
+		
+		# remove the &subj argument?
+		if self.currentevent['arguments'].has_key('&subj'):
+			del self.currentevent['arguments']['&subj']
+			
+		# check for arguments len(a) < 4, and pad with spaces
+		for k in self.currentevent['arguments'].keys():
+			if len(k)<4:
+				newk = k + (4-len(k))*' '
+				self.currentevent['arguments'][newk] = self.currentevent['arguments'][k]
+				del self.currentevent['arguments'][k]
+
+	def parseobject(self, obj):
+		a, b = self.findtag(obj)
+		stuff = None
+		if a<>None and b<>None:
+			stuff = obj[a:b]
+			name = 'AEobject_'+string.zfill(self.objectindex, 2)
+			self.currentevent['objects'][name] = self.splitparts(stuff, ':')
+			obj = obj[:a-5] + name + obj[b+1:]
+			self.objectindex = self.objectindex +1
+		return obj, stuff
+		
+	def nextopen(self, pos, text):
+		return string.find(text, opentag, pos)
+		
+	def nextclosed(self, pos, text):
+		return string.find(text, closetag, pos)
+	
+	def nexttag(self, pos, text):
+		start = self.nextopen(pos, text)
+		stop = self.nextclosed(pos, text)
+		if start == -1:
+			if stop == -1:
+				return -1, -1
+			return 0, stop
+		if start < stop and start<>-1:
+			return 1, start
+		else:
+			return 0, stop
+					
+	def findtag(self, text):
+		p = -1
+		last = None,None
+		while 1:
+			kind, p = self.nexttag(p+1, text)
+			if last[0]==1 and kind==0:
+				return last[1]+len(opentag), p
+			if (kind, p) == (-1, -1):
+				break
+			last=kind, p
+		return None, None
+	
+	def splitparts(self, txt, splitter):
+		res = {}
+		parts = string.split(txt, ', ')
+		for p in parts:
+			pos = string.find(p, splitter)
+			key = string.strip(p[:pos])
+			value = string.strip(p[pos+1:])
+			res[key] = self.map(value)
+		return res
+		
+	def eventheader(self, hdr):
+		self.currentevent['event'] = self.splitparts(hdr[7:-1], '=')
+	
+	def printobject(self, d):
+		'''print one object as python code'''
+		t = []
+		obj = {}
+		obj.update(d)
+		t.append("aetypes.ObjectSpecifier(")
+		if obj.has_key('want'):
+			t.append('want=' + self.map(obj['want']))
+			del obj['want']
+			t.append(', ')
+		if obj.has_key('form'):
+			t.append('form=' + addquotes(self.map(obj['form'])))
+			del obj['form']
+			t.append(', ')
+		if obj.has_key('seld'):
+			t.append('seld=' + self.map(obj['seld']))
+			del obj['seld']
+			t.append(', ')
+		if obj.has_key('from'):
+			t.append('fr=' + self.map(obj['from']))
+			del obj['from']
+		if len(obj.keys()) > 0:
+			print '# ', `obj`			
+		t.append(")")
+		return string.join(t, '')
+	
+	def map(self, t):
+		'''map some Capture syntax to python
+		matchstring : [(old, new), ... ]
+		'''
+		m = {
+				'type(': [('type(', "aetypes.Type('"), (')', "')")],
+				"'null'()": [("'null'()", "None")],
+				'abso(': [('abso(', "aetypes.Unknown('abso', ")],
+				'³':	[('³', '"')],
+				'²':	[('²', '"')],
+				'[':	[('[', '('), (', ', ',')],
+				']':	[(']', ')')],
+				'«':	[('«', "«")],
+				'»':	[('»', "»")],
+				
+			}
+		for k in m.keys():
+			if string.find(t, k) <> -1:
+				for old, new in m[k]:
+					p = string.split(t, old)
+					t = string.join(p, new)
+		return t
+		
+	def printevent(self, i):
+		'''print the entire captured sequence as python'''
+		evt = self.events[i]
+		code = []
+		code.append('\n# start event ' + `i` + ', talking to ' + evt['event']['target'])
+		# get the signature for the target application
+		code.append('talker = eventtalker("'+self.gettarget(evt['event']['target'])+'")')
+		code.append("_arguments = {}")
+		code.append("_attributes = {}")
+		# write the variables
+		for key, value in evt['variables'].items():
+			value = evt['variables'][key]
+			code.append(key + ' = ' + value)
+		# write the object in the right order
+		objkeys = evt['objects'].keys()
+		objkeys.sort()
+		for key in objkeys:
+			value = evt['objects'][key]
+			code.append(key + ' = ' + self.printobject(value))
+		# then write the arguments
+		for key, value in evt['arguments'].items():
+			code.append("_arguments[" + addquotes(key) + "] = " + value )
+		code.append('_reply, _arguments, _attributes = talker.send("'+
+				evt['event']['class']+'", "'+evt['event']['id']+'", _arguments, _attributes)')
+		code.append("if _arguments.has_key('errn'):")
+		code.append('\traise aetools.Error, aetools.decodeerror(_arguments)')	
+		code.append("if _arguments.has_key('----'):")
+		code.append("\tprint _arguments['----']")
+		code.append('# end event ' + `i`)
+		return string.join(code, '\n')
+	
+	def gettarget(self, target):
+		'''get the signature for the target application'''
+		target = target[1:-1]
+		if target == 'Finder':
+			return "MACS"
+		apps = processes()
+		for name, creator in apps:
+			if name == target:
+				return creator
+		return '****'
+			
+	def makecode(self):
+		code = []
+		code.append("\n\n")
+		code.append("# code generated by AECaptureParser v " + __version__)
+		code.append("# imports, definitions for all events")
+		code.append("import aetools")
+		code.append("import aetypes")
+		code.append("class eventtalker(aetools.TalkTo):")
+		code.append("\tpass")
+		code.append("# the events")
+		# print the events
+		for i in range(len(self.events)):
+			code.append(self.printevent(i))
+		code.append("# end code")
+		return string.join(code, '\n')
+
+def addquotes(txt):
+	quotes = ['"', "'"]
+	if not txt[0] in quotes and not txt[-1] in quotes:
+		return '"'+txt+'"'
+	return txt 
+	
+	
+
+
+
+
+# ------------------------------------------
+#	the factory
+# ------------------------------------------
+
+# for instance, this event was captured from the Script Editor asking the Finder for a list of active processes.
+
+eventreceptacle = """
+
+[event: target="Finder", class=core, id=setd]
+'----':obj {form:prop, want:type(prop), seld:type(posn), from:obj {form:name, want:type(cfol), seld:³MoPar:Data:DevDev:Python:Python 1.5.2c1:Extensions², from:'null'()}}, data:[100, 10]
+[/event]
+
+"""
+
+aet = AECaptureParser(eventreceptacle)
+print aet.makecode()
diff --git a/Mac/Contrib/AECaptureParser/readme.txt b/Mac/Contrib/AECaptureParser/readme.txt
new file mode 100644
index 0000000..1506111
--- /dev/null
+++ b/Mac/Contrib/AECaptureParser/readme.txt
@@ -0,0 +1,5 @@
+AECaptureParser is a tool by Erik van Blokland, erik@letterror.com, which
+listens for AppleEvents and turns them into the Python code that will generate
+those events when executed.
+
+Lots more information is in the docstring in the code.