MAINT: Support Python 2.

Author: Scott Sanderson

README.rst

@@ -4,7 +4,8 @@
 |build status|
 
 ``interface`` provides facilities for declaring interfaces and for statically
-asserting that classes implement those interfaces.
+asserting that classes implement those interfaces. It supports Python 2.7 and
+Python 3.4+.
 
 ``interface`` improves on Python's ``abc`` module in two ways:
 

interface/compat.py

@@ -0,0 +1,64 @@
+import sys
+from itertools import repeat
+
+version_info = sys.version_info
+
+PY2 = version_info.major == 2
+PY3 = version_info.major == 3
+
+if PY2:  # pragma: nocover
+    from funcsigs import signature, Parameter
+
+    def raise_from(e, from_):
+        raise e
+
+    def viewkeys(d):
+        return d.viewkeys()
+
+else:  # pragma: nocover
+    from inspect import signature, Parameter
+    exec("def raise_from(e, from_):"  # pragma: nocover
+         "    raise e from from_")
+
+    def viewkeys(d):
+        return d.keys()
+
+
+def zip_longest(left, right):
+    """Simple zip_longest that only supports two iterators and None default.
+    """
+    left = iter(left)
+    right = iter(right)
+    left_done = False
+    right_done = False
+    while True:
+        try:
+            left_yielded = next(left)
+        except StopIteration:
+            left_done = True
+            left_yielded = None
+            left = repeat(None)
+        try:
+            right_yielded = next(right)
+        except StopIteration:
+            right_done = True
+            right_yielded = None
+            right = repeat(None)
+
+        if left_done and right_done:
+            raise StopIteration()
+
+        yield left_yielded, right_yielded
+
+
+# Taken from six version 1.10.0.
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(meta):
+
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+    return type.__new__(metaclass, 'temporary_class', (), {})

interface/functional.py

@@ -3,6 +3,7 @@
 ----------
 Functional programming utilities.
 """
+from .compat import viewkeys
 
 
 def complement(f):
@@ -20,4 +21,7 @@ def valfilter(f, d):
 
 
 def dzip(left, right):
-    return {k: (left.get(k), right.get(k)) for k in left.keys() & right.keys()}
+    return {
+        k: (left.get(k), right.get(k))
+        for k in viewkeys(left) & viewkeys(right)
+    }

interface/interface.py

@@ -8,6 +8,7 @@
 from textwrap import dedent
 from weakref import WeakKeyDictionary
 
+from .compat import raise_from, with_metaclass
 from .functional import complement, keyfilter
 from .typecheck import compatible
 from .typed_signature import TypedSignature
@@ -66,10 +67,10 @@ def __new__(mcls, name, bases, clsdict):
                         attrtype=getname(type(v)),
                     )
                 )
-                raise TypeError(errmsg) from e
+                raise_from(TypeError(errmsg), e)
 
         clsdict['_signatures'] = signatures
-        return super().__new__(mcls, name, bases, clsdict)
+        return super(InterfaceMeta, mcls).__new__(mcls, name, bases, clsdict)
 
     def _diff_signatures(self, type_):
         """
@@ -205,7 +206,7 @@ def _format_mismatched_methods(self, mismatched):
         ]))
 
 
-class Interface(metaclass=InterfaceMeta):
+class Interface(with_metaclass(InterfaceMeta)):
     """
     Base class for interface definitions.
     """
@@ -223,7 +224,7 @@ class ImplementsMeta(type):
     def __new__(mcls, name, bases, clsdict, interfaces=empty_set):
         assert isinstance(interfaces, frozenset)
 
-        newtype = super().__new__(mcls, name, bases, clsdict)
+        newtype = super(ImplementsMeta, mcls).__new__(mcls, name, bases, clsdict)
 
         if interfaces:
             # Don't do checks on the types returned by ``implements``.
@@ -245,15 +246,19 @@ def __new__(mcls, name, bases, clsdict, interfaces=empty_set):
 
     def __init__(mcls, name, bases, clsdict, interfaces=empty_set):
         mcls._interfaces = interfaces
-        super().__init__(name, bases, clsdict)
+        super(ImplementsMeta, mcls).__init__(name, bases, clsdict)
 
     def interfaces(self):
-        yield from unique(self._interfaces_with_duplicates())
+        for elem in unique(self._interfaces_with_duplicates()):
+            yield elem
 
     def _interfaces_with_duplicates(self):
-        yield from self._interfaces
+        for elem in self._interfaces:
+            yield elem
+
         for t in filter(is_a(ImplementsMeta), self.mro()):
-            yield from t._interfaces
+            for elem in t._interfaces:
+                yield elem
 
 
 def format_iface_method_docs(I):

interface/tests/_py3_typecheck_tests.py

@@ -0,0 +1,59 @@
+from inspect import signature
+
+from ..typecheck import compatible
+
+
+def test_allow_new_params_with_defaults_with_kwonly():
+
+    @signature
+    def iface(a, b, c):  # pragma: nocover
+        pass
+
+    @signature
+    def impl(a, b, c, d=3, e=5, *, f=5):  # pragma: nocover
+        pass
+
+    assert compatible(impl, iface)
+    assert not compatible(iface, impl)
+
+
+def test_allow_reorder_kwonlys():
+
+    @signature
+    def foo(a, b, c, *, d, e, f):  # pragma: nocover
+        pass
+
+    @signature
+    def bar(a, b, c, *, f, d, e):  # pragma: nocover
+        pass
+
+    assert compatible(foo, bar)
+    assert compatible(bar, foo)
+
+
+def test_allow_default_changes():
+
+    @signature
+    def foo(a, b, c=3, *, d=1, e, f):  # pragma: nocover
+        pass
+
+    @signature
+    def bar(a, b, c=5, *, f, e, d=12):  # pragma: nocover
+        pass
+
+    assert compatible(foo, bar)
+    assert compatible(bar, foo)
+
+
+def test_disallow_kwonly_to_positional():
+
+    @signature
+    def foo(a, *, b):  # pragma: nocover
+        pass
+
+    @signature
+    def bar(a, b):  # pragma: nocover
+        pass
+
+    assert not compatible(foo, bar)
+    assert not compatible(bar, foo)

