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