Skip to content

Conversation

@mohsinm-dev
Copy link
Contributor

@mohsinm-dev mohsinm-dev commented Nov 8, 2025

Fixes issue #141186 by documenting that cancelling a Task cancels what it's waiting for.

Problem

The docs said cancelling a coroutine waiting on a Future cancels the Future, but didn't mention this also happens with Tasks. Users didn't know Tasks work the same way.

Solution

  • Added "or Task" to the documentation where it only mentioned Future
  • Explained that cancellation goes down the whole chain of waiting tasks
  • Mentioned that Tasks inherit from Future so they work the same

Testing

Ran the exact code from the issue - it works as expected. Tested multiple scenarios to confirm the behavior.

Documentation-only change. No code was modified.


📚 Documentation preview 📚: https://cpython-previews--141247.org.readthedocs.build/

Changed "Objects of different types, except different numeric types, never
compare equal" to "Objects of different types, unless documented otherwise,
never compare equal" to account for documented exceptions like set/frozenset
comparisons.
The acquire() method documentation stated 'Exactly one thread will be awoken
by each call to release()' which became incorrect when the n parameter was
added to release() in Python 3.9.

The release() method documentation was ambiguous about behavior when
n > waiting_threads.

Changes:
- acquire(): Updated to reflect that release(n) wakes min(j,n) threads
  where j = waiting threads
- release(): Clarified that it wakes 'up to n' threads, or all available
  if fewer than n are waiting

The fix aligns documentation with actual implementation behavior in
Lib/threading.py where release(n) calls Condition.notify(n).
Clarifies that cancelling a Task awaiting another Task or Future will
also cancel the awaited object. This behavior was undocumented despite
being fundamental to asyncio's cancellation architecture.

Changes:
- Updated general Task description to mention Task cancellation propagation
- Added explicit explanation in Task.cancel() method documentation
- Clarified that Tasks inherit Future's cancellation behavior

Addresses issue python#141186 where users were unaware this cancellation
propagation was intentional architectural behavior, not a side effect.

The fix uses the exact wording suggested by the issue reporter and
documents the _fut_waiter implementation behavior that enables the
propagation down entire await chains.
Copy link
Member

@StanFromIreland StanFromIreland left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

You seem to have changes for three different issues in this PR, please remove the unrelated ones.

@mohsinm-dev
Copy link
Contributor Author

Closing this PR due to mixed commits from multiple issues. Will create a clean PR with only the asyncio changes.

@mohsinm-dev mohsinm-dev closed this Nov 8, 2025
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

docs Documentation in the Doc dir skip news

Projects

Status: Todo

Development

Successfully merging this pull request may close these issues.

2 participants