asyncio: is an async generator closed when the task iterating it is cancelled while awaiting queue.put()?

A producer task runs "async for token in stream(): await queue.put(token)" where stream() is an async generator with a try/finally that releases a connection, and the queue is a bounded asyncio.Queue feeding a slower consumer. On a timeout the producer task is cancelled while it is suspended in queue.put(), not inside the generator. The worry is that CancelledError is raised at the put, the generator is left suspended at its yield, and its finally block runs late (at garbage collection or loop shutdown) or not at all, leaking the connection. Questions: (1) when exactly does the generator's finally run in this case, on current CPython; (2) is wrapping the generator in contextlib.aclosing() enough to make it run before the cancelled task finishes, wherever the cancellation lands; (3) what is the smallest reliable pattern for producer, bounded queue and consumer. Source: restated from https://stackoverflow.com/q/79991144 (unanswered when read).

How an answer is checked: A stdlib-only script that cancels the producer while it is blocked in queue.put() and prints the order of: generator finally, producer task done, asyncio.run returning, for (a) plain async for and (b) async with aclosing(...). The answer states the Python version and whether cleanup in (a) depends on asyncgen hooks or garbage collection.

Tested on CPython 3.15.2, macOS arm64, stdlib only, cyclic gc disabled (gc.disable()) so nothing below depends on the garbage collector. (1) Plain async for: the finally does NOT run inside the cancelled task. CancelledError is raised at the put(), the producer coroutine dies, its frame drops the last reference to the generator, and asyncio's asyncgen finalizer hook (installed by the loop, sys.set_asyncgen_hooks) schedules gen.aclose() as a new task. So finally runs a few loop iterations AFTER the producer task is done, and before asyncio.run returns. It is refcount plus hook, not gc. If anything else still references the generator, finally waits until loop.shutdown_asyncgens() at the end of asyncio.run. Measured order: (a) plain async for: cancelling producer while blocked in put() / producer task done / await p -> CancelledError / main returning / after one sleep(0) / generator finally ran / asyncio.run returned (a2) same, generator also kept in a list: producer done, 200 ms of main still running with no finally, then 'generator finally ran' only after main returned (shutdown_asyncgens) and before asyncio.run returned. (b) async with aclosing(gen): cancelling producer while blocked in put() / generator finally ran / producer task done / await p -> CancelledError / ... / asyncio.run returned. Finally runs inside the task, before it is done. (2) Yes. aclosing (contextlib, docs: 'supports deterministic cleanup of async generators when they happen to exit early by break or an exception') awaits aclose() in its __aexit__, which runs when CancelledError propagates out of the put(). Same result when cancellation lands inside the generator at an await (generator awaits sleep(10)): finally runs first, then task done. Caveat: if a second cancel arrives while aclose() itself is awaiting, the cleanup is interrupted; keep finally bodies short or shield them. (3) Smallest pattern, run with a bounded Queue(2), slower consumer, asyncio.timeout(0.3) around the producer: async def producer(q): async with aclosing(stream()) as s: async for tok in s: await q.put(tok) # consumer: while True: await q.get(); await asyncio.sleep(0.05) # main: c=create_task(consumer(q)); p=create_task(producer(q)) # try: async with asyncio.timeout(0.3): await p # except TimeoutError: ... # finally: c.cancel(); await asyncio.gather(c, return_exceptions=True) Output for cancel at put() and cancel inside generator, both: ['gen finally', 'producer done', 'timeout; producer.cancelled=True', 'run exits']. Does cleanup in (a) depend on hooks or gc? On hooks (and on the last reference being dropped). Extra: with asyncio's hooks removed (sys.set_asyncgen_hooks(None, None) before the first iteration) finally also ran at once on refcount drop in this build, i.e. the interpreter closed it itself; I did not test other versions or loops (uvloop, trio), and did not test a reference cycle holding the generator, where only gc or shutdown_asyncgens would close it. Not tested: Windows, PyPy, Python older than 3.15 (asyncio.timeout needs 3.11, aclosing 3.10). Docs checked at docs.python.org: contextlib.aclosing, loop.shutdown_asyncgens (not needed with asyncio.run), sys.get_asyncgen_hooks.

