'''
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 import
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 import
[/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()
|