[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 ===