nannified

Demo/metaclasses/Trace.py

@@ -20,38 +20,38 @@ class TraceMetaClass:
     __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
+        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
+        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
+        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
+        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
 
@@ -59,52 +59,52 @@ class TracingInstance:
     """Helper class to represent an instance of a tracing class."""
 
     def __trace_call__(self, fp, fmt, *args):
-	fp.write((fmt+'\n') % args)
+        fp.write((fmt+'\n') % args)
 
     def __meta_init__(self, klass):
-	self.__class = 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)
+        # 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
+        self.__name__ = name
+        self.func = func
+        self.inst = inst
     def __call__(self, *args, **kw):
-	return apply(self.func, (self.inst,) + 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
+        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})
 
@@ -112,13 +112,13 @@ 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
+        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(%s)" % `y`; return C.m2(self, y)
-	__trace_output__ = None
+        def m2(self, y): print "D.m2(%s)" % `y`; return C.m2(self, y)
+        __trace_output__ = None
     x = C(4321)
     print x
     print x.x