1 """Tracing metaclass.

     2 

     3 XXX This is very much a work in progress.

     4 

     5 """

     6 

     7 import types, sys

     8 

     9 class TraceMetaClass:

    10     """Metaclass for tracing.

    11 

    12     Classes defined using this metaclass have an automatic tracing

    13     feature -- by setting the __trace_output__ instance (or class)

    14     variable to a file object, trace messages about all calls are

    15     written to the file.  The trace formatting can be changed by

    16     defining a suitable __trace_call__ method.

    17 

    18     """

    19 

    20     __inited = 0

    21 

    22     def __init__(self, name, bases, dict):

    23         self.__name__ = name

    24         self.__bases__ = bases

    25         self.__dict = dict

    26         # XXX Can't define __dict__, alas

    27         self.__inited = 1

    28 

    29     def __getattr__(self, name):

    30         try:

    31             return self.__dict[name]

    32         except KeyError:

    33             for base in self.__bases__:

    34                 try:

    35                     return base.__getattr__(name)

    36                 except AttributeError:

    37                     pass

    38             raise AttributeError, name

    39 

    40     def __setattr__(self, name, value):

    41         if not self.__inited:

    42             self.__dict__[name] = value

    43         else:

    44             self.__dict[name] = value

    45 

    46     def __call__(self, *args, **kw):

    47         inst = TracingInstance()

    48         inst.__meta_init__(self)

    49         try:

    50             init = inst.__getattr__('__init__')

    51         except AttributeError:

    52             init = lambda: None

    53         apply(init, args, kw)

    54         return inst

    55 

    56     __trace_output__ = None

    57 

    58 class TracingInstance:

    59     """Helper class to represent an instance of a tracing class."""

    60 

    61     def __trace_call__(self, fp, fmt, *args):

    62         fp.write((fmt+'\n') % args)

    63 

    64     def __meta_init__(self, klass):

    65         self.__class = klass

    66 

    67     def __getattr__(self, name):

    68         # Invoked for any attr not in the instance's __dict__

    69         try:

    70             raw = self.__class.__getattr__(name)

    71         except AttributeError:

    72             raise AttributeError, name

    73         if type(raw) != types.FunctionType:

    74             return raw

    75         # It's a function

    76         fullname = self.__class.__name__ + "." + name

    77         if not self.__trace_output__ or name == '__trace_call__':

    78             return NotTracingWrapper(fullname, raw, self)

    79         else:

    80             return TracingWrapper(fullname, raw, self)

    81 

    82 class NotTracingWrapper:

    83     def __init__(self, name, func, inst):

    84         self.__name__ = name

    85         self.func = func

    86         self.inst = inst

    87     def __call__(self, *args, **kw):

    88         return apply(self.func, (self.inst,) + args, kw)

    89 

    90 class TracingWrapper(NotTracingWrapper):

    91     def __call__(self, *args, **kw):

    92         self.inst.__trace_call__(self.inst.__trace_output__,

    93                                  "calling %s, inst=%s, args=%s, kw=%s",

    94                                  self.__name__, self.inst, args, kw)

    95         try:

    96             rv = apply(self.func, (self.inst,) + args, kw)

    97         except:

    98             t, v, tb = sys.exc_info()

    99             self.inst.__trace_call__(self.inst.__trace_output__,

   100                                      "returning from %s with exception %s: %s",

   101                                      self.__name__, t, v)

   102             raise t, v, tb

   103         else:

   104             self.inst.__trace_call__(self.inst.__trace_output__,

   105                                      "returning from %s with value %s",

   106                                      self.__name__, rv)

   107             return rv

   108 

   109 Traced = TraceMetaClass('Traced', (), {'__trace_output__': None})

   110 

   111 

   112 def _test():

   113     global C, D

   114     class C(Traced):

   115         def __init__(self, x=0): self.x = x

   116         def m1(self, x): self.x = x

   117         def m2(self, y): return self.x + y

   118         __trace_output__ = sys.stdout

   119     class D(C):

   120         def m2(self, y): print "D.m2(%r)" % (y,); return C.m2(self, y)

   121         __trace_output__ = None

   122     x = C(4321)

   123     print x

   124     print x.x

   125     print x.m1(100)

   126     print x.m1(10)

   127     print x.m2(33)

   128     print x.m1(5)

   129     print x.m2(4000)

   130     print x.x

   131 

   132     print C.__init__

   133     print C.m2

   134     print D.__init__

   135     print D.m2

   136 

   137     y = D()

   138     print y

   139     print y.m1(10)

   140     print y.m2(100)

   141     print y.x

   142 

   143 if __name__ == '__main__':

   144     _test()