从另一个类继承的类装饰器

Question

Ive been on a tear of writing some decorators recently. One of the ones I just wrote allows you to put the decorator just before a class definition, and it will cause every method of the class to print some logigng info when its run (more for debugging/initial super basic speed tests during a build)

def class_logit(cls):

    class NCls(object):
        def __init__(self, *args, **kwargs):
            self.instance = cls(*args, **kwargs)

        @staticmethod
        def _class_logit(original_function):
            def arg_catch(*args, **kwargs):
                start = time.time()
                result = original_function(*args, **kwargs)

                print('Called: {0} | From: {1} | Args: {2} | Kwargs: {3} | Run Time: {4}'
                  ''.format(original_function.__name__, str(inspect.getmodule(original_function)),
                            args, kwargs, time.time() - start))
                return result

            return arg_catch

        def __getattribute__(self, s):
            try:
                x = super(NCls, self).__getattribute__(s)
            except AttributeError:
                pass
            else:
                return x
            x = self.instance.__getattribute__(s)
            if type(x) == type(self.__init__):
                return self._class_logit(x)
            else:
                return x

    return NCls

This works great when applied to a very basic class i create.

Where I start to encounter issues is when I apply it to a class that is inheriting another - for instance, using QT:

@scld.class_logit
class TestWindow(QtGui.QDialog):
    def __init__(self):
        print self
        super(TestWindow, self).__init__()
a = TestWindow()

Im getting the following error... and im not entirely sure what to do about it!

self.instance = cls(*args, **kwargs)
File "<string>", line 15, in __init__
TypeError: super(type, obj): obj must be an instance or subtype of type

Any help would be appreciated!

(Apologies in advance, no matter WHAT i do SO is breaking the formatting on my first bit of code... Im even manually spending 10 minutes adding spaces but its coming out incorrectly... sorry!)

Answer 1

You are being a bit too intrusive with your decorator.

While if you want to profile methods defined on the Qt framework itself, a somewhat aggressive approach is needed, your decorator replaces the entire class by a proxy.

Qt bindings are somewhat complicated indeed, and it is hard to tell why it is erroring when being instantiated in this case.

So - first things first - if your intent would be to apply the decorator to a class hierarchy defined by yourself, or at least one defined in pure Python, a good approach there could be using metaclasses: with a metaclass you could decorate each method when a class is created, and do not mess anymore at runtime, when methods are retrieved from each class.

but Qt, as some other libraries, have its methods and classes defined in native code, and that will prevent you from wrapping existing methods in a new class. So, wrapping the methods on attribute retrieval on __getattribute__ could work.

Here is a simpler approach that instead of using a Proxy, just plug-in a foreign __getattribute__ that does the wrap-with-logger thing you want.
Your mileage may vary with it. Specially, it won't be triggered if one method of the class is called by other method in native code - as this won't go through Python's attribute retrieval mechanism (instead, it will use C++ method retrieval directly).

from  PyQt5 import QtWidgets, QtGui

def log_dec(func):
    def wraper(*args, **kwargs):
        print(func.__name__, args, kwargs)
        return func(*args, **kwargs)
    return wraper


def decorate(cls):
    def __getattribute__(self, attr):
        attr = super(cls, self).__getattribute__(attr)
        if callable(attr):
            return log_dec(attr)
        return attr
    cls.__getattribute__ = __getattribute__
    return cls

@decorate
class Example(QtGui.QWindow):
    pass

app = QtWidgets.QApplication([])

w = Example()
w.show()

(Of course, just replace the basic logger by your fancy logger above)