在大量使用元类的库中，如何避免因元类冲突而烦扰用户？

Question

我正在编写的库大量使用了元classes。例如，这是一个基本的单例实现：

class SingletonMeta(type):
    _instance = None

    def __call__(self, *args, **kwargs):
        if self._instance is None:
            self._instance = super().__call__(*args, **kwargs)

        return self._instance

class ExampleSingleton(metaclass=SingletonMeta):
    pass

这工作得很好，但是当使用多重继承并且另一个 class 也有元 class 时就会出现问题。 Metaclasses 在标准库中相当普遍；最值得注意的是 abc.ABCMeta。制作抽象单例的天真尝试失败了：

class AbstractSingleton(ExampleSingleton, abc.ABC):
    pass

Traceback (most recent call last):
  File "untitled.py", line 25, in <module>
    class AbstractSingleton(ExampleSingleton, abc.ABC):
TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

解决方法很简单 - 创建一个继承自 SingletonMeta 和 ABCMeta 的新元 class - 但对于任何想使用我的库的人来说，这真的很烦人。

class AbstractSingletonMeta(SingletonMeta, abc.ABCMeta):
    pass

class AbstractSingleton(metaclass=AbstractSingletonMeta):
    pass

# no metaclass conflict

处理这个问题的最佳方法是什么？

我的一些想法：

由于抽象 class 相当普遍，我可以将 SingletonMeta 设为 ABCMeta 的子 class。
为了方便用户，我可以在我的库中实现 AbstractSingletonMeta。
因为任何可调用对象都可以用作元class，我可以实现一个自动合并所有父classes 的metaclasses 的函数。（用法类似于 class AbstractSingleton(ExampleSingleton, abc.ABC, metaclass=auto_merge_metaclasses):）
本着"explicit is better than implicit"的精神，我无能为力，让用户解决元class冲突。

Answer 1

由于所有关于所需元类和需要组合的信息已经存在于基础类中，并且这些信息被传递给元类调用，所以有可能一个可调用对象，它将检查所有基类及其使用的元类，并动态创建一个组合元类。

types 模块有一些可调用项，否则可以很容易地为一组基础类选择正确的元类。因此，如果您使用的所有 meta类都可以按任意顺序组合，则下面的函数应该足以满足您的需求：

from types import prepare_class

def combine_meta(name, bases, namespace, **kwargs):
    metaclasses = {prepare_class(name, (base,))[0] for base in bases}
    metaclasses.discard(type)

    if len(metaclasses) > 1:
        meta_name = '_'.join(mcs.__name__ for mcs in metaclasses)
        metaclass = combine_meta(meta_name, tuple(metaclasses), {})
    elif len(metaclasses) == 1:
        metaclass = metaclasses.pop()
    else:
        metaclass = type
    return metaclass(name, bases, namespace, **kwargs)

我已经在交互式解释器中用这个序列测试了它，它工作到现在为止：

class M1(type): pass
class M2(type): pass
class A(metaclass=M1): pass
class B(metaclass=M2): pass
class C(A, B): pass  # This raises a metaclassconflict
class C(A, B, metaclass=combine_meta): pass

在大量使用元类的库中，如何避免因元类冲突而烦扰用户？

In a library that uses metaclasses a lot, how can I avoid annoying the user with metaclass conflicts?

python

metaclass