Question

我有一个元类，它定义了一个类级别的属性，该属性对于每个子类应该是唯一的，但在每个子类的实例之间是共享的。

class MetaValidator(type):
    def __new__(
             cls, name, bases, dct
    ):
        new_cls = super().__new__(cls, name, bases, dct)
        new_cls.valid_funcs = []
        return new_cls

现在，我想实现一个装饰器，将装饰器的类方法附加到派生类中的valid_funcs。但是，由于仍在定义派生类，因此我没有对派生装饰器的引用，所以最终将其追加到基类上。这是我的代码：

class Validator(object, metaclass=MetaValidator):

    @classmethod
    def add(cls, f):
        cls.valid_funcs.append(f)
        return f

    def _validate(self, **kwargs):
        for f in self.valid_funcs:
            params = inspect.signature(f).parameters.keys()
            f_kwargs = {name: kwargs[name] for name in params}
            f(**f_kwargs)

    def validate(self, **kwargs):
        self._validate(**kwargs)

class A(Validator):

    @staticmethod
    @Validator.add
    def test_func(x):
        return x

class B(Validator):

    @staticmethod
    @Validator.add
    def test_func(x, y):
        return x, y

a = A()
a.validate(x="In A")
b = B()
b.validate(x="In B", y=" Called with arg y")

print(Validator.valid_funcs)
print(a.valid_funcs)
print(b.valid_funcs)

此打印：

[<function A.test_func at 0x7f0189d4fc80>, 
<function B.test_func at 0x7f0189d4fd08>]
[]
[]

我想要：

[]
[<function A.test_func at 0x7f0189d4fc80>]
[<function B.test_func at 0x7f0189d4fd08>]

Answer 1

在类主体中的函数上执行装饰器时，还没有任何类对象。首先执行类主体，然后然后创建类。

与其让装饰器寻找要突变的类属性，还不如将属性添加到装饰的函数对象中。然后，元类或_validate()实现将查找具有此属性的所有对象，并在创建类对象后将它们添加到列表中。

我假设您要保留装饰者将装饰物品添加到列表中的顺序：

from itertools import count

class Validator(metaclass=MetaValidator):
    @classmethod
    def add(cls, f):
        _count = getattr(Validator.add, '_count', None)
        if _count is None:
            _count = Validator.add.__func__._count = count()
        f._validator_function_id = next(_count)
        return f

并在元类中：

class MetaValidator(type):
    def __new__(cls, name, bases, dct):
        new_cls = super().__new__(cls, name, bases, dct)
        registered = []
        for v in dct.values():
            id = getattr(v, '_validator_function_id', None)
            if id is None and isinstance(v, (staticmethod, classmethod)):
                # unwrap staticmethod or classmethod decorators
                id = getattr(v.__func__, '_validator_function_id', None)
            if id is not None:
                registered.append((id, v))
        new_cls.valid_funcs = [f for _, f in sorted(registered)]
        return new_cls

请注意，如果您使用的是Python 3.6或更高版本，则完全不需要元类。您可以将相同的逻辑放入class.__init_subclass__ method。

请注意，这会注册未绑定对象。对于staticmethod对象，这意味着调用将失败，并显示：

TypeError: <staticmethod object at 0x10d1b7048> is not a callable object

在这种情况下，您可能想要注册__func__属性，或使用.__get__将对象“绑定”到某物（staticmethod仍会忽略绑定上下文）。< / p>

如果您在_validate()方法中进行显式绑定，则实际上不必使用staticmethod对象：

def _validate(self, **kwargs):
    for f in self.valid_funcs:
        bound = f.__get__(self)
        signature = inspect.signature(bound)
        bound(**{name: kwargs[name] for name in signature.parameters})

现在@validator.add将与staticmethod，classmethod和常规函数一起使用。

如果您使用_validate()方法来查找方法，则可以为您完成绑定。您可以在这里选择使用dir()和getattr()来支持继承：

from operator import itemgetter
from itertools import count


class Validator:
    @classmethod
    def add(cls, f):
        _count = getattr(Validator.add, '_count', None)
        if _count is None:
            _count = Validator.add.__func__._count = count()
        f._validator_function_id = next(_count)
        return f

    def _list_validators(self):
        objects = (getattr(self, name) for name in dir(self))
        return sorted(
            (o for o in objects if hasattr(o, '_validator_function_id')),
            key=attrgetter('_validator_function_id'))

    def _validate(self, **kwargs):
        for f in self._list_validators():
            signature = inspect.signature(f)
            f(**{name: kwargs[name] for name in signature.parameters})

getattr()为您提供了一个绑定对象，无需进一步绑定。

Answer 2

虽然有一个元类__new__可以向valid_funcs添加函数，但是另一个选择是在类存在之前将valid_funcs注入到类体的名称空间中， __prepare__：

class MetaValidator(type):
    @classmethod
    def __prepare__(cls, name, bases, **kwds):
        ns = super().__prepare__(name, bases, **kwds)
        ns['valid_funcs'] = []
        return ns

def register(func_list):
    def inner_register(func):
        func_list.append(func)
        return func
    return inner_register

class A(metaclass=MetaValidator):
    @register(valid_funcs)
    def method(self):
        ...

不过，我可能会跳过所有元类的内容，并要求类自己做valid_funcs = []。仅为每个类节省一行样板，就不值得增加元类的复杂性。

派生类的类/元类方法装饰器

2 个答案: