ENH: Add subinterfaces.

Author: Scott Sanderson

interface/functional.py

@@ -46,3 +46,16 @@ def sliding_window(iterable, n):
     for item in it:
         items.append(item)
         yield tuple(items)
+
+
+def merge(dicts):
+    dicts = list(dicts)
+    if len(dicts) == 0:
+        return {}
+    elif len(dicts) == 1:
+        return dicts[0]
+    else:
+        out = dicts[0].copy()
+        for other in dicts[1:]:
+            out.update(other)
+        return out

interface/interface.py

@@ -6,7 +6,7 @@
 from .compat import raise_from, with_metaclass
 from .default import default, warn_if_defaults_use_non_interface_members
 from .formatting import bulleted_list
-from .functional import complement, keyfilter, valfilter
+from .functional import complement, keyfilter, merge, valfilter
 from .typecheck import compatible
 from .typed_signature import TypedSignature
 from .utils import is_a, unique
@@ -21,9 +21,14 @@ class InvalidImplementation(TypeError):
     """
 
 
-CLASS_ATTRIBUTE_WHITELIST = frozenset(
-    ["__doc__", "__module__", "__name__", "__qualname__", "__weakref__"]
-)
+CLASS_ATTRIBUTE_WHITELIST = frozenset([
+    '__doc__',
+    '__module__',
+    '__name__',
+    '__qualname__',
+    '__weakref__',
+    '_INTERFACE_IGNORE_MEMBERS',
+])
 
 is_interface_field_name = complement(CLASS_ATTRIBUTE_WHITELIST.__contains__)
 
@@ -72,6 +77,14 @@ def _conflicting_defaults(typename, conflicts):
     return InvalidImplementation(message)
 
 
+def _merge_parent_signatures(bases):
+    return merge(filter(None, (getattr(b, '_signatures') for b in bases)))
+
+
+def _merge_parent_defaults(bases):
+    return merge(filter(None, (getattr(b, '_defaults') for b in bases)))
+
+
 class InterfaceMeta(type):
     """
     Metaclass for interfaces.
@@ -80,22 +93,47 @@ class InterfaceMeta(type):
     """
 
     def __new__(mcls, name, bases, clsdict):
-        signatures = {}
-        defaults = {}
-        for k, v in keyfilter(is_interface_field_name, clsdict).items():
+        signatures = _merge_parent_signatures(bases)
+        defaults = _merge_parent_defaults(bases)
+        ignored = clsdict.get('_INTERFACE_IGNORE_MEMBERS', set())
+
+        for field, v in keyfilter(is_interface_field_name, clsdict).items():
+            if field in ignored:
+                continue
+
             try:
-                signatures[k] = TypedSignature(v)
+                signature = 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)),
+                        iface_name=name,
+                        fieldname=field,
+                        attrtype=getname(type(v)),
                     )
                 )
                 raise_from(TypeError(errmsg), e)
 
+            if field in signatures:
+                for base in bases:
+                    if field in bases._signatures:
+                        raise TypeError(
+                            "Interface field {new}.{field} conflicts with "
+                            "parent field {old}.{field}.".format(
+                                new=name,
+                                old=base.name,
+                                field=field,
+                            )
+                        )
+                else:
+                    # If we hit this there's a bug in
+                    # _extract_parent_signatures above.
+                    raise AssertionError("Inconsistent bases!")
+            else:
+                signatures[field] = signature
+
             if isinstance(v, default):
-                defaults[k] = v
+                defaults[field] = v
 
         warn_if_defaults_use_non_interface_members(
             name, defaults, set(signatures.keys())
@@ -258,6 +296,9 @@ def _format_mismatched_methods(self, mismatched):
         )
 
 
+empty_set = frozenset([])
+
+
 class Interface(with_metaclass(InterfaceMeta)):
     """
     Base class for interface definitions.
@@ -312,6 +353,9 @@ def delete(self, key):
     --------
     :func:`implements`
     """
+    # Don't consider these members part of the interface definition for
+    # children of `Interface`.
+    _INTERFACE_IGNORE_MEMBERS = {'__new__', 'from_class'}
 
     def __new__(cls, *args, **kwargs):
         raise TypeError("Can't instantiate interface %s" % getname(cls))
@@ -349,7 +393,10 @@ def from_class(cls, existing_class, subset=None, name=None):
         )
 
 
-empty_set = frozenset([])
+# Signature requirements are inherited, so make sure the base interface doesn't
+# require any methods of children.
+assert Interface._signatures == {}
+assert Interface._defaults == {}
 
 
 class ImplementsMeta(type):

interface/tests/test_interface.py

@@ -890,3 +890,31 @@ class BadImpl failed to implement interface HasMagicMethodsInterface:
           - __getitem__(self, key)"""
     )
     assert actual_message == expected_message
+
+
+def test_interface_subclass():
+
+    class A(Interface):  # pragma: nocover
+        def method_a(self):
+            pass
+
+    class AandB(A):  # pragma: nocover
+        def method_b(self):
+            pass
+
+    with pytest.raises(InvalidImplementation):
+        class JustA(implements(AandB)):
+            def method_a(self):
+                pass
+
+    with pytest.raises(InvalidImplementation):
+        class JustB(implements(AandB)):
+            def method_b(self):
+                pass
+
+    class Both(implements(AandB)):
+        def method_a(self):
+            pass
+
+        def method_b(self):
+            pass