| """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 |
| 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 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 = 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() |