Assertion that all base class initializers get called (metaclass solution) (Python recipe) by Hannu Kankaanpää

ActiveState Code (http://code.activestate.com/recipes/224980/)

class AssertInit(type):
    """Assert that initializers get called.

    Set this as a __metaclass__ for the root class
    in a class hierarchy, and you will get AssertionError
    if some of the base class initializers isn't called.
    """
    def __new__(cls, classname, bases, classdict):
        # if class has no real init method, it doesn't
        # matter if it isn't called
        classdict['_has_real_init_'] = ('__init__' in classdict)

        old_init = classdict.get('__init__', lambda self: None)

        def new_init(self, *args, **kwargs):
            # here selfclass refers to the class in which
            # this __init__ function lies (see below this function
            # definition for the definition of selfclass)

            # this is code that will be executed by
            # all initializers except the first one:
            if hasattr(self, '_visited_bases_'):
                self._visited_bases_[selfclass] = True
                old_init(self, *args, **kwargs)
                return

            # initialize _visited_bases_ by scanning *all* superclasses
            # and by creating mappings from the class object to False
            # if the base class needs to be visited, True otherwise.
            self._visited_bases_ = vb = {}
            def recurseBases(bases):
                for claz in bases:
                    vb[claz] = (not hasattr(claz, '_has_real_init_') or
                                not claz.__dict__['_has_real_init_'])
                    recurseBases(claz.__bases__)
            recurseBases(bases)
            
            old_init(self, *args, **kwargs)

            # scan _visited_bases_ to see which base class
            # initializers didn't get visited
            unvisited = ['%s.%s' % (claz.__module__, claz.__name__)
                         for claz, visited in vb.items() if not visited]
            if unvisited:
                fullClassName = '%s.%s' %\
                                (selfclass.__module__, selfclass.__name__)

                raise AssertionError("Initializer%s in class%s (%s) not "
                                     "visited when constructing object "
                                     "from class %s" %
                                     (len(unvisited) > 1 and 's' or '',
                                      len(unvisited) > 1 and 'es' or '',
                                      ', '.join(unvisited),
                                      fullClassName))
        # ^def new_init
        
        classdict['__init__'] = new_init

        # the newly created class, selfclass, is referred to inside
        # the new_init function, so it has to be put in a new variable
        selfclass = super(AssertInit, cls).__new__\
                        (cls, classname, bases, classdict)
        return selfclass

########### USAGE ############

def test():
    class A(object):
        __metaclass__ = AssertInit
        def __init__(self):
            print 'A init'

    class B(A):
        def __init__(self):
            #A.__init__(self)
            print 'B init'

    class C(A):
        pass

    # a separate root class needs to set the __metaclass__ properly
    class G(object):
        __metaclass__ = AssertInit
        def __init__(self):
            print 'G init'

    class D(C, B, G):
        def __init__(self):
            B.__init__(self)
            #G.__init__(self)
            print 'D init'

    # This will raise an error for not calling two base
    # class initializers: A and G.
    # It properly sees that C.__init__ needs not be
    # called and that B.__init__ was called.
    D()

if __name__ == '__main__':
    test()