Alex Martelli wrote: > class Meta_for_NR(type): > def __init__(cls, cn, cb, cd): > super(Meta_for_NR, cls).__init__(cn, cb, cd) > abstract_methods = [] > for n, v in inspect.getmembers(cls, inspect.ismethod): > if v is notimplemented: abstract_methods.append(n) etc etc etc
I'm missing the point of the question and Alex's answer. Let's step through this: 1. Programmer A designs a base class some (or all) of whose methods are abstract i.e. not implemented in a do-something-useful fashion; they may be only stubs which document their arguments. 2. Programmer B designs a sub-class, which *should* implement methods which override those of the base class. 3. Programmer C writes an application which *should* create instances of the sub-class. 4. Things that can go wrong are (a) C instantiates the base class (b) B has not provided all the methods (c) B has provided methods but they don't work properly (d) C's app doesn't invoke B's methods in the approved manner or sequence or with meaningful arguments or ... 5. The standard approach in Python is to have the virtual methods raise an exception if invoked. This of course doesn't help with problems c and d. In an attempt to root out instances of problems c and d, programmer C will unit-test the @#$% out of the app. This will quickly discover any instances of problems a and b. One would hope that as well B has unit-tested the @#$% out of the sub-class. 6. Alex's magnum opus appears to operate on problem a, and maybe on b (it's over my head). It involves a fair chunk of mucking about -- for what? Early warning, a few microseconds ahead of the invocation of a method which will cause the stub in the base class to raise an exception? -- http://mail.python.org/mailman/listinfo/python-list
