[Python-Dev] Re: proposal for interfaces (original) (raw)

Gerald S. Williams gsw@agere.com
Tue, 1 Oct 2002 13:48:11 -0400

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