home *** CD-ROM | disk | FTP | other *** search
- # Source Generated with Decompyle++
- # File: in.pyo (Python 2.5)
-
- from types import ClassType, FunctionType
- import sys
- import os
- __all__ = [
- 'decorate_class',
- 'metaclass_is_decorator',
- 'metaclass_for_bases',
- 'frameinfo',
- 'decorate_assignment',
- 'decorate',
- 'struct',
- 'classy',
- 'template_function',
- 'rewrap',
- 'cache_source',
- 'enclosing_frame',
- 'synchronized']
-
- def decorate(*decorators):
- if len(decorators) > 1:
- decorators = list(decorators)
- decorators.reverse()
-
-
- def callback(frame, k, v, old_locals):
- for d in decorators:
- v = d(v)
-
- return v
-
- return decorate_assignment(callback)
-
-
- def enclosing_frame(frame = None, level = 3):
- if not frame:
- pass
- frame = sys._getframe(level)
- while frame.f_globals.get('__name__') == __name__:
- frame = frame.f_back
- return frame
-
-
- def name_and_spec(func):
- formatargspec = formatargspec
- getargspec = getargspec
- import inspect
- funcname = func.__name__
- if funcname == '<lambda>':
- funcname = 'anonymous'
-
- (args, varargs, kwargs, defaults) = getargspec(func)
- return (funcname, formatargspec(args, varargs, kwargs)[1:-1])
-
-
- def qname(func):
- m = func.__module__
- if not m or m + '.' + func.__name__:
- pass
- return func.__name__
-
-
- def apply_template(wrapper, func, *args, **kw):
- (funcname, argspec) = name_and_spec(func)
- (wrapname, wrapspec) = name_and_spec(wrapper)
- body = wrapper.__doc__.replace('%', '%%').replace('$args', '%(argspec)s')
- d = { }
- body = '\ndef %(wrapname)s(%(wrapspec)s):\n def %(funcname)s(%(argspec)s): ' + body + '\n return %(funcname)s\n'
- body %= locals()
- filename = '<%s wrapping %s at 0x%08X>' % (qname(wrapper), qname(func), id(func))
- exec compile(body, filename, 'exec') in func.func_globals, d
- f = d[wrapname](func, *args, **kw)
- cache_source(filename, body, f)
- f.func_defaults = func.func_defaults
- f.__doc__ = func.__doc__
- f.__dict__ = func.__dict__
- return f
-
-
- def rewrap(func, wrapper):
-
- def rewrap(__original, __decorated):
- pass
-
- rewrap.__doc__ = 'return __decorated($args)'
- return apply_template(rewrap, func, wrapper)
-
- if sys.version < '2.5':
-
- def checkcache(filename = None):
- if filename is None:
- filenames = linecache.cache.keys()
- elif filename in linecache.cache:
- filenames = [
- filename]
- else:
- return None
- for filename in filenames:
- (size, mtime, lines, fullname) = linecache.cache[filename]
- if mtime is None:
- continue
-
-
- try:
- stat = os.stat(fullname)
- except os.error:
- del linecache.cache[filename]
- continue
-
- if size != stat.st_size or mtime != stat.st_mtime:
- del linecache.cache[filename]
- continue
-
-
-
-
- def _cache_lines(filename, lines, owner = None):
- global linecache
- if owner is None:
- owner = filename
- else:
- ref = ref
- import weakref
- owner = ref((owner,), (lambda r: if linecache:
- passlinecache.cache.__delitem__(filename)))
- import linecache
- if sys.version < '2.5' and linecache.checkcache.__module__ != __name__:
- linecache.checkcache = checkcache
-
- linecache.cache[filename] = (0, None, lines, owner)
-
-
- def cache_source(filename, source, owner = None):
- _cache_lines(filename, source.splitlines(True), owner)
-
-
- def template_function(wrapper = None):
- if wrapper is None:
- return decorate_assignment((lambda f, k, v, o: template_function(v)))
-
- return apply_template.__get__(wrapper)
-
-
- def struct(*mixins, **kw):
-
- def callback(frame, name, func, old_locals):
-
- def __new__(cls, *args, **kw):
- result = func(*args, **kw)
- if type(result) is tuple:
- return tuple.__new__(cls, (cls,) + result)
- else:
- return result
-
-
- def __repr__(self):
- return name + tuple.__repr__(self[1:])
-
- import inspect
- (args, star, dstar, defaults) = inspect.getargspec(func)
- d = dict(__new__ = __new__, __repr__ = __repr__, __doc__ = func.__doc__, __module__ = func.__module__, __args__ = args, __star__ = star, __slots__ = [])
- for p, a in enumerate(args):
- if isinstance(a, str):
- d[a] = property((lambda self, p = p + 1: self[p]))
- continue
- ((None,),)
-
- if star:
- d[star] = property((lambda self, p = len(args) + 1: self[p:]))
-
- d.update(kw)
- return type(name, mixins + (tuple,), d)
-
- return decorate_assignment(callback)
-
-
- def synchronized(func = None):
- if func is None:
- return decorate_assignment((lambda f, k, v, o: synchronized(v)))
-
-
- def wrap(__func):
- pass
-
- 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()"
- getargspec = getargspec
- import inspect
- first_arg = getargspec(func)[0][0]
- wrap.__doc__ = wrap.__doc__.replace('$self', first_arg)
- return apply_template(wrap, func)
-
-
- def frameinfo(frame):
- f_locals = frame.f_locals
- f_globals = frame.f_globals
- sameNamespace = f_locals is f_globals
- hasModule = '__module__' in f_locals
- hasName = '__name__' in f_globals
- if hasModule:
- pass
- sameName = hasName
- if sameName:
- pass
- sameName = f_globals['__name__'] == f_locals['__module__']
- if not hasName or sys.modules.get(f_globals['__name__']):
- pass
- module = None
- if module:
- pass
- namespaceIsModule = module.__dict__ is f_globals
- if not namespaceIsModule:
- kind = 'exec'
- if hasModule and not sameNamespace:
- kind = 'class'
-
- elif sameNamespace and not hasModule:
- kind = 'module'
- elif sameName and not sameNamespace:
- kind = 'class'
- elif not sameNamespace:
- kind = 'function call'
- else:
- kind = 'unknown'
- return (kind, module, f_locals, f_globals)
-
-
- def decorate_class(decorator, depth = 2, frame = None, allow_duplicates = False):
- frame = enclosing_frame(frame, depth + 1)
- (kind, module, caller_locals, caller_globals) = frameinfo(frame)
- if kind != 'class':
- raise SyntaxError('Class decorators may only be used inside a class statement')
- elif not allow_duplicates and has_class_decorator(decorator, None, frame):
- return None
-
- previousMetaclass = caller_locals.get('__metaclass__')
- defaultMetaclass = caller_globals.get('__metaclass__', ClassType)
-
- def advise(name, bases, cdict):
- if '__metaclass__' in cdict:
- del cdict['__metaclass__']
-
- if previousMetaclass is None:
- if bases:
- meta = metaclass_for_bases(bases)
- else:
- meta = defaultMetaclass
- elif metaclass_is_decorator(previousMetaclass):
- meta = previousMetaclass
- else:
- meta = metaclass_for_bases(bases, previousMetaclass)
- newClass = meta(name, bases, cdict)
- return decorator(newClass)
-
- advise.previousMetaclass = previousMetaclass
- advise.callback = decorator
- caller_locals['__metaclass__'] = advise
-
-
- def metaclass_is_decorator(ob):
- if isinstance(ob, FunctionType):
- pass
- return hasattr(ob, 'previousMetaclass')
-
-
- def iter_class_decorators(depth = 2, frame = None):
- frame = enclosing_frame(frame, depth + 1)
- m = frame.f_locals.get('__metaclass__')
- while metaclass_is_decorator(m):
- yield getattr(m, 'callback', None)
- m = m.previousMetaclass
-
-
- def has_class_decorator(decorator, depth = 2, frame = None):
- if not frame:
- pass
- return decorator in iter_class_decorators(0, sys._getframe(depth))
-
-
- def metaclass_for_bases(bases, explicit_mc = None):
- meta = [ getattr(b, '__class__', type(b)) for b in bases ]
- if len(meta) == 1:
- return meta[0]
-
- classes = _[2]
- candidates = []
- for m in classes:
- for n in classes:
- if issubclass(n, m) and m is not n:
- break
- continue
- []
- elif m in candidates:
- candidates.remove(m)
-
- candidates.append(m)
-
- if not candidates:
- return ClassType
- elif len(candidates) > 1:
- raise TypeError('Incompatible metatypes', bases)
-
- return candidates[0]
-
-
- def decorate_assignment(callback, depth = 2, frame = None):
- frame = enclosing_frame(frame, depth + 1)
- oldtrace = [
- frame.f_trace]
- old_locals = frame.f_locals.copy()
-
- def tracer(frm, event, arg):
- if event == 'call':
- if oldtrace[0]:
- return oldtrace[0](frm, event, arg)
- else:
- return None
-
-
- try:
- if frm is frame and event != 'exception':
- for k, v in frm.f_locals.items():
- if k not in old_locals or old_locals[k] is not v:
- break
- continue
- else:
- return tracer
- frm.f_locals[k] = callback(frm, k, v, old_locals)
- finally:
- if oldtrace[0]:
- oldtrace[0] = oldtrace[0](frm, event, arg)
-
-
- uninstall()
- return oldtrace[0]
-
-
- def uninstall():
- frame.f_trace = oldtrace[0]
- sys.settrace(oldtrace[0])
-
- frame.f_trace = tracer
- sys.settrace(tracer)
-
- def do_decorate(f):
- uninstall()
- frame = sys._getframe(1)
- return callback(frame, getattr(f, '__name__', None), f, frame.f_locals)
-
- return do_decorate
-
-
- def super_next(cls, attr):
- for c in cls.__mro__:
- if attr in c.__dict__:
- yield getattr(c, attr).im_func
- continue
-
-
-
- class classy_class(type):
-
- def __new__(meta, name, bases, cdict):
- cls = super(classy_class, meta).__new__(meta, name, bases, cdict)
- supr = super_next(cls, '__class_new__').next
- return supr()(meta, name, bases, cdict, supr)
-
-
- def __init__(cls, name, bases, cdict):
- supr = super_next(cls, '__class_init__').next
- return supr()(cls, name, bases, cdict, supr)
-
-
- def __call__(cls, *args, **kw):
- return cls.__class_call__.im_func(cls, *args, **kw)
-
-
-
- class classy(object):
- __metaclass__ = classy_class
- __slots__ = ()
-
- def __class_new__(meta, name, bases, cdict, supr):
- return type.__new__(meta, name, bases, cdict)
-
-
- def __class_init__(cls, name, bases, cdict, supr):
- return type.__init__(cls, name, bases, cdict)
-
-
- def __class_call__(cls, *args, **kw):
- return type.__call__(cls, *args, **kw)
-
- __class_call__ = classmethod(__class_call__)
-
-