import types

class ClassWithLoggedFunctions(type):
    def __call__(self, *args, **kargs):
        self.instance = super(ClassWithLoggedFunctions, self).__call__(*args,**kargs)
        def __call__(self, *args, **kargs):
            print 'execution %s(%s, %s)' % (func, args, kargs)
            func.__call__(self, *args, **kargs)
        for i in dir(self.instance):
            func = getattr(self.instance, i)
            if isinstance(func, types.MethodType):
                pass # magic here!
        return self.instance

class C():
    __metaclass__ = ClassWithLoggedFunctions
    def f(self, a, b, c):
        return (a,b,c)

C().f(1,2,3)

import logging

logger = logging.getLogger(__name__)

class C(object):

    def f(self, a, b, c):
        logger.debug('f called with %r, %r, %r' % (a, b, c))
        # ... process
        logger.debug('f done')

class MetaProperty(type):
    def __init__(cls, name, base, cls_dict):
        for attr, value in cls_dict.items():
            if callable(value):
                setattr(cls, attr, property(value))

class StrangeObject(object):
    __metaclass__ = MetaProperty

    def a(self):
        return 'a'

so = StarangeObject()
assert so.a == 'a'

import types

def decorator(f):
    def func(*args, **kargs):
        print 'executing %s...' % f.__name__
        return f(*args, **kargs)
    return func


class LoggedClass(type):
    def __call__(cls, *args, **kargs):
        def func(f):
            print f.__name__
            return f 
        
        for attr in dir(cls):
            value = getattr(cls, attr)
            if isinstance(value, types.MethodType):
                setattr(cls, attr, decorator(value))
        return type.__call__(cls, *args, **kargs)

class CustomClass(object):
    __metaclass__ = LoggedClass

    def some_function(self):
        return 'a'

c = CustomClass()
print c.some_function()

class CustomClass(object):
    __metaclass__ = LoggedClass
    _throw_exc_on_False = True