[Zope-Checkins] CVS: Zope/lib/python/Interface - Attribute.py:1.2 Document.py:1.2 IAttribute.py:1.2 IElement.py:1.2 IInterface.py:1.2 IMethod.py:1.2 Implements.py:1.2 Verify.py:1.2 _Element.py:1.2 _Interface.py:1.2 _InterfaceClass.py:1.2 _object.py:1.2 pyskel.py:1.2 Exceptions.py:1.7 Method.py:1.9 __init__.py:1.6 iclass.py:1.13 verify.py:1.5 Attr.py:NONE Basic.py:NONE CHANGES.txt:NONE InterfaceBase.py:NONE Number.py:NONE README:NONE README.txt:NONE Standard.py:NONE Util.py:NONE pyfiles:NONE release.sh:NONE test.py:NONE unitfixtures.py:NONE unittests.py:NONE

Jim Fulton jim@zope.com
Fri, 7 Jun 2002 13:19:00 -0400


Update of /cvs-repository/Zope/lib/python/Interface
In directory cvs.zope.org:/tmp/cvs-serv24067/lib/python/Interface

Modified Files:
	Exceptions.py Method.py __init__.py iclass.py verify.py 
Added Files:
	Attribute.py Document.py IAttribute.py IElement.py 
	IInterface.py IMethod.py Implements.py Verify.py _Element.py 
	_Interface.py _InterfaceClass.py _object.py pyskel.py 
Removed Files:
	Attr.py Basic.py CHANGES.txt InterfaceBase.py Number.py README 
	README.txt Standard.py Util.py pyfiles release.sh test.py 
	unitfixtures.py unittests.py 
Log Message:
Backported Zope 3 Interface package to Python 2.1 and Zope 2.  Some
modifications were needed in Zope (only two files). A lot of unused
(or rarely) features were removed from the Interface package. Slightly
deeper imports are needed.


=== Zope/lib/python/Interface/Attribute.py 1.1 => 1.2 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+from _Element import Element
+
+class Attribute(Element):
+    """Attribute descriptions
+    """
+
+    # We can't say this yet because we don't have enough
+    # infrastructure in place.
+    #
+    #__implements__ = IAttribute
+
+


=== Zope/lib/python/Interface/Document.py 1.1 => 1.2 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+""" Pretty-Print an Interface object as structured text (Yum)
+
+This module provides a function, asStructuredText, for rendering an
+interface as structured text.
+
+Revision information:
+$Id$
+"""
+
+from string import maketrans
+
+def asStructuredText(I, munge=0):
+    """ Output structured text format.  Note, this will wack any existing
+    'structured' format of the text.  """
+
+    
+    r = ["%s\n\n" % I.getName()]
+    outp = r.append
+    level = 1
+
+    if I.getDoc():
+        outp(_justify_and_indent(_trim_doc_string(I.getDoc()), level)+ "\n\n")
+
+    if I.getBases():
+        outp((" " * level) + "This interface extends:\n\n")
+        level = level + 1
+        for b in I.getBases():
+            item = "o %s" % b.getName()
+            outp(_justify_and_indent(_trim_doc_string(item), level, munge)
+                 + "\n\n")
+
+        level = level - 1
+
+    namesAndDescriptions = list(I.namesAndDescriptions())
+    namesAndDescriptions.sort()
+
+
+    outp(_justify_and_indent("Attributes:", level, munge)+'\n\n')
+    level = level + 1
+    for name, desc in namesAndDescriptions:
+        if not hasattr(desc, 'getSignatureString'):   # ugh...
+            item = "%s -- %s" % (desc.getName(),
+                                 desc.getDoc() or 'no documentation')
+            outp(_justify_and_indent(_trim_doc_string(item), level, munge)
+                 + "\n\n")
+    level = level - 1
+
+    outp(_justify_and_indent("Methods:", level, munge)+'\n\n')
+    level = level + 1
+    for name, desc in namesAndDescriptions:
+        if hasattr(desc, 'getSignatureString'):   # ugh...
+            item = "%s%s -- %s" % (desc.getName(),
+                                   desc.getSignatureString(),
+                                   desc.getDoc() or 'no documentation')
+            outp(_justify_and_indent(_trim_doc_string(item), level, munge)
+                 + "\n\n")
+
+    return "".join(r)
+
+def _trim_doc_string(text):
+    """
+    Trims a doc string to make it format
+    correctly with structured text.
+    """
+    text = text.strip().replace('\r\n', '\n')
+    lines = text.split('\n')
+    nlines = [lines[0]]
+    if len(lines) > 1:
+        min_indent=None
+        for line in lines[1:]:
+            indent=len(line) - len(line.lstrip())
+            if indent < min_indent or min_indent is None:
+                min_indent=indent   
+        for line in lines[1:]:
+            nlines.append(line[min_indent:])
+    return '\n'.join(nlines)
+    
+    
+_trans = maketrans("\r\n", "  ")
+def _justify_and_indent(text, level, munge=0, width=72):
+    """ indent and justify text, rejustify (munge) if specified """
+
+    lines = []
+
+    if munge:
+        line = " " * level
+        text = text.translate(text, _trans).strip().split()
+
+        for word in text:
+            line = ' '.join([line, word])
+            if len(line) > width:
+                lines.append(line)
+                line = " " * level
+        else:
+            lines.append(line)
+
+        return "\n".join(lines)
+
+    else:
+        text = text.replace("\r\n", "\n").split("\n")
+
+        for line in text:
+            lines.append( (" " * level) + line)
+
+        return '\n'.join(lines)
+            
+
+
+
+    
+
+
+


