ENH: Assert that static/class methods match.

Author: Scott Sanderson

interface/functional.py

@@ -11,6 +11,10 @@ def not_f(*args, **kwargs):
     return not_f
 
 
+def keyfilter(f, d):
+    return {k: v for k, v in d.items() if f(k)}
+
+
 def valfilter(f, d):
     return {k: v for k, v in d.items() if f(v)}
 

interface/interface.py

@@ -8,7 +8,9 @@
 from textwrap import dedent
 from weakref import WeakKeyDictionary
 
+from .functional import complement, keyfilter
 from .typecheck import compatible
+from .typed_signature import TypedSignature
 from .utils import is_a, unique
 
 first = itemgetter(0)
@@ -21,19 +23,50 @@ class IncompleteImplementation(TypeError):
     """
 
 
+CLASS_ATTRIBUTE_WHITELIST = frozenset([
+    '__doc__',
+    '__module__',
+    '__name__',
+    '__qualname__',
+    '__weakref__',
+])
+
+is_interface_field_name = complement(CLASS_ATTRIBUTE_WHITELIST.__contains__)
+
+
+def static_get_type_attr(t, name):
+    """
+    Get a type attribute statically, circumventing the descriptor protocol.
+    """
+    for type_ in t.mro():
+        try:
+            return vars(type_)[name]
+        except KeyError:
+            pass
+    raise AttributeError(name)
+
+
 class InterfaceMeta(type):
     """
     Metaclass for interfaces.
 
-    Supplies a ``_signatures`` attribute and a ``check_implementation`` method.
+    Supplies a ``_signatures`` attribute.
     """
     def __new__(mcls, name, bases, clsdict):
         signatures = {}
-        for k, v in clsdict.items():
+        for k, v in keyfilter(is_interface_field_name, clsdict).items():
             try:
-                signatures[k] = inspect.signature(v)
-            except TypeError:
-                pass
+                signatures[k] = TypedSignature(v)
+            except TypeError as e:
+                errmsg = (
+                    "Couldn't parse signature for field "
+                    "{iface_name}.{fieldname} of type {attrtype}.".format(
+                        iface_name=name,
+                        fieldname=k,
+                        attrtype=getname(type(v)),
+                    )
+                )
+                raise TypeError(errmsg) from e
 
         clsdict['_signatures'] = signatures
         return super().__new__(mcls, name, bases, clsdict)
@@ -49,23 +82,33 @@ def _diff_signatures(self, type_):
 
         Returns
         -------
-        missing, mismatched : list[str], dict[str -> signature]
-            ``missing`` is a list of missing method names.
-            ``mismatched`` is a dict mapping method names to incorrect
-            signatures.
+        missing, mistyped, mismatched : list[str], dict[str -> type], dict[str -> signature]  # noqa
+            ``missing`` is a list of missing interface names.
+            ``mistyped`` is a list mapping names to incorrect types.
+            ``mismatched`` is a dict mapping names to incorrect signatures.
         """
         missing = []
+        mistyped = {}
         mismatched = {}
         for name, iface_sig in self._signatures.items():
             try:
-                f = getattr(type_, name)
+                # Don't invoke the descriptor protocol here so that we get
+                # staticmethod/classmethod/property objects instead of the
+                # functions they wrap.
+                f = static_get_type_attr(type_, name)
             except AttributeError:
                 missing.append(name)
                 continue
-            impl_sig = inspect.signature(f)
-            if not compatible(impl_sig, iface_sig):
+
+            impl_sig = TypedSignature(f)
+
+            if not issubclass(impl_sig.type, iface_sig.type):
+                mistyped[name] = impl_sig.type
+
+            if not compatible(impl_sig.signature, iface_sig.signature):
                 mismatched[name] = impl_sig
-        return missing, mismatched
+
+        return missing, mistyped, mismatched
 
     def verify(self, type_):
         """
@@ -85,16 +128,16 @@ def verify(self, type_):
         -------
         None
         """
-        missing, mismatched = self._diff_signatures(type_)
-        if not missing and not mismatched:
+        missing, mistyped, mismatched = self._diff_signatures(type_)
+        if not any((missing, mistyped, mismatched)):
             return
-        raise self._invalid_implementation(type_, missing, mismatched)
+        raise self._invalid_implementation(type_, missing, mistyped, mismatched)
 
-    def _invalid_implementation(self, t, missing, mismatched):
+    def _invalid_implementation(self, t, missing, mistyped, mismatched):
         """
         Make a TypeError explaining why ``t`` doesn't implement our interface.
         """
-        assert missing or mismatched, "Implementation wasn't invalid."
+        assert missing or mistyped or mismatched, "Implementation wasn't invalid."
 
         message = "\nclass {C} failed to implement interface {I}:".format(
             C=getname(t),
@@ -111,6 +154,17 @@ def _invalid_implementation(self, t, missing, mismatched):
                 missing_methods=self._format_missing_methods(missing)
             )
 
