有没有办法在继承期间持久化装饰器？

Question

我正在尝试使用未实现的方法编写一个抽象类，这将强制继承的子级在重写方法（在装饰器中定义）时返回特定类型的值。

当我使用下面显示的代码时，子方法不会调用装饰器。我认为这是因为该方法被覆盖，这很有意义。我的问题基本上是这样的： 有没有办法通过方法覆盖使装饰器持久化？

我不反对使用装饰器以外的其他东西，但这是一个很快就浮现在脑海中的解决方案，我很想知道是否有任何方法可以让它发挥作用。

如果使用装饰器是正确且可能的选择，它将如下所示：

def decorator(returntype):
    def real_decorator(function):
        def wrapper(*args, **kwargs):
            result = function(*args, **kwargs)
            if not type(result) == returntype:
                raise TypeError("Method must return {0}".format(returntype))
            else:
                return result
        return wrapper
    return real_decorator

我需要我的父类看起来与这个相似：

class Parent(ABC):
    @decorator(int)
    @abstractmethod
    def aye(self, a):
        raise NotImplementedError

子类会做这样的事情：

class Child(Parent):
    def aye(self, a):
        return a

如果需要，我非常乐意更好地澄清我的问题，并感谢所有花时间提前阅读此问题的人！

Answer 1

我不确定你是否可以按照你想要的方式保持装饰器的效果，但你仍然可以在 Parent 类中装饰一个包装函数，它不会是一个 abstractmethod 并让子类实现像这样的包装函数：

from abc import ABC, abstractmethod

def decorator(returntype):
    def real_decorator(function):
        def wrapper(*args, **kwargs):
            result = function(*args, **kwargs)
            if not type(result) == returntype:
                raise TypeError("Method must return {0}".format(returntype))
            else:
                return result
        return wrapper
    return real_decorator

class Parent(ABC):
    @decorator(int)
    def aye(self, a):
        return self.impl_aye(a)

    @abstractmethod
    def impl_aye(self, a):
        raise NotImplementedError


class Child(Parent):
    def impl_aye(self, a):
        return a

还有一些解决方案可以保护 aye 方法不受 Parent 类的影响，如果需要，请参阅 this answer 示例。

否则，如果您想使用 type hints 并使用 mypy（Python 的可选静态类型检查器）检查您的代码，如果您尝试使用以下命令实现子类，则会收到错误消息返回类型与其父类不兼容：

from abc import ABC, abstractmethod

class Parent(ABC):
    @abstractmethod
    def aye(self, a) -> int:
        raise NotImplementedError

class Child(Parent):
    def aye(self, a) -> str :
        return a

mypy 的输出：

a.py:9: error: Return type "str" of "aye" incompatible with return type "int" in supertype "Parent"
Found 1 error in 1 file (checked 1 source file)

Answer 2

如果你只是想要强制返回类型，这是我的非装饰器建议（最初没有放入，因为我不喜欢你-不要-想要在 SO 上做这个“答案”）。

class Parent:

    def aye(self, a):
        res = self._aye(a)
        if not isinstance(res, int):
            raise TypeError("result should be an int")
        return res

    def _aye(self, a):
        raise NotImplementedError()

class Child(Parent):

    def _aye(self, a):
        return 1

Answer 3

以下是使用元类执行此操作的方法。在 Python 3.8 上测试。应该在 3.6 及更高版本上按原样工作。诚然，这有点复杂，使用另一种技术可能会更好。

from abc import ABCMeta, abstractmethod
from functools import wraps
from inspect import isfunction


class InheritedDecoratorMeta(ABCMeta):

    def __init__(cls, name, bases, attrs):
        for name, attr in attrs.items():
            for base in bases:
                base_attr = base.__dict__.get(name)
                if isfunction(base_attr):
                    inherited_decorator = getattr(base_attr, 'inherited_decorator', None)
                    if inherited_decorator:
                        setattr(cls, name, inherited_decorator()(attr))
                        break


def inherited_decorator(decorator, result_callback):
    def inner_decorator(method):
        method.inherited_decorator = lambda: inherited_decorator(decorator, result_callback)
        @wraps(method)
        def wrapper(*args, **kwargs):
            result = method(*args, **kwargs)
            return result_callback(method, result, args, kwargs)
        return wrapper
    return inner_decorator


def returns(type_):
    if not isinstance(type_, type) and type_ is not None:
        raise TypeError(f'Expected type or None; got {type_}')
    def callback(method, result, args, kwargs):
        result_type = type(result)
        if type_ is None:
            if result is not None:
                raise TypeError(f'Expected method {method} to return None; got {result_type}')
        elif not isinstance(result, type_):
            raise TypeError(f'Expected method {method} to return {type_}; got {result_type}')
        return result
    return inherited_decorator(returns, callback)


class MyBaseClass(metaclass=InheritedDecoratorMeta):

    @returns(int)
    @abstractmethod
    def aye(self, a):
        raise NotImplementedError

    @returns(None)
    @abstractmethod
    def bye(self, b):
        raise NotImplementedError


class MyClass(MyBaseClass):

    def aye(self, a):
        return a

    def bye(self, b):
        return b

    @returns(str)
    def cye(self, c):
        return c


if __name__ == '__main__':
    instance = MyClass()

    instance.aye(1)
    try:
        instance.aye('1')
    except TypeError as exc:
        print(exc)

    instance.bye(None)
    try:
        instance.bye(1)
    except TypeError as exc:
        print(exc)

    instance.cye('string')
    try:
        instance.cye(1)
    except TypeError as exc:
        print(exc)