Fix subclassing builtin protocols on older Python versions (#650)

This was recently fixed in CPython repo (while adding `Protocol` there). This PR backports the fix to all the older versions including now Python 2 version in `typing`.

I also removed the unnecessary conditional import in Python 2 tests since I stumbled at it while adding the test.

Author: ilevkivskyi

python2/test_typing.py

@@ -26,10 +26,7 @@
 from typing import Pattern, Match
 import typing
 import weakref
-try:
-    import collections.abc as collections_abc
-except ImportError:
-    import collections as collections_abc  # Fallback for PY3.2.
+import collections
 
 
 class BaseTestCase(TestCase):
@@ -1055,7 +1052,7 @@ def test_supports_index(self):
         self.assertIsSubclass(int, typing.SupportsIndex)
         self.assertNotIsSubclass(str, typing.SupportsIndex)
 
-    def test_protocol_instance_type_error(self):
+    def test_protocol_instance_works(self):
         self.assertIsInstance(0, typing.SupportsAbs)
         self.assertNotIsInstance('no', typing.SupportsAbs)
         class C1(typing.SupportsInt):
@@ -1066,6 +1063,21 @@ class C2(C1):
         c = C2()
         self.assertIsInstance(c, C1)
 
+    def test_collections_protocols_allowed(self):
+        @runtime_checkable
+        class Custom(collections.Iterable, Protocol):
+            def close(self): pass
+
+        class A(object): pass
+        class B(object):
+            def __iter__(self):
+                return []
+            def close(self):
+                return 0
+
+        self.assertIsSubclass(B, Custom)
+        self.assertNotIsSubclass(A, Custom)
+
 
 class GenericTests(BaseTestCase):
 
@@ -1243,17 +1255,17 @@ def __len__(self):
                 return 0
         # this should just work
         MM().update()
-        self.assertIsInstance(MM(), collections_abc.MutableMapping)
+        self.assertIsInstance(MM(), collections.MutableMapping)
         self.assertIsInstance(MM(), MutableMapping)
         self.assertNotIsInstance(MM(), List)
         self.assertNotIsInstance({}, MM)
 
     def test_multiple_bases(self):
-        class MM1(MutableMapping[str, str], collections_abc.MutableMapping):
+        class MM1(MutableMapping[str, str], collections.MutableMapping):
             pass
         with self.assertRaises(TypeError):
             # consistent MRO not possible
-            class MM2(collections_abc.MutableMapping, MutableMapping[str, str]):
+            class MM2(collections.MutableMapping, MutableMapping[str, str]):
                 pass
 
     def test_orig_bases(self):
@@ -1426,9 +1438,9 @@ def __call__(self):
 
         self.assertEqual(repr(C1[int]).split('.')[-1], 'C1[int]')
         self.assertEqual(C2.__parameters__, ())
-        self.assertIsInstance(C2(), collections_abc.Callable)
-        self.assertIsSubclass(C2, collections_abc.Callable)
-        self.assertIsSubclass(C1, collections_abc.Callable)
+        self.assertIsInstance(C2(), collections.Callable)
+        self.assertIsSubclass(C2, collections.Callable)
+        self.assertIsSubclass(C1, collections.Callable)
         self.assertIsInstance(T1(), tuple)
         self.assertIsSubclass(T2, tuple)
         self.assertIsSubclass(Tuple[int, ...], typing.Sequence)
@@ -2287,11 +2299,11 @@ def __len__(self):
         self.assertIsSubclass(MMC, typing.Mapping)
 
         self.assertIsInstance(MMB[KT, VT](), typing.Mapping)
-        self.assertIsInstance(MMB[KT, VT](), collections_abc.Mapping)
+        self.assertIsInstance(MMB[KT, VT](), collections.Mapping)
 
-        self.assertIsSubclass(MMA, collections_abc.Mapping)
-        self.assertIsSubclass(MMB, collections_abc.Mapping)
-        self.assertIsSubclass(MMC, collections_abc.Mapping)
+        self.assertIsSubclass(MMA, collections.Mapping)
+        self.assertIsSubclass(MMB, collections.Mapping)
+        self.assertIsSubclass(MMC, collections.Mapping)
 
         self.assertIsSubclass(MMB[str, str], typing.Mapping)
         self.assertIsSubclass(MMC, MMA)
@@ -2303,9 +2315,9 @@ class G(typing.Generator[int, int, int]): pass
         def g(): yield 0
         self.assertIsSubclass(G, typing.Generator)
         self.assertIsSubclass(G, typing.Iterable)
-        if hasattr(collections_abc, 'Generator'):
-            self.assertIsSubclass(G, collections_abc.Generator)
-        self.assertIsSubclass(G, collections_abc.Iterable)
+        if hasattr(collections, 'Generator'):
+            self.assertIsSubclass(G, collections.Generator)
+        self.assertIsSubclass(G, collections.Iterable)
         self.assertNotIsSubclass(type(g), G)
 
     def test_subclassing_subclasshook(self):
@@ -2341,23 +2353,23 @@ class D: pass
         self.assertIsSubclass(D, B)
 
         class M(): pass
-        collections_abc.MutableMapping.register(M)
+        collections.MutableMapping.register(M)
         self.assertIsSubclass(M, typing.Mapping)
 
     def test_collections_as_base(self):
 
-        class M(collections_abc.Mapping): pass
+        class M(collections.Mapping): pass
         self.assertIsSubclass(M, typing.Mapping)
         self.assertIsSubclass(M, typing.Iterable)
 
-        class S(collections_abc.MutableSequence): pass
+        class S(collections.MutableSequence): pass
         self.assertIsSubclass(S, typing.MutableSequence)
         self.assertIsSubclass(S, typing.Iterable)
 
-        class I(collections_abc.Iterable): pass
+        class I(collections.Iterable): pass
         self.assertIsSubclass(I, typing.Iterable)
 
-        class A(collections_abc.Mapping): pass
+        class A(collections.Mapping): pass
         class B: pass
         A.register(B)
         self.assertIsSubclass(B, typing.Mapping)

python2/typing.py

@@ -1759,6 +1759,11 @@ def utf8(value):
     return _overload_dummy
 
 
+_PROTO_WHITELIST = ['Callable', 'Iterable', 'Iterator',
+                    'Hashable', 'Sized', 'Container', 'Collection',
+                    'Reversible', 'ContextManager']
+
+
 class _ProtocolMeta(GenericMeta):
     """Internal metaclass for Protocol.
 
@@ -1774,7 +1779,8 @@ def __init__(cls, *args, **kwargs):
                                    for b in cls.__bases__)
         if cls._is_protocol:
             for base in cls.__mro__[1:]:
-                if not (base in (object, Generic, Callable) or
+                if not (base in (object, Generic) or
+                        base.__module__ == '_abcoll' and base.__name__ in _PROTO_WHITELIST or
                         isinstance(base, TypingMeta) and base._is_protocol or
                         isinstance(base, GenericMeta) and base.__origin__ is Generic):
                     raise TypeError('Protocols can only inherit from other protocols,'

typing_extensions/src_py3/test_typing_extensions.py

@@ -14,7 +14,7 @@
 from typing import no_type_check
 from typing_extensions import NoReturn, ClassVar, Final, IntVar, Literal, Type, NewType, TypedDict
 try:
-    from typing_extensions import Protocol, runtime
+    from typing_extensions import Protocol, runtime, runtime_checkable
 except ImportError:
     pass
 try:
@@ -1391,6 +1391,21 @@ class E:
                     x = 1
                 self.assertIsInstance(E(), D)
 
+        def test_collections_protocols_allowed(self):
+            @runtime_checkable
+            class Custom(collections.abc.Iterable, Protocol):
+                def close(self): pass
+
+            class A: ...
+            class B:
+                def __iter__(self):
+                    return []
+                def close(self):
+                    return 0
+
+            self.assertIsSubclass(B, Custom)
+            self.assertNotIsSubclass(A, Custom)
+
 
 class TypedDictTests(BaseTestCase):
 

typing_extensions/src_py3/typing_extensions.py

@@ -1080,6 +1080,12 @@ def _next_in_mro(cls):
         return next_in_mro
 
 
+_PROTO_WHITELIST = ['Callable', 'Awaitable',
+                    'Iterable', 'Iterator', 'AsyncIterable', 'AsyncIterator',
+                    'Hashable', 'Sized', 'Container', 'Collection', 'Reversible',
+                    'ContextManager', 'AsyncContextManager']
+
+
 def _get_protocol_attrs(cls):
     attrs = set()
     for base in cls.__mro__[:-1]:  # without object
@@ -1187,7 +1193,9 @@ def __init__(cls, *args, **kwargs):
                                        for b in cls.__bases__)
             if cls._is_protocol:
                 for base in cls.__mro__[1:]:
-                    if not (base in (object, Generic, Callable) or
+                    if not (base in (object, Generic) or
+                            base.__module__ == 'collections.abc' and
+                            base.__name__ in _PROTO_WHITELIST or
                             isinstance(base, TypingMeta) and base._is_protocol or
                             isinstance(base, GenericMeta) and
                             base.__origin__ is Generic):
@@ -1513,7 +1521,9 @@ def _proto_hook(other):
 
             # Check consistency of bases.
             for base in cls.__bases__:
-                if not (base in (object, Generic, Callable) or
+                if not (base in (object, Generic) or
+                        base.__module__ == 'collections.abc' and
+                        base.__name__ in _PROTO_WHITELIST or
                         isinstance(base, _ProtocolMeta) and base._is_protocol):
                     raise TypeError('Protocols can only inherit from other'
                                     ' protocols, got %r' % base)