Merge branch 'master' into dependabot/pip/pathspec-0.10.2

Author: pquentin

docs-requirements.txt

@@ -28,7 +28,7 @@ docutils==0.17.1
     # via
     #   sphinx
     #   sphinx-rtd-theme
-exceptiongroup==1.0.1
+exceptiongroup==1.0.4
     # via -r docs-requirements.in
 idna==3.4
     # via

docs/source/reference-lowlevel.rst

@@ -510,25 +510,9 @@ Task API
 
    .. attribute:: coro
 
-      This task's coroutine object. Example usage: extracting a stack
-      trace::
-
-          import traceback
-
-          def walk_coro_stack(coro):
-              while coro is not None:
-                  if hasattr(coro, "cr_frame"):
-                      # A real coroutine
-                      yield coro.cr_frame, coro.cr_frame.f_lineno
-                      coro = coro.cr_await
-                  else:
-                      # A generator decorated with @types.coroutine
-                      yield coro.gi_frame, coro.gi_frame.f_lineno
-                      coro = coro.gi_yieldfrom
-
-          def print_stack_for_task(task):
-              ss = traceback.StackSummary.extract(walk_coro_stack(task.coro))
-              print("".join(ss.format()))
+      This task's coroutine object.
+
+   .. automethod:: iter_await_frames
 
    .. attribute:: context
 

newsfragments/1810.feature.rst

@@ -0,0 +1 @@
+`trio.socket.socket` now prints the address it tried to connect to upon failure.

setup.py

