Defining a method final

[Jeff Epler]

The following code uses a metaclass to attempt to enforce "final"
methods.  Warning: Use of metaclasses has exploded brains.  Accessing
directly through __dict__ or object.__setattr__ can bypass these
protections.

def finalmethod(f):
    """Marks a method as a final method.  Use like classmethod(), etc.  Only
       works in subclasses of FinalMethods:
       class C(FinalMethods):
           def f(x): ...
           f = finalmethod(f)"""
    f.__final__ = 1
    return f

class FinalMethodsMeta(type):
    """Metatype for FinalMethods"""
    def __init__(cls, name, bases, dict):
	super(FinalMethodsMeta, cls).__init__(name, bases, dict)
	for base in cls.__mro__:
	    if base is cls: continue
	    for attrname in base.__dict__:
		attr = base.__dict__[attrname]
		if hasattr(attr, "__final__") and attr.__final__:
		    func = getattr(cls, attrname).im_func
		    print attrname, attr, func
		    if func is not attr:
			raise ValueError, \
			    "Subclasses of %s may not override the method %s" \
			    % (base.__name__, attrname)

    def __setattr__(cls, name, attr):
	oldval = getattr(cls, name, None)
	if hasattr(oldval, "__final__") and oldval.__final__:
	    raise ValueError, "final methods may not be overridden by assignment to class"
	super(FinalMethodsMeta, cls).__setattr__(name, attr)

class FinalMethods:
    """Subclasses of FinalMethods may define a method to be a finalmethod().
    This probably only works with instancemethods, not classmethods or 
    staticmethods.  A subclass may not override a finalmethod"""


    __metaclass__ = FinalMethodsMeta

    def __setattr__(self, name, attr):
	oldval = getattr(self, name, None)
	if hasattr(oldval, "__final__") and oldval.__final__:
	    raise ValueError, "final methods may not be overridden by assignment to instance"
	super(FinalMethods, self).__setattr__(name, attr)

def _test():
    class c1(FinalMethods):
	def f(x): pass
	f = finalmethod(f)

	def g(x): pass

    class c2(FinalMethods):
	def g(x): pass
	g = finalmethod(g)

    # Test that FinalMethods classes can be subclassed when they don't
    # interfere with each others' final methods
    class c3(c2, c1): pass
    assert c3.f.im_func is c1.f.im_func

    # Test that a FinalMethods class can be subclassed when the added
    # methods do not interfere with the super's final methods
    class c4(c1):
	def g(x): pass

    # Test that when a final method is concealed by a non-final method,
    # it blows up
    try:
	class c5(c1, c2): pass
    except ValueError, detail:
	print "Caught expected ValueError:", detail
    else:
	print "Did not catch expected error"
	print c5.g, c1.g, c2.g
	raise RuntimeError

    # Test that when a final method is overridden in the subclass, it
    # blows up
    try:
	class c5(c1):
	    def f(x): pass
    except ValueError, detail:
	print "Caught expected ValueError:", detail
    else:
	print c5.f, c1.f
	print "Did not catch expected error"
	raise RuntimeError

    # Test that when a final method is overridden in the sub-subclass,
    # it blows up
    try:
	class c6(c3):
	    def f(x): pass
    except ValueError, detail:
	print "Caught expected ValueError:", detail
    else:
	print c6.f, c3.f
	print "Did not catch expected error"
	raise RuntimeError

    # Test that assigning to non-final attributes works (class)
    class c7(c1): pass
    c7.g = lambda: None

    # Test that assigning to final attributes fails (class)
    try:
	class c7(c3): pass
	c7.f = None
    except ValueError, detail:
	print "Caught expected ValueError:", detail
    else:
	print "Did not catch expected error"
	raise RuntimeError

    # Test that assigning to non-final attributes works (instance)
    i = c1()
    i.g = None

    # Test that assigning to final attributes fails (instance)
    try:
	i = c1();
	i.f = None
    except ValueError, detail:
	print "Caught expected ValueError:", detail
    else:
	print "Did not catch expected error"
	raise RuntimeError

    print "seems ta work"

if __name__ == '__main__': _test()