home *** CD-ROM | disk | FTP | other *** search
/ Freelog 116 / FreelogNo116-JuilletSeptembre2013.iso / GestionFichiers / metamorphose / metamorphose2_0.8.2_setup.exe / metamorphose2.exe / inspect.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2011-01-12  |  21KB  |  738 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. __author__ = 'Ka-Ping Yee <ping@lfw.org>'
  5. __date__ = '1 Jan 2001'
  6. import sys
  7. import os
  8. import types
  9. import string
  10. import re
  11. import dis
  12. import imp
  13. import tokenize
  14. import linecache
  15. from operator import attrgetter
  16. from collections import namedtuple
  17. (CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS) = (1, 2, 4, 8)
  18. (CO_NESTED, CO_GENERATOR, CO_NOFREE) = (16, 32, 64)
  19. TPFLAGS_IS_ABSTRACT = 1048576
  20.  
  21. def ismodule(object):
  22.     return isinstance(object, types.ModuleType)
  23.  
  24.  
  25. def isclass(object):
  26.     if not isinstance(object, types.ClassType):
  27.         pass
  28.     return hasattr(object, '__bases__')
  29.  
  30.  
  31. def ismethod(object):
  32.     return isinstance(object, types.MethodType)
  33.  
  34.  
  35. def ismethoddescriptor(object):
  36.     if hasattr(object, '__get__') and not hasattr(object, '__set__') and not ismethod(object) and not isfunction(object):
  37.         pass
  38.     return not isclass(object)
  39.  
  40.  
  41. def isdatadescriptor(object):
  42.     if hasattr(object, '__set__'):
  43.         pass
  44.     return hasattr(object, '__get__')
  45.  
  46. if hasattr(types, 'MemberDescriptorType'):
  47.     
  48.     def ismemberdescriptor(object):
  49.         return isinstance(object, types.MemberDescriptorType)
  50.  
  51. else:
  52.     
  53.     def ismemberdescriptor(object):
  54.         return False
  55.  
  56. if hasattr(types, 'GetSetDescriptorType'):
  57.     
  58.     def isgetsetdescriptor(object):
  59.         return isinstance(object, types.GetSetDescriptorType)
  60.  
  61. else:
  62.     
  63.     def isgetsetdescriptor(object):
  64.         return False
  65.  
  66.  
  67. def isfunction(object):
  68.     return isinstance(object, types.FunctionType)
  69.  
  70.  
  71. def isgeneratorfunction(object):
  72.     if isfunction(object) or ismethod(object):
  73.         pass
  74.     return bool(object.func_code.co_flags & CO_GENERATOR)
  75.  
  76.  
  77. def isgenerator(object):
  78.     return isinstance(object, types.GeneratorType)
  79.  
  80.  
  81. def istraceback(object):
  82.     return isinstance(object, types.TracebackType)
  83.  
  84.  
  85. def isframe(object):
  86.     return isinstance(object, types.FrameType)
  87.  
  88.  
  89. def iscode(object):
  90.     return isinstance(object, types.CodeType)
  91.  
  92.  
  93. def isbuiltin(object):
  94.     return isinstance(object, types.BuiltinFunctionType)
  95.  
  96.  
  97. def isroutine(object):
  98.     if not isbuiltin(object) and isfunction(object) and ismethod(object):
  99.         pass
  100.     return ismethoddescriptor(object)
  101.  
  102.  
  103. def isabstract(object):
  104.     if isinstance(object, type):
  105.         pass
  106.     return object.__flags__ & TPFLAGS_IS_ABSTRACT
  107.  
  108.  
  109. def getmembers(object, predicate = None):
  110.     results = []
  111.     for key in dir(object):
  112.         value = getattr(object, key)
  113.         if not predicate or predicate(value):
  114.             results.append((key, value))
  115.             continue
  116.     
  117.     results.sort()
  118.     return results
  119.  
  120. Attribute = namedtuple('Attribute', 'name kind defining_class object')
  121.  
  122. def classify_class_attrs(cls):
  123.     mro = getmro(cls)
  124.     names = dir(cls)
  125.     result = []
  126.     for name in names:
  127.         if name in cls.__dict__:
  128.             obj = cls.__dict__[name]
  129.         else:
  130.             obj = getattr(cls, name)
  131.         homecls = getattr(obj, '__objclass__', None)
  132.         if homecls is None:
  133.             for base in mro:
  134.                 if name in base.__dict__:
  135.                     homecls = base
  136.                     break
  137.                     continue
  138.             
  139.         
  140.         if homecls is not None and name in homecls.__dict__:
  141.             obj = homecls.__dict__[name]
  142.         
  143.         obj_via_getattr = getattr(cls, name)
  144.         if isinstance(obj, staticmethod):
  145.             kind = 'static method'
  146.         elif isinstance(obj, classmethod):
  147.             kind = 'class method'
  148.         elif isinstance(obj, property):
  149.             kind = 'property'
  150.         elif ismethod(obj_via_getattr) or ismethoddescriptor(obj_via_getattr):
  151.             kind = 'method'
  152.         else:
  153.             kind = 'data'
  154.         result.append(Attribute(name, kind, homecls, obj))
  155.     
  156.     return result
  157.  
  158.  
  159. def _searchbases(cls, accum):
  160.     if cls in accum:
  161.         return None
  162.     accum.append(cls)
  163.     for base in cls.__bases__:
  164.         _searchbases(base, accum)
  165.     
  166.  
  167.  
  168. def getmro(cls):
  169.     if hasattr(cls, '__mro__'):
  170.         return cls.__mro__
  171.     result = []
  172.     _searchbases(cls, result)
  173.     return tuple(result)
  174.  
  175.  
  176. def indentsize(line):
  177.     expline = string.expandtabs(line)
  178.     return len(expline) - len(string.lstrip(expline))
  179.  
  180.  
  181. def getdoc(object):
  182.     
  183.     try:
  184.         doc = object.__doc__
  185.     except AttributeError:
  186.         return None
  187.  
  188.     if not isinstance(doc, types.StringTypes):
  189.         return None
  190.     return cleandoc(doc)
  191.  
  192.  
  193. def cleandoc(doc):
  194.     
  195.     try:
  196.         lines = string.split(string.expandtabs(doc), '\n')
  197.     except UnicodeError:
  198.         return None
  199.  
  200.     margin = sys.maxint
  201.     for line in lines[1:]:
  202.         content = len(string.lstrip(line))
  203.         if content:
  204.             indent = len(line) - content
  205.             margin = min(margin, indent)
  206.             continue
  207.     
  208.     if lines:
  209.         lines[0] = lines[0].lstrip()
  210.     
  211.     if margin < sys.maxint:
  212.         for i in range(1, len(lines)):
  213.             lines[i] = lines[i][margin:]
  214.         
  215.     
  216.     while lines and not lines[-1]:
  217.         lines.pop()
  218.     while lines and not lines[0]:
  219.         lines.pop(0)
  220.     return string.join(lines, '\n')
  221.  
  222.  
  223. def getfile(object):
  224.     if ismodule(object):
  225.         if hasattr(object, '__file__'):
  226.             return object.__file__
  227.         raise TypeError('arg is a built-in module')
  228.     ismodule(object)
  229.     if isclass(object):
  230.         object = sys.modules.get(object.__module__)
  231.         if hasattr(object, '__file__'):
  232.             return object.__file__
  233.         raise TypeError('arg is a built-in class')
  234.     isclass(object)
  235.     if ismethod(object):
  236.         object = object.im_func
  237.     
  238.     if isfunction(object):
  239.         object = object.func_code
  240.     
  241.     if istraceback(object):
  242.         object = object.tb_frame
  243.     
  244.     if isframe(object):
  245.         object = object.f_code
  246.     
  247.     if iscode(object):
  248.         return object.co_filename
  249.     raise TypeError('arg is not a module, class, method, function, traceback, frame, or code object')
  250.  
  251. ModuleInfo = namedtuple('ModuleInfo', 'name suffix mode module_type')
  252.  
  253. def getmoduleinfo(path):
  254.     filename = os.path.basename(path)
  255.     suffixes = map((lambda info: (-len(info[0]), info[0], info[1], info[2])), imp.get_suffixes())
  256.     suffixes.sort()
  257.     for neglen, suffix, mode, mtype in suffixes:
  258.         if filename[neglen:] == suffix:
  259.             return ModuleInfo(filename[:neglen], suffix, mode, mtype)
  260.     
  261.  
  262.  
  263. def getmodulename(path):
  264.     info = getmoduleinfo(path)
  265.     if info:
  266.         return info[0]
  267.  
  268.  
  269. def getsourcefile(object):
  270.     filename = getfile(object)
  271.     if string.lower(filename[-4:]) in ('.pyc', '.pyo'):
  272.         filename = filename[:-4] + '.py'
  273.     
  274.     for suffix, mode, kind in imp.get_suffixes():
  275.         if 'b' in mode and string.lower(filename[-len(suffix):]) == suffix:
  276.             return None
  277.     
  278.     if os.path.exists(filename):
  279.         return filename
  280.     if hasattr(getmodule(object, filename), '__loader__'):
  281.         return filename
  282.  
  283.  
  284. def getabsfile(object, _filename = None):
  285.     if _filename is None:
  286.         if not getsourcefile(object):
  287.             pass
  288.         _filename = getfile(object)
  289.     
  290.     return os.path.normcase(os.path.abspath(_filename))
  291.  
  292. modulesbyfile = { }
  293. _filesbymodname = { }
  294.  
  295. def getmodule(object, _filename = None):
  296.     if ismodule(object):
  297.         return object
  298.     if hasattr(object, '__module__'):
  299.         return sys.modules.get(object.__module__)
  300.     if _filename is not None and _filename in modulesbyfile:
  301.         return sys.modules.get(modulesbyfile[_filename])
  302.     
  303.     try:
  304.         file = getabsfile(object, _filename)
  305.     except TypeError:
  306.         _filename in modulesbyfile
  307.         _filename in modulesbyfile
  308.         hasattr(object, '__module__')
  309.         return None
  310.         ismodule(object)
  311.  
  312.     if file in modulesbyfile:
  313.         return sys.modules.get(modulesbyfile[file])
  314.     for modname, module in sys.modules.items():
  315.         if ismodule(module) and hasattr(module, '__file__'):
  316.             f = module.__file__
  317.             _filesbymodname[modname] = f
  318.             f = getabsfile(module)
  319.             continue
  320.         modulesbyfile[f] = modulesbyfile[os.path.realpath(f)] = module.__name__
  321.     
  322.     if file in modulesbyfile:
  323.         return sys.modules.get(modulesbyfile[file])
  324.     main = sys.modules['__main__']
  325.     if not hasattr(object, '__name__'):
  326.         return None
  327.     builtin = sys.modules['__builtin__']
  328.  
  329.  
  330. def findsource(object):
  331.     if not getsourcefile(object):
  332.         pass
  333.     file = getfile(object)
  334.     module = getmodule(object, file)
  335.     if module:
  336.         lines = linecache.getlines(file, module.__dict__)
  337.     else:
  338.         lines = linecache.getlines(file)
  339.     if not lines:
  340.         raise IOError('could not get source code')
  341.     lines
  342.     if ismodule(object):
  343.         return (lines, 0)
  344.     if isclass(object):
  345.         name = object.__name__
  346.         pat = re.compile('^(\\s*)class\\s*' + name + '\\b')
  347.         candidates = []
  348.         for i in range(len(lines)):
  349.             match = pat.match(lines[i])
  350.             if match:
  351.                 if lines[i][0] == 'c':
  352.                     return (lines, i)
  353.                 candidates.append((match.group(1), i))
  354.                 continue
  355.             lines[i][0] == 'c'
  356.         
  357.         if candidates:
  358.             candidates.sort()
  359.             return (lines, candidates[0][1])
  360.         raise IOError('could not find class definition')
  361.     isclass(object)
  362.     if ismethod(object):
  363.         object = object.im_func
  364.     
  365.     if isfunction(object):
  366.         object = object.func_code
  367.     
  368.     if istraceback(object):
  369.         object = object.tb_frame
  370.     
  371.     if isframe(object):
  372.         object = object.f_code
  373.     
  374.     if iscode(object):
  375.         if not hasattr(object, 'co_firstlineno'):
  376.             raise IOError('could not find function definition')
  377.         hasattr(object, 'co_firstlineno')
  378.         lnum = object.co_firstlineno - 1
  379.         pat = re.compile('^(\\s*def\\s)|(.*(?<!\\w)lambda(:|\\s))|^(\\s*@)')
  380.         while lnum > 0:
  381.             if pat.match(lines[lnum]):
  382.                 break
  383.             
  384.             lnum = lnum - 1
  385.         return (lines, lnum)
  386.     raise IOError('could not find code object')
  387.  
  388.  
  389. def getcomments(object):
  390.     
  391.     try:
  392.         (lines, lnum) = findsource(object)
  393.     except (IOError, TypeError):
  394.         return None
  395.  
  396.     if ismodule(object):
  397.         start = 0
  398.         if lines and lines[0][:2] == '#!':
  399.             start = 1
  400.         
  401.         while start < len(lines) and string.strip(lines[start]) in ('', '#'):
  402.             start = start + 1
  403.         if start < len(lines) and lines[start][:1] == '#':
  404.             comments = []
  405.             end = start
  406.             while end < len(lines) and lines[end][:1] == '#':
  407.                 comments.append(string.expandtabs(lines[end]))
  408.                 end = end + 1
  409.             return string.join(comments, '')
  410.     elif lnum > 0:
  411.         indent = indentsize(lines[lnum])
  412.         end = lnum - 1
  413.         if end >= 0 and string.lstrip(lines[end])[:1] == '#' and indentsize(lines[end]) == indent:
  414.             comments = [
  415.                 string.lstrip(string.expandtabs(lines[end]))]
  416.             if end > 0:
  417.                 end = end - 1
  418.                 comment = string.lstrip(string.expandtabs(lines[end]))
  419.                 while comment[:1] == '#' and indentsize(lines[end]) == indent:
  420.                     comments[:0] = [
  421.                         comment]
  422.                     end = end - 1
  423.                     if end < 0:
  424.                         break
  425.                     
  426.                     comment = string.lstrip(string.expandtabs(lines[end]))
  427.             
  428.             while comments and string.strip(comments[0]) == '#':
  429.                 comments[:1] = []
  430.             while comments and string.strip(comments[-1]) == '#':
  431.                 comments[-1:] = []
  432.             return string.join(comments, '')
  433.     
  434.  
  435.  
  436. class EndOfBlock(Exception):
  437.     pass
  438.  
  439.  
  440. class BlockFinder:
  441.     
  442.     def __init__(self):
  443.         self.indent = 0
  444.         self.islambda = False
  445.         self.started = False
  446.         self.passline = False
  447.         self.last = 1
  448.  
  449.     
  450.     def tokeneater(self, type, token, srow_scol, erow_ecol, line):
  451.         (srow, scol) = srow_scol
  452.         (erow, ecol) = erow_ecol
  453.         if not self.started:
  454.             if token in ('def', 'class', 'lambda'):
  455.                 if token == 'lambda':
  456.                     self.islambda = True
  457.                 
  458.                 self.started = True
  459.             
  460.             self.passline = True
  461.         elif type == tokenize.NEWLINE:
  462.             self.passline = False
  463.             self.last = srow
  464.             if self.islambda:
  465.                 raise EndOfBlock
  466.             self.islambda
  467.         elif self.passline:
  468.             pass
  469.         elif type == tokenize.INDENT:
  470.             self.indent = self.indent + 1
  471.             self.passline = True
  472.         elif type == tokenize.DEDENT:
  473.             self.indent = self.indent - 1
  474.             if self.indent <= 0:
  475.                 raise EndOfBlock
  476.             self.indent <= 0
  477.         elif self.indent == 0 and type not in (tokenize.COMMENT, tokenize.NL):
  478.             raise EndOfBlock
  479.         
  480.  
  481.  
  482.  
  483. def getblock(lines):
  484.     blockfinder = BlockFinder()
  485.     
  486.     try:
  487.         tokenize.tokenize(iter(lines).next, blockfinder.tokeneater)
  488.     except (EndOfBlock, IndentationError):
  489.         pass
  490.  
  491.     return lines[:blockfinder.last]
  492.  
  493.  
  494. def getsourcelines(object):
  495.     (lines, lnum) = findsource(object)
  496.     if ismodule(object):
  497.         return (lines, 0)
  498.     return (getblock(lines[lnum:]), lnum + 1)
  499.  
  500.  
  501. def getsource(object):
  502.     (lines, lnum) = getsourcelines(object)
  503.     return string.join(lines, '')
  504.  
  505.  
  506. def walktree(classes, children, parent):
  507.     results = []
  508.     classes.sort(key = attrgetter('__module__', '__name__'))
  509.     for c in classes:
  510.         results.append((c, c.__bases__))
  511.         if c in children:
  512.             results.append(walktree(children[c], children, c))
  513.             continue
  514.     
  515.     return results
  516.  
  517.  
  518. def getclasstree(classes, unique = 0):
  519.     children = { }
  520.     roots = []
  521.     for c in classes:
  522.         if c.__bases__:
  523.             for parent in c.__bases__:
  524.                 if parent not in children:
  525.                     children[parent] = []
  526.                 
  527.                 children[parent].append(c)
  528.                 if unique and parent in classes:
  529.                     break
  530.                     continue
  531.             
  532.         if c not in roots:
  533.             roots.append(c)
  534.             continue
  535.     
  536.     for parent in children:
  537.         if parent not in classes:
  538.             roots.append(parent)
  539.             continue
  540.     
  541.     return walktree(roots, children, None)
  542.  
  543. Arguments = namedtuple('Arguments', 'args varargs keywords')
  544.  
  545. def getargs(co):
  546.     if not iscode(co):
  547.         raise TypeError('arg is not a code object')
  548.     iscode(co)
  549.     nargs = co.co_argcount
  550.     names = co.co_varnames
  551.     args = list(names[:nargs])
  552.     step = 0
  553.     for i in range(nargs):
  554.         if args[i][:1] in ('', '.'):
  555.             stack = []
  556.             remain = []
  557.             count = []
  558.             while step < len(co.co_code):
  559.                 op = ord(co.co_code[step])
  560.                 step = step + 1
  561.                 if op >= dis.HAVE_ARGUMENT:
  562.                     opname = dis.opname[op]
  563.                     value = ord(co.co_code[step]) + ord(co.co_code[step + 1]) * 256
  564.                     step = step + 2
  565.                     if opname in ('UNPACK_TUPLE', 'UNPACK_SEQUENCE'):
  566.                         remain.append(value)
  567.                         count.append(value)
  568.                     elif opname == 'STORE_FAST':
  569.                         stack.append(names[value])
  570.                         if not remain:
  571.                             stack[0] = [
  572.                                 stack[0]]
  573.                             break
  574.                         else:
  575.                             remain[-1] = remain[-1] - 1
  576.                             while remain[-1] == 0:
  577.                                 remain.pop()
  578.                                 size = count.pop()
  579.                                 stack[-size:] = [
  580.                                     stack[-size:]]
  581.                                 if not remain:
  582.                                     break
  583.                                 
  584.                                 remain[-1] = remain[-1] - 1
  585.                             if not remain:
  586.                                 break
  587.                             
  588.                     
  589.                 opname in ('UNPACK_TUPLE', 'UNPACK_SEQUENCE')
  590.             args[i] = stack[0]
  591.             continue
  592.     
  593.     varargs = None
  594.     if co.co_flags & CO_VARARGS:
  595.         varargs = co.co_varnames[nargs]
  596.         nargs = nargs + 1
  597.     
  598.     varkw = None
  599.     if co.co_flags & CO_VARKEYWORDS:
  600.         varkw = co.co_varnames[nargs]
  601.     
  602.     return Arguments(args, varargs, varkw)
  603.  
  604. ArgSpec = namedtuple('ArgSpec', 'args varargs keywords defaults')
  605.  
  606. def getargspec(func):
  607.     if ismethod(func):
  608.         func = func.im_func
  609.     
  610.     if not isfunction(func):
  611.         raise TypeError('arg is not a Python function')
  612.     isfunction(func)
  613.     (args, varargs, varkw) = getargs(func.func_code)
  614.     return ArgSpec(args, varargs, varkw, func.func_defaults)
  615.  
  616. ArgInfo = namedtuple('ArgInfo', 'args varargs keywords locals')
  617.  
  618. def getargvalues(frame):
  619.     (args, varargs, varkw) = getargs(frame.f_code)
  620.     return ArgInfo(args, varargs, varkw, frame.f_locals)
  621.  
  622.  
  623. def joinseq(seq):
  624.     if len(seq) == 1:
  625.         return '(' + seq[0] + ',)'
  626.     return '(' + string.join(seq, ', ') + ')'
  627.  
  628.  
  629. def strseq(object, convert, join = joinseq):
  630.     if type(object) in (list, tuple):
  631.         return join(map((lambda o, c = convert, j = join: strseq(o, c, j)), object))
  632.     return convert(object)
  633.  
  634.  
  635. def formatargspec(args, varargs = None, varkw = None, defaults = None, formatarg = str, formatvarargs = (lambda name: '*' + name), formatvarkw = (lambda name: '**' + name), formatvalue = (lambda value: '=' + repr(value)), join = joinseq):
  636.     specs = []
  637.     if defaults:
  638.         firstdefault = len(args) - len(defaults)
  639.     
  640.     for i in range(len(args)):
  641.         spec = strseq(args[i], formatarg, join)
  642.         if defaults and i >= firstdefault:
  643.             spec = spec + formatvalue(defaults[i - firstdefault])
  644.         
  645.         specs.append(spec)
  646.     
  647.     if varargs is not None:
  648.         specs.append(formatvarargs(varargs))
  649.     
  650.     if varkw is not None:
  651.         specs.append(formatvarkw(varkw))
  652.     
  653.     return '(' + string.join(specs, ', ') + ')'
  654.  
  655.  
  656. def formatargvalues(args, varargs, varkw, locals, formatarg = str, formatvarargs = (lambda name: '*' + name), formatvarkw = (lambda name: '**' + name), formatvalue = (lambda value: '=' + repr(value)), join = joinseq):
  657.     
  658.     def convert(name, locals = locals, formatarg = formatarg, formatvalue = formatvalue):
  659.         return formatarg(name) + formatvalue(locals[name])
  660.  
  661.     specs = []
  662.     for i in range(len(args)):
  663.         specs.append(strseq(args[i], convert, join))
  664.     
  665.     if varargs:
  666.         specs.append(formatvarargs(varargs) + formatvalue(locals[varargs]))
  667.     
  668.     if varkw:
  669.         specs.append(formatvarkw(varkw) + formatvalue(locals[varkw]))
  670.     
  671.     return '(' + string.join(specs, ', ') + ')'
  672.  
  673. Traceback = namedtuple('Traceback', 'filename lineno function code_context index')
  674.  
  675. def getframeinfo(frame, context = 1):
  676.     if istraceback(frame):
  677.         lineno = frame.tb_lineno
  678.         frame = frame.tb_frame
  679.     else:
  680.         lineno = frame.f_lineno
  681.     if not isframe(frame):
  682.         raise TypeError('arg is not a frame or traceback object')
  683.     isframe(frame)
  684.     if not getsourcefile(frame):
  685.         pass
  686.     filename = getfile(frame)
  687.     if context > 0:
  688.         start = lineno - 1 - context // 2
  689.         
  690.         try:
  691.             (lines, lnum) = findsource(frame)
  692.         except IOError:
  693.             lines = None
  694.             index = None
  695.  
  696.         start = max(start, 1)
  697.         start = max(0, min(start, len(lines) - context))
  698.         lines = lines[start:start + context]
  699.         index = lineno - 1 - start
  700.     else:
  701.         lines = None
  702.         index = None
  703.     return Traceback(filename, lineno, frame.f_code.co_name, lines, index)
  704.  
  705.  
  706. def getlineno(frame):
  707.     return frame.f_lineno
  708.  
  709.  
  710. def getouterframes(frame, context = 1):
  711.     framelist = []
  712.     while frame:
  713.         framelist.append((frame,) + getframeinfo(frame, context))
  714.         frame = frame.f_back
  715.     return framelist
  716.  
  717.  
  718. def getinnerframes(tb, context = 1):
  719.     framelist = []
  720.     while tb:
  721.         framelist.append((tb.tb_frame,) + getframeinfo(tb, context))
  722.         tb = tb.tb_next
  723.     return framelist
  724.  
  725. if hasattr(sys, '_getframe'):
  726.     currentframe = sys._getframe
  727. else:
  728.     
  729.     currentframe = lambda _ = None: pass
  730.  
  731. def stack(context = 1):
  732.     return getouterframes(sys._getframe(1), context)
  733.  
  734.  
  735. def trace(context = 1):
  736.     return getinnerframes(sys.exc_info()[2], context)
  737.  
  738.