@@ -81,7 +81,6 @@
     install_requires=[
         "attrs >= 19.2.0",  # for eq
         "sortedcontainers",
-        "async_generator >= 1.9",
         "idna",
         "outcome",
         "sniffio",

test-requirements.in

@@ -1,6 +1,7 @@
 # For tests
 pytest >= 5.0         # for faulthandler in core
 pytest-cov >= 2.6.0
+async_generator >= 1.9
 # ipython 7.x is the last major version supporting Python 3.7
 ipython < 7.32        # for the IPython traceback integration tests
 pyOpenSSL >= 22.0.0   # for the ssl + DTLS tests
@@ -26,9 +27,7 @@ typing-extensions; implementation_name == "cpython"
 cffi; os_name == "nt"
 attrs >= 19.2.0
 sortedcontainers
-async_generator >= 1.9
 idna
 outcome
 sniffio
 exceptiongroup >= 1.0.0rc9; python_version < "3.11"
-

test-requirements.txt

@@ -58,7 +58,7 @@ mccabe==0.6.1
     # via
     #   flake8
     #   pylint
-mypy==0.982 ; implementation_name == "cpython"
+mypy==0.991 ; implementation_name == "cpython"
     # via -r test-requirements.in
 mypy-extensions==0.4.3 ; implementation_name == "cpython"
     # via
@@ -77,7 +77,7 @@ pexpect==4.8.0
     # via ipython
 pickleshare==0.7.5
     # via ipython
-platformdirs==2.5.3
+platformdirs==2.5.4
     # via
     #   black
     #   pylint

trio/_core/_ki.py

@@ -1,14 +1,16 @@
+from __future__ import annotations
+
 import inspect
 import signal
 import sys
 from functools import wraps
-import attr
+from typing import TYPE_CHECKING
 
-import async_generator
+import attr
 
 from .._util import is_main_thread
 
-if False:
+if TYPE_CHECKING:
     from typing import Any, TypeVar, Callable
 
     F = TypeVar("F", bound=Callable[..., Any])
@@ -55,7 +57,7 @@
 #
 #   If this raises a KeyboardInterrupt, it might be because the coroutine got
 #   interrupted and has unwound... or it might be the KeyboardInterrupt
-#   arrived just *after* 'send' returned, so the coroutine is still running
+#   arrived just *after* 'send' returned, so the coroutine is still running,
 #   but we just lost the message it sent. (And worse, in our actual task
 #   runner, the send is hidden inside a utility function etc.)
 #
@@ -109,6 +111,14 @@ def currently_ki_protected():
     return ki_protection_enabled(sys._getframe())
 
 
+# This is to support the async_generator package necessary for aclosing on <3.10
+# functions decorated @async_generator are given this magic property that's a
+# reference to the object itself
+# see python-trio/async_generator/async_generator/_impl.py
+def legacy_isasyncgenfunction(obj):
+    return getattr(obj, "_async_gen_function", None) == id(obj)
+
+
 def _ki_protection_decorator(enabled):
     def decorator(fn):
         # In some version of Python, isgeneratorfunction returns true for
@@ -141,7 +151,7 @@ def wrapper(*args, **kwargs):
                 return gen
 
             return wrapper
-        elif async_generator.isasyncgenfunction(fn):
+        elif inspect.isasyncgenfunction(fn) or legacy_isasyncgenfunction(fn):
 
             @wraps(fn)
             def wrapper(*args, **kwargs):
@@ -163,10 +173,10 @@ def wrapper(*args, **kwargs):
     return decorator
 
 
-enable_ki_protection = _ki_protection_decorator(True)  # type: Callable[[F], F]
+enable_ki_protection: Callable[[F], F] = _ki_protection_decorator(True)
 enable_ki_protection.__name__ = "enable_ki_protection"
 
-disable_ki_protection = _ki_protection_decorator(False)  # type: Callable[[F], F]
+disable_ki_protection: Callable[[F], F] = _ki_protection_decorator(False)
 disable_ki_protection.__name__ = "disable_ki_protection"
 
 

trio/_core/_run.py

@@ -4,6 +4,7 @@
 import select
 import sys
 import threading
+import gc
 from collections import deque
 from contextlib import contextmanager
 import warnings
@@ -1181,6 +1182,53 @@ def child_nurseries(self):
         """
         return list(self._child_nurseries)
 
+    def iter_await_frames(self):
+        """Iterates recursively over the coroutine-like objects this
+        task is waiting on, yielding the frame and line number at each
+        frame.
+
+        This is similar to `traceback.walk_stack` in a synchronous
+        context. Note that `traceback.walk_stack` returns frames from
+        the bottom of the call stack to the top, while this function
+        starts from `Task.coro <trio.lowlevel.Task.coro>` and works it
+        way down.
+
+        Example usage: extracting a stack trace::
+
+            import traceback
+
+            def print_stack_for_task(task):
+                ss = traceback.StackSummary.extract(task.iter_await_frames())
+                print("".join(ss.format()))
+
+        """
+        coro = self.coro
+        while coro is not None:
+            if hasattr(coro, "cr_frame"):
+                # A real coroutine
+                yield coro.cr_frame, coro.cr_frame.f_lineno
+                coro = coro.cr_await
+            elif hasattr(coro, "gi_frame"):
+                # A generator decorated with @types.coroutine
+                yield coro.gi_frame, coro.gi_frame.f_lineno
+                coro = coro.gi_yieldfrom
+            elif coro.__class__.__name__ in [
+                "async_generator_athrow",
+                "async_generator_asend",
+            ]:
+                # cannot extract the generator directly, see https://github.com/python/cpython/issues/76991
+                # we can however use the gc to look through the object
+                for referent in gc.get_referents(coro):
+                    if hasattr(referent, "ag_frame"):
+                        yield referent.ag_frame, referent.ag_frame.f_lineno
+                        coro = referent.ag_await
+                        break
+                else:
+                    # either cpython changed or we are running on an alternative python implementation
+                    return
+            else:
+                return
+
     ################
     # Cancellation
     ################

trio/_core/_thread_cache.py

@@ -1,3 +1,5 @@
+import sys
+import traceback
 from threading import Thread, Lock
 import outcome
 from itertools import count
@@ -67,7 +69,11 @@ def _handle_job(self):
         # 'deliver' triggers a new job, it can be assigned to us
         # instead of spawning a new thread.
         self._thread_cache._idle_workers[self] = None
-        deliver(result)
+        try:
+            deliver(result)
+        except BaseException as e:
+            print("Exception while delivering result of thread", file=sys.stderr)
+            traceback.print_exception(type(e), e, e.__traceback__)
 
     def _work(self):
         while True:

trio/_core/tests/test_asyncgen.py

@@ -1,13 +1,15 @@
 import sys
 import weakref
 import pytest
+import contextlib
 from math import inf
 from functools import partial
-from async_generator import aclosing
+
 from ... import _core
 from .tutil import gc_collect_harder, buggy_pypy_asyncgens, restore_unraisablehook
 
 
+@pytest.mark.skipif(sys.version_info < (3, 10), reason="no aclosing() in stdlib<3.10")
 def test_asyncgen_basics():
     collected = []
 
@@ -46,7 +48,7 @@ async def async_main():
         assert collected.pop() == "abandoned"
 
         # aclosing() ensures it's cleaned up at point of use
-        async with aclosing(example("exhausted 1")) as aiter:
+        async with contextlib.aclosing(example("exhausted 1")) as aiter:
             assert 42 == await aiter.asend(None)
         assert collected.pop() == "exhausted 1"
 
@@ -58,7 +60,7 @@ async def async_main():
         gc_collect_harder()
 
         # No problems saving the geniter when using either of these patterns
-        async with aclosing(example("exhausted 3")) as aiter:
+        async with contextlib.aclosing(example("exhausted 3")) as aiter:
             saved.append(aiter)
             assert 42 == await aiter.asend(None)
         assert collected.pop() == "exhausted 3"