Multi inheritance from metaclasses factories

Question

I want SuperClass12 to inherit from SuperClass1 and SuperClass2:

def getClass1(): 
    class MyMetaClass1(type):
        def __new__(cls, name, bases, dct):
            print dct.get("Attr","")+"Meta1"
            return super(MyMetaClass1, cls).__new__(cls, name, bases, dct)
    return MyMetaClass1

def getClass2(): 
    class MyMetaClass2(type):
        def __new__(cls, name, bases, dct):
            print dct.get("Attr","")+"Meta2"
            return super(MyMetaClass2, cls).__new__(cls, name, bases, dct)
    return MyMetaClass2    

class SuperClass1():
    __metaclass__ = getClass1()
    def fun1(self):
        pass

class SuperClass2():
    __metaclass__ = getClass2()
    def fun2(self):
        pass

class MyClass1(SuperClass1):
    Attr = "MC1"

class MyClass2(SuperClass2):
    Attr = "MC2"

def getClass12(): 
    class myMultiMeta(getClass1(),getClass2()):
        pass
    return myMultiMeta

class SuperClass12(SuperClass1,SuperClass2):
#class SuperClass12(): gives no errors in class construction but then 
#fun1() and fun2() are not members of SuperClass12. 
    __metaclass__ = getClass12()

class MyClass12(SuperClass12):
    Attr = "MC12"

Instance = MyClass12()
Instance.fun1()
Instance.fun2()

sadly I've got this error:

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

but I cannot understand why, since the metaclass myMultiMeta of my derived class SuperClass12 indeed is a subclass of bothe the metaclasses (MyMetaClass1,MyMetaClass2) of all its bases (SuperClass1,SUperClass2).

kindall kindall · Accepted Answer · 2012-01-20T18:31:00

As noted by Michael Merickel, the getClass() functions need to return the same object on each call for your inheritance to work. A class that is merely identical isn't good enough. Here's one way to do that, abusing a class to make it act like your getClass() functions. Since the class definition is only executed once, MyMetaClass1 is always the same object when returned.

class getClass1(object):
    class MyMetaClass1(type):
        def __new__(cls, name, bases, dct):
            print dct.get("Attr","")+"Meta1"
            return super(MyMetaClass1, cls).__new__(cls, name, bases, dct)
    class __metaclass__(type):
        def __call__(cls):
            return cls.MyMetaClass1

You could also do it like so, using a real function and abusing a mutable default argument to cache the class instance:

def getClass1(cls=[]):
    if not cls:
        class MyMetaClass1(type):
            def __new__(cls, name, bases, dct):
                print dct.get("Attr","")+"Meta1"
                return super(MyMetaClass1, cls).__new__(cls, name, bases, dct)
        cls.append(MyMetaClass1)
    return cls[0]

You will notice a recurring theme here: abuse of Python features. :-) That is usually a sign that you are doing something that maybe is done better some other way. For example, why are you using factories, rather than just defining the class the normal way? I've seen class factories have some use, but I don't think I've ever seen a metaclass factory in the wild.

Multi inheritance from metaclasses factories

4 Answers