interface/tests/test_interface.py

@@ -79,10 +79,10 @@ def _fixture(request):
 def combine_interfaces():
 
     def combine_with_multiple_types(*interfaces):
-        return list(map(implements, interfaces))
+        return tuple(map(implements, interfaces))
 
     def combine_with_single_type(*interfaces):
-        return [implements(*interfaces)]
+        return (implements(*interfaces),)
 
     yield combine_with_multiple_types
     yield combine_with_single_type
@@ -107,30 +107,23 @@ def shared(self, a, b, c):
     bases = combine_interfaces(I1, I2)
 
     with pytest.raises(IncompleteImplementation):
-        class C(*bases):  # pragma: nocover
-            def i1_method(self, arg1):
-                pass
-
-            def i2_method(self, arg2):
-                pass
+        type('C', bases, {
+            'i1_method': lambda self, arg1: None,
+            'i2_method': lambda self, arg2: None,
+        })
 
     with pytest.raises(IncompleteImplementation):
-        class C(*bases):  # pragma: nocover
-
-            def i1_method(self, arg1):
-                pass
-
-            def shared(self, a, b, c):
-                pass
+        type('C', bases, {
+            'i1_method': lambda self, arg1: None,
+            'i2_method': lambda self, a, b, c: None,
+        })
 
     with pytest.raises(IncompleteImplementation):
-        class C(*bases):  # pragma: nocover
 
-            def i2_method(self, arg2):
-                pass
-
-            def shared(self, a, b, c):
-                pass
+        type('C', bases, {
+            'i2_method': lambda self, arg2: None,
+            'shared': lambda self, a, b, c: None,
+        })
 
 
 def test_missing_methods():

interface/tests/test_typecheck.py

@@ -1,5 +1,4 @@
-from inspect import signature
-
+from ..compat import PY3, signature
 from ..typecheck import compatible
 
 
@@ -18,48 +17,6 @@ def bar():  # pragma: nocover
     assert compatible(bar, bar)
 
 
-def test_allow_new_params_with_defaults():
-
-    @signature
-    def iface(a, b, c):  # pragma: nocover
-        pass
-
-    @signature
-    def impl(a, b, c, d=3, e=5, *, f=5):  # pragma: nocover
-        pass
-
-    assert compatible(impl, iface)
-    assert not compatible(iface, impl)
-
-
-def test_allow_reorder_kwonlys():
-
-    @signature
-    def foo(a, b, c, *, d, e, f):  # pragma: nocover
-        pass
-
-    @signature
-    def bar(a, b, c, *, f, d, e):  # pragma: nocover
-        pass
-
-    assert compatible(foo, bar)
-    assert compatible(bar, foo)
-
-
-def test_allow_default_changes():
-
-    @signature
-    def foo(a, b, c=3, *, d=1, e, f):  # pragma: nocover
-        pass
-
-    @signature
-    def bar(a, b, c=5, *, f, e, d=12):  # pragma: nocover
-        pass
-
-    assert compatible(foo, bar)
-    assert compatible(bar, foo)
-
-
 def test_disallow_new_or_missing_positionals():
 
     @signature
@@ -101,15 +58,19 @@ def bar(b, a):  # pragma: nocover
     assert not compatible(bar, foo)
 
 
-def test_disallow_kwonly_to_positional():
+def test_allow_new_params_with_defaults_no_kwonly():
 
     @signature
-    def foo(a, *, b):  # pragma: nocover
+    def iface(a, b, c):  # pragma: nocover
         pass
 
     @signature
-    def bar(a, b):  # pragma: nocover
+    def impl(a, b, c, d=3, e=5, f=5):  # pragma: nocover
         pass
 
-    assert not compatible(foo, bar)
-    assert not compatible(bar, foo)
+    assert compatible(impl, iface)
+    assert not compatible(iface, impl)
+
+
+if PY3:  # pragma: nocover
+    from ._py3_typecheck_tests import *

interface/typecheck.py

@@ -1,9 +1,9 @@
 """
 Utilities for typed interfaces.
 """
-from inspect import Parameter
-from itertools import starmap, takewhile, zip_longest
+from itertools import starmap, takewhile
 
+from .compat import Parameter, zip_longest
 from .functional import complement, dzip, valfilter
 
 
@@ -23,7 +23,7 @@ def compatible(impl_sig, iface_sig):
     implementation.
 
     Consequently, the following differences are allowed between the signature
-    of an implementation methodand the signature of its interface definition:
+    of an implementation method and the signature of its interface definition:
 
     1. An implementation may add new arguments to an interface iff:
        a. All new arguments have default values.

interface/typed_signature.py

@@ -4,7 +4,7 @@
 This is useful for when we care about the distinction between different kinds
 of callables, e.g., between methods, classmethods, and staticmethods.
 """
-from inspect import signature
+from .compat import signature
 
 
 class TypedSignature(object):

setup.py

@@ -21,9 +21,12 @@ def extras_require():
 
 
 def install_requires():
+    requires = ['six']
     if sys.version_info[:2] < (3, 5):
-        return ["typing>=3.5.2"]
-    return []
+        requires.append("typing>=3.5.2")
+    if sys.version_info[0] == 2:
+        requires.append("funcsigs>=1.0.2")
+    return requires
 
 
 setup(