mirror of
https://github.com/python/cpython.git
synced 2025-10-30 21:21:22 +00:00
144 lines
4 KiB
Python
144 lines
4 KiB
Python
"""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()
|