add AsyncGenerator

Author: JelleZijlstra

src/test_typing.py

@@ -1320,6 +1320,7 @@ def blah():
 
 
 ASYNCIO = sys.version_info[:2] >= (3, 5)
+ASYNC_GENERATOR = sys.version_info[:2] >= (3, 6)
 
 ASYNCIO_TESTS = """
 import asyncio
@@ -1696,6 +1697,23 @@ def test_no_generator_instantiation(self):
         with self.assertRaises(TypeError):
             typing.Generator[int, int, int]()
 
+    @skipUnless(PY36, 'Python 3.6 required')
+    def test_async_generator(self):
+        ns = {}
+        exec("async def f():\n"
+            "    yield 42\n", globals(), ns)
+        g = ns['f']()
+        self.assertIsSubclass(type(g), typing.AsyncGenerator)
+
+    @skipUnless(PY36, 'Python 3.6 required')
+    def test_no_async_generator_instantiation(self):
+        with self.assertRaises(TypeError):
+            typing.AsyncGenerator()
+        with self.assertRaises(TypeError):
+            typing.AsyncGenerator[T, T]()
+        with self.assertRaises(TypeError):
+            typing.AsyncGenerator[int, int]()
+
     def test_subclassing(self):
 
         class MMA(typing.MutableMapping):
@@ -1765,6 +1783,18 @@ def g(): yield 0
         self.assertIsSubclass(G, collections.Iterable)
         self.assertNotIsSubclass(type(g), G)
 
+    @skipUnless(PY36, 'Python 3.6 required')
+    def test_subclassing_async_generator(self):
+        class G(typing.AsyncGenerator[int, int]): ...
+        ns = {}
+        exec('async def g(): yield 0', globals(), ns)
+        g = ns['g']
+        self.assertIsSubclass(G, typing.AsyncGenerator)
+        self.assertIsSubclass(G, typing.AsyncIterable)
+        self.assertIsSubclass(G, collections.AsyncGenerator)
+        self.assertIsSubclass(G, collections.AsyncIterable)
+        self.assertNotIsSubclass(type(g), G)
+
     def test_subclassing_subclasshook(self):
 
         class Base(typing.Iterable):

src/typing.py

@@ -49,7 +49,8 @@
     # AsyncIterable,
     # Coroutine,
     # Collection,
-    # ContextManager
+    # ContextManager,
+    # AsyncGenerator,
 
     # Structural checks, a.k.a. protocols.
     'Reversible',
@@ -1859,6 +1860,21 @@ def __new__(cls, *args, **kwds):
                             "create a subclass instead")
         return _generic_new(_G_base, cls, *args, **kwds)
 
+if hasattr(collections_abc, 'AsyncGenerator'):
+    _AG_base = collections_abc.AsyncGenerator
+
+    class AsyncGenerator(AsyncIterator[T_co], Generic[T_co, T_contra],
+                         extra=_AG_base):
+        __slots__ = ()
+
+        def __new__(cls, *args, **kwds):
+            if _geqv(cls, AsyncGenerator):
+                raise TypeError("Type AsyncGenerator cannot be instantiated; "
+                                "create a subclass instead")
+            return _generic_new(_AG_base, cls, *args, **kwds)
+
+    __all__.append('AsyncGenerator')
+
 
 # Internal type variable used for Type[].
 CT_co = TypeVar('CT_co', covariant=True, bound=type)