I'm not talking about having the runtime call the superclass __init__ for you, as I am aware of the arguments over it and I am against it myself. I'm talking about checking whether it's been called within a subclass's own __init__.
There are many kinds of objects with such complex underpinnings or initialization that leaving out the call to superclass __init__ would be disastrous. There are two situations I can think of where enforcing its invocation could be useful: a corporate environment and a teaching environment. (I've done the former and I'm working in the latter.)
If someone forgets to call a superclass __init__, problems may not show up until much later. Even if they do show up immediately, it's almost never obvious what the real problem is, especially to someone who is new to programming or is working on someone else's code.
I've got a working prototype metaclass and class instance (require_super) and decorator (super_required). Decorating a require_super method with @super_required will require any subclass override to call its superclass method, or it throws a TypeError upon exiting the subclass method. Here's how it works on the __init__ problem:
class A(require_super): @super_required def __init__(self): pass
a = A() # No problem
class B(A): def __init__(self): super(B, self).__init__()
b = B() # No problem
class C(B): def __init__(self): pass # this could be a problem
c = C() # TypeError: C.__init__: no super call
class D(C): def __init__(self): super(D, self).__init__()
d = D() # TypeError: C.__init__: no super call
As long as A.__init__ is eventually called, it doesn't raise a TypeError.
There's not much magic involved (as metaclasses go), just explicit and implicit method wrappers, and no crufty-looking magic words in the subclasses. Not calling the superclass method results in immediate runtime feedback. I've tested this on a medium-small, real-life single-inheritance hierarchy and it seems to work just fine. (I *think* it should work with multiple inheritance.)
1. Is the original problem (missed superclass method calls) big enough to warrant language, runtime, or library support for a similar solution?
2. Does anybody but me think this is a great idea?