=== Zope/lib/python/Interface/IAttribute.py 1.1 => 1.2 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+from IElement import IElement
+
+class IAttribute(IElement):
+    """Attribute descriptors"""
+    


=== Zope/lib/python/Interface/IElement.py 1.1 => 1.2 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+from _Interface import Interface
+from Attribute import Attribute
+
+class IElement(Interface):
+    """Objects that have basic documentation and tagged values.
+    """
+
+    __name__ = Attribute('__name__', 'The object name')
+    __doc__  = Attribute('__doc__', 'The object doc string')
+
+    def getName():
+        """Returns the name of the object."""
+
+    def getDoc():
+        """Returns the documentation for the object."""
+        
+    def getTaggedValue(tag):
+        """Returns the value associated with 'tag'."""
+
+    def getTaggedValueTags():
+        """Returns a list of all tags."""
+
+    def setTaggedValue(tag, value):
+        """Associates 'value' with 'key'."""


=== Zope/lib/python/Interface/IInterface.py 1.1 => 1.2 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+from IElement import IElement
+
+class IInterface(IElement):
+    """Interface objects
+
+    Interface objects describe the behavior of an object by containing
+    useful information about the object.  This information includes:
+
+      o Prose documentation about the object.  In Python terms, this
+        is called the "doc string" of the interface.  In this element,
+        you describe how the object works in prose language and any
+        other useful information about the object.
+
+      o Descriptions of attributes.  Attribute descriptions include
+        the name of the attribute and prose documentation describing
+        the attributes usage.
+
+      o Descriptions of methods.  Method descriptions can include:
+
+        o Prose "doc string" documentation about the method and its
+          usage.
+
+        o A description of the methods arguments; how many arguments
+          are expected, optional arguments and their default values,
+          the position or arguments in the signature, whether the
+          method accepts arbitrary arguments and whether the method
+          accepts arbitrary keyword arguments. 
+
+      o Optional tagged data.  Interface objects (and their attributes and
+        methods) can have optional, application specific tagged data
+        associated with them.  Examples uses for this are examples,
+        security assertions, pre/post conditions, and other possible
+        information you may want to associate with an Interface or its
+        attributes.
+
+    Not all of this information is mandatory.  For example, you may
+    only want the methods of your interface to have prose
+    documentation and not describe the arguments of the method in
+    exact detail.  Interface objects are flexible and let you give or
+    take any of these components.
+
+    Interfaces are created with the Python class statement using
+    either Interface.Interface or another interface, as in::
+
+      from Interface import Interface
+
+      class IMyInterface(Interface):
+        '''Interface documentation
+        '''
+
+        def meth(arg1, arg2):
+            '''Documentation for meth
+            '''
+
+        # Note that there is no self argument
+
+     class IMySubInterface(IMyInterface):
+        '''Interface documentation
+        '''
+
+        def meth2():
+            '''Documentation for meth2
+            '''
+
+    You use interfaces in two ways:
+
+    o You assert that your object implement the interfaces.
+
+      There are several ways that you can assert that an object
+      implements an interface::
+
+      1. Include an '__implements__' attribute in the object's class
+         definition. The value of the '__implements__' attribute must
+         be an implementation specification. An implementation
+         specification is either an interface or a tuple of
+         implementation specifications.
+
+      2. Incluse an '__implements__' attribute in the object.
+         Because Python classes don't have their own attributes, to
+         assert that a class implements interfaces, you must provide a
+         '__class_implements__' attribute in the class definition.
+
+         **Important**: A class usually doesn't implement the
+           interfaces that it's instances implement. The class and
+           it's instances are separate objects with their own
+           interfaces.
+
+      3. Call 'Interface.Implements.implements' to assert that instances
+         of a class implement an interface.
+
+         For example::
+
+           from Interface.Implements import implements
+
+           implements(some_class, some_interface)
+
+         This is approach is useful when it is not an option to modify
+         the class source.  Note that this doesn't affect what the
+         class itself implements, but only what it's instances
+         implement.
+
+      4. For types that can't be modified, you can assert that
+         instances of the type implement an interface using
+         'Interface.Implements.assertTypeImplements'.
+
+         For example::
+
+           from Interface.Implements import assertTypeImplements
+
+           assertTypeImplements(some_type, some_interface)
+
+    o You query interface meta-data. See the IInterface methods and
+      attributes for details.
+
+    """
+
+    def getBases():
+        """Return a sequence of the base interfaces
+        """
+
+    def extends(other, strict=1):
+        """Test whether the interface extends another interface
+
+        A true value is returned in the interface extends the other
+        interface, and false otherwise.
+        
+        Normally, an interface doesn't extend itself. If a false value
+        is passed as the second argument, or via the 'strict' keyword
+        argument, then a true value will be returned if the interface
+        and the other interface are the same.
+        """
+
+    def isImplementedBy(object):
+        """Test whether the interface is implemented by the object.
+
+        Return true of the object asserts that it implements the
+        interface, including asseting that it implements an extended
+        interface.
+        """
+
+    def isImplementedByInstancesOf(class_):
+        """Test whether the interface is implemented by instances of the class
+
+        Return true of the class asserts that it's instances implement the
+        interface, including asseting that they implement an extended
+        interface.
+        """
+    def names(all=0):
+        """Get the interface attribute names.
+
+        Return a sequence of the names of the attributes, including
+        methods, included in the interface definition.
+
+        Normally, only directly defined attributes are included. If
+        a true positional or keyword argument is given, then
+        attributes defined by nase classes will be included.
+        """
+
+    def namesAndDescriptions(all=0):
+        """Get the interface attribute names and descriptions.
+
+        Return a sequence of the names and descriptions of the
+        attributes, including methods, as name-value pairs, included
+        in the interface definition.
+
+        Normally, only directly defined attributes are included. If
+        a true positional or keyword argument is given, then
+        attributes defined by nase classes will be included.
+        """
+
+    def getDescriptionFor(name):
+        """Get the description for a name
+
+        If the named attribute does not exist, a KeyError is raised.
+        """
+
+    def queryDescriptionFor(name, default=None):
+        """Get the description for a name
+
+        Return the default if no description exists.
+        """


=== Zope/lib/python/Interface/IMethod.py 1.1 => 1.2 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+from IAttribute import IAttribute
+
+class IMethod(IAttribute):
+    """Method attributes
+    """
+    # XXX What the heck should methods provide? Grrrr
+
+    def getSignatureString():
+        """Return a signature string suitable for inclusion in documentation.
+        """


=== Zope/lib/python/Interface/Implements.py 1.1 => 1.2 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+"""Implemantation assertion facilities.
+
+Revision information:
+$Id$
+"""
+
+import Exceptions
+from types import ClassType
+from Verify import verifyClass
+from _InterfaceClass import Interface as InterfaceClass
+from types import TupleType, ClassType, StringType
+
+# Special value indicating the object supports
+# what its class supports.
+CLASS_INTERFACES = 1
+
+from _object import ClassTypes, isInstance
+
+_typeImplements={}
+
+def getImplements(object):
+    t = type(object)
+    if t in ClassTypes:
+        if hasattr(object, '__class_implements__'):
+            return object.__class_implements__
+    elif hasattr(object, '__implements__'):
+        return object.__implements__
+
+    return _typeImplements.get(t, None)
+
+
+def getImplementsOfInstances(klass, tiget=_typeImplements.get):
+    if type(klass) in ClassTypes:
+        if hasattr(klass, '__implements__'):
+            return klass.__implements__
+        else:
+            return None
+    else:
+        return tiget(klass, None)
+
+
+def visitImplements(implements, object, visitor, getInterface=None):
+    """
+    Visits the interfaces described by an __implements__ attribute,
+    invoking the visitor for each interface object.
+    If the visitor returns anything true, the loop stops.
+    This does not, and should not, visit superinterfaces.
+    """
+    # this allows us to work with proxy wrappers in Python 2.2,
+    # yet remain compatible with earlier versions of python.
+    implements_class = getattr(implements, '__class__', None)
+    
+    if implements_class == InterfaceClass or \
+       isInstance(implements, InterfaceClass):
+        return visitor(implements)
+    elif implements == CLASS_INTERFACES:
+        klass = getattr(object, '__class__', None)
+        if klass is not None:
+            i = getImplementsOfInstances(klass)
+            if i:
+                return visitImplements(i, object, visitor, getInterface)
+    elif implements_class == StringType or type(implements) is StringType:
+        if getInterface is not None:
+            # Look up a named interface.
+            i = getInterface(object, implements)
+            if i is not None:
+                return visitImplements(i, object, visitor, getInterface)
+    elif implements_class == TupleType or type(implements) is TupleType:
+        for i in implements:
+            r = visitImplements(i, object, visitor, getInterface)
+            if r:
+                # If the visitor returns anything true, stop.
+                return r
+    else:
+        if implements_class is not None and \
+           type(implements) != implements_class:
+            raise Exceptions.BadImplements(
+                """__implements__ should be an interface or tuple,
+                not a %s pretending to be a %s"""
+                % (type(implements).__name__, implements_class.__name__)
+                )
+        raise Exceptions.BadImplements(
+            """__implements__ should be an interface or tuple,
+            not a %s""" % type(implements).__name__)
+    return None
+
+
+def assertTypeImplements(type, interfaces):
+    """Assign a set of interfaces to a Python type such as int, str, tuple,
+       list and dict.
+    """
+    _typeImplements[type]=interfaces
+
+def objectImplements(object, getInterface=None):
+    r = []
+    implements = getImplements(object)
+    if not implements:
+        return r
+    visitImplements(implements, object, r.append, getInterface)
+    return r
+
+def instancesOfObjectImplements(klass, getInterface=None):
+    r = []
+    implements = getImplementsOfInstances(klass)
+    if not implements:
+        return r
+    visitImplements(implements, klass, r.append, getInterface)
+    return r
+
+
+def _flatten(i, append):
+    append(i)
+    bases = i.getBases()
+    if bases:
+        for b in bases:
+            _flatten(b, append)
+
+
+def flattenInterfaces(interfaces, remove_duplicates=1):
+    res = []
+    for i in interfaces:
+        _flatten(i, res.append)
+    if remove_duplicates:
+        # Remove duplicates in reverse.
+        # Similar to Python 2.2's method resolution order.
+        seen = {}
+        index = len(res) - 1
+        while index >= 0:
+            i = res[index]
+            if seen.has_key(i):
+                del res[index]
+            else:
+                seen[i] = 1
+            index = index - 1
+    return res
+
+def implements(klass, interface, check=1):
+    if check:
+        verifyClass(interface, klass, tentative=1)
+
+    old=getattr(klass, '__implements__', None)
+    if old is None:
+        klass.__implements__ = interface
+    else:
+        klass.__implements__ = old, interface
+


=== Zope/lib/python/Interface/Verify.py 1.1 => 1.2 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+
+from Exceptions import BrokenImplementation, DoesNotImplement
+from Exceptions import BrokenMethodImplementation
+from types import FunctionType
+from Method import fromMethod, fromFunction
+from _object import MethodTypes
+
+def _verify(iface, candidate, tentative=0, vtype=None):
+    """
+
+    Verify that 'candidate' might correctly implements 'iface'.
+    This involves:
+
+      o Making sure the candidate defines all the necessary methods
+
+      o Making sure the methods have the correct signature
+
+      o Making sure the candidate asserts that it implements the interface
+
+    Note that this isn't the same as verifying that the class does
+    implement the interface.
+
+    If optional tentative is true, suppress the "is implemented by" test.
+    """
+
+    if vtype is 'c':
+        tester = iface.isImplementedByInstancesOf
+    else:
+        tester = iface.isImplementedBy
+
+    if not tentative and not tester( candidate ):
+        raise DoesNotImplement(iface)
+
+    for n, d in iface.namesAndDescriptions():
+        if not hasattr(candidate, n):
+            raise BrokenImplementation(iface, n)
+
+        attr = getattr(candidate, n)
+        if type(attr) is FunctionType:
+            # should never get here
+            meth = fromFunction(attr, n)
+        elif type(attr) in MethodTypes:
+            meth = fromMethod(attr, n)
+        else:
+            continue # must be an attribute...
+
+        d=d.getSignatureInfo()
+        meth = meth.getSignatureInfo()
+
+        mess = _incompat(d, meth)
+        if mess:
+            raise BrokenMethodImplementation(n, mess)
+            
+    return 1
+
+def verifyClass(iface, candidate, tentative=0):
+    return _verify(iface, candidate, tentative, vtype='c')
+
+def verifyObject(iface, candidate, tentative=0):
+    return _verify(iface, candidate, tentative, vtype='o')
+
+def _incompat(required, implemented):
+    #if (required['positional'] !=
+    #    implemented['positional'][:len(required['positional'])]
+    #    and implemented['kwargs'] is None):
+    #    return 'imlementation has different argument names'
+    if len(implemented['required']) > len(required['required']):
+        return 'implementation requires too many arguments'
+    if ((len(implemented['positional']) < len(required['positional']))
+        and not implemented['varargs']):
+        return "implementation doesn't allow enough arguments"
+    if required['kwargs'] and not implemented['kwargs']:
+        return "implementation doesn't support keyword arguments"
+    if required['varargs'] and not implemented['varargs']:
+        return "implementation doesn't support variable arguments"


=== Zope/lib/python/Interface/_Element.py 1.1 => 1.2 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+from _object import object
+
+class Element(object):
+
+    # We can't say this yet because we don't have enough
+    # infrastructure in place.
+    #
+    #__implements__ = IElement
+
+    __tagged_values = {}
+    
+    def __init__(self, __name__, __doc__=''):
+        """Create an 'attribute' description
+        """
+        if not __doc__ and __name__.find(' ') >= 0:
+            __doc__ = __name__
+            __name__ = None
+        
+        self.__name__=__name__
+        self.__doc__=__doc__
+
+    def getName(self):
+        """ Returns the name of the object. """
+        return self.__name__
+
+    def getDoc(self):
+        """ Returns the documentation for the object. """
+        return self.__doc__
+
+    def getTaggedValue(self, tag):
+        """ Returns the value associated with 'tag'. """
+        return self.__tagged_values[tag]
+
+    def getTaggedValueTags(self):
+        """ Returns a list of all tags. """
+        return self.__tagged_values.keys()
+
+    def setTaggedValue(self, tag, value):
+        """ Associates 'value' with 'key'. """
+        self.__tagged_values[tag] = value
+


=== Zope/lib/python/Interface/_Interface.py 1.1 => 1.2 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+"""Interface object implementation
+
+Revision information:
+$Id$
+"""
+
+from _InterfaceClass import Interface as InterfaceClass
+
+Interface = InterfaceClass("Interface")
+
+# Now we can create the interesting interfaces and wire them up:
+def wire():
+
+    from Implements import implements
+
+    from Attribute import Attribute
+    from IAttribute import IAttribute
+    implements(Attribute, IAttribute)
+
+    from Method import Method
+    from IMethod import IMethod
+    implements(Method, IMethod)
+
+    from IInterface import IInterface
+    implements(InterfaceClass, IInterface)
+
+wire()
+del wire 
+del InterfaceClass


=== Zope/lib/python/Interface/_InterfaceClass.py 1.1 => 1.2 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+"""Interface object implementation
+
+Revision information:
+$Id$
+"""
+
+from inspect import currentframe
+import sys
+from Method import Method, fromFunction
+from Attribute import Attribute
+from types import FunctionType
+import Exceptions
+from _Element import Element
+from _object import isInstance
+
+class Interface(Element):
+    """Prototype (scarecrow) Interfaces Implementation
+    """
+
+    # We can't say this yet because we don't have enough
+    # infrastructure in place.
+    #
+    #__implements__ = IInterface
+
+    def __init__(self, name, bases=(), attrs=None, __doc__=None,
+                 __module__=None):
+        
+        if __module__ is None:
+            if attrs is not None and attrs.has_key('__module__'):
+                __module__ = attrs['__module__']
+                del attrs['__module__']
+            else:
+                try:
+                    # Figure out what module defined the interface.
+                    # This is how cPython figures out the module of
+                    # a class, but of course it does it in C. :-/
+                    __module__ = currentframe().f_back.f_globals['__name__']
+                except (AttributeError, KeyError):
+                    pass
+        self.__module__ = __module__
+
+        for b in bases:
+            if not isInstance(b, Interface):
+                raise TypeError, 'Expected base interfaces'
+        self.__bases__=bases
+
+        if attrs is None: attrs={}
+        if attrs.has_key('__doc__'):
+            if __doc__ is None: __doc__=attrs['__doc__']
+            del attrs['__doc__']
+
+        if __doc__ is not None:
+            self.__doc__=__doc__
+        else:
+            self.__doc__ = ""
+
+        Element.__init__(self, name, __doc__)
+
+        for k, v in attrs.items():
+            if isInstance(v, Attribute):
+                v.interface=name
+                if not v.__name__:
+                    v.__name__ = k
+            elif isinstance(v, FunctionType):
+                attrs[k]=fromFunction(v, name)
+            else:
+                raise Exceptions.InvalidInterface(
+                    "Concrete attribute, %s" % k)
+
+        self.__attrs = attrs
+
+    def getBases(self):
+        return self.__bases__
+
+    def extends(self, other, strict=1):
+        """Does an interface extend another?
+        """
+        if not strict and self is other:
+            return 1
+        
+        for b in self.__bases__:
+            if b == other: return 1
+            if b.extends(other): return 1
+        return 0
+
+    def isEqualOrExtendedBy(self, other):
+        """Same interface or extends?
+        """
+        if self == other:
+            return 1
+        return other.extends(self)
+
+    def isImplementedBy(self, object):
+        """Does the given object implement the interface?
+        """
+        i = getImplements(object)
+        if i is not None:
+            return visitImplements(
+                i, object, self.isEqualOrExtendedBy, self._getInterface)
+        return 0
+
+    def isImplementedByInstancesOf(self, klass):
+        """Do instances of the given class implement the interface?
+        """
+        i = getImplementsOfInstances(klass)
+        if i is not None:
+            return visitImplements(
+                i, klass, self.isEqualOrExtendedBy, self._getInterface)
+        return 0
+
+    def names(self, all=0):
+        """Return the attribute names defined by the interface
+        """
+        if not all:
+            return self.__attrs.keys()
+
+        r = {}
+        for name in self.__attrs.keys():
+            r[name] = 1
+        for base in self.__bases__:
+            for name in base.names():
+                r[name] = 1
+        return r.keys()
+            
+    def namesAndDescriptions(self, all=0):
+        """Return the attribute names and descriptions defined by the interface
+        """
+        if not all:
+            return self.__attrs.items()
+
+        r = {}
+        for name, d in self.__attrs.items():
+            r[name] = d
+            
+        for base in self.__bases__:
+            for name, d in base.namesAndDescriptions():
+                if not r.has_key(name):
+                    r[name] = d
+
+        return r.items()
+
+    def getDescriptionFor(self, name):
+        """Return the attribute description for the given name
+        """
+        r = self.queryDescriptionFor(name)
+        if r is not None:
+            return r
+        
+        raise KeyError, name
+
+    def queryDescriptionFor(self, name, default=None):
+        """Return the attribute description for the given name
+        """
+        r = self.__attrs.get(name, self)
+        if r is not self:
+            return r
+        for base in self.__bases__:
+            r = base.queryDescriptionFor(name, self)
+            if r is not self:
+                return r
+            
+        return default
+
+    def deferred(self):
+        """Return a defered class corresponding to the interface
+        """
+        if hasattr(self, "_deferred"): return self._deferred
+
+        klass={}
+        exec "class %s: pass" % self.__name__ in klass
+        klass=klass[self.__name__]
+        
+        self.__d(klass.__dict__)
+
+        self._deferred=klass
+
+        return klass
+
+    def _getInterface(self, ob, name):
+        '''
+        Retrieve a named interface.
+        '''
+        return None
+            
+    def __d(self, dict):
+
+        for k, v in self.__attrs.items():
+            if isInstance(v, Method) and not dict.has_key(k):
+                dict[k]=v
+
+        for b in self.__bases__: b.__d(dict)
+
+    def __repr__(self):
+        name = self.__name__
+        m = self.__module__
+        if m:
+            name = '%s.%s' % (m, name)
+        return "<%s %s at %x>" % (self.__class__.__name__, name, id(self))
+
+    def __reduce__(self):
+        return self.__name__
+
+# We import this here to deal with module dependencies.
+from Implements import getImplementsOfInstances, visitImplements, getImplements
+from Implements import instancesOfObjectImplements


=== Zope/lib/python/Interface/_object.py 1.1 => 1.2 ===
+#
+# Copyright (c) 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+"""Provide a halfway believable rendition of Python 2.2's object
+
+$Id$
+"""
+
+class _x:
+    def m(self):
+        pass
+
+ClassTypes  = (type(_x), )
+MethodTypes = (type(_x.m), )
+
+isInstance = isinstance
+
+try:
+    object
+    
+except NameError:
+    # Python 2.1
+    
+    try:
+        from ExtensionClass import Base as object
+    except ImportError:
+        
+        # Python 2.1 wo ExtensionClass
+        class object: pass
+
+    else:
+
+        # Python 2.1 w ExtensionClass
+
+        def isInstance(ob, klass):
+            if type(type(ob)) is type(klass):
+                return isinstance(ob, klass)
+            return 0
+
+        class _x(object):
+            def m(self): pass
+
+        ClassTypes  += (type(_x), )
+        MethodTypes += (type(_x.m), )            
+
+else:
+    # Python 2.2
+    ClassTypes += (type, )
+    object = object
+    isinstance = isinstance
+
+


=== Zope/lib/python/Interface/pyskel.py 1.1 => 1.2 ===
+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+"""
+Generate method skeletins for intefaces.
+
+Usage: python pyskel.py dotted_name
+
+Example:
+
+    cd lib/python
+    python Interfaces/pyskel.py Zope.App.Security.IRoleService.IRoleService
+
+The dotted name is the module name and interface object name connected
+with a dot.
+
+Revision information: $Id$
+"""
+
+import sys, os, re
+
+sys.path.insert(0, os.getcwd())
+
+from _object import isInstance
+
+from types import ModuleType
+from Interface.Method import Method
+from Interface.Attribute import Attribute
+
+class_re = re.compile(r'\s*class\s+([a-zA-Z_][a-zA-Z0-9_]*)')
+def_re = re.compile(r'\s*def\s+([a-zA-Z_][a-zA-Z0-9_]*)')
+attr_re = re.compile(r'\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*Attribute')
+
+
+def rskel(iface, print_iface=1):
+    name = "%s.%s" % (iface.__module__, iface.__name__)
+
+    file = resolve(iface.__module__).__file__
+    if file.endswith('pyc'):
+        file = file[:-1]
+    order = guessOrder(open(file))
+    namesAndDescriptions =  getAttributesInOrder(iface, order)
+
+    if namesAndDescriptions and print_iface:
+        print
+        print "    ######################################"
+        print "    # from:", name
+
+    for aname, ades in namesAndDescriptions:
+        if isInstance(ades, Method):
+            sig = ades.getSignatureString()[1:-1]
+            if sig: sig = "self, %s" % sig
+            else:   sig = "self"
+            print
+            print "    def %s(%s):" % (aname, sig)
+            print "        'See %s'" % name
+
+        elif isInstance(ades, Attribute):
+            print
+            print "    # See %s" % name
+            print "    %s = None" %aname
+
+    for base in iface.__bases__:
+        if base.__name__ not in ('Interface',):
+            rskel(base)
+
+def skel(name):
+    iface = resolve(name)
+    class_name = iface.__name__
+    if class_name.startswith('I'):
+        class_name = class_name[1:]
+    print "from %s import %s" % (iface.__module__, iface.__name__)
+    print
+    print "class %s:" %class_name
+    print
+    print "    __implements__ = ", iface.__name__
+    print
+    print "    ############################################################"
+    print "    # Implementation methods for interface"
+    print "    #", name
+
+    rskel(iface, 0)
+
+    print
+    print "    #"
+    print "    ############################################################"
+    
+
+def resolve(name, _silly=('__doc__',), _globals={}):
+    # Support for file path syntax; this way I can use TAB to search for
+    # the module.
+    if '/' in name or name.endswith('.py'):
+        # We got a relative path. Let's try to get the full one and then
+        # make a package path out of it.
+        if not name.startswith('/'):
+            cwd = os.getcwd()
+            for path in sys.path[1:]: # Yeah, we need to exclude the cwd itself
+                if path != '' and cwd.startswith(path):
+                    name = os.path.join(cwd[len(path)+1:], name)
+                    name = os.path.normpath(name)
+                    break
+
+        # get rid of the file ending :)
+        if name.endswith('.py'):
+            name = name[:-3]
+        name = name.replace('/', '.')
+
+    # Now to the regular lookup
+    if name[:1]=='.':
+        name='ZopeProducts'+name
+
+    if name[-1:] == '.':
+        name = name[:-1]
+        repeat = 1
+    else:
+        repeat = 0
+
+    names=name.split('.')
+    last=names[-1]
+    mod='.'.join(names[:-1])
+
+    while 1:
+        m=__import__(mod, _globals, _globals, _silly)
+        try:
+            a=getattr(m, last)
+        except AttributeError:
+            pass
+        else:
+            if not repeat or (type(a) is not ModuleType):
+                return a
+        mod += '.' + last
+
+
+def guessOrder(source_file):
+    order = {}  # { class name -> list of methods }
+    lines = source_file.readlines()
+    class_name = None
+    for line in lines:
+        m = class_re.match(line)
+        if m and m.groups():
+            class_name = m.groups()[0]
+        else:
+            for m in (def_re.match(line),
+                      attr_re.match(line)):
+                if m and m.groups():
+                    def_name = m.groups()[0]
+                    name_order = order.get(class_name)
+                    if name_order is None:
+                        name_order = []
+                        order[class_name] = name_order
+                    name_order.append(def_name)
+
+    return order
+
+
+def getAttributesInOrder(interface, order):
+    # order is the dictionary returned from guessOrder().
+    # interface is a metaclass-based interface object.
+    name_order = order.get(interface.__name__)
+
+    if name_order is None:
+        # Something's wrong.  Oh well.
+        return interface.__dict__.items()
+    else:
+        items = []
+        for key, value in interface.namesAndDescriptions():
+            if key in name_order:
+                items.append((name_order.index(key), key, value))
+            else:
+                items.append((99999, key, value))  # Go to end.
+        items.sort()
+        return map(lambda item: item[1:], items)
+
+
+        
+if __name__ == '__main__':
+    for a in sys.argv[1:]:
+        skel(a)
+    
+    


=== Zope/lib/python/Interface/Exceptions.py 1.6 => 1.7 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
 
 class DoesNotImplement(Exception):
     """ This object does not implement """
@@ -27,15 +40,25 @@
     """An method is not completely implemented.
     """
 
-    def __init__(self, method):
+    def __init__(self, method, mess):
         self.method=method
+        self.mess=mess
 
     def __str__(self):
-        return """An object has failed to implement the method %(method)s
-
-        The signature is incorrect.
+        return """The implementation of %(method)s violates it's contract
+        because %(mess)s.
         """ % self.__dict__
 