Method: Wrote three scripts and ran them with python3 3.15.2: (a)/(a2)/(b) cancel a producer blocked in Queue(1).put() and log order of generator finally, task done callback, run exit; a variant with asyncgen hooks removed; and a producer/bounded-queue/slow-consumer program with asyncio.timeout cancelling at put() and inside the generator. Read the aclosing, shutdown_asyncgens and sys asyncgen hooks docs. Not tested: Windows, other versions, uvloop, reference cycles.

artifacts: a plain    ['cancel while blocked in put', 'producer task done', 'await p -> CancelledError', 'generator finally', 'main returning', 'asyncio.run returned']
a2 kept    ['cancel while blocked in put', 'producer task done', 'await p -> CancelledError', 'main returning', 'generator finally', 'asyncio.run returned']
b aclosing ['cancel while blocked in put', 'generator finally', 'producer task done', 'await p -> CancelledError', 'main returning', 'asyncio.run returned']
no hooks, non-awaiting finally ['generator finally', 'producer task done', 'main returning', 'asyncio.run returned']
pattern inside=False ['gen finally (after await)', 'producer done', 'timeout; producer.cancelled=True', 'run exits']
pattern inside=True  ['gen finally (after await)', 'producer done', 'timeout; producer.cancelled=True', 'run exits']
plain, awaiting finally, hooks    ['producer done', 'gen finally (after await)', 'main returning', 'run exits']
plain, awaiting finally, no hooks ['producer done', 'main returning', 'run exits']
  stderr: Exception ignored while closing generator ... RuntimeError: async generator ignored GeneratorExit
docs.python.org contextlib: 'Significantly, aclosing() supports deterministic cleanup of async generators when they happen to exit early by break or an exception.'
ran on: CPython 3.15.2, macOS arm64, stdlib only
caveat: The 'Extra' about hooks removed holds only for a finally that does not await. With an awaiting finally (an async connection release), the synchronous close fails with RuntimeError 'async generator ignored GeneratorExit' and the code after the await never runs, so in (a) cleanup of a real async release depends on asyncio's asyncgen hooks.

artifacts: 3.15.2 a: cancelling / producer task done / await p -> CancelledError / main after await / generator finally / after sleep(0) #1 / ... / asyncio.run returned
3.15.2 a2: ... main returning / generator finally / asyncio.run returned
3.15.2 b: cancelling / generator finally / producer task done / ...
3.15.2 b_inner: cancelling / generator finally / producer task done / ...
3.15.2 nohooks: cancelling / generator finally / producer task done / ...
3.15.2 cycle: ... main returning / generator finally / asyncio.run returned
(3.14.8 and 3.12.16 identical)
Pattern: 3.15.2 at put ['gen finally', 'producer done', 'timeout; producer.cancelled=True', 'run exits'] (inner and 3.12.16 same)
Awaiting finally (await asyncio.sleep(0.01) inside finally):
3.15.2 a: producer task done / finally start / finally end (released) / main returning
3.15.2 b: finally start / finally end (released) / producer task done
3.15.2 nohooks: finally start / producer task done / main returning / asyncio.run returned   (stderr: Exception ignored while closing generator ... RuntimeError: async generator ignored GeneratorExit; 3.12.16 same)
ran on: CPython 3.15.2, 3.14.8 and 3.12.16 on macOS arm64, stdlib only, gc.disable()
caveat: The 'hooks removed, the interpreter closed it itself' extra holds only for a finally body with no await. With an await in finally (an async connection release), the no-hooks close starts finally, the await raises RuntimeError: async generator ignored GeneratorExit, and the rest of finally never runs. With asyncio's hooks (case a) or aclosing the awaiting finally completes.