Cleanups after code review

Author: oremanj

async_generator/_impl.py

@@ -277,6 +277,7 @@ def __init__(self, coroutine):
         self.ag_running = False
         self._finalizer = None
         self._closed = False
+        self._hooks_inited = False
 
     # On python 3.5.0 and 3.5.1, __aiter__ must be awaitable.
     # Starting in 3.5.2, it should not be awaitable, and if it is, then it
@@ -325,8 +326,8 @@ def athrow(self, type, value=None, traceback=None):
         return self._do_it(self._it.throw, type, value, traceback)
 
     def _do_it(self, start_fn, *args):
-        coro_state = getcoroutinestate(self._coroutine)
-        if coro_state is CORO_CREATED:
+        if not self._hooks_inited:
+            self._hooks_inited = True
             (firstiter, self._finalizer) = get_asyncgen_hooks()
             if firstiter is not None:
                 firstiter(self)
@@ -357,6 +358,9 @@ async def aclose(self):
         state = getcoroutinestate(self._coroutine)
         if state is CORO_CLOSED or self._closed:
             return
+        # Make sure that even if we raise "async_generator ignored
+        # GeneratorExit", and thus fail to exhaust the coroutine,
+        # __del__ doesn't complain again.
         self._closed = True
         if state is CORO_CREATED:
             # Make sure that aclose() on an unstarted generator returns

async_generator/_tests/test_async_generator.py

@@ -624,13 +624,13 @@ async def test___del__(capfd):
 
     @async_generator
     async def awaits_when_unwinding():
-        await yield_(1)
+        await yield_(0)
         try:
-            await yield_(2)
+            await yield_(1)
         finally:
             await mock_sleep()
         try:
-            await yield_(3)
+            await yield_(2)
         finally:
             nonlocal completions
             completions += 1
@@ -640,21 +640,21 @@ async def awaits_when_unwinding():
     gen.__del__()
 
     gen = awaits_when_unwinding()
-    assert await collect(gen) == [1, 2, 3]
+    assert await collect(gen) == [0, 1, 2]
     # Exhausted, so no problem
     gen.__del__()
 
-    for turns in (1, 2, 3):
+    for stop_after_turn in (1, 2, 3):
         gen = awaits_when_unwinding()
-        for turn in range(1, turns + 1):
+        for turn in range(stop_after_turn):
             assert await gen.__anext__() == turn
         await gen.aclose()
         # Closed, so no problem
         gen.__del__()
 
-    for turns in (1, 2, 3):
+    for stop_after_turn in (1, 2, 3):
         gen = awaits_when_unwinding()
-        for turn in range(1, turns + 1):
+        for turn in range(stop_after_turn):
             assert await gen.__anext__() == turn
 
         if sys.implementation.name == "pypy":
@@ -665,14 +665,14 @@ async def awaits_when_unwinding():
             with pytest.raises(RuntimeError) as info:
                 gen.__del__()
             assert "partially-exhausted async_generator" in str(info.value)
-            if turns == 3:
+            if stop_after_turn == 3:
                 # We didn't increment completions, because we didn't finalize
                 # the generator. Increment it now so the check below (which is
                 # calibrated for the correct/CPython behavior) doesn't fire;
                 # we know about the pypy bug.
                 completions += 1
 
-        elif turns == 2:
+        elif stop_after_turn == 2:
             # Stopped in the middle of a try/finally that awaits in the finally,
             # so __del__ can't cleanup.
             with pytest.raises(RuntimeError) as info:
@@ -892,7 +892,7 @@ def two(agen):  # pragma: no cover
     with pytest.raises(TypeError):
         set_asyncgen_hooks(finalizer=False)
 
-    def in_thread(results=[]):
+    def in_thread(results):
         results.append(get_asyncgen_hooks())
         set_asyncgen_hooks(two, one)
         results.append(get_asyncgen_hooks())
@@ -964,6 +964,18 @@ async def anext_verbosely(iter, ident):
     ]
     del events[:]
 
+    # Ensure that firstiter is only called once, even if we create
+    # two asend() coroutines before iterating either of them.
+    iterX = agen("X")
+    sender1 = iterX.asend(None)
+    sender2 = iterX.asend(None)
+    events.append("before close")
+    sender1.close()
+    sender2.close()
+    await iterX.aclose()
+    assert events == ["firstiter X", "before close"]
+    del events[:]
+
     if sys.implementation.name == "pypy":
         # pypy segfaults if an async generator's __del__ is called (even if it resurrects!)
         # and then the underlying coroutine encounters another await:

docs/source/reference.rst

@@ -123,7 +123,11 @@ You can use ``async_generator.set_asyncgen_hooks()`` exactly
 like you would use ``sys.set_asyncgen_hooks()`` with native
 generators. On Python 3.6+, the former is an alias for the latter,
 so libraries that use the native mechanism should work seamlessly
-with ``@async_generator`` functions.
+with ``@async_generator`` functions. On Python 3.5, where there is
+no ``sys.set_asyncgen_hooks()``, most libraries probably *won't* know
+about ``async_generator.set_asyncgen_hooks()``, so you'll need
+to exercise more care with explicit cleanup, or install appropriate
+hooks yourself.
 
 While finishing cleanup of an async generator is better than dropping
 it on the floor at the first ``await``, it's still not a perfect solution;