| ''' |
| 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() |