Functools.wraps Equivalent For Class Decorator

When we decorate function, we use functools.wraps to make decorated function look like original. Is there any wat to do same, when we want to decorate class? def some_class_decorat

Solution 1:

No, there isn't, assuming your decorator really subclasses the wrapped class like some_class_decorator does. The output of help is defined by the pydoc.Helper class, which for classes ultimately calls pydoc.text.docclass, which contains this code:

# List the mro, if non-trivial.
mro = deque(inspect.getmro(object))
iflen(mro) > 2:
    push("Method resolution order:")
    forbasein mro:
        push('    ' + makename(base))
    push('')

You can see that it is hard-coded to display the class's real MRO. This is as it should be. The MRO displayed in your last example is not "broken", it is correct. By making your wrapper class inherit from the wrapped class, you added an additional class to the inheritance hierarchy. It would be misleading to show an MRO that left that out, because there really is a class there. In your example, this wrapper class doesn't provide any behavior of its own, but a realistic wrapper class would (or else why would you be doing the wrapping at all?), and you would want to know which behavior came from the wrapper class and which from the wrapped class.

If you wanted, you could make a decorator that dynamically renamed the wrapper class with some name derived from the original, so the MRO would show something like DecoratorWrapper_of_MainClass in the appropriate position. Whether this would be more readable than just having Wrapper there is debatable.

Solution 2:

Oh, I guess now I understand what are your trying to achieve.

You want to attach new methods from a "wrapper" using a class decorator.

Here is a workng example:

classWrapper(object):
    """Some Wrapper not important doc."""defanother_method(self):
        """Another method."""print'Another method'defsome_class_decorator(cls_to_decorate):
    returntype(cls_to_decorate.__name__, cls_to_decorate.__bases__, dict
        (cls_to_decorate.__dict__, another_method=Wrapper.__dict__['another_method']))


classMainClass(object):
    """MainClass important doc."""defmethod(self):
        """A method."""print"A method"help(MainClass)
_MainClass = some_class_decorator(MainClass)
help(_MainClass)
_MainClass().another_method()
MainClass().another_method()

This example creates a new class not modifying the old class.

But I guess you could also just inject the given methods in the old class, modifying it in place.