omlish 0.0.0.dev194__py3-none-any.whl → 0.0.0.dev196__py3-none-any.whl

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

@@ -0,0 +1,89 @@
+# Based on pytest-trio, licensed under the MIT license, duplicated below.
+#
+#  https://github.com/python-trio/pytest-trio/tree/cd6cc14b061d34f35980e38c44052108ed5402d1
+#
+# The MIT License (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# 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
+from _pytest.outcomes import XFailed  # noqa
+
+from ...... import cached
+from ...... import lang
+from ......diag import pydevd as pdu
+from .base import AsyncsBackend
+
+
+if ta.TYPE_CHECKING:
+    import trio_asyncio
+else:
+    trio = lang.proxy_import('trio', extras=['abc'])
+    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
+
+    #
+
+    @cached.function
+    def _prepare(self) -> None:
+        # NOTE: Importing it here is apparently necessary to get its patching working - otherwise fails later with
+        # `no running event loop` in anyio._backends._asyncio and such.
+        import trio_asyncio  # noqa
+
+        if pdu.is_present():
+            pdu.patch_for_trio_asyncio()
+
+    def prepare_for_metafunc(self, metafunc) -> None:
+        self._prepare()
+
+    #
+
+    def wrap_runner(self, fn):
+        @functools.wraps(fn)
+        def wrapper(**kwargs):
+            return trio_asyncio.run(
+                trio_asyncio.aio_as_trio(
+                    functools.partial(fn, **kwargs),
+                ),
+            )
+
+        return wrapper
+
+    async def install_context(self, contextvars_ctx):
+        # Seemingly no longer necessary?
+        # https://github.com/python-trio/pytest-trio/commit/ef0cd267ea62188a8e475c66cb584e7a2addc02a
+
+        # # This is a gross hack. I guess Trio should provide a context= argument to start_soon/start?
+        # task = trio.lowlevel.current_task()
+        # if CANARY in task.context:
+        #     return
+
+        # task.context = contextvars_ctx
+
+        # # Force a yield so we pick up the new context
+        # await trio.sleep(0)
+
+        pass

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

@@ -0,0 +1,3 @@
+ASYNCS_MARK = 'asyncs'
+
+PARAM_NAME = '__async_backend'

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

