remove async_generator as dependency, add it as test dependency but also

guard all revelant tests with skips

Author: jakkdl

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"
-

trio/_core/_ki.py

@@ -2,9 +2,8 @@
 import signal
 import sys
 from functools import wraps
-import attr
 
-import async_generator
+import attr
 
 from .._util import is_main_thread
 
@@ -109,6 +108,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 +148,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):

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"

trio/_core/tests/test_ki.py

@@ -6,13 +6,12 @@
 import threading
 import contextlib
 import time
+import inspect
 
-from async_generator import (
-    async_generator,
-    yield_,
-    isasyncgenfunction,
-    asynccontextmanager,
-)
+try:
+    from async_generator import yield_, async_generator
+except ImportError:  # pragma: no cover
+    async_generator = yield_ = None
 
 from ... import _core
 from ...testing import wait_all_tasks_blocked
@@ -142,7 +141,8 @@ def protected_manager():
             raise KeyError
 
 
-async def test_agen_protection():
+@pytest.mark.skipif(async_generator is None, reason="async_generator not installed")
+async def test_async_generator_agen_protection():
     @_core.enable_ki_protection
     @async_generator
     async def agen_protected1():
@@ -180,45 +180,49 @@ async def agen_unprotected2():
         finally:
             assert not _core.currently_ki_protected()
 
+    await _check_agen(agen_protected1)
+    await _check_agen(agen_protected2)
+    await _check_agen(agen_unprotected1)
+    await _check_agen(agen_unprotected2)
+
+
+async def test_native_agen_protection():
     # Native async generators
     @_core.enable_ki_protection
-    async def agen_protected3():
+    async def agen_protected():
         assert _core.currently_ki_protected()
         try:
             yield
         finally:
             assert _core.currently_ki_protected()
 
     @_core.disable_ki_protection
-    async def agen_unprotected3():
+    async def agen_unprotected():
         assert not _core.currently_ki_protected()
         try:
             yield
         finally:
             assert not _core.currently_ki_protected()
 
-    for agen_fn in [
-        agen_protected1,
-        agen_protected2,
-        agen_protected3,
-        agen_unprotected1,
-        agen_unprotected2,
-        agen_unprotected3,
-    ]:
-        async for _ in agen_fn():  # noqa
+    await _check_agen(agen_protected)
+    await _check_agen(agen_unprotected)
+
+
+async def _check_agen(agen_fn):
+    async for _ in agen_fn():  # noqa
+        assert not _core.currently_ki_protected()
+
+    # asynccontextmanager insists that the function passed must itself be an
+    # async gen function, not a wrapper around one
+    if inspect.isasyncgenfunction(agen_fn):
+        async with contextlib.asynccontextmanager(agen_fn)():
             assert not _core.currently_ki_protected()
 
-        # asynccontextmanager insists that the function passed must itself be an
-        # async gen function, not a wrapper around one
-        if isasyncgenfunction(agen_fn):
-            async with asynccontextmanager(agen_fn)():
-                assert not _core.currently_ki_protected()
-
-            # Another case that's tricky due to:
-            #   https://bugs.python.org/issue29590
-            with pytest.raises(KeyError):
-                async with asynccontextmanager(agen_fn)():
-                    raise KeyError
+        # Another case that's tricky due to:
+        #   https://bugs.python.org/issue29590
+        with pytest.raises(KeyError):
+            async with contextlib.asynccontextmanager(agen_fn)():
+                raise KeyError
 
 
 # Test the case where there's no magic local anywhere in the call stack

trio/_util.py

@@ -11,8 +11,7 @@
 import typing as t
 import threading
 import collections
-
-from async_generator import isasyncgen
+import inspect
 
 import trio
 
@@ -143,6 +142,7 @@ def _return_value_looks_like_wrong_library(value):
     # for things like functools.partial objects wrapping an async
     # function. So we have to just call it and then check whether the
     # return value is a coroutine object.
+    # Note: will not be necessary on python>=3.8, see https://bugs.python.org/issue34890
     if not isinstance(coro, collections.abc.Coroutine):
         # Give good error for: nursery.start_soon(func_returning_future)
         if _return_value_looks_like_wrong_library(coro):
@@ -152,7 +152,7 @@ def _return_value_looks_like_wrong_library(value):
                 "That won't work without some sort of compatibility shim.".format(coro)
             )
 
-        if isasyncgen(coro):
+        if inspect.isasyncgen(coro):
             raise TypeError(
                 "start_soon expected an async function but got an async "
                 "generator {!r}".format(coro)

trio/testing/_sequencer.py

@@ -1,7 +1,7 @@
 from collections import defaultdict
+from contextlib import asynccontextmanager
 
 import attr
-from async_generator import asynccontextmanager
 
 from .. import _core
 from .. import _util

trio/tests/test_dtls.py

@@ -4,7 +4,7 @@
 from trio import DTLSEndpoint
 import random
 import attr
-from async_generator import asynccontextmanager
+from contextlib import asynccontextmanager
 from itertools import count
 
 import trustme

trio/tests/test_ssl.py

@@ -7,12 +7,11 @@
 import threading
 import socket as stdlib_socket
 import ssl
-from contextlib import contextmanager
+from contextlib import asynccontextmanager, contextmanager
 from functools import partial
 
 from OpenSSL import SSL
 import trustme
-from async_generator import asynccontextmanager
 
 import trio
 from .. import _core

trio/tests/test_subprocess.py

@@ -3,11 +3,11 @@
 import signal
 import subprocess
 import sys
+from contextlib import asynccontextmanager
 from functools import partial
 from pathlib import Path as SyncPath
 
 import pytest
-from async_generator import asynccontextmanager
 
 from .. import (
     ClosedResourceError,