-class InvalidInterface(Exception): pass
+class InvalidInterface(Exception):
+    """The interface has invalid contents
+    """
+
 
+
+class BadImplements(TypeError):
+    """An implementation assertion is invalid
+
+    because it doesn't contain an interface or a sequence of valid
+    implementation assertions.
+    """
 


=== Zope/lib/python/Interface/Method.py 1.8 => 1.9 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
 """Method interfaces
+
+Revision information:
+$Id$
 """
 import Exceptions
-from Attr import Attribute
+from Attribute import Attribute
 
 sig_traits = ['positional', 'required', 'optional', 'varargs', 'kwargs']
 
 CO_VARARGS = 4
 CO_VARKEYWORDS = 8
 
-class MethodClass:
-
-    def fromFunction(self, func, interface='', strip_first=0):
-        m=Method(func.__name__, func.__doc__)
-        defaults=func.func_defaults or ()
-        c=func.func_code
-        na=c.co_argcount
-        names=c.co_varnames
-        d={}
-        nr=na-len(defaults)
-
-        if strip_first and nr==0: # 'strip_first' implies method, has 'self'
-            defaults=defaults[1:]
-            nr=1
-        
-        for i in range(len(defaults)):
-            d[names[i+nr]]=defaults[i]
-
-        start_index = strip_first and 1 or 0
-        m.positional=names[start_index:na]
-        m.required=names[start_index:nr]
-        m.optional=d
-
-        argno = na
-        if c.co_flags & CO_VARARGS:
-            m.varargs = names[argno]
-            argno = argno + 1
-        else:
-            m.varargs = None
-        if c.co_flags & CO_VARKEYWORDS:
-            m.kwargs = names[argno]
-        else:
-            m.kwargs = None
-
-        m.interface=interface
-        return m
-
-    def fromMethod(self, meth, interface=''):
-        func = meth.im_func
-        return self.fromFunction(func, interface, strip_first=1)
-
 class Method(Attribute):
     """Method interfaces
 
@@ -56,15 +31,12 @@
     This provides an opportunity for rich meta-data.
     """
 
-    fromFunction=MethodClass().fromFunction
-    fromMethod=MethodClass().fromMethod
-    interface=''
+    # We can't say this yet because we don't have enough
+    # infrastructure in place.
+    #
+    #__implements__ = IMethod
 
-    def __init__(self, __name__=None, __doc__=None):
-        """Create a 'method' description
-        """
-        self.__name__=__name__
-        self.__doc__=__doc__ or __name__
+    interface=''
 
     def __call__(self, *args, **kw):
         raise Exceptions.BrokenImplementation(self.interface, self.__name__)
@@ -95,6 +67,43 @@
         sig = sig + ")"
         return sig
 
+
+def fromFunction(func, interface='', imlevel=0):
+    m=Method(func.__name__, func.__doc__)
+    defaults=func.func_defaults or ()
+    c=func.func_code
+    na=c.co_argcount-imlevel
+    names=c.co_varnames[imlevel:]
+    d={}
+    nr=na-len(defaults)
+    if nr < 0:
+        defaults=defaults[-nr:]
+        nr=0
+
+    for i in range(len(defaults)):
+        d[names[i+nr]]=defaults[i]
+
+    m.positional=names[:na]
+    m.required=names[:nr]
+    m.optional=d
+
+    argno = na
+    if c.co_flags & CO_VARARGS:
+        m.varargs = names[argno]
+        argno = argno + 1
+    else:
+        m.varargs = None
+    if c.co_flags & CO_VARKEYWORDS:
+        m.kwargs = names[argno]
+    else:
+        m.kwargs = None
+
+    m.interface=interface
+    return m
+
+def fromMethod(meth, interface=''):
+    func = meth.im_func
+    return fromFunction(func, interface, imlevel=1)
 
 
 


