Py3 fixes

src/zc/relationship/index.py

@@ -42,8 +42,8 @@
 ##############################################################################
 # a common case transitive queries factory
 
+@interface.implementer(interfaces.ITransitiveQueriesFactory)
 class TransposingTransitiveQueriesFactory(persistent.Persistent):
-    interface.implements(interfaces.ITransitiveQueriesFactory)
 
     def __init__(self, name1, name2):
         self.names = [name1, name2] # a list so we can use index
@@ -105,11 +105,12 @@ def resolveToken(token, index, cache):
 ##############################################################################
 # the relationship index
 
+@interface.implementer_only(
+    interfaces.IIndex, interface.implementedBy(persistent.Persistent),
+    interface.implementedBy(zope.app.container.contained.Contained)
+)
 class Index(zc.relation.catalog.Catalog,
             zope.app.container.contained.Contained):
-    interface.implementsOnly(
-        interfaces.IIndex, interface.implementedBy(persistent.Persistent),
-        interface.implementedBy(zope.app.container.contained.Contained))
 
     def __init__(self, attrs, defaultTransitiveQueriesFactory=None,
                  dumpRel=generateToken, loadRel=resolveToken,
@@ -158,7 +159,7 @@ def apply(self, query):
         # there are two kinds of queries: values and relationships.
         if len(query) != 1:
             raise ValueError('one key in the primary query dictionary')
-        (searchType, query) = query.items()[0]
+        (searchType, query) = list(query.items())[0]
         if searchType=='relationships':
             relTools = self.getRelationModuleTools()
             if relTools['TreeSet'].__name__[:2] not in ('IF', 'LF'):

src/zc/relationship/shared.py

@@ -16,6 +16,7 @@
 $Id$
 """
 import random
+import six
 
 import persistent
 from zope import interface
@@ -41,9 +42,16 @@ class RelationshipBase(
         zc.listcontainer.Contained):
         pass
 
+try:
+    apply
+except NameError:
+    # PY3
+    def apply(func, *args, **kw):
+        return func(*args, **kw)
+
+@interface.implementer(interfaces.IRelationship)
 class ImmutableRelationship(RelationshipBase):
-    interface.implements(interfaces.IRelationship)
-
+
     _marker = __name__ = __parent__ = None
 
     def __init__(self, sources, targets):
@@ -61,8 +69,8 @@ def targets(self):
     def __repr__(self):
         return '<Relationship from %r to %r>' % (self.sources, self.targets)
 
+@interface.implementer(interfaces.IMutableRelationship)
 class Relationship(ImmutableRelationship):
-    interface.implements(interfaces.IMutableRelationship)
 
     @apply
     def sources():
@@ -89,8 +97,8 @@ def set(self, value):
 # some small conveniences; maybe overkill, but I wanted some for a client
 # package.
 
+@interface.implementer(interfaces.IOneToOneRelationship)
 class OneToOneRelationship(ImmutableRelationship):
-    interface.implements(interfaces.IOneToOneRelationship)
 
     def __init__(self, source, target):
         super(OneToOneRelationship, self).__init__((source,), (target,))
@@ -117,8 +125,8 @@ def set(self, value):
                 self.__parent__.reindex(self)
         return property(get, set)
 
+@interface.implementer(interfaces.IOneToManyRelationship)
 class OneToManyRelationship(ImmutableRelationship):
-    interface.implements(interfaces.IOneToManyRelationship)
 
     def __init__(self, source, targets):
         super(OneToManyRelationship, self).__init__((source,), targets)
@@ -145,8 +153,8 @@ def set(self, value):
                 self.__parent__.reindex(self)
         return property(get, set)
 
+@interface.implementer(interfaces.IManyToOneRelationship)
 class ManyToOneRelationship(ImmutableRelationship):
-    interface.implements(interfaces.IManyToOneRelationship)
 
     def __init__(self, sources, target):
         super(ManyToOneRelationship, self).__init__(sources, (target,))
@@ -188,7 +196,7 @@ def __call__(self, relchain, query, index, cache):
 def minDepthFilter(depth):
     if depth is None:
         return None
-    if not isinstance(depth, (int, long)) or depth < 1:
+    if not isinstance(depth, six.integer_types) or depth < 1:
         raise ValueError('invalid minDepth', depth)
     return lambda relchain, query, index, cache: len(relchain) >= depth
 
@@ -213,7 +221,7 @@ def __init__(self,
             target['load'] = loadTarget
         if targetFamily is not None:
             target['btree'] = targetFamily
-        
+
         ix = index.Index(
             (source, target),
             index.TransposingTransitiveQueriesFactory('source', 'target'),