|
| 1 | +''' |
| 2 | +AECaptureParser makes a brave attempt to convert the text output |
| 3 | +of the very handy Lasso Capture AE control panel |
| 4 | +into close-enough executable python code. |
| 5 | +
|
| 6 | +In a roundabout way AECaptureParser offers the way to write lines of AppleScript |
| 7 | +and convert them to python code. Once Pythonised, the code can be made prettier, |
| 8 | +and it can run without Capture or Script Editor being open. |
| 9 | +
|
| 10 | +You need Lasso Capture AE from Blueworld: |
| 11 | +ftp://ftp.blueworld.com/Lasso251/LassoCaptureAE.hqx |
| 12 | +
|
| 13 | +Lasso Capture AE prints structured ascii representations in a small window. |
| 14 | +As these transcripts can be very complex, cut and paste to AECaptureParser, it parses and writes |
| 15 | +python code that will, when executed, cause the same events to happen. |
| 16 | +It's been tested with some household variety events, I'm sure there will be tons that |
| 17 | +don't work. |
| 18 | +
|
| 19 | +All objects are converted to standard aetypes.ObjectSpecifier instances. |
| 20 | +
|
| 21 | +How to use: |
| 22 | + 1. Start the Capture window |
| 23 | + 2. Cause the desired appleevent to happen |
| 24 | + - by writing a line of applescript in Script Editor and running it (!) |
| 25 | + - by recording some action in Script Editor and running it |
| 26 | + 3. Find the events in Capture: |
| 27 | + - make sure you get the appropriate events, cull if necessary |
| 28 | + - sometimes Capture barfs, just quit and start Capture again, run events again |
| 29 | + - AECaptureParser can process multiple events - it will just make more code. |
| 30 | + 4. Copy and paste in this script and execute |
| 31 | + 5. It will print python code that, when executed recreates the events. |
| 32 | +
|
| 33 | +Example: |
| 34 | + For instance the following line of AppleScript in Script Editor |
| 35 | + tell application "Finder" |
| 36 | + return application processes |
| 37 | + end tell |
| 38 | + will result in the following transcript: |
| 39 | + [event: target="Finder", class=core, id=getd] |
| 40 | + '----':obj {form:indx, want:type(pcap), seld:abso(«616C6C20»), from:'null'()} |
| 41 | + [/event] |
| 42 | + Feed a string with this (and perhaps more) events to AECaptureParser |
| 43 | + |
| 44 | +Some mysteries: |
| 45 | + * what is '&subj' - it is sent in an activate event: &subj:'null'() |
| 46 | + The activate event works when this is left out. A possibility? |
| 47 | + * needs to deal with embedded aliasses |
| 48 | +
|
| 49 | +
|
| 50 | +''' |
| 51 | +__version__ = '0.002' |
| 52 | +__author__ = 'evb' |
| 53 | + |
| 54 | + |
| 55 | +import string |
| 56 | + |
| 57 | +opentag = '{' |
| 58 | +closetag = '}' |
| 59 | + |
| 60 | + |
| 61 | + |
| 62 | +import aetools |
| 63 | +import aetypes |
| 64 | + |
| 65 | +class eventtalker(aetools.TalkTo): |
| 66 | + pass |
| 67 | + |
| 68 | +def processes(): |
| 69 | + '''Helper function to get the list of current processes and their creators |
| 70 | + This code was mostly written by AECaptureParser! It ain't pretty, but that's not python's fault!''' |
| 71 | + talker = eventtalker('MACS') |
| 72 | + _arguments = {} |
| 73 | + _attributes = {} |
| 74 | + p = [] |
| 75 | + names = [] |
| 76 | + creators = [] |
| 77 | + results = [] |
| 78 | + # first get the list of process names |
| 79 | + _arguments['----'] = aetypes.ObjectSpecifier(want=aetypes.Type('pcap'), |
| 80 | + form="indx", seld=aetypes.Unknown('abso', "all "), fr=None) |
| 81 | + _reply, _arguments, _attributes = talker.send('core', 'getd', _arguments, _attributes) |
| 82 | + if _arguments.has_key('errn'): |
| 83 | + raise aetools.Error, aetools.decodeerror(_arguments) |
| 84 | + if _arguments.has_key('----'): |
| 85 | + p = _arguments['----'] |
| 86 | + for proc in p: |
| 87 | + names.append(proc.seld) |
| 88 | + # then get the list of process creators |
| 89 | + _arguments = {} |
| 90 | + _attributes = {} |
| 91 | + AEobject_00 = aetypes.ObjectSpecifier(want=aetypes.Type('pcap'), form="indx", seld=aetypes.Unknown('abso', "all "), fr=None) |
| 92 | + AEobject_01 = aetypes.ObjectSpecifier(want=aetypes.Type('prop'), form="prop", seld=aetypes.Type('fcrt'), fr=AEobject_00) |
| 93 | + _arguments['----'] = AEobject_01 |
| 94 | + _reply, _arguments, _attributes = talker.send('core', 'getd', _arguments, _attributes) |
| 95 | + if _arguments.has_key('errn'): |
| 96 | + raise aetools.Error, aetools.decodeerror(_arguments) |
| 97 | + if _arguments.has_key('----'): |
| 98 | + p = _arguments['----'] |
| 99 | + for proc in p: |
| 100 | + creators.append(proc.type) |
| 101 | + # then put the lists together |
| 102 | + for i in range(len(names)): |
| 103 | + results.append((names[i], creators[i])) |
| 104 | + return results |
| 105 | + |
| 106 | + |
| 107 | +class AECaptureParser: |
| 108 | + '''convert a captured appleevent-description into executable python code''' |
| 109 | + def __init__(self, aetext): |
| 110 | + self.aetext = aetext |
| 111 | + self.events = [] |
| 112 | + self.arguments = {} |
| 113 | + self.objectindex = 0 |
| 114 | + self.varindex = 0 |
| 115 | + self.currentevent = {'variables':{}, 'arguments':{}, 'objects':{}} |
| 116 | + self.parse() |
| 117 | + |
| 118 | + def parse(self): |
| 119 | + self.lines = string.split(self.aetext, '\n') |
| 120 | + for l in self.lines: |
| 121 | + if l[:7] == '[event:': |
| 122 | + self.eventheader(l) |
| 123 | + elif l[:7] == '[/event': |
| 124 | + if len(self.currentevent)<>0: |
| 125 | + self.events.append(self.currentevent) |
| 126 | + self.currentevent = {'variables':{}, 'arguments':{}, 'objects':{}} |
| 127 | + self.objectindex = 0 |
| 128 | + else: |
| 129 | + self.line(l) |
| 130 | + |
| 131 | + def line(self, value): |
| 132 | + '''interpret literals, variables, lists etc.''' |
| 133 | + # stuff in [ ], l ists |
| 134 | + varstart = string.find(value, '[') |
| 135 | + varstop = string.find(value, ']') |
| 136 | + if varstart <> -1 and varstop <> -1 and varstop>varstart: |
| 137 | + variable = value[varstart:varstop+1] |
| 138 | + name = 'aevar_'+string.zfill(self.varindex, 2) |
| 139 | + self.currentevent['variables'][name] = variable |
| 140 | + value = value[:varstart]+name+value[varstop+1:] |
| 141 | + self.varindex = self.varindex + 1 |
| 142 | + # stuff in « » |
| 143 | + # these are 'ordinal' descriptors of 4 letter codes, so translate |
| 144 | + varstart = string.find(value, '«') |
| 145 | + varstop = string.find(value, '»') |
| 146 | + if varstart <> -1 and varstop <> -1 and varstop>varstart: |
| 147 | + variable = value[varstart+1:varstop] |
| 148 | + t = '' |
| 149 | + for i in range(0, len(variable), 2): |
| 150 | + c = eval('0x'+variable[i : i+2]) |
| 151 | + t = t + chr(c) |
| 152 | + |
| 153 | + name = 'aevar_'+string.zfill(self.varindex, 2) |
| 154 | + self.currentevent['variables'][name] = '"' + t + '"' |
| 155 | + value = value[:varstart]+name+value[varstop+1:] |
| 156 | + self.varindex = self.varindex + 1 |
| 157 | + pos = string.find(value, ':') |
| 158 | + if pos==-1:return |
| 159 | + ok = 1 |
| 160 | + while ok <> None: |
| 161 | + value, ok = self.parseobject(value) |
| 162 | + self.currentevent['arguments'].update(self.splitparts(value, ':')) |
| 163 | + |
| 164 | + # remove the &subj argument? |
| 165 | + if self.currentevent['arguments'].has_key('&subj'): |
| 166 | + del self.currentevent['arguments']['&subj'] |
| 167 | + |
| 168 | + # check for arguments len(a) < 4, and pad with spaces |
| 169 | + for k in self.currentevent['arguments'].keys(): |
| 170 | + if len(k)<4: |
| 171 | + newk = k + (4-len(k))*' ' |
| 172 | + self.currentevent['arguments'][newk] = self.currentevent['arguments'][k] |
| 173 | + del self.currentevent['arguments'][k] |
| 174 | + |
| 175 | + def parseobject(self, obj): |
| 176 | + a, b = self.findtag(obj) |
| 177 | + stuff = None |
| 178 | + if a<>None and b<>None: |
| 179 | + stuff = obj[a:b] |
| 180 | + name = 'AEobject_'+string.zfill(self.objectindex, 2) |
| 181 | + self.currentevent['objects'][name] = self.splitparts(stuff, ':') |
| 182 | + obj = obj[:a-5] + name + obj[b+1:] |
| 183 | + self.objectindex = self.objectindex +1 |
| 184 | + return obj, stuff |
| 185 | + |
| 186 | + def nextopen(self, pos, text): |
| 187 | + return string.find(text, opentag, pos) |
| 188 | + |
| 189 | + def nextclosed(self, pos, text): |
| 190 | + return string.find(text, closetag, pos) |
| 191 | + |
| 192 | + def nexttag(self, pos, text): |
| 193 | + start = self.nextopen(pos, text) |
| 194 | + stop = self.nextclosed(pos, text) |
| 195 | + if start == -1: |
| 196 | + if stop == -1: |
| 197 | + return -1, -1 |
| 198 | + return 0, stop |
| 199 | + if start < stop and start<>-1: |
| 200 | + return 1, start |
| 201 | + else: |
| 202 | + return 0, stop |
| 203 | + |
| 204 | + def findtag(self, text): |
| 205 | + p = -1 |
| 206 | + last = None,None |
| 207 | + while 1: |
| 208 | + kind, p = self.nexttag(p+1, text) |
| 209 | + if last[0]==1 and kind==0: |
| 210 | + return last[1]+len(opentag), p |
| 211 | + if (kind, p) == (-1, -1): |
| 212 | + break |
| 213 | + last=kind, p |
| 214 | + return None, None |
| 215 | + |
| 216 | + def splitparts(self, txt, splitter): |
| 217 | + res = {} |
| 218 | + parts = string.split(txt, ', ') |
| 219 | + for p in parts: |
| 220 | + pos = string.find(p, splitter) |
| 221 | + key = string.strip(p[:pos]) |
| 222 | + value = string.strip(p[pos+1:]) |
| 223 | + res[key] = self.map(value) |
| 224 | + return res |
| 225 | + |
| 226 | + def eventheader(self, hdr): |
| 227 | + self.currentevent['event'] = self.splitparts(hdr[7:-1], '=') |
| 228 | + |
| 229 | + def printobject(self, d): |
| 230 | + '''print one object as python code''' |
| 231 | + t = [] |
| 232 | + obj = {} |
| 233 | + obj.update(d) |
| 234 | + t.append("aetypes.ObjectSpecifier(") |
| 235 | + if obj.has_key('want'): |
| 236 | + t.append('want=' + self.map(obj['want'])) |
| 237 | + del obj['want'] |
| 238 | + t.append(', ') |
| 239 | + if obj.has_key('form'): |
| 240 | + t.append('form=' + addquotes(self.map(obj['form']))) |
| 241 | + del obj['form'] |
| 242 | + t.append(', ') |
| 243 | + if obj.has_key('seld'): |
| 244 | + t.append('seld=' + self.map(obj['seld'])) |
| 245 | + del obj['seld'] |
| 246 | + t.append(', ') |
| 247 | + if obj.has_key('from'): |
| 248 | + t.append('fr=' + self.map(obj['from'])) |
| 249 | + del obj['from'] |
| 250 | + if len(obj.keys()) > 0: |
| 251 | + print '# ', `obj` |
| 252 | + t.append(")") |
| 253 | + return string.join(t, '') |
| 254 | + |
| 255 | + def map(self, t): |
| 256 | + '''map some Capture syntax to python |
| 257 | + matchstring : [(old, new), ... ] |
| 258 | + ''' |
| 259 | + m = { |
| 260 | + 'type(': [('type(', "aetypes.Type('"), (')', "')")], |
| 261 | + "'null'()": [("'null'()", "None")], |
| 262 | + 'abso(': [('abso(', "aetypes.Unknown('abso', ")], |
| 263 | + '³': [('³', '"')], |
| 264 | + '²': [('²', '"')], |
| 265 | + '[': [('[', '('), (', ', ',')], |
| 266 | + ']': [(']', ')')], |
| 267 | + '«': [('«', "«")], |
| 268 | + '»': [('»', "»")], |
| 269 | + |
| 270 | + } |
| 271 | + for k in m.keys(): |
| 272 | + if string.find(t, k) <> -1: |
| 273 | + for old, new in m[k]: |
| 274 | + p = string.split(t, old) |
| 275 | + t = string.join(p, new) |
| 276 | + return t |
| 277 | + |
| 278 | + def printevent(self, i): |
| 279 | + '''print the entire captured sequence as python''' |
| 280 | + evt = self.events[i] |
| 281 | + code = [] |
| 282 | + code.append('\n# start event ' + `i` + ', talking to ' + evt['event']['target']) |
| 283 | + # get the signature for the target application |
| 284 | + code.append('talker = eventtalker("'+self.gettarget(evt['event']['target'])+'")') |
| 285 | + code.append("_arguments = {}") |
| 286 | + code.append("_attributes = {}") |
| 287 | + # write the variables |
| 288 | + for key, value in evt['variables'].items(): |
| 289 | + value = evt['variables'][key] |
| 290 | + code.append(key + ' = ' + value) |
| 291 | + # write the object in the right order |
| 292 | + objkeys = evt['objects'].keys() |
| 293 | + objkeys.sort() |
| 294 | + for key in objkeys: |
| 295 | + value = evt['objects'][key] |
| 296 | + code.append(key + ' = ' + self.printobject(value)) |
| 297 | + # then write the arguments |
| 298 | + for key, value in evt['arguments'].items(): |
| 299 | + code.append("_arguments[" + addquotes(key) + "] = " + value ) |
| 300 | + code.append('_reply, _arguments, _attributes = talker.send("'+ |
| 301 | + evt['event']['class']+'", "'+evt['event']['id']+'", _arguments, _attributes)') |
| 302 | + code.append("if _arguments.has_key('errn'):") |
| 303 | + code.append('\traise aetools.Error, aetools.decodeerror(_arguments)') |
| 304 | + code.append("if _arguments.has_key('----'):") |
| 305 | + code.append("\tprint _arguments['----']") |
| 306 | + code.append('# end event ' + `i`) |
| 307 | + return string.join(code, '\n') |
| 308 | + |
| 309 | + def gettarget(self, target): |
| 310 | + '''get the signature for the target application''' |
| 311 | + target = target[1:-1] |
| 312 | + if target == 'Finder': |
| 313 | + return "MACS" |
| 314 | + apps = processes() |
| 315 | + for name, creator in apps: |
| 316 | + if name == target: |
| 317 | + return creator |
| 318 | + return '****' |
| 319 | + |
| 320 | + def makecode(self): |
| 321 | + code = [] |
| 322 | + code.append("\n\n") |
| 323 | + code.append("# code generated by AECaptureParser v " + __version__) |
| 324 | + code.append("# imports, definitions for all events") |
| 325 | + code.append("import aetools") |
| 326 | + code.append("import aetypes") |
| 327 | + code.append("class eventtalker(aetools.TalkTo):") |
| 328 | + code.append("\tpass") |
| 329 | + code.append("# the events") |
| 330 | + # print the events |
| 331 | + for i in range(len(self.events)): |
| 332 | + code.append(self.printevent(i)) |
| 333 | + code.append("# end code") |
| 334 | + return string.join(code, '\n') |
| 335 | + |
| 336 | +def addquotes(txt): |
| 337 | + quotes = ['"', "'"] |
| 338 | + if not txt[0] in quotes and not txt[-1] in quotes: |
| 339 | + return '"'+txt+'"' |
| 340 | + return txt |
| 341 | + |
| 342 | + |
| 343 | + |
| 344 | + |
| 345 | + |
| 346 | + |
| 347 | +# ------------------------------------------ |
| 348 | +# the factory |
| 349 | +# ------------------------------------------ |
| 350 | + |
| 351 | +# for instance, this event was captured from the Script Editor asking the Finder for a list of active processes. |
| 352 | + |
| 353 | +eventreceptacle = """ |
| 354 | +
|
| 355 | +[event: target="Finder", class=core, id=setd] |
| 356 | +'----':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] |
| 357 | +[/event] |
| 358 | +
|
| 359 | +""" |
| 360 | + |
| 361 | +aet = AECaptureParser(eventreceptacle) |
| 362 | +print aet.makecode() |
0 commit comments