使用元类作为默认属性初始化

Question

假设我有一个资源 class 看起来像这样：

class Resource(metaclass=ResourceInit):
    def __init__(self, a, b):
        self.a = a
        self.b = b

我的目标是创建一个元class，即ResourceInit，它处理自动分配属性给实例化的Resource。

我的以下代码不起作用：

config = {"resources": {"some_resource": {"a": "testA", "b": "testB"}}}

class ResourceInit(type):

    def __call__(self, *args, **kwargs):

        obj = super(ResourceInit, self)

        argspec = inspect.getargspec(obj.__self__.__init__)

        defaults = {}

        for argument in [x for x in argspec.args if x != "self"]:
            for settings in config["resources"].values():
                for key, val in settings.items():
                    if key == argument:
                        defaults.update({argument: val})
            if os.environ.get(argument):
                defaults.update({argument: os.environ[argument]})

        defaults.update(kwargs)
        for key, val in defaults.items():
            setattr(obj, key, val)
        return obj

想法是，在实例化时使用此元class

res = Resource()

将自动填充 a 和 b 如果它存在于 config 中或作为环境变量..

显然这是一个虚拟示例，其中 a 和 b 将更加具体，即 xx__resource__name.

我的问题：

你能在子class中传递一个参数给metaclass吗，即resource="some_resource"
如果 config 或 os.environ 未设置，我怎样才能让它正常工作 class，即 x = Test() 导致 TypeError: __init__() missing 2 required positional arguments: 'a' and 'b'

Answer 1

备选

你让事情变得比需要的更复杂。简单的解决方案如下所示：

def get_configured(name, value, config):
    if value is None:
        try:
            value = next(c for c in config['resources'].values() if name in c)[name]
        except StopIteration:
            value = os.environ.get(name, None)
    return value

class Resource:
    def __init__(self, a=None, b=None):
        self.a = get_configured('a', a, config)
        self.b = get_configured('a', b, config)

该函数可重用，您可以轻松修改它以最大限度地减少每个 class 将拥有的样板文件数量。

完整答案

但是，如果您坚持走 metaclass 道路，您也可以简化它。您可以在 class 定义中添加任意数量的 keyword-only 参数（问题 1）。

class Resource(metaclass=ResourceInit, config=config): ...

config 以及除 metaclass 之外的任何其他参数将直接传递给 meta-metaclass 的 __call__ 方法。从那里，它们被传递给 metaclass 中的 __new__ 和 __init__。因此，您必须实施 __new__。您可能想改为实现 __init__，但是从 type.__new__ 调用的 object.__init_subclass__ 如果您传入关键字参数，则会引发错误：

class ResourceInit(type):
    def __new__(meta, name, bases, namespace, *, config, **kwargs):
        cls = super().__new__(meta, name, bases, namespace, **kwargs)

注意最后一个参数，config 和 kwargs。位置参数作为 bases 传递。 kwargs 在传递给 type.__new__ 之前不得包含意外参数，但应该传递 class 上的 __init_subclass__ 期望的任何内容。

当您可以直接访问 namespace 时，无需使用 __self__。请记住，如果实际定义了 __init__ 方法，这只会更新默认值。您可能不想弄乱 parent __init__。为了安全起见，如果 __init__ 不存在，让我们抛出一个错误：

        if '__init__' not in namespace or not callable(getattr(cls, '__init__')):
            raise ValueError(f'Class {name} must specify its own __init__ function')
        init = getattr(cls, '__init__')

现在我们可以使用类似于我上面显示的函数来建立默认值。您必须小心避免以错误的顺序设置默认值。因此，虽然所有 keyword-only 参数都可以有可选的默认值，但只有列表末尾的位置参数才能获得它们。这意味着位置默认值的循环应该从末尾开始，并且一旦找到没有默认值的名称就应该立即停止：

def lookup(name, configuration):
    try:
        return next(c for c in configuration['resources'].values() if name in c)[name]
    except StopIteration:
        return os.environ.get(name)

...

        spec = inspect.getfullargspec(init)

        defaults = []
        for name in spec.args[:0:-1]:
            value = lookup(name, config)
            if value is None:
                break
            defaults.append(value)

        kwdefaults = {}
        for name in spec.kwonlyargs:
            value = lookup(name, config)
            if value is not None:
                kwdefaults[name] = value

表达式spec.args[:0:-1] 向后遍历除第一个参数之外的所有位置参数。请记住，self 是一个约定俗成的、非强制性的名称。因此，按索引删除它比按名称删除它更可靠。

使 defaults 和 kwdefaults 值有意义的关键是将它们分配给实际 __init__ 函数上的 __defaults__ 和 __kwdefaults__ object（问题 2）：

        init.__defaults__ = tuple(defaults[::-1])
        init.__kwdefaults__ = kwdefaults
        return cls

__defaults__ 必须反转并转换为元组。前者对于获得正确的参数顺序是必要的。 __defaults__ 描述符需要后者。

快速测试

>>> configR = {"resources": {"some_resource": {"a": "testA", "b": "testB"}}}
>>> class Resource(metaclass=ResourceInit, config=configR):
...     def __init__(self, a, b):
...         self.a = a
...         self.b = b
... 
>>> r = Resource()
>>> r.a
'testA'
>>> r.b
'testB'

TL;DR

def lookup(name, configuration):
    try:
        return next(c for c in configuration['resources'].values() if name in c)[name]
    except StopIteration:
        return os.environ.get(name)

class ResourceInit(type):
    def __new__(meta, name, bases, namespace, **kwargs):
        config = kwargs.pop('config')
        cls = super().__new__(meta, name, bases, namespace, **kwargs)

        if '__init__' not in namespace or not callable(getattr(cls, '__init__')):
            raise ValueError(f'Class {name} must specify its own __init__ function')
        init = getattr(cls, '__init__')
        spec = inspect.getfullargspec(init)

        defaults = []
        for name in spec.args[:0:-1]:
            value = lookup(name, config)
            if value is None:
                break
            defaults.append(value)

        kwdefaults = {}
        for name in spec.kwonlyargs:
            value = lookup(name, config)
            if value is not None:
                kwdefaults[name] = value

        init.__defaults__ = tuple(defaults[::-1])
        init.__kwdefaults__ = kwdefaults

        return cls

使用元类作为默认属性初始化

using metaclass for default attribute init

python

metaclass

init