Question

How can you access class values from within the top level class scope? What I mean by that is, how do you do something like:

class FooClass(object):
    zeroith_base = __bases__[0]
    .
    .
    .

What I’m specifically trying to do in this case is derive the metaclasses of all base classes to dynamically generate a metaclass that subclasses all the base classes’ metaclasses to get past metclass conflict problems. I found http://code.activestate.com/recipes/204197-solving-the-metaclass-conflict/, and while all the concepts make sense to me, the actual code of the recipe is just beyond my ability to follow it. I don’t want to use code I can’t understand though, so instead, I tried to implement my own, more rudimentary system, but I’m stuck at square one trying to inspect the class object during creation.

Answer 1

You cannot inspect a class prior to its creation, and it has not yet been created yet until the suite of statements, or class body, have finished executing. The first time you have access to this information would be in the MetaClass.__new__ method of the class creating the class in question, or the execution of the thing creating the class in question, which technically need not be a meta-class or a class at all (as in the example below).

Here is a very rough prototype that probably does not work in all cases, but works in the simple case, and is probably easier to follow than the recipe.

def meta_class_synthesize(name, bases, attrmap):
    seen = set()
    seen_add = seen.add
    metas = [type(base) for base in bases]
    metas = tuple([
        meta for meta in metas
        if meta is not type and meta not in seen and not seen_add(meta)])
    if not metas:
        return type(name, bases, attrmap)
    elif len(metas) == 1:
        return metas[0](name, bases, attrmap)
    newmeta_name = "__".join(meta.__name__ for meta in metas)
    newmeta = type(newmeta_name, metas, {})
    return newmeta(name, bases, attrmap)

class M_A(type):
    pass

class M_B(type):
    pass

class A:
    __metaclass__ = M_A

class B:
    __metaclass__ = M_B

class C(A, B):
    __metaclass__ = meta_class_synthesize


print type(C)  # prints "<class '__main__.M_A__M_B'>"