I'm not sure why you'd need a new keyword for this feature when you can simply create a class that can check if methods in a derived class have been implemented. You can also check for other attributes if you use a live object instead of a class. All it needs to do is raise an exception if the interface isn't fully implemented. Here is an (admittedly simplified) example: import types from exceptions import TypeError class Interface(object): def implemented_by(self,implementer): # Verify against class methods: methods = [] for i in dir(self.__class__): if i not in dir(Interface): methods.append(i) for i in methods: if i not in dir(implementer): raise TypeError, "%s not implemented" % str(i) # and verify its type, parameters, ... # For objects, can also verify that attributes created in the # interface's __init__ exist: if type(implementer) not in (type(Interface), types.ClassType): # Assume it's an object. There's probably a better way. # (type(implementer) is types.ObjectType) works, but only # for new-style classes. methods += dir(Interface) attributes = [] for i in dir(self): if i not in methods: attributes.append(i) for i in attributes: if i not in dir(implementer): raise TypeError, "%s not implemented" % str(i) Something as simple as this would let you verify that a class or object has implemented an interface. For example: class TestInterface(Interface): def __init__(self): # object attributes to look for: self.attrib = "Some attribute" # class methods to look for: def method(self): "Some method" # To verify only methods, check the class TestInterface().implemented_by(Foo) # To verify attributes, check an object TestInterface().implemented_by(Foo()) I don't know what Zope does, but this doesn't seem that ugly to me. -Jerry