Triple inheritance causes metaclass conflict... Sometimes

The error message indicates that you have two conflicting metaclasses somewhere in your hierarchy. You need to examine each of your classes and the QT classes to figure out where the conflict is.

Here's some simple example code that sets up the same situation:

class MetaA(type):    passclass MetaB(type):    passclass A:    __metaclass__ = MetaAclass B:    __metaclass__ = MetaB

We can't subclass both of those classes directly, because python wouldn't know which metaclass to use:

>>> 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

What the error is trying to tell us is that we need to resolve the conflict between the two metaclasses by introducing a third metaclass that is a subclass of all the metaclasses from the base classes.

I'm not sure that's any clearer than the error message itself, but basically, you fix it by doing this:

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

This code now compiles and runs correctly. Of course, in the real situation, your conflict-resolving metaclass would have to decide which of the parent metaclass behaviors to adopt, which you'll have to figure out for yourself from your application's requirements.

Bear in mind that your inherited class only gets one of the two metaclass.__init__ methods, which sometimes do all the work, so in a lot of cases, you are going to have to add an __init__ that calls into both in some way that helps them get along.

We use something like this:

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)

Assuming good, modern metaclass-implementation hygiene (where metaclasses subclass type, and whatever can be done in __init__ gets done there) this allows many metaclasses to get along.

Metaclasses that really and necessarily do most of their work in __new__, are going to be hard to combine anyway. You can sneak one of them in here by making sure its class is the first element in the multiple inheritance.

To use this, you just declare:

__metaclass__ = CooperativeMeta

for those classes where different metaclasses come together.

In this case, for instance:

class A:    __metaclass__ = MetaAclass B:    __metaclass__ = MetaBclass Fixed(A, B):    __metaclass__ = CooperativeMeta

This is many times more likely to work correctly across the board for different MetaA and MetaB than just inheriting them together to shut the compiler up.

Hopefully the comments explain the code. There is just one tricky line, and it is about removing redundant calls to any given __metaclass__ inherited from different places and allowing classes with no explicit metaclass to play nicely with the others. If it seems overreaching, you can omit it and in your code, just order the base classes carefully.

That makes the solution three lines and pretty clear.