Тройное наследование вызывает конфликт метакласса... Иногда

Ответ 1

Сообщение об ошибке указывает, что у вас есть две конфликтующие метаклассы где-то в вашей иерархии. Вам нужно изучить каждый из ваших классов и классов QT, чтобы выяснить, где конфликт.

Вот пример простого кода, который устанавливает ту же ситуацию:

class MetaA(type):
    pass
class MetaB(type):
    pass
class A:
    __metaclass__ = MetaA
class B:
    __metaclass__ = MetaB

Мы не можем подклассифицировать оба этих класса напрямую, потому что python не знал, какой метакласс использовать:

>>> class Broken(A, B): pass
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Error when calling the metaclass bases
  metaclass conflict: the metaclass of a derived class must be a (non-strict)
  subclass of the metaclasses of all its bases

То, что ошибка пытается сказать нам, состоит в том, что нам нужно разрешить конфликт между двумя метаклассами, введя третий метакласс, являющийся подклассом всех метаклассов из базовых классов.

Я не уверен, что яснее самого сообщения об ошибке, но в основном вы его исправляете, делая это:

class MetaAB(MetaA, MetaB):
    pass

class Fixed(A, B):
    __metaclass__ = MetaAB

Этот код теперь компилируется и выполняется правильно. Конечно, в реальной ситуации ваш мета-класс, разрешающий конфликт, должен будет решить, какое из поведения родительского метакласса принять, что вам нужно будет выяснить из ваших требований к приложениям.

Имейте в виду, что ваш унаследованный класс получает только один из двух методов metaclass. __init__, которые иногда выполняют всю работу, поэтому во многих случаях вам придется добавить __init__, который вызывает и в том, и в другом, что помогает им ладить.

Ответ 2

Мы используем что-то вроде этого:

class CooperativeMeta(type):
    def __new__(cls, name, bases, members):
        #collect up the metaclasses
        metas = [type(base) for base in bases]

        # prune repeated or conflicting entries
        metas = [meta for index, meta in enumerate(metas)
            if not [later for later in metas[index+1:]
                if issubclass(later, meta)]]

        # whip up the actual combined meta class derive off all of these
        meta = type(name, tuple(metas), dict(combined_metas = metas))

        # make the actual object
        return meta(name, bases, members)

    def __init__(self, name, bases, members):
        for meta in self.combined_metas:
            meta.__init__(self, name, bases, members)

Предполагая, что хорошая, современная метаклассическая реализация (где выполняется подкласс класса metaclass type и все, что можно сделать в __init__), это позволяет многим метаклассам ладить.

Метаклассы, которые действительно и обязательно выполняют большую часть своей работы в __new__, все равно сложно объединить. Вы можете прокрасть один из них здесь, убедившись, что его класс является первым элементом в множественном наследовании.

Чтобы использовать это, вы просто объявляете:

__metaclass__ = CooperativeMeta

для тех классов, где разные метаклассы объединяются.

В этом случае, например:

class A:
    __metaclass__ = MetaA
class B:
    __metaclass__ = MetaB
class Fixed(A, B):
    __metaclass__ = CooperativeMeta

Это во много раз больше шансов правильно работать по всем разделам для разных MetaA и MetaB, чем просто наследовать их вместе, чтобы закрыть компилятор.

Надеемся, что комментарии объяснят код. Существует только одна сложная строка, и речь идет об удалении избыточных вызовов для любого заданного __metaclass__, унаследованного из разных мест, и предоставления классам без явного метакласса, чтобы хорошо играть с другими. Если это кажется чрезмерным, вы можете опустить его и в своем коде, просто закажите базовые классы.

Это делает решение трех строк и довольно четким.