home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / peak / util / decorators.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  12.8 KB  |  397 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from types import ClassType, FunctionType
  5. import sys
  6. import os
  7. __all__ = [
  8.     'decorate_class',
  9.     'metaclass_is_decorator',
  10.     'metaclass_for_bases',
  11.     'frameinfo',
  12.     'decorate_assignment',
  13.     'decorate',
  14.     'struct',
  15.     'classy',
  16.     'template_function',
  17.     'rewrap',
  18.     'cache_source',
  19.     'enclosing_frame',
  20.     'synchronized']
  21.  
  22. def decorate(*decorators):
  23.     if len(decorators) > 1:
  24.         decorators = list(decorators)
  25.         decorators.reverse()
  26.     
  27.     
  28.     def callback(frame, k, v, old_locals):
  29.         for d in decorators:
  30.             v = d(v)
  31.         
  32.         return v
  33.  
  34.     return decorate_assignment(callback)
  35.  
  36.  
  37. def enclosing_frame(frame = None, level = 3):
  38.     if not frame:
  39.         pass
  40.     frame = sys._getframe(level)
  41.     while frame.f_globals.get('__name__') == __name__:
  42.         frame = frame.f_back
  43.     return frame
  44.  
  45.  
  46. def name_and_spec(func):
  47.     formatargspec = formatargspec
  48.     getargspec = getargspec
  49.     import inspect
  50.     funcname = func.__name__
  51.     if funcname == '<lambda>':
  52.         funcname = 'anonymous'
  53.     
  54.     (args, varargs, kwargs, defaults) = getargspec(func)
  55.     return (funcname, formatargspec(args, varargs, kwargs)[1:-1])
  56.  
  57.  
  58. def qname(func):
  59.     m = func.__module__
  60.     if not m or m + '.' + func.__name__:
  61.         pass
  62.     return func.__name__
  63.  
  64.  
  65. def apply_template(wrapper, func, *args, **kw):
  66.     (funcname, argspec) = name_and_spec(func)
  67.     (wrapname, wrapspec) = name_and_spec(wrapper)
  68.     body = wrapper.__doc__.replace('%', '%%').replace('$args', '%(argspec)s')
  69.     d = { }
  70.     body = '\ndef %(wrapname)s(%(wrapspec)s):\n def %(funcname)s(%(argspec)s): ' + body + '\n return %(funcname)s\n'
  71.     body %= locals()
  72.     filename = '<%s wrapping %s at 0x%08X>' % (qname(wrapper), qname(func), id(func))
  73.     exec compile(body, filename, 'exec') in func.func_globals, d
  74.     f = d[wrapname](func, *args, **kw)
  75.     cache_source(filename, body, f)
  76.     f.func_defaults = func.func_defaults
  77.     f.__doc__ = func.__doc__
  78.     f.__dict__ = func.__dict__
  79.     return f
  80.  
  81.  
  82. def rewrap(func, wrapper):
  83.     
  84.     def rewrap(__original, __decorated):
  85.         pass
  86.  
  87.     rewrap.__doc__ = 'return __decorated($args)'
  88.     return apply_template(rewrap, func, wrapper)
  89.  
  90. if sys.version < '2.5':
  91.     
  92.     def checkcache(filename = None):
  93.         if filename is None:
  94.             filenames = linecache.cache.keys()
  95.         elif filename in linecache.cache:
  96.             filenames = [
  97.                 filename]
  98.         else:
  99.             return None
  100.         for filename in filenames:
  101.             (size, mtime, lines, fullname) = linecache.cache[filename]
  102.             if mtime is None:
  103.                 continue
  104.             
  105.             
  106.             try:
  107.                 stat = os.stat(fullname)
  108.             except os.error:
  109.                 del linecache.cache[filename]
  110.                 continue
  111.  
  112.             if size != stat.st_size or mtime != stat.st_mtime:
  113.                 del linecache.cache[filename]
  114.                 continue
  115.         
  116.  
  117.  
  118.  
  119. def _cache_lines(filename, lines, owner = None):
  120.     global linecache
  121.     if owner is None:
  122.         owner = filename
  123.     else:
  124.         ref = ref
  125.         import weakref
  126.         owner = ref((owner,), (lambda r: if linecache:
  127. passlinecache.cache.__delitem__(filename)))
  128.     import linecache
  129.     if sys.version < '2.5' and linecache.checkcache.__module__ != __name__:
  130.         linecache.checkcache = checkcache
  131.     
  132.     linecache.cache[filename] = (0, None, lines, owner)
  133.  
  134.  
  135. def cache_source(filename, source, owner = None):
  136.     _cache_lines(filename, source.splitlines(True), owner)
  137.  
  138.  
  139. def template_function(wrapper = None):
  140.     if wrapper is None:
  141.         return decorate_assignment((lambda f, k, v, o: template_function(v)))
  142.     
  143.     return apply_template.__get__(wrapper)
  144.  
  145.  
  146. def struct(*mixins, **kw):
  147.     
  148.     def callback(frame, name, func, old_locals):
  149.         
  150.         def __new__(cls, *args, **kw):
  151.             result = func(*args, **kw)
  152.             if type(result) is tuple:
  153.                 return tuple.__new__(cls, (cls,) + result)
  154.             else:
  155.                 return result
  156.  
  157.         
  158.         def __repr__(self):
  159.             return name + tuple.__repr__(self[1:])
  160.  
  161.         import inspect
  162.         (args, star, dstar, defaults) = inspect.getargspec(func)
  163.         d = dict(__new__ = __new__, __repr__ = __repr__, __doc__ = func.__doc__, __module__ = func.__module__, __args__ = args, __star__ = star, __slots__ = [])
  164.         for p, a in enumerate(args):
  165.             if isinstance(a, str):
  166.                 d[a] = property((lambda self, p = p + 1: self[p]))
  167.                 continue
  168.             ((None,),)
  169.         
  170.         if star:
  171.             d[star] = property((lambda self, p = len(args) + 1: self[p:]))
  172.         
  173.         d.update(kw)
  174.         return type(name, mixins + (tuple,), d)
  175.  
  176.     return decorate_assignment(callback)
  177.  
  178.  
  179. def synchronized(func = None):
  180.     if func is None:
  181.         return decorate_assignment((lambda f, k, v, o: synchronized(v)))
  182.     
  183.     
  184.     def wrap(__func):
  185.         pass
  186.  
  187.     wrap.__doc__ = "\n        try:\n            lock = $self.__lock__\n        except AttributeError:\n            try:\n                from threading import RLock\n            except ImportError:\n                from dummy_threading import RLock\n            lock = $self.__dict__.setdefault('__lock__',RLock())\n        lock.acquire()\n        try:\n            return __func($args)\n        finally:\n            lock.release()"
  188.     getargspec = getargspec
  189.     import inspect
  190.     first_arg = getargspec(func)[0][0]
  191.     wrap.__doc__ = wrap.__doc__.replace('$self', first_arg)
  192.     return apply_template(wrap, func)
  193.  
  194.  
  195. def frameinfo(frame):
  196.     f_locals = frame.f_locals
  197.     f_globals = frame.f_globals
  198.     sameNamespace = f_locals is f_globals
  199.     hasModule = '__module__' in f_locals
  200.     hasName = '__name__' in f_globals
  201.     if hasModule:
  202.         pass
  203.     sameName = hasName
  204.     if sameName:
  205.         pass
  206.     sameName = f_globals['__name__'] == f_locals['__module__']
  207.     if not hasName or sys.modules.get(f_globals['__name__']):
  208.         pass
  209.     module = None
  210.     if module:
  211.         pass
  212.     namespaceIsModule = module.__dict__ is f_globals
  213.     if not namespaceIsModule:
  214.         kind = 'exec'
  215.         if hasModule and not sameNamespace:
  216.             kind = 'class'
  217.         
  218.     elif sameNamespace and not hasModule:
  219.         kind = 'module'
  220.     elif sameName and not sameNamespace:
  221.         kind = 'class'
  222.     elif not sameNamespace:
  223.         kind = 'function call'
  224.     else:
  225.         kind = 'unknown'
  226.     return (kind, module, f_locals, f_globals)
  227.  
  228.  
  229. def decorate_class(decorator, depth = 2, frame = None, allow_duplicates = False):
  230.     frame = enclosing_frame(frame, depth + 1)
  231.     (kind, module, caller_locals, caller_globals) = frameinfo(frame)
  232.     if kind != 'class':
  233.         raise SyntaxError('Class decorators may only be used inside a class statement')
  234.     elif not allow_duplicates and has_class_decorator(decorator, None, frame):
  235.         return None
  236.     
  237.     previousMetaclass = caller_locals.get('__metaclass__')
  238.     defaultMetaclass = caller_globals.get('__metaclass__', ClassType)
  239.     
  240.     def advise(name, bases, cdict):
  241.         if '__metaclass__' in cdict:
  242.             del cdict['__metaclass__']
  243.         
  244.         if previousMetaclass is None:
  245.             if bases:
  246.                 meta = metaclass_for_bases(bases)
  247.             else:
  248.                 meta = defaultMetaclass
  249.         elif metaclass_is_decorator(previousMetaclass):
  250.             meta = previousMetaclass
  251.         else:
  252.             meta = metaclass_for_bases(bases, previousMetaclass)
  253.         newClass = meta(name, bases, cdict)
  254.         return decorator(newClass)
  255.  
  256.     advise.previousMetaclass = previousMetaclass
  257.     advise.callback = decorator
  258.     caller_locals['__metaclass__'] = advise
  259.  
  260.  
  261. def metaclass_is_decorator(ob):
  262.     if isinstance(ob, FunctionType):
  263.         pass
  264.     return hasattr(ob, 'previousMetaclass')
  265.  
  266.  
  267. def iter_class_decorators(depth = 2, frame = None):
  268.     frame = enclosing_frame(frame, depth + 1)
  269.     m = frame.f_locals.get('__metaclass__')
  270.     while metaclass_is_decorator(m):
  271.         yield getattr(m, 'callback', None)
  272.         m = m.previousMetaclass
  273.  
  274.  
  275. def has_class_decorator(decorator, depth = 2, frame = None):
  276.     if not frame:
  277.         pass
  278.     return decorator in iter_class_decorators(0, sys._getframe(depth))
  279.  
  280.  
  281. def metaclass_for_bases(bases, explicit_mc = None):
  282.     meta = [ getattr(b, '__class__', type(b)) for b in bases ]
  283.     if len(meta) == 1:
  284.         return meta[0]
  285.     
  286.     classes = _[2]
  287.     candidates = []
  288.     for m in classes:
  289.         for n in classes:
  290.             if issubclass(n, m) and m is not n:
  291.                 break
  292.                 continue
  293.             []
  294.         elif m in candidates:
  295.             candidates.remove(m)
  296.         
  297.         candidates.append(m)
  298.     
  299.     if not candidates:
  300.         return ClassType
  301.     elif len(candidates) > 1:
  302.         raise TypeError('Incompatible metatypes', bases)
  303.     
  304.     return candidates[0]
  305.  
  306.  
  307. def decorate_assignment(callback, depth = 2, frame = None):
  308.     frame = enclosing_frame(frame, depth + 1)
  309.     oldtrace = [
  310.         frame.f_trace]
  311.     old_locals = frame.f_locals.copy()
  312.     
  313.     def tracer(frm, event, arg):
  314.         if event == 'call':
  315.             if oldtrace[0]:
  316.                 return oldtrace[0](frm, event, arg)
  317.             else:
  318.                 return None
  319.         
  320.         
  321.         try:
  322.             if frm is frame and event != 'exception':
  323.                 for k, v in frm.f_locals.items():
  324.                     if k not in old_locals or old_locals[k] is not v:
  325.                         break
  326.                         continue
  327.                 else:
  328.                     return tracer
  329.                 frm.f_locals[k] = callback(frm, k, v, old_locals)
  330.         finally:
  331.             if oldtrace[0]:
  332.                 oldtrace[0] = oldtrace[0](frm, event, arg)
  333.             
  334.  
  335.         uninstall()
  336.         return oldtrace[0]
  337.  
  338.     
  339.     def uninstall():
  340.         frame.f_trace = oldtrace[0]
  341.         sys.settrace(oldtrace[0])
  342.  
  343.     frame.f_trace = tracer
  344.     sys.settrace(tracer)
  345.     
  346.     def do_decorate(f):
  347.         uninstall()
  348.         frame = sys._getframe(1)
  349.         return callback(frame, getattr(f, '__name__', None), f, frame.f_locals)
  350.  
  351.     return do_decorate
  352.  
  353.  
  354. def super_next(cls, attr):
  355.     for c in cls.__mro__:
  356.         if attr in c.__dict__:
  357.             yield getattr(c, attr).im_func
  358.             continue
  359.     
  360.  
  361.  
  362. class classy_class(type):
  363.     
  364.     def __new__(meta, name, bases, cdict):
  365.         cls = super(classy_class, meta).__new__(meta, name, bases, cdict)
  366.         supr = super_next(cls, '__class_new__').next
  367.         return supr()(meta, name, bases, cdict, supr)
  368.  
  369.     
  370.     def __init__(cls, name, bases, cdict):
  371.         supr = super_next(cls, '__class_init__').next
  372.         return supr()(cls, name, bases, cdict, supr)
  373.  
  374.     
  375.     def __call__(cls, *args, **kw):
  376.         return cls.__class_call__.im_func(cls, *args, **kw)
  377.  
  378.  
  379.  
  380. class classy(object):
  381.     __metaclass__ = classy_class
  382.     __slots__ = ()
  383.     
  384.     def __class_new__(meta, name, bases, cdict, supr):
  385.         return type.__new__(meta, name, bases, cdict)
  386.  
  387.     
  388.     def __class_init__(cls, name, bases, cdict, supr):
  389.         return type.__init__(cls, name, bases, cdict)
  390.  
  391.     
  392.     def __class_call__(cls, *args, **kw):
  393.         return type.__call__(cls, *args, **kw)
  394.  
  395.     __class_call__ = classmethod(__class_call__)
  396.  
  397.