Remove Collections backport

In retrospect, attempting to backport typing.Collection was a mistake.
It's difficult in practice to use it in a consistently meaningful way
because the typing module deliberately does not have types like Sequence
or List subclass anything resembling the Collections type for older
versions of Python.

This means that the following code will not typecheck on Python 2
and on older versions of Python 3:

    from mypy_extensions import Collection

    def foo(x):
        # type: Collection[int] -> int
        return sum(x)

    foo([1, 2, 3])

...because `List` is not defined to be a subclass of `Collection` in
Python 2 and Python 3.x - 3.5 at runtime and within the typing stubs
in typeshed.

I think this is potentially repairable with some careful surgery on
the typing stubs, but doing that seems highly questionable to me,
so I'm thinking attempting to backport `Collection` is out-of-scope
for this pull request and should be handled later (or potentially
never).

Author: Michael0x2a

typing_extensions/README.rst

@@ -35,7 +35,6 @@ All Python versions:
 --------------------
 
 - ``ClassVar``
-- ``Collection``
 - ``ContextManager``
 - ``Counter``
 - ``DefaultDict``

typing_extensions/src_py2/test_typing_extensions.py

@@ -6,7 +6,7 @@
 from unittest import TestCase, main, skipUnless
 
 from typing_extensions import NoReturn, ClassVar
-from typing_extensions import Collection, ContextManager, Counter, Deque, DefaultDict
+from typing_extensions import ContextManager, Counter, Deque, DefaultDict
 from typing_extensions import NewType, overload
 import typing
 import typing_extensions
@@ -117,25 +117,6 @@ def test_no_isinstance(self):
 
 class CollectionsAbcTests(BaseTestCase):
 
-    def test_collection(self):
-        self.assertIsInstance(tuple(), Collection)
-        self.assertIsInstance(frozenset(), Collection)
-        self.assertIsSubclass(dict, Collection)
-        self.assertNotIsInstance(42, Collection)
-
-    def test_collection_instantiation(self):
-        class MyAbstractCollection(Collection[int]):
-            pass
-        class MyCollection(Collection[int]):
-            def __contains__(self, item): pass
-            def __iter__(self): pass
-            def __len__(self): pass
-
-        self.assertIsSubclass(type(MyCollection()), Collection)
-        self.assertIsSubclass(MyCollection, Collection)
-        with self.assertRaises(TypeError):
-            MyAbstractCollection()
-
     def test_contextmanager(self):
         @contextlib.contextmanager
         def manager():
@@ -242,7 +223,6 @@ def test_typing_extensions_includes_standard(self):
         self.assertIn('overload', a)
         self.assertIn('Text', a)
         self.assertIn('TYPE_CHECKING', a)
-        self.assertIn('Collection', a)
 
     def test_typing_extensions_defers_when_possible(self):
         exclude = {'overload', 'Text', 'TYPE_CHECKING'}

typing_extensions/src_py2/typing_extensions.py

@@ -14,7 +14,6 @@
     'Type',
 
     # Concrete collection types.
-    'Collection',
     'ContextManager',
     'Counter',
     'Deque',
@@ -90,24 +89,3 @@ def __subclasshook__(cls, C):
                     return True
             return NotImplemented
 
-
-# Backport collections.Collection
-class _CollectionAbc(collections.Sized,
-                     collections.Iterable,
-                     collections.Container):
-    pass
-
-
-_CollectionAbc.register(list)
-_CollectionAbc.register(tuple)
-_CollectionAbc.register(set)
-_CollectionAbc.register(frozenset)
-_CollectionAbc.register(basestring)
-_CollectionAbc.register(dict)
-
-
-class Collection(typing.Sized,
-                 typing.Iterable[T_co],
-                 typing.Container[T_co]):
-    __slots__ = ()
-    __extra__ = _CollectionAbc

typing_extensions/src_py3/test_typing_extensions.py

@@ -371,26 +371,6 @@ def test_async_iterator(self):
             self.assertIsInstance(it, typing_extensions.AsyncIterator)
         self.assertNotIsInstance(42, typing_extensions.AsyncIterator)
 
-    def test_collection(self):
-        self.assertIsInstance(tuple(), typing_extensions.Collection)
-        self.assertIsInstance(frozenset(), typing_extensions.Collection)
-        self.assertIsSubclass(dict, typing_extensions.Collection)
-        self.assertNotIsInstance(42, typing_extensions.Collection)
-
-    @skipUnless(TYPING_3_5_1, "Behavior added in typing 3.5.1+")
-    def test_collection_instantiation(self):
-        class MyCollection(typing_extensions.Collection[int]):
-            def __contains__(self, item): ...
-            def __iter__(self): ...
-            def __len__(self): ...
-
-        self.assertIsSubclass(
-            type(MyCollection()),
-            typing_extensions.Collection)
-        self.assertIsSubclass(
-            MyCollection,
-            typing_extensions.Collection)
-
     def test_deque(self):
         self.assertIsSubclass(collections.deque, typing_extensions.Deque)
         class MyDeque(typing_extensions.Deque[int]): ...
@@ -630,8 +610,6 @@ def test_typing_extensions_includes_standard(self):
 
         if PY36:
             self.assertIn('AsyncGenerator', a)
-        if hasattr(collections_abc, 'Collection'):
-            self.assertIn('Collection', a)
 
     def test_typing_extensions_defers_when_possible(self):
         exclude = {'overload', 'Text', 'TYPE_CHECKING'}

typing_extensions/src_py3/typing_extensions.py

@@ -46,7 +46,6 @@ def _check_methods_in_mro(C, *methods):
     # 'ChainMap',
 
     # Concrete collection types.
-    'Collection',
     'ContextManager',
     'Counter',
     'Deque',
@@ -391,33 +390,6 @@ class AsyncIterator(AsyncIterable[T_co],
         __slots__ = ()
 
 
-if hasattr(typing, 'Collection'):
-    Collection = typing.Collection
-else:
-    __all__.append('Collection')
-
-    # Backport collections.abc.Collections
-    class _CollectionAbc(collections.Sized,
-                         collections.Iterable,
-                         collections.Container):
-        __slots__ = ()
-
-        @classmethod
-        def __subclasshook__(cls, C):
-            if cls is _CollectionAbc:
-                return _check_methods_in_mro(
-                    C, "__len__", "__iter__", "__contains__")
-            return NotImplemented
-
-    extra = getattr(collections_abc, 'Collection', _CollectionAbc)
-
-    class Collection(typing.Sized,
-                     typing.Iterable[T_co],
-                     typing.Container[T_co],
-                     extra=extra):
-        __slots__ = ()
-
-
 if hasattr(typing, 'Deque'):
     Deque = typing.Deque
 else: