Merge branch 'main' into gh-161166-stack

Author: deadlovelll

.github/workflows/reusable-macos.yml

@@ -51,6 +51,7 @@ jobs:
           --enable-slower-safety \
           --enable-safety \
           ${{ inputs.free-threading && '--disable-gil' || '' }} \
+          --with-tail-call-interp \
           --prefix=/opt/python-dev \
           --with-openssl="$(brew --prefix openssl@3.5)"
     - name: Build CPython

.github/workflows/tail-call.yml

@@ -23,31 +23,6 @@ env:
   LLVM_VERSION: 21
 
 jobs:
-  macos:
-    name: aarch64-apple-darwin/clang
-    runs-on: macos-26
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
-        with:
-          python-version: '3.11'
-      - name: Install dependencies
-        run: |
-          brew update
-          brew install llvm@${{ env.LLVM_VERSION }}
-      - name: Build
-        run: |
-          export SDKROOT="$(xcrun --show-sdk-path)"
-          export PATH="/opt/homebrew/opt/llvm@${{ env.LLVM_VERSION }}/bin:$PATH"
-          CC=clang-${{ env.LLVM_VERSION }} ./configure --with-tail-call-interp
-          make all --jobs 4
-      - name: Test
-        run: |
-          ./python.exe -m test --multiprocess 0 --timeout 4500 --verbose2 --verbose3
-
   linux:
     name: ${{ matrix.target }}
     runs-on: ${{ matrix.runner }}

Lib/asyncio/base_tasks.py

@@ -42,8 +42,11 @@ def _task_get_stack(task, limit):
     elif hasattr(task._coro, 'ag_frame'):
         # case 3: async generators
         f = task._coro.ag_frame
+    elif not task.done() and hasattr(task._coro, 'aga_gen'):
+        # case 4: async generator's asend/athrow/aclose
+        f = task._coro.aga_gen.ag_frame
     else:
-        # case 4: unknown objects
+        # case 5: unknown objects
         f = None
     if f is not None:
         while f is not None:

Lib/asyncio/tools.py

@@ -128,14 +128,22 @@ def _find_cycles(graph):
     def dfs(v):
         color[v] = GREY
         path.append(v)
-        for w in graph.get(v, ()):
-            if color[w] == WHITE:
-                dfs(w)
-            elif color[w] == GREY:            # back-edge → cycle!
-                i = path.index(w)
-                cycles.append(path[i:] + [w])  # make a copy
-        color[v] = BLACK
-        path.pop()
+        stack = [(v, iter(graph.get(v, ())))]
+        while stack:
+            node, children = stack[-1]
+            for w in children:
+                if color[w] == WHITE:
+                    color[w] = GREY
+                    path.append(w)
+                    stack.append((w, iter(graph.get(w, ()))))
+                    break
+                elif color[w] == GREY:            # back-edge → cycle!
+                    i = path.index(w)
+                    cycles.append(path[i:] + [w])  # make a copy
+            else:
+                color[node] = BLACK
+                path.pop()
+                stack.pop()
 
     for v in list(graph):
         if color[v] == WHITE:
@@ -167,14 +175,16 @@ def pretty(node):
         flag = task_emoji if node[0] == NodeType.TASK else cor_emoji
         return f"{flag} {labels[node]}"
 
-    def render(node, prefix="", last=True, buf=None):
-        if buf is None:
-            buf = []
-        buf.append(f"{prefix}{'└── ' if last else '├── '}{pretty(node)}")
-        new_pref = prefix + ("    " if last else "│   ")
-        kids = children.get(node, [])
-        for i, kid in enumerate(kids):
-            render(kid, new_pref, i == len(kids) - 1, buf)
+    def render(root):
+        buf = []
+        stack = [(root, "", True)]
+        while stack:
+            node, prefix, last = stack.pop()
+            buf.append(f"{prefix}{'└── ' if last else '├── '}{pretty(node)}")
+            new_pref = prefix + ("    " if last else "│   ")
+            kids = children.get(node, [])
+            for i in range(len(kids) - 1, -1, -1):
+                stack.append((kids[i], new_pref, i == len(kids) - 1))
         return buf
 
     return [render(root) for root in _roots(labels, children)]

