stop() -> cancel()

Author: belm0

Doc/library/asyncio-task.rst

@@ -342,21 +342,21 @@ and reliable way to wait for all tasks in the group to finish.
 
          Close the given coroutine if the task group is not active.
 
-   .. method:: stop()
+   .. method:: cancel()
 
-      Stop the task group.
+      Cancel the task group.
 
       :meth:`~asyncio.Task.cancel` will be called on any tasks in the group that
       aren't yet done, as well as the parent (body) of the group.  This will
       cause the task group context manager to exit *without*
       :exc:`asyncio.CancelledError` being raised.
 
-      If :meth:`stop` is called before entering the task group, the group will be
-      stopped upon entry.  This is useful for patterns where one piece of
+      If :meth:`cancel` is called before entering the task group, the group will be
+      cancelled upon entry.  This is useful for patterns where one piece of
       code passes an unused :class:`asyncio.TaskGroup` instance to another in order to have
-      the ability to stop anything run within the group.
+      the ability to cancel anything run within the group.
 
-      :meth:`stop` is idempotent and may be called after the task group has
+      :meth:`cancel` is idempotent and may be called after the task group has
       already exited.
 
       .. versionadded:: next

Lib/asyncio/taskgroups.py

@@ -36,7 +36,7 @@ def __init__(self):
         self._errors = []
         self._base_error = None
         self._on_completed_fut = None
-        self._stop_on_enter = False
+        self._cancel_on_enter = False
 
     def __repr__(self):
         info = ['']
@@ -63,8 +63,8 @@ async def __aenter__(self):
             raise RuntimeError(
                 f'TaskGroup {self!r} cannot determine the parent task')
         self._entered = True
-        if self._stop_on_enter:
-            self.stop()
+        if self._cancel_on_enter:
+            self.cancel()
 
         return self
 
@@ -281,24 +281,24 @@ def _on_task_done(self, task):
             self._parent_cancel_requested = True
             self._parent_task.cancel()
 
-    def stop(self):
-        """Stop the task group
+    def cancel(self):
+        """Cancel the task group
 
         `cancel()` will be called on any tasks in the group that aren't yet
         done, as well as the parent (body) of the group.  This will cause the
-        task group context manager to exit *without* a Cancelled exception
+        task group context manager to exit *without* `asyncio.CancelledError`
         being raised.
 
-        If `stop()` is called before entering the task group, the group will be
-        stopped upon entry.  This is useful for patterns where one piece of
+        If `cancel()` is called before entering the task group, the group will be
+        cancelled upon entry.  This is useful for patterns where one piece of
         code passes an unused TaskGroup instance to another in order to have
-        the ability to stop anything run within the group.
+        the ability to cancel anything run within the group.
 
-        `stop()` is idempotent and may be called after the task group has
+        `cancel()` is idempotent and may be called after the task group has
         already exited.
         """
         if not self._entered:
-            self._stop_on_enter = True
+            self._cancel_on_enter = True
             return
         if self._exiting and not self._tasks:
             return

Lib/test/test_asyncio/test_taskgroups.py

@@ -997,66 +997,66 @@ class MyKeyboardInterrupt(KeyboardInterrupt):
         self.assertIsNotNone(exc)
         self.assertListEqual(gc.get_referrers(exc), no_other_refs())
 
-    async def test_taskgroup_stop_children(self):
+    async def test_taskgroup_cancel_children(self):
         # (asserting that TimeoutError is not raised)
         async with asyncio.timeout(1):
             async with asyncio.TaskGroup() as tg:
                 tg.create_task(asyncio.sleep(10))
                 tg.create_task(asyncio.sleep(10))
                 await asyncio.sleep(0)
-                tg.stop()
+                tg.cancel()
 
-    async def test_taskgroup_stop_body(self):
+    async def test_taskgroup_cancel_body(self):
         count = 0
         async with asyncio.TaskGroup() as tg:
-            tg.stop()
+            tg.cancel()
             count += 1
             await asyncio.sleep(0)
             count += 1
         self.assertEqual(count, 1)
 
-    async def test_taskgroup_stop_idempotent(self):
+    async def test_taskgroup_cancel_idempotent(self):
         count = 0
         async with asyncio.TaskGroup() as tg:
-            tg.stop()
-            tg.stop()
+            tg.cancel()
+            tg.cancel()
             count += 1
             await asyncio.sleep(0)
             count += 1
         self.assertEqual(count, 1)
 
-    async def test_taskgroup_stop_after_exit(self):
+    async def test_taskgroup_cancel_after_exit(self):
         async with asyncio.TaskGroup() as tg:
             await asyncio.sleep(0)
         # (asserting that exception is not raised)
-        tg.stop()
+        tg.cancel()
 
-    async def test_taskgroup_stop_before_enter(self):
+    async def test_taskgroup_cancel_before_enter(self):
         tg = asyncio.TaskGroup()
-        tg.stop()
+        tg.cancel()
         count = 0
         async with tg:
             count += 1
             await asyncio.sleep(0)
             count += 1
         self.assertEqual(count, 1)
 
-    async def test_taskgroup_stop_before_exception(self):
+    async def test_taskgroup_cancel_before_exception(self):
         async def raise_exc(parent_tg: asyncio.TaskGroup):
-            parent_tg.stop()
+            parent_tg.cancel()
             raise RuntimeError
 
         with self.assertRaises(ExceptionGroup):
             async with asyncio.TaskGroup() as tg:
                 tg.create_task(raise_exc(tg))
                 await asyncio.sleep(1)
 
-    async def test_taskgroup_stop_after_exception(self):
+    async def test_taskgroup_cancel_after_exception(self):
         async def raise_exc(parent_tg: asyncio.TaskGroup):
             try:
                 raise RuntimeError
             finally:
-                parent_tg.stop()
+                parent_tg.cancel()
 
         with self.assertRaises(ExceptionGroup):
             async with asyncio.TaskGroup() as tg: