🐛 Fix syncify with raise_sync_error=False on AnyIO 4.x.x, do not start new event loops unnecessarily (#130)

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: tiangolo

.github/workflows/test.yml

@@ -26,6 +26,9 @@ jobs:
           - "3.10"
           - "3.11"
           - "3.12"
+        anyio-version:
+          - anyio-v3
+          - anyio-v4
       fail-fast: false
 
     steps:
@@ -56,6 +59,12 @@ jobs:
       - name: Install Dependencies
         if: steps.cache.outputs.cache-hit != 'true'
         run: python -m poetry install
+      - name: Install AnyIO v3
+        if: matrix.anyio-version == 'anyio-v3'
+        run: pip install --upgrade "anyio>=3.4.0,<4.0"
+      - name: Install AnyIO v4
+        if: matrix.anyio-version == 'anyio-v4'
+        run: pip install --upgrade "anyio>=4.0.0,<5.0"
       - name: Lint
         run: python -m poetry run bash scripts/lint.sh
       - run: mkdir coverage

asyncer/_main.py

@@ -26,7 +26,9 @@
 
 # This was obtained with: from anyio._core._eventloop import get_asynclib
 # Removed in https://github.com/agronholm/anyio/pull/429
-# First release (not released yet): 4.0-dev
+# Released in AnyIO 4.x.x
+# The new function is anyio._core._eventloop.get_async_backend but that returns a
+# class, not a module to extract the TaskGroup class from.
 def get_asynclib(asynclib_name: Union[str, None] = None) -> Any:
     if asynclib_name is None:
         asynclib_name = sniffio.current_async_library()
@@ -298,7 +300,12 @@ async def do_work(arg1, arg2, kwarg1="", kwarg2=""):
 
     @functools.wraps(async_function)
     def wrapper(*args: T_ParamSpec.args, **kwargs: T_ParamSpec.kwargs) -> T_Retval:
-        current_async_module = getattr(threadlocals, "current_async_module", None)
+        current_async_module = (
+            getattr(threadlocals, "current_async_backend", None)
+            or
+            # TODO: remove when deprecating AnyIO 3.x
+            getattr(threadlocals, "current_async_module", None)
+        )
         partial_f = functools.partial(async_function, *args, **kwargs)
         if current_async_module is None and raise_sync_error is False:
             return anyio.run(partial_f)

tests/test_syncify_no_raise.py

@@ -0,0 +1,87 @@
+import threading
+from dataclasses import dataclass
+from typing import List
+
+import anyio
+from asyncer import asyncify, syncify
+
+
+@dataclass
+class Report:
+    thread_id: int
+    caller_func: str
+
+
+def test_syncify_no_raise_async():
+    reports: List[Report] = []
+
+    async def do_sub_async_work():
+        report = Report(
+            thread_id=threading.get_ident(),
+            caller_func="do_sub_async_work",
+        )
+        reports.append(report)
+
+    def do_sub_sync_work():
+        report = Report(
+            thread_id=threading.get_ident(),
+            caller_func="do_sub_sync_work",
+        )
+        reports.append(report)
+        syncify(do_sub_async_work, raise_sync_error=False)()
+
+    async def do_async_work():
+        report = Report(
+            thread_id=threading.get_ident(),
+            caller_func="do_async_work",
+        )
+        reports.append(report)
+        await asyncify(do_sub_sync_work)()
+
+    def do_sync_work():
+        own_report = Report(
+            thread_id=threading.get_ident(),
+            caller_func="do_sync_work",
+        )
+        reports.append(own_report)
+        syncify(do_async_work, raise_sync_error=False)()
+
+    async def main():
+        own_report = Report(
+            thread_id=threading.get_ident(),
+            caller_func="main",
+        )
+        reports.append(own_report)
+        await asyncify(do_sync_work)()
+
+    def sync_main():
+        own_report = Report(
+            thread_id=threading.get_ident(),
+            caller_func="sync_main",
+        )
+        reports.append(own_report)
+        do_sync_work()
+
+    anyio.run(main)
+    sync_main()
+    main_thread_id = threading.get_ident()
+    assert reports[0].caller_func == "main"
+    assert reports[0].thread_id == main_thread_id
+    assert reports[1].caller_func == "do_sync_work"
+    assert reports[1].thread_id != main_thread_id
+    assert reports[2].caller_func == "do_async_work"
+    assert reports[2].thread_id == main_thread_id
+    assert reports[3].caller_func == "do_sub_sync_work"
+    assert reports[3].thread_id != main_thread_id
+    assert reports[4].caller_func == "do_sub_async_work"
+    assert reports[4].thread_id == main_thread_id
+    assert reports[5].caller_func == "sync_main"
+    assert reports[5].thread_id == main_thread_id
+    assert reports[6].caller_func == "do_sync_work"
+    assert reports[6].thread_id == main_thread_id
+    assert reports[7].caller_func == "do_async_work"
+    assert reports[7].thread_id == main_thread_id
+    assert reports[8].caller_func == "do_sub_sync_work"
+    assert reports[8].thread_id != main_thread_id
+    assert reports[9].caller_func == "do_sub_async_work"
+    assert reports[9].thread_id == main_thread_id

tests/test_tutorial/test_soonify_return/test_tutorial002.py

@@ -16,10 +16,13 @@ def test_tutorial():
     new_print = get_testing_print_function(calls)
 
     with patch("builtins.print", new=new_print):
-        with pytest.raises(ExceptionGroup) as e:
+        with pytest.raises((ExceptionGroup, asyncer.PendingValueException)) as e:
             from docs_src.tutorial.soonify_return import tutorial002 as mod
 
             # Avoid autoflake removing this import
             assert mod  # pragma: nocover
-        assert isinstance(e.value.exceptions[0], asyncer.PendingValueException)
+        if isinstance(e.value, ExceptionGroup):
+            assert isinstance(e.value.exceptions[0], asyncer.PendingValueException)
+        else:
+            assert isinstance(e.value, asyncer.PendingValueException)
     assert calls == []