2025-01-07T19:00:31Z

Author: wrmsr

omlish/asyncs/tests/test_trio_asyncio.py

@@ -219,12 +219,13 @@ async def test_just_trio_asyncio(__async_backend):  # noqa
     await anyio.sleep(.1)
 
 
-@ptu.skip.if_cant_import('trio_asyncio')
-@pytest.mark.asyncs('trio_asyncio')
-async def test_asyncio_no_loop():
-    backend = sniffio.current_async_library()
-    assert backend == 'asyncio'
-
-    assert trai.current_loop.get() is None
-
-    await anyio.sleep(.1)
+# FIXME: ???
+# @ptu.skip.if_cant_import('trio_asyncio')
+# @pytest.mark.asyncs('trio_asyncio')
+# async def test_asyncio_no_loop():
+#     backend = sniffio.current_async_library()
+#     assert backend == 'asyncio'
+#
+#     assert trai.current_loop.get() is None
+#
+#     await anyio.sleep(.1)

omlish/testing/pytest/plugins/asyncs/backends/__init__.py

@@ -0,0 +1,17 @@
+import typing as _ta
+
+
+from .asyncio import AsyncioAsyncsBackend  # noqa
+from .base import AsyncsBackend  # noqa
+from .trio import TrioAsyncsBackend  # noqa
+from .trio_asyncio import TrioAsyncioAsyncsBackend  # noqa
+
+
+##
+
+
+ASYNC_BACKENDS: _ta.Collection[type[AsyncsBackend]] = [
+    AsyncioAsyncsBackend,
+    TrioAsyncioAsyncsBackend,
+    TrioAsyncsBackend,
+]

omlish/testing/pytest/plugins/asyncs/backends/asyncio.py

@@ -1,4 +1,5 @@
 import functools
+import sys
 import typing as ta
 
 from ...... import check
@@ -13,6 +14,16 @@
 
 
 class AsyncioAsyncsBackend(AsyncsBackend):
+    name = 'asyncio'
+
+    def is_available(self) -> bool:
+        return True
+
+    def is_imported(self) -> bool:
+        return 'asyncio' in sys.modules
+
+    #
+
     def wrap_runner(self, fn):
         @functools.wraps(fn)
         def wrapper(**kwargs):
@@ -22,6 +33,3 @@ def wrapper(**kwargs):
                 return runner.run(fn(**kwargs))
 
         return wrapper
-
-    async def install_context(self, contextvars_ctx):
-        pass

omlish/testing/pytest/plugins/asyncs/backends/base.py

@@ -2,6 +2,21 @@
 
 
 class AsyncsBackend(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def name(self) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def is_available(self) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def is_imported(self) -> bool:
+        raise NotImplementedError
+
+    #
+
     @abc.abstractmethod
     def wrap_runner(self, fn):
         raise NotImplementedError

omlish/testing/pytest/plugins/asyncs/backends/trio.py

@@ -17,6 +17,7 @@
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 import functools
+import sys
 import typing as ta
 
 import pytest
@@ -33,58 +34,58 @@
     trio = lang.proxy_import('trio', extras=['abc'])
 
 
-##
-
-
-def trio_test(fn):
-    @functools.wraps(fn)
-    def wrapper(**kwargs):
-        __tracebackhide__ = True
-
-        clocks = {k: c for k, c in kwargs.items() if isinstance(c, trio.abc.Clock)}
-        if not clocks:
-            clock = None
-        elif len(clocks) == 1:
-            clock = list(clocks.values())[0]  # noqa
-        else:
-            raise ValueError(f'Expected at most one Clock in kwargs, got {clocks!r}')
-
-        instruments = [i for i in kwargs.values() if isinstance(i, trio.abc.Instrument)]
-
-        try:
-            return trio.run(
-                functools.partial(fn, **kwargs),
-                clock=clock,
-                instruments=instruments,
-            )
-
-        except BaseExceptionGroup as eg:
-            queue: list[BaseException] = [eg]
-            leaves = []
-
-            while queue:
-                ex = queue.pop()
-                if isinstance(ex, BaseExceptionGroup):
-                    queue.extend(ex.exceptions)
-                else:
-                    leaves.append(ex)
-
-            if len(leaves) == 1:
-                if isinstance(leaves[0], XFailed):
-                    pytest.xfail()
-                if isinstance(leaves[0], Skipped):
-                    pytest.skip()
-
-            # Since our leaf exceptions don't consist of exactly one 'magic' skipped or xfailed exception, re-raise the
-            # whole group.
-            raise
-
-    return wrapper
+class TrioAsyncsBackend(AsyncsBackend):
+    name = 'trio'
 
+    def is_available(self) -> bool:
+        return lang.can_import('trio')
 
-##
+    def is_imported(self) -> bool:
+        return 'trio' in sys.modules
 
+    #
 
-class TrioAsyncsBackend(AsyncsBackend):
     def wrap_runner(self, fn):
-        return trio_test(fn)
+        @functools.wraps(fn)
+        def wrapper(**kwargs):
+            __tracebackhide__ = True
+
+            clocks = {k: c for k, c in kwargs.items() if isinstance(c, trio.abc.Clock)}
+            if not clocks:
+                clock = None
+            elif len(clocks) == 1:
+                clock = list(clocks.values())[0]  # noqa
+            else:
+                raise ValueError(f'Expected at most one Clock in kwargs, got {clocks!r}')
+
+            instruments = [i for i in kwargs.values() if isinstance(i, trio.abc.Instrument)]
+
+            try:
+                return trio.run(
+                    functools.partial(fn, **kwargs),
+                    clock=clock,
+                    instruments=instruments,
+                )
+
+            except BaseExceptionGroup as eg:
+                queue: list[BaseException] = [eg]
+                leaves = []
+
+                while queue:
+                    ex = queue.pop()
+                    if isinstance(ex, BaseExceptionGroup):
+                        queue.extend(ex.exceptions)
+                    else:
+                        leaves.append(ex)
+
+                if len(leaves) == 1:
+                    if isinstance(leaves[0], XFailed):
+                        pytest.xfail()
+                    if isinstance(leaves[0], Skipped):
+                        pytest.skip()
+
+                # Since our leaf exceptions don't consist of exactly one 'magic' skipped or xfailed exception, re-raise
+                # the whole group.
+                raise
+
+        return wrapper

omlish/testing/pytest/plugins/asyncs/backends/trio_asyncio.py

@@ -17,6 +17,7 @@
 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 import functools
+import sys
 import typing as ta
 
 from _pytest.outcomes import Skipped  # noqa
@@ -33,10 +34,17 @@
     trio_asyncio = lang.proxy_import('trio_asyncio')
 
 
-##
+class TrioAsyncioAsyncsBackend(AsyncsBackend):
+    name = 'trio_asyncio'
 
+    def is_available(self) -> bool:
+        return lang.can_import('trio_asyncio')
+
+    def is_imported(self) -> bool:
+        return 'trio_asyncio' in sys.modules
+
+    #
 
-class TrioAsyncioAsyncsBackend(AsyncsBackend):
     def wrap_runner(self, fn):
         @functools.wraps(fn)
         def wrapper(**kwargs):

omlish/testing/pytest/plugins/asyncs/consts.py

@@ -1,9 +1,3 @@
 ASYNCS_MARK = 'asyncs'
 
-KNOWN_BACKENDS = (
-    'asyncio',
-    'trio',
-    'trio_asyncio',
-)
-
 PARAM_NAME = '__async_backend'

omlish/testing/pytest/plugins/asyncs/plugin.py

@@ -12,15 +12,13 @@
 from _pytest.outcomes import Skipped  # noqa
 from _pytest.outcomes import XFailed  # noqa
 
+from ..... import check
 from ..... import lang
 from .....diag import pydevd as pdu
 from .._registry import register
-from .backends.asyncio import AsyncioAsyncsBackend
-from .backends.base import AsyncsBackend
-from .backends.trio import TrioAsyncsBackend
-from .backends.trio_asyncio import TrioAsyncioAsyncsBackend
+from .backends import ASYNC_BACKENDS
+from .backends import AsyncsBackend
 from .consts import ASYNCS_MARK
-from .consts import KNOWN_BACKENDS
 from .consts import PARAM_NAME
 from .fixtures import CANARY
 from .fixtures import AsyncsFixture
@@ -41,9 +39,21 @@
 
 @register
 class AsyncsPlugin:
-    ASYNC_BACKENDS: ta.ClassVar[ta.Sequence[str]] = [
-        *[s for s in KNOWN_BACKENDS if lang.can_import(s)],
-    ]
+    def __init__(self, backends: ta.Collection[type[AsyncsBackend]] | None = None) -> None:
+        super().__init__()
+
+        if backends is None:
+            backends = ASYNC_BACKENDS
+
+        bd: dict[str, AsyncsBackend] = {}
+        for bc in backends:
+            be = bc()
+            if not be.is_available():
+                continue
+            bn = be.name
+            check.not_in(bn, bd)
+            bd[bn] = be
+        self._backends = bd
 
     def pytest_cmdline_main(self, config):
         if (aio_plugin := sys.modules.get('pytest_asyncio.plugin')):
@@ -67,7 +77,7 @@ def pytest_generate_tests(self, metafunc):
             if m.args:
                 bes = m.args
             else:
-                bes = self.ASYNC_BACKENDS
+                bes = list(self._backends)
         else:
             return
 
@@ -120,45 +130,13 @@ def pytest_runtest_call(self, item):
             yield
             return
 
-        be = item.callspec.params[PARAM_NAME]
+        bn = item.callspec.params[PARAM_NAME]
+        be = self._backends[bn]
 
-        beo: AsyncsBackend
-        if be == 'asyncio':
-            beo = AsyncioAsyncsBackend()
-        elif be == 'trio':
-            beo = TrioAsyncsBackend()
-        elif be == 'trio_asyncio':
-            beo = TrioAsyncioAsyncsBackend()
-        else:
-            raise ValueError(be)
-
-        item.obj = self.test_runner_factory(beo, item)
+        item.obj = self.test_runner_factory(be, item)
 
         yield
 
-        # bes = [be for be in self.ASYNC_BACKENDS if item.get_closest_marker(be) is not None]
-        # if len(bes) > 1 and set(bes) != {'trio', 'trio_asyncio'}:
-        #     raise Exception(f'{item.nodeid}: multiple async backends specified: {bes}')
-        # elif is_async_function(item.obj) and not bes:
-        #     from _pytest.unittest import UnitTestCase  # noqa
-        #     if isinstance(item.parent, UnitTestCase):
-        #         # unittest handles these itself.
-        #         pass
-        #     else:
-        #         raise Exception(f'{item.nodeid}: async def function and no async plugin specified')
-        #
-        # if 'trio_asyncio' in bes:
-        #     obj = item.obj
-        #
-        #     @functools.wraps(obj)
-        #     @trai.with_trio_asyncio_loop(wait=True)
-        #     async def run(*args, **kwargs):
-        #         await trio_asyncio.aio_as_trio(obj)(*args, **kwargs)
-        #
-        #     item.obj = run
-        #
-        # yield
-
     def test_runner_factory(self, backend: AsyncsBackend, item, testfunc=None):
         if not testfunc:
             testfunc = item.obj