+        if mistyped:
+            message += dedent(
+                """
+
+                The following methods of {I} were implemented with incorrect types:
+                {mismatched_types}"""
+            ).format(
+                I=getname(self),
+                mismatched_types=self._format_mismatched_types(mistyped),
+            )
+
         if mismatched:
             message += dedent(
                 """
@@ -129,6 +183,17 @@ def _format_missing_methods(self, missing):
             for name in missing
         ]))
 
+    def _format_mismatched_types(self, mistyped):
+        return "\n".join(sorted([
+            "  - {name}: {actual!r} is not a subtype "
+            "of expected type {expected!r}".format(
+                name=name,
+                actual=getname(bad_type),
+                expected=getname(self._signatures[name].type),
+            )
+            for name, bad_type in mistyped.items()
+        ]))
+
     def _format_mismatched_methods(self, mismatched):
         return "\n".join(sorted([
             "  - {name}{actual} != {name}{expected}".format(

interface/tests/test_interface.py

@@ -291,8 +291,105 @@ def method3(self, a, b, c):
 
 def test_cant_instantiate_interface():
 
-    class I(Interface):  # pragma: nocover
+    class I(Interface):
         pass
 
     with pytest.raises(TypeError):
         I()
+
+
+def test_reject_non_callable_interface_field():
+
+    with pytest.raises(TypeError) as e:
+        class IFace(Interface):
+            x = "not allowed"
+
+
+def test_static_method():
+
+    class I(Interface):
+        @staticmethod
+        def foo(a, b):  # pragma: nocover
+            pass
+
+    class my_staticmethod(staticmethod):
+        pass
+
+    class Impl(implements(I)):
+        @my_staticmethod   # allow staticmethod subclasses
+        def foo(a, b):  # pragma: nocover
+            pass
+
+    with pytest.raises(IncompleteImplementation) as e:
+        class Impl(implements(I)):
+            @staticmethod
+            def foo(self, a, b):  # pragma: nocover
+                pass
+
+    expected = dedent(
+        """
+        class Impl failed to implement interface I:
+
+        The following methods of I were implemented with invalid signatures:
+          - foo(self, a, b) != foo(a, b)"""
+    )
+    assert expected == str(e.value)
+
+    with pytest.raises(IncompleteImplementation) as e:
+        class Impl(implements(I)):
+            def foo(a, b):  # pragma: nocover
+                pass
+
+    expected = dedent(
+        """
+        class Impl failed to implement interface I:
+
+        The following methods of I were implemented with incorrect types:
+          - foo: 'function' is not a subtype of expected type 'staticmethod'"""
+    )
+    assert expected == str(e.value)
+
+
+def test_class_method():
+
+    class I(Interface):
+        @classmethod
+        def foo(cls, a, b):  # pragma: nocover
+            pass
+
+    class my_classmethod(classmethod):
+        pass
+
+    class Impl(implements(I)):
+        @my_classmethod
+        def foo(cls, a, b):  # pragma: nocover
+            pass
+
+    with pytest.raises(IncompleteImplementation) as e:
+        class Impl(implements(I)):
+            @classmethod
+            def foo(a, b):  # pragma: nocover
+                pass
+
+    expected = dedent(
+        """
+        class Impl failed to implement interface I:
+
+        The following methods of I were implemented with invalid signatures:
+          - foo(a, b) != foo(cls, a, b)"""
+    )
+    assert expected == str(e.value)
+
+    with pytest.raises(IncompleteImplementation) as e:
+        class Impl(implements(I)):
+            def foo(cls, a, b):  # pragma: nocover
+                pass
+
+    expected = dedent(
+        """
+        class Impl failed to implement interface I:
+
+        The following methods of I were implemented with incorrect types:
+          - foo: 'function' is not a subtype of expected type 'classmethod'"""
+    )
+    assert expected == str(e.value)

interface/typed_signature.py

@@ -0,0 +1,35 @@
+"""
+A subclass of inspect.signature that knows what kind of type it came from.
+
+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
+
+
+class TypedSignature(object):
+    """
+    Wrapper around an inspect.Signature that knows what kind of callable it came from.
+
+    Parameters
+    ----------
+    obj : callable
+        An object from which to extract a signature and a type.
+    """
+    def __init__(self, obj):
+        self._type = type(obj)
+        if isinstance(obj, (classmethod, staticmethod)):
+            self._signature = signature(obj.__func__)
+        else:
+            self._signature = signature(obj)
+
+    @property
+    def signature(self):
+        return self._signature
+
+    @property
+    def type(self):
+        return self._type
+
+    def __str__(self):
+        return str(self._signature)