Lib/test/test_asyncio/test_tasks.py

@@ -349,6 +349,40 @@ async def coro():
         file = io.StringIO()
         task.print_stack(file=file)
         self.assertIn('    1 / 0\n', file.getvalue())
+        
+    def test_get_stack_async_generator(self):
+        # gh-161178
+        async def gen():
+            try:
+                yield
+            except ValueError:
+                pass
+            finally:
+                await asyncio.sleep(0)
+            yield
+
+        async def runner(method, args):
+            agen = gen()
+            await anext(agen)
+            task = self.new_task(self.loop, getattr(agen, method)(*args))
+            await asyncio.sleep(0)
+            frame = agen.ag_frame
+            stack = task.get_stack()
+            await task
+            try:
+                self.assertEqual(stack, [frame])
+                self.assertEqual(task.get_stack(), [])
+            finally:
+                await agen.aclose()
+
+        for method, args in (
+            ('__anext__', ()),
+            ('asend', (None,)),
+            ('athrow', (ValueError(),)),
+            ('aclose', ()),
+        ):
+            with self.subTest(method=method):
+                self.loop.run_until_complete(runner(method, args))
 
     def test_task_repr(self):
         self.loop.set_debug(False)

Lib/test/test_asyncio/test_tools.py

@@ -1,3 +1,4 @@
+import sys
 import unittest
 
 from asyncio import tools
@@ -1465,6 +1466,77 @@ def test_deep_coroutine_chain(self):
         result = tools.build_async_tree(input_)
         self.assertEqual(result, expected)
 
+    def test_deep_task_chain(self):
+        # gh-159168
+        n = sys.getrecursionlimit()
+        input_ = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=i,
+                        task_name=f"Task-{i}",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("f", "", LocationInfo(0))],
+                                task_name=i - 1
+                            )
+                        ] if i > 1 else []
+                    )
+                    for i in range(1, n + 1)
+                ]
+            )
+        ]
+        tree = tools.build_async_tree(input_)
+        self.assertEqual(len(tree[0]), 2 * n - 1)
+        self.assertEqual(tree[0][-1], " " * 8 * (n - 1) + f"└── (T) Task-{n}")
+
+    def test_cycle_below_task(self):
+        # gh-159168
+        input_ = [
+            AwaitedInfo(
+                thread_id=1,
+                awaited_by=[
+                    TaskInfo(
+                        task_id=1,
+                        task_name="Task-1",
+                        coroutine_stack=[],
+                        awaited_by=[]
+                    ),
+                    TaskInfo(
+                        task_id=2,
+                        task_name="Task-2",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("f", "", LocationInfo(0))],
+                                task_name=1
+                            ),
+                            CoroInfo(
+                                call_stack=[FrameInfo("f", "", LocationInfo(0))],
+                                task_name=3
+                            )
+                        ]
+                    ),
+                    TaskInfo(
+                        task_id=3,
+                        task_name="Task-3",
+                        coroutine_stack=[],
+                        awaited_by=[
+                            CoroInfo(
+                                call_stack=[FrameInfo("f", "", LocationInfo(0))],
+                                task_name=2
+                            )
+                        ]
+                    )
+                ]
+            )
+        ]
+        with self.assertRaises(tools.CycleFoundException) as ctx:
+            tools.build_async_tree(input_)
+        self.assertEqual(ctx.exception.cycles, [[2, 3, 2]])
+
     def test_multiple_cycles_same_node(self):
         input_ = [
             AwaitedInfo(

Misc/NEWS.d/next/Library/2026-10-11-13-40-44.gh-issue-159168.z3KjB8.rst

@@ -0,0 +1,2 @@
+Fix :exc:`RecursionError` in ``python -m asyncio pstree`` on a deep chain of
+awaiting tasks. Patch by Timofei Ivankov.

Misc/NEWS.d/next/Library/2026-11-02-16-28-11.gh-issue-161178.D3-23R.rst

@@ -0,0 +1,2 @@
+Fix :meth:`asyncio.Task.print_stack` to include frames from async generator
+operations. Patch by Timofei Ivankov