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
