????
Current Path : /lib64/python2.7/Demo/metaclasses/ |
Current File : //lib64/python2.7/Demo/metaclasses/Trace.py |
"""Tracing metaclass. XXX This is very much a work in progress. """ import types, sys class TraceMetaClass: """Metaclass for tracing. Classes defined using this metaclass have an automatic tracing feature -- by setting the __trace_output__ instance (or class) variable to a file object, trace messages about all calls are written to the file. The trace formatting can be changed by defining a suitable __trace_call__ method. """ __inited = 0 def __init__(self, name, bases, dict): self.__name__ = name self.__bases__ = bases self.__dict = dict # XXX Can't define __dict__, alas self.__inited = 1 def __getattr__(self, name): try: return self.__dict[name] except KeyError: for base in self.__bases__: try: return base.__getattr__(name) except AttributeError: pass raise AttributeError, name def __setattr__(self, name, value): if not self.__inited: self.__dict__[name] = value else: self.__dict[name] = value def __call__(self, *args, **kw): inst = TracingInstance() inst.__meta_init__(self) try: init = inst.__getattr__('__init__') except AttributeError: init = lambda: None apply(init, args, kw) return inst __trace_output__ = None class TracingInstance: """Helper class to represent an instance of a tracing class.""" def __trace_call__(self, fp, fmt, *args): fp.write((fmt+'\n') % args) def __meta_init__(self, klass): self.__class = klass def __getattr__(self, name): # Invoked for any attr not in the instance's __dict__ try: raw = self.__class.__getattr__(name) except AttributeError: raise AttributeError, name if type(raw) != types.FunctionType: return raw # It's a function fullname = self.__class.__name__ + "." + name if not self.__trace_output__ or name == '__trace_call__': return NotTracingWrapper(fullname, raw, self) else: return TracingWrapper(fullname, raw, self) class NotTracingWrapper: def __init__(self, name, func, inst): self.__name__ = name self.func = func self.inst = inst def __call__(self, *args, **kw): return apply(self.func, (self.inst,) + args, kw) class TracingWrapper(NotTracingWrapper): def __call__(self, *args, **kw): self.inst.__trace_call__(self.inst.__trace_output__, "calling %s, inst=%s, args=%s, kw=%s", self.__name__, self.inst, args, kw) try: rv = apply(self.func, (self.inst,) + args, kw) except: t, v, tb = sys.exc_info() self.inst.__trace_call__(self.inst.__trace_output__, "returning from %s with exception %s: %s", self.__name__, t, v) raise t, v, tb else: self.inst.__trace_call__(self.inst.__trace_output__, "returning from %s with value %s", self.__name__, rv) return rv Traced = TraceMetaClass('Traced', (), {'__trace_output__': None}) def _test(): global C, D class C(Traced): def __init__(self, x=0): self.x = x def m1(self, x): self.x = x def m2(self, y): return self.x + y __trace_output__ = sys.stdout class D(C): def m2(self, y): print "D.m2(%r)" % (y,); return C.m2(self, y) __trace_output__ = None x = C(4321) print x print x.x print x.m1(100) print x.m1(10) print x.m2(33) print x.m1(5) print x.m2(4000) print x.x print C.__init__ print C.m2 print D.__init__ print D.m2 y = D() print y print y.m1(10) print y.m2(100) print y.x if __name__ == '__main__': _test()