=== Zope/lib/python/Interface/__init__.py 1.5 => 1.6 ===
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+# 
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+# 
+##############################################################################
+"""Interfaces
 
-from Standard import Base
+This package implements the Python "scarecrow" proposal.
 
-import iclass
-new=iclass.Interface
-InterfaceInterface=iclass.InterfaceInterface
-# del iclass
+The package exports a single name, 'Interface' directly. Interface
+is used to create an interface with a class statement, as in:
 
-from Util import impliedInterface
-from Util import assertTypeImplements, objectImplements, instancesOfObjectImplements
+  from Interface import Interface
 
-from Attr import Attribute
-from Method import Method
+  class IMyInterface(Interface):
+    '''Interface documentation
+    '''
 
-from Exceptions import BrokenImplementation
+    def meth(arg1, arg2):
+        '''Documentation for meth
+        '''
+
+    # Note that there is no self argument
+
+To find out what you can do with interfaces, see the interface
+interface, IInterface in the IInterface module.
+
+The package has several public modules:
+    
+  o Attribute has the implementation for interface attributes
+    for people who want to build interfaces by hand.
+    (Maybe someone should cry YAGNI for this. ;)
+
+  o Document has a utility for documenting an interface as structured text.
+
+  o Exceptions has the interface-defined exceptions
+
+  o IAttribute defines the attribute descriptor interface.
+
+  o IElement defined the base interface for IAttribute, IInterface,
+    and IMethod.
+
+  o IInterface defines the interface interface
+
+  o IMethod defined the method interface.
+
+  o Implements has various utilities for examining interface assertions.
+
+  o Method has the implementation for interface methods. See above.
+
+  o Verify has utilities for verifying (sort of) interfaces.
+
+See the module doc strings for more information.
+
+There is also a script, pyself.py in the package that can be used to
+create interface skeletins. Run it without arguments to get documentation.
+
+Revision information:
+$Id$
+"""
+
+from _Interface import Interface
+Base = Interface # XXX We need to stamp out Base usage
 
-from pprint import interface_as_stx
-from verify import verify_class_implementation


=== Zope/lib/python/Interface/iclass.py 1.12 => 1.13 ===
 import Exceptions
 from InterfaceBase import InterfaceBase
-
-try:
-    from ExtensionClass import Base
-except ImportError:
-    ClassTypes = (ClassType,)
-else:
-    class dummy (Base): pass
-    ClassTypes = (type(dummy), ClassType)
-
+from _object import ClassTypes, isInstance
 
 _typeImplements={}
 
@@ -34,7 +26,7 @@
         """Create a new interface
         """        
         for b in bases:
-            if not isinstance(b, Interface):
+            if not isInstance(b, Interface):
                 raise TypeError, 'Expected base interfaces'
         self.__bases__=bases
         self.__name__=name
@@ -54,12 +46,12 @@
             self.__doc__ = ""
 
         for k, v in attrs.items():
-            if isinstance(v, Method):
+            if isInstance(v, Method):
                 v.interface=name
                 v.__name__=k
-            elif isinstance(v, FunctionType):
+            elif isInstance(v, FunctionType):
                 attrs[k]=Method.fromFunction(v, name)
-            elif not isinstance(v, Attribute):
+            elif not isInstance(v, Attribute):
                 raise Exceptions.InvalidInterface(
                     "Concrete attribute, %s" % k)
 
@@ -91,7 +83,7 @@
             implements=tiget(t, None)
             if implements is None: return 0
     
-        if isinstance(implements,Interface):
+        if isInstance(implements,Interface):
             return implements is self or implements.extends(self)
         else:
             return self.__any(implements)
@@ -112,7 +104,7 @@
 
         if implements is None: return 0
         
-        if isinstance(implements,Interface):
+        if isInstance(implements,Interface):
             return implements is self or implements.extends(self)
         else:
             return self.__any(implements)
@@ -150,7 +142,7 @@
     def __d(self, dict):
 
         for k, v in self.__attrs.items():
-            if isinstance(v, Method) and not dict.has_key(k):
+            if isInstance(v, Method) and not dict.has_key(k):
                 dict[k]=v
 
         for b in self.__bases__: b.__d(dict)
@@ -158,7 +150,7 @@
 
     def __any(self, interfaces):
         for i in interfaces:
-            if isinstance(i,Interface):
+            if isInstance(i,Interface):
                 if i is self or i.extends(self): return 1
             else:
                 if self.__any(i): return 1
@@ -173,7 +165,7 @@
 class Named(Base):
     "Objects that have a name."
 
-    __name__=Attribute("The name of the object")
+    __name__ = Attribute("The name of the object")
 
 class Class(Named):
     """Implement shared instance behavior and create instances


=== Zope/lib/python/Interface/verify.py 1.4 => 1.5 ===
 from Method import Method
-import types
+from types import FunctionType
+from _object import MethodTypes
 
 def verify_class_implementation(iface, klass):
     """
@@ -23,9 +24,9 @@
             raise BrokenImplementation(iface, n)
 
         attr = getattr(klass, n)
-        if type(attr) is types.FunctionType:
+        if type(attr) is FunctionType:
             meth = Method().fromFunction(attr, n)
-        elif type(attr) is types.MethodType:
+        elif type(attr) in MethodTypes:
             meth = Method().fromMethod(attr, n)
         else:
             continue # must be an attribute...

=== Removed File Zope/lib/python/Interface/Attr.py ===

=== Removed File Zope/lib/python/Interface/Basic.py ===

=== Removed File Zope/lib/python/Interface/CHANGES.txt ===

=== Removed File Zope/lib/python/Interface/InterfaceBase.py ===

=== Removed File Zope/lib/python/Interface/Number.py ===

=== Removed File Zope/lib/python/Interface/README ===

=== Removed File Zope/lib/python/Interface/README.txt ===

=== Removed File Zope/lib/python/Interface/Standard.py ===

=== Removed File Zope/lib/python/Interface/Util.py ===

=== Removed File Zope/lib/python/Interface/pyfiles ===

=== Removed File Zope/lib/python/Interface/release.sh ===

=== Removed File Zope/lib/python/Interface/test.py ===

=== Removed File Zope/lib/python/Interface/unitfixtures.py ===

=== Removed File Zope/lib/python/Interface/unittests.py ===