@@ -0,0 +1,273 @@
+# Based on pytest-trio, licensed under the MIT license, duplicated below.
+#
+#  https://github.com/python-trio/pytest-trio/tree/cd6cc14b061d34f35980e38c44052108ed5402d1
+#
+# The MIT License (MIT)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# 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 collections.abc
+import contextlib
+import contextvars
+import inspect
+import typing as ta
+
+from _pytest.outcomes import Skipped  # noqa
+from _pytest.outcomes import XFailed  # noqa
+
+from ..... import check
+from ..... import lang
+from ..... import outcome
+from .backends.base import AsyncsBackend
+from .utils import is_coroutine_function
+
+
+if ta.TYPE_CHECKING:
+    import anyio.abc
+else:
+    anyio = lang.proxy_import('anyio', extras=['abc'])
+
+
+##
+
+
+CANARY: contextvars.ContextVar[ta.Any] = contextvars.ContextVar('pytest-omlish-asyncs canary')
+
+
+class NURSERY_FIXTURE_PLACEHOLDER:  # noqa
+    pass
+
+
+##
+
+
+class AsyncsTestContext:
+    def __init__(self, backend: AsyncsBackend) -> None:
+        super().__init__()
+
+        self.backend = backend
+
+        self.crashed = False
+
+        # This holds cancel scopes for whatever setup steps are currently running -- initially it's the fixtures that
+        # are in the middle of evaluating themselves, and then once fixtures are set up it's the test itself. Basically,
+        # at any given moment, it's the stuff we need to cancel if we want to start tearing down our fixture DAG.
+        self.active_cancel_scopes: set[anyio.CancelScope] = set()
+
+        self.fixtures_with_errors: set[AsyncsFixture] = set()
+        self.fixtures_with_cancel: set[AsyncsFixture] = set()
+
+        self.error_list: list[BaseException] = []
+
+    def crash(self, fixture: 'AsyncsFixture', exc: BaseException | None) -> None:
+        if exc is None:
+            self.fixtures_with_cancel.add(fixture)
+        else:
+            self.error_list.append(exc)
+            self.fixtures_with_errors.add(fixture)
+
+        self.crashed = True
+
+        for cscope in self.active_cancel_scopes:
+            cscope.cancel()
+
+
+##
+
+
+class AsyncsFixture:
+    """
+    Represent a fixture that need to be run in a async context to be resolved.
+
+    The name is actually a misnomer, because we use it to represent the actual test itself as well, since the
+    test is basically just a fixture with no dependents and no teardown.
+    """
+
+    def __init__(
+            self,
+            name: str,
+            func: ta.Callable,
+            pytest_kwargs: ta.Mapping[str, ta.Any],
+            *,
+            is_test: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self.name = name
+        self._func = func
+        self._pytest_kwargs = pytest_kwargs
+        self._is_test = is_test
+        self._teardown_done = anyio.Event()
+
+        # These attrs are all accessed from other objects: Downstream users read this value.
+        self.fixture_value: ta.Any = None
+
+        # This event notifies downstream users that we're done setting up. Invariant: if this is set, then either
+        # fixture_value is usable *or* test_ctx.crashed is True.
+        self.setup_done = anyio.Event()
+
+        # Downstream users *modify* this value, by adding their _teardown_done events to it, so we know who we need to
+        # wait for before tearing down.
+        self.user_done_events: set[anyio.Event] = set()
+
+    def register_and_collect_dependencies(self) -> set['AsyncsFixture']:
+        # Returns the set of all AsyncsFixtures that this fixture depends on, directly or indirectly, and sets up all
+        # their user_done_events.
+        deps = set()
+        deps.add(self)
+        for value in self._pytest_kwargs.values():
+            if isinstance(value, AsyncsFixture):
+                value.user_done_events.add(self._teardown_done)
+                deps.update(value.register_and_collect_dependencies())
+        return deps
+
+    @contextlib.asynccontextmanager
+    async def _fixture_manager(self, test_ctx: AsyncsTestContext) -> ta.AsyncIterator['anyio.abc.TaskGroup']:
+        __tracebackhide__ = True
+
+        try:
+            async with anyio.create_task_group() as nursery_fixture:
+                try:
+                    yield nursery_fixture
+                finally:
+                    nursery_fixture.cancel_scope.cancel()
+
+        except BaseException as exc:  # noqa
+            test_ctx.crash(self, exc)
+
+        finally:
+            self.setup_done.set()
+            self._teardown_done.set()
+
+    async def run(
+            self,
+            test_ctx: AsyncsTestContext,
+            contextvars_ctx: contextvars.Context,
+    ) -> None:
+        __tracebackhide__ = True
+
+        await test_ctx.backend.install_context(contextvars_ctx)
+
+        # Check that it worked, since technically trio doesn't *guarantee* that sleep(0) will actually yield.
+        check.equal(CANARY.get(), 'in correct context')
+
+        # This 'with' block handles the nursery fixture lifetime, the teardown_done event, and crashing the context if
+        # there's an unhandled exception.
+        async with self._fixture_manager(test_ctx) as nursery_fixture:
+            # Resolve our kwargs
+            resolved_kwargs: dict = {}
+            for name, value in self._pytest_kwargs.items():
+                if isinstance(value, AsyncsFixture):
+                    await value.setup_done.wait()
+                    if value.fixture_value is NURSERY_FIXTURE_PLACEHOLDER:
+                        resolved_kwargs[name] = nursery_fixture
+                    else:
+                        resolved_kwargs[name] = value.fixture_value
+                else:
+                    resolved_kwargs[name] = value
+
+            # If something's already crashed before we're ready to start, then there's no point in even setting up.
+            if test_ctx.crashed:
+                return
+
+            # Run actual fixture setup step. If another fixture crashes while we're in the middle of setting up, we want
+            # to be cancelled immediately, so we'll save an encompassing cancel scope where self._crash can find it.
+            test_ctx.active_cancel_scopes.add(nursery_fixture.cancel_scope)
+            if self._is_test:
+                # Tests are exactly like fixtures, except that they to be
+                # regular async functions.
+                check.state(not self.user_done_events)
+                func_value = None
+                check.state(not test_ctx.crashed)
+                await self._func(**resolved_kwargs)
+
+            else:
+                func_value = self._func(**resolved_kwargs)
+                if isinstance(func_value, collections.abc.Coroutine):
+                    self.fixture_value = await func_value
+                elif inspect.isasyncgen(func_value):
+                    self.fixture_value = await func_value.asend(None)
+                elif isinstance(func_value, collections.abc.Generator):
+                    self.fixture_value = func_value.send(None)
+                else:
+                    # Regular synchronous function
+                    self.fixture_value = func_value
+
+            # Now that we're done setting up, we don't want crashes to cancel us immediately; instead we want them to
+            # cancel our downstream dependents, and then eventually let us clean up normally. So remove this from the
+            # set of cancel scopes affected by self._crash.
+            test_ctx.active_cancel_scopes.remove(nursery_fixture.cancel_scope)
+
+            # self.fixture_value is ready, so notify users that they can continue. (Or, maybe we crashed and were
+            # cancelled, in which case our users will check test_ctx.crashed and immediately exit, which is fine too.)
+            self.setup_done.set()
+
+            # Wait for users to be finished.
+            #
+            # At this point we're in a very strange state: if the fixture yielded inside a nursery or cancel scope, then
+            # we are still "inside" that scope even though its with block is not on the stack. In particular this means
+            # that if they get cancelled, then our waiting might get a Cancelled error, that we cannot really deal with
+            # - it should get thrown back into the fixture generator, but pytest fixture generators don't work that way:
+            #   https://github.com/python-trio/pytest-trio/issues/55
+            # And besides, we can't start tearing down until all our users have finished.
+            #
+            # So if we get an exception here, we crash the context (which cancels the test and starts the cleanup
+            # process), save any exception that *isn't* Cancelled (because if its Cancelled then we can't route it to
+            # the right place, and anyway the teardown code will get it again if it matters), and then use a shield to
+            # keep waiting for the teardown to finish without having to worry about cancellation.
+            yield_outcome: outcome.Outcome = outcome.Value(None)
+            try:
+                for event in self.user_done_events:
+                    await event.wait()
+
+            except BaseException as exc:  # noqa
+                check.isinstance(exc, anyio.get_cancelled_exc_class())
+                yield_outcome = outcome.Error(exc)
+                test_ctx.crash(self, None)
+                with anyio.CancelScope(shield=True):
+                    for event in self.user_done_events:
+                        await event.wait()
+
+            # Do our teardown
+            if inspect.isasyncgen(func_value):
+                try:
+                    await yield_outcome.asend(func_value)
+                except StopAsyncIteration:
+                    pass
+                else:
+                    raise RuntimeError('too many yields in fixture')
+
+            elif isinstance(func_value, collections.abc.Generator):
+                try:
+                    yield_outcome.send(func_value)
+                except StopIteration:
+                    pass
+                else:
+                    raise RuntimeError('too many yields in fixture')
+
+
+##
+
+
+def is_asyncs_fixture(
+        func: ta.Callable,
+        coerce_async: bool,
+        kwargs: ta.Mapping[str, ta.Any],
+) -> bool:
+    if coerce_async and (is_coroutine_function(func) or inspect.isasyncgenfunction(func)):
+        return True
+
+    if any(isinstance(value, AsyncsFixture) for value in kwargs.values()):
+        return True
+
+    return False

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

@@ -0,0 +1,182 @@
+"""
+TODO:
+ - auto drain_asyncio
+"""
+import contextvars
+import functools
+import sys
+import typing as ta
+import warnings
+
+import pytest
+from _pytest.outcomes import Skipped  # noqa
+from _pytest.outcomes import XFailed  # noqa
+
+from ..... import check
+from ..... import lang
+from .._registry import register
+from .backends import ASYNC_BACKENDS
+from .backends import AsyncsBackend
+from .consts import ASYNCS_MARK
+from .consts import PARAM_NAME
+from .fixtures import CANARY
+from .fixtures import AsyncsFixture
+from .fixtures import AsyncsTestContext
+from .fixtures import is_asyncs_fixture
+from .utils import is_async_function
+from .utils import is_coroutine_function
+
+
+if ta.TYPE_CHECKING:
+    import anyio
+else:
+    anyio = lang.proxy_import('anyio')
+
+
+##
+
+
+@register
+class AsyncsPlugin:
+    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')):
+            # warnings.filterwarnings is clobbered by pytest using warnings.catch_warnings
+            def aio_plugin_warn(message, *args, **kwargs):
+                if (
+                        isinstance(message, pytest.PytestDeprecationWarning) and
+                        message.args[0].startswith('The configuration option "asyncio_default_fixture_loop_scope" is unset.')  # noqa
+                ):
+                    return
+                warnings.warn(message, *args, **kwargs)
+
+            aio_plugin.warnings = lang.proxy_import('warnings')  # type: ignore
+            aio_plugin.warnings.warn = aio_plugin_warn  # type: ignore
+
+    def pytest_configure(self, config):
+        config.addinivalue_line('markers', f'{ASYNCS_MARK}: marks for all async backends')
+
+    def pytest_generate_tests(self, metafunc):
+        if (m := metafunc.definition.get_closest_marker(ASYNCS_MARK)) is not None:
+            if m.args:
+                bns = m.args
+            else:
+                bns = list(self._backends)
+        else:
+            return
+
+        for bn in bns:
+            be = self._backends[bn]
+            be.prepare_for_metafunc(metafunc)
+
+        metafunc.fixturenames.append(PARAM_NAME)
+        metafunc.parametrize(PARAM_NAME, bns)
+
+    def pytest_fixture_setup(self, fixturedef, request):
+        is_asyncs_test = request.node.get_closest_marker(ASYNCS_MARK) is not None
+
+        kwargs = {name: request.getfixturevalue(name) for name in fixturedef.argnames}
+
+        if not is_asyncs_fixture(fixturedef.func, is_asyncs_test, kwargs):
+            return None
+
+        if request.scope != 'function':
+            raise RuntimeError('Asyncs fixtures must be function-scope')
+
+        if not is_asyncs_test:
+            raise RuntimeError('Asyncs fixtures can only be used by Asyncs tests')
+
+        fixture = AsyncsFixture(
+            '<fixture {!r}>'.format(fixturedef.argname),  # noqa
+            fixturedef.func,
+            kwargs,
+        )
+
+        fixturedef.cached_result = (fixture, request.param_index, None)
+
+        return fixture
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_call(self, item):
+        if (m := item.get_closest_marker(ASYNCS_MARK)) is None:  # noqa
+            if is_async_function(item.obj):
+                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')
+
+            yield
+            return
+
+        bn = item.callspec.params[PARAM_NAME]
+        be = self._backends[bn]
+
+        item.obj = self.test_runner_factory(be, item)
+
+        yield
+
+    def test_runner_factory(self, backend: AsyncsBackend, item, testfunc=None):
+        if not testfunc:
+            testfunc = item.obj
+
+        if not is_coroutine_function(testfunc):
+            pytest.fail(f'test function `{item!r}` is marked asyncs but is not async')
+
+        @backend.wrap_runner
+        async def _bootstrap_fixtures_and_run_test(**kwargs):
+            __tracebackhide__ = True
+
+            test_ctx = AsyncsTestContext(backend)
+            test = AsyncsFixture(
+                '<test {!r}>'.format(testfunc.__name__),  # noqa
+                testfunc,
+                kwargs,
+                is_test=True,
+            )
+
+            contextvars_ctx = contextvars.copy_context()
+            contextvars_ctx.run(CANARY.set, 'in correct context')
+
+            async with anyio.create_task_group() as nursery:
+                for fixture in test.register_and_collect_dependencies():
+                    contextvars_ctx.run(
+                        functools.partial(
+                            nursery.start_soon,
+                            fixture.run,
+                            test_ctx,
+                            contextvars_ctx,
+                            name=fixture.name,
+                        ),
+                    )
+
+            silent_cancellers = test_ctx.fixtures_with_cancel - test_ctx.fixtures_with_errors
+
+            if silent_cancellers:
+                for fixture in silent_cancellers:
+                    test_ctx.error_list.append(
+                        RuntimeError(f"{fixture.name} cancelled the test but didn't raise an error"),
+                    )
+
+            if len(test_ctx.error_list) == 1:
+                raise test_ctx.error_list[0]
+            elif test_ctx.error_list:
+                raise BaseExceptionGroup('errors in async test and async fixtures', test_ctx.error_list)
+
+        return _bootstrap_fixtures_and_run_test

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

@@ -0,0 +1,10 @@
+import inspect
+import typing as ta
+
+
+def is_coroutine_function(func: ta.Any) -> bool:
+    return inspect.iscoroutinefunction(func) or getattr(func, '_is_coroutine', False)
+
+
+def is_async_function(func: ta.Any) -> bool:
+    return is_coroutine_function(func) or inspect.isasyncgenfunction(func)

omlish/text/indent.py

@@ -4,7 +4,7 @@ import contextlib
 import io
 import typing as ta
 
-from omlish.lite.check import check
+from ..lite.check import check
 
 
 class IndentWriter:

omlish/text/minja.py

@@ -9,8 +9,8 @@ import io
 import re
 import typing as ta
 
-from omlish.lite.cached import cached_nullary
-from omlish.lite.check import check
+from ..lite.cached import cached_nullary
+from ..lite.check import check
 
 
 ##

{omlish-0.0.0.dev194.dist-info → omlish-0.0.0.dev196.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev194
+Version: 0.0.0.dev196
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -13,7 +13,7 @@ Classifier: Operating System :: POSIX
 Requires-Python: >=3.12
 License-File: LICENSE
 Provides-Extra: all
-Requires-Dist: anyio~=4.7; extra == "all"
+Requires-Dist: anyio~=4.8; extra == "all"
 Requires-Dist: sniffio~=1.3; extra == "all"
 Requires-Dist: greenlet~=3.1; extra == "all"
 Requires-Dist: trio~=0.27; extra == "all"
@@ -44,7 +44,7 @@ Requires-Dist: apsw~=3.47; extra == "all"
 Requires-Dist: sqlean.py~=3.45; extra == "all"
 Requires-Dist: duckdb~=1.1; extra == "all"
 Requires-Dist: pytest~=8.0; extra == "all"
-Requires-Dist: anyio~=4.7; extra == "all"
+Requires-Dist: anyio~=4.8; extra == "all"
 Requires-Dist: sniffio~=1.3; extra == "all"
 Requires-Dist: asttokens~=3.0; extra == "all"
 Requires-Dist: executing~=2.1; extra == "all"
@@ -52,7 +52,7 @@ Requires-Dist: orjson~=3.10; extra == "all"
 Requires-Dist: pyyaml~=6.0; extra == "all"
 Requires-Dist: wrapt~=1.14; extra == "all"
 Provides-Extra: async
-Requires-Dist: anyio~=4.7; extra == "async"
+Requires-Dist: anyio~=4.8; extra == "async"
 Requires-Dist: sniffio~=1.3; extra == "async"
 Requires-Dist: greenlet~=3.1; extra == "async"
 Requires-Dist: trio~=0.27; extra == "async"
@@ -93,7 +93,7 @@ Requires-Dist: duckdb~=1.1; extra == "sqldrivers"
 Provides-Extra: testing
 Requires-Dist: pytest~=8.0; extra == "testing"
 Provides-Extra: plus
-Requires-Dist: anyio~=4.7; extra == "plus"
+Requires-Dist: anyio~=4.8; extra == "plus"
 Requires-Dist: sniffio~=1.3; extra == "plus"
 Requires-Dist: asttokens~=3.0; extra == "plus"
 Requires-Dist: executing~=2.1; extra == "plus"