pytest-asyncio-concurrent-fork 0.5.2__py3-none-any.whl

pytest_asyncio_concurrent/__init__.py

@@ -0,0 +1,7 @@
+"""The main point for importing pytest-asyncio-concurrent items."""
+
+from .plugin import AsyncioConcurrentGroup
+
+__all__ = [
+    AsyncioConcurrentGroup.__name__,
+]

pytest_asyncio_concurrent/fixture_async.py

@@ -0,0 +1,139 @@
+import copy
+import inspect
+import asyncio
+import functools
+
+from typing import Any, Dict, Optional, Sequence
+import warnings
+
+import pytest
+from _pytest import fixtures
+from _pytest import nodes
+
+event_loop_key = pytest.StashKey[asyncio.AbstractEventLoop]()
+
+
+@pytest.hookimpl(specname="pytest_fixture_setup", tryfirst=True)
+def pytest_fixture_setup_wrap_async(
+    fixturedef: pytest.FixtureDef, request: pytest.FixtureRequest
+) -> None:
+    """Wraps the fixture function of an async fixture in a synchronous function."""
+    event_loop = request.config.stash[event_loop_key]
+    if inspect.isasyncgenfunction(fixturedef.func):
+        _wrap_asyncgen_fixture(fixturedef, event_loop)
+    elif inspect.iscoroutinefunction(fixturedef.func):
+        _wrap_asyncfunc_fixture(fixturedef, event_loop)
+
+
+def _wrap_asyncgen_fixture(fixturedef: pytest.FixtureDef, event_loop) -> None:
+    fixtureFunc = fixturedef.func
+
+    @functools.wraps(fixtureFunc)
+    def _asyncgen_fixture_wrapper(**kwargs: Any):
+        gen_obj = fixtureFunc(**kwargs)
+
+        async def setup():
+            res = await gen_obj.__anext__()  # type: ignore[union-attr]
+            return res
+
+        async def teardown() -> None:
+            try:
+                await gen_obj.__anext__()  # type: ignore[union-attr]
+            except StopAsyncIteration:
+                pass
+            else:
+                msg = "Async generator fixture didn't stop."
+                msg += "Yield only once."
+                raise ValueError(msg)
+
+        result = event_loop.run_until_complete(setup())
+        yield result
+        event_loop.run_until_complete(teardown())
+
+    fixturedef.func = _asyncgen_fixture_wrapper  # type: ignore[misc]
+
+
+def _wrap_asyncfunc_fixture(fixturedef: pytest.FixtureDef, event_loop) -> None:
+    fixtureFunc = fixturedef.func
+
+    @functools.wraps(fixtureFunc)
+    def _async_fixture_wrapper(**kwargs: Dict[str, Any]):
+        async def setup():
+            res = await fixtureFunc(**kwargs)
+            return res
+
+        return event_loop.run_until_complete(setup())
+
+    fixturedef.func = _async_fixture_wrapper  # type: ignore[misc]
+
+
+fixture_cache_key = pytest.StashKey[Dict[str, Optional[Sequence[pytest.FixtureDef[Any]]]]]()
+
+
+@pytest.hookimpl(specname="pytest_sessionstart", trylast=True)
+def pytest_sessionstart_cache_fixture(session: pytest.Session):
+    event_loop = session.config.stash[event_loop_key] = asyncio.new_event_loop()
+    session.config.add_cleanup(event_loop.close)
+    # This function in general utilized some private properties.
+
+    # This is to solve two problem:
+    # 1. Funtion scoped fixture result value got shared in different tests in same group.
+    # 2. And fixture teardown got registered under right test using it.
+
+    # FixtureDef for each fixture is unique and held in FixtureManger and got injected into
+    # pytest.Item when the Item is constructed, and FixtureDef class is also in charge of
+    # holding finalizers and cache value.
+
+    # Fixture value caching is highly coupled with pytest entire lifecycle, implementing a
+    # thirdparty fixture cache manager will be hard.
+    # The first problem can be solved by shallow copy the fixtureDef, to split the cache_value.
+    # The finalizers are stored in a private list property in fixtureDef, which need to touch
+    # private API anyway.
+
+    # If the private API change, finalizer errors from this fixture but in different
+    # tests in same group will be reported in one function.
+
+    fixManager: fixtures.FixtureManager = session.config.pluginmanager.get_plugin(
+        "funcmanage"
+    )  # type: ignore
+    getfixturedefs_original = fixManager.getfixturedefs
+
+    @functools.wraps(getfixturedefs_original)
+    def getfixturedefs_wrapper(
+        argname: str,
+        node: nodes.Node,
+    ) -> Optional[Sequence[pytest.FixtureDef[Any]]]:
+        if fixture_cache_key not in node.stash:
+            node.stash[fixture_cache_key] = {}
+
+        cache = node.stash[fixture_cache_key]
+        if argname not in cache:
+            fixtureDefs = getfixturedefs_original(argname, node)
+
+            if fixtureDefs:
+                fixtureDefs = tuple(_clone_function_fixture(fixDef) for fixDef in fixtureDefs)
+
+            cache[argname] = fixtureDefs
+
+        return cache[argname]
+
+    fixManager.getfixturedefs = getfixturedefs_wrapper  # type: ignore
+
+
+def _clone_function_fixture(fixtureDef: pytest.FixtureDef) -> pytest.FixtureDef:
+    if fixtureDef.scope != "function":
+        return fixtureDef
+
+    new_fixdef = copy.copy(fixtureDef)
+    if hasattr(fixtureDef, "_finalizers"):
+        new_fixdef._finalizers = []  # type: ignore
+    else:
+        warnings.warn(
+            f"""
+            pytest {pytest.__version__} changed internal property which this plugin relies on.
+            The teardown error in fixture {fixtureDef.argname} might be reported in wrong place.
+            Please raise an issue.
+            """
+        )
+
+    return new_fixdef

pytest_asyncio_concurrent/grouping.py

@@ -0,0 +1,152 @@
+import copy
+import sys
+import dataclasses
+from typing import Any, Callable, Dict, List
+
+import pytest
+from _pytest import fixtures
+from _pytest import outcomes
+
+
+if sys.version_info < (3, 11):
+    from exceptiongroup import BaseExceptionGroup
+
+
+class PytestAsyncioConcurrentGroupingWarning(pytest.PytestWarning):
+    """Raised when Test from different parent grouped into same group."""
+
+
+class PytestAsyncioConcurrentInvalidMarkWarning(pytest.PytestWarning):
+    """Raised when Sync Test got marked."""
+
+
+class PytestAysncioGroupInvokeError(BaseException):
+    """Raised when AsyncioGroup got invoked"""
+
+
+class AsyncioConcurrentGroup(pytest.Function):
+    """
+    The Function Group containing underneath children functions.
+    AsyncioConcurrentGroup will be pushed onto `SetupState` representing all children.
+    and in charging of holding and tearing down the finalizers from all children nodes.
+    """
+
+    children: List["AsyncioConcurrentGroupMember"]
+    children_have_same_parent: bool
+    children_finalizer: Dict["AsyncioConcurrentGroupMember", List[Callable[[], Any]]]
+    has_setup: bool
+
+    def __init__(
+        self,
+        parent,
+        originalname: str,
+    ):
+        self.children_have_same_parent = True
+        self.has_setup = False
+        self.children = []
+        self.children_finalizer = {}
+        super().__init__(
+            name=originalname,
+            parent=parent,
+            callobj=lambda: None,
+        )
+
+    def runtest(self) -> None:
+        raise PytestAysncioGroupInvokeError()
+
+    def setup(self) -> None:
+        pass
+
+    def add_child(self, item: "AsyncioConcurrentGroupMember") -> None:
+        child_parent = list(item.iter_parents())[1]
+
+        if child_parent is not self.parent:
+            self.children_have_same_parent = False
+            for child in self.children:
+                child.add_marker("skip")
+
+        if not self.children_have_same_parent:
+            item.add_marker("skip")
+
+        item.group = self
+        self.children.append(item)
+        self.children_finalizer[item] = []
+
+    def teardown_child(self, item: "AsyncioConcurrentGroupMember") -> None:
+        item.session._setupstate.stack.pop(item, None)
+        finalizers = self.children_finalizer.pop(item)
+        exceptions = []
+
+        while finalizers:
+            fin = finalizers.pop()
+            try:
+                fin()
+            except outcomes.TEST_OUTCOME as e:
+                exceptions.append(e)
+
+        if len(exceptions) == 1:
+            raise exceptions[0]
+        elif len(exceptions) > 1:
+            msg = f"errors while tearing down {item!r}"
+            raise BaseExceptionGroup(msg, exceptions[::-1])
+
+    def remove_child(self, item: "AsyncioConcurrentGroupMember") -> None:
+        assert item in self.children
+        self.children.remove(item)
+        self.children_finalizer.pop(item)
+
+
+class AsyncioConcurrentGroupMember(pytest.Function):
+    """
+    A light wrapper around Function, representing a child of AsyncioConcurrentGroup.
+    The group registers active members in SetupState and tears them down individually.
+    """
+
+    group: AsyncioConcurrentGroup
+    _inner: pytest.Function
+
+    @staticmethod
+    def promote_from_function(item: pytest.Function) -> "AsyncioConcurrentGroupMember":
+        AsyncioConcurrentGroupMember._refresh_function_scoped_fixture(item)
+        member = AsyncioConcurrentGroupMember.from_parent(
+            name=item.name,
+            parent=item.parent,
+            callspec=item.callspec if hasattr(item, "callspec") else None,
+            callobj=item.obj,
+            keywords=item.keywords,
+            fixtureinfo=item._fixtureinfo,
+            originalname=item.originalname,
+        )
+
+        member._inner = item
+        return member
+
+    @staticmethod
+    def _refresh_function_scoped_fixture(item: pytest.Function):
+        # Parametrized tests will use their meta func to gather fixture information
+        # on collection, which means they all share same fixture infomation.
+        # Have to refresh fixtureDef here to get their own their own fixtureDef
+
+        if not hasattr(item, "callspec"):
+            return
+
+        fixtureManager: fixtures.FixtureManager = item.config.pluginmanager.get_plugin(
+            "funcmanage"
+        )  # type: ignore
+
+        new_name2fixturedefs = {}
+        for name in item._fixtureinfo.name2fixturedefs.keys():
+            if name in item.callspec.params.keys():
+                new_name2fixturedefs[name] = item._fixtureinfo.name2fixturedefs[name]
+            else:
+                new_name2fixturedefs[name] = fixtureManager.getfixturedefs(
+                    name, item
+                )  # type: ignore
+
+        try:
+            item._fixtureinfo = dataclasses.replace(
+                item._fixtureinfo, name2fixturedefs=new_name2fixturedefs
+            )
+        except TypeError:  # if item._fixtureinfo no longer a dataclass
+            item._fixtureinfo = copy.copy(item._fixtureinfo)
+            item._fixtureinfo.name2fixturedefs = new_name2fixturedefs  # type: ignore

pytest_asyncio_concurrent/hooks.py

@@ -0,0 +1,40 @@
+import pytest
+from typing import Optional, Coroutine
+
+from .plugin import AsyncioConcurrentGroup
+
+
+@pytest.hookspec(firstresult=True)
+def pytest_runtest_protocol_async_group(
+    group: "AsyncioConcurrentGroup", nextgroup: Optional["AsyncioConcurrentGroup"]
+) -> object:
+    """
+    The pytest_runtest_protocol for async group.
+    """
+
+
+@pytest.hookspec(firstresult=True)
+def pytest_runtest_call_async(item: pytest.Item) -> Optional[Coroutine]:
+    """
+    The pytest_runtest_call for async function.
+    """
+
+
+@pytest.hookspec()
+def pytest_runtest_setup_async_group(item: "AsyncioConcurrentGroup") -> None:
+    """
+    The pytest_runtest_setup for async group.
+    Should be called before any of its children setup
+    Also work as a safe guard to prevent polluting pytest environment.
+    """
+
+
+@pytest.hookspec()
+def pytest_runtest_teardown_async_group(
+    item: "AsyncioConcurrentGroup", nextitem: "AsyncioConcurrentGroup"
+) -> None:
+    """
+    The pytest_runtest_teardown for async group.
+    Should be called after all children finished teardown.
+    Also work as a safe guard to prevent polluting pytest environment.
+    """

pytest_asyncio_concurrent/plugin.py

@@ -0,0 +1,534 @@
+import asyncio
+import bdb
+import functools
+import inspect
+import warnings
+import sys
+import contextlib
+
+from typing import (
+    Any,
+    Callable,
+    Generator,
+    List,
+    Literal,
+    Optional,
+    Coroutine,
+    Dict,
+    Sequence,
+    Union,
+    cast,
+)
+
+import pluggy
+import pytest
+from _pytest import timing
+from _pytest import outcomes
+from .fixture_async import event_loop_key
+
+from .grouping import (
+    AsyncioConcurrentGroup,
+    AsyncioConcurrentGroupMember,
+    PytestAsyncioConcurrentInvalidMarkWarning,
+    PytestAsyncioConcurrentGroupingWarning,
+)
+
+if sys.version_info < (3, 11):
+    from exceptiongroup import BaseExceptionGroup
+
+
+# =========================== # Config # =========================== #
+
+asyncio_concurrent_group_key = pytest.StashKey[Dict[str, AsyncioConcurrentGroup]]()
+GroupStrategy = Literal["self", "parent"]
+
+
+def pytest_addoption(parser: pytest.Parser):
+    parser.addoption(
+        "--default-group-strategy",
+        choices=["self", "parent"],
+        help="asyncio-concurrent: default grouping strategy, \
+            please refer to documentation for more info.",
+    )
+    parser.addini(
+        "default_group_strategy",
+        "asyncio: asyncio-concurrent: default grouping strategy, \
+            please refer to documentation for more info.",
+        default="self",
+    )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "asyncio_concurrent(group, timeout): " "mark the async tests to run concurrently",
+    )
+    config.stash[asyncio_concurrent_group_key] = {}
+
+
+@pytest.hookimpl
+def pytest_addhooks(pluginmanager: pytest.PytestPluginManager) -> None:
+    from . import hooks
+    from . import fixture_async
+
+    pluginmanager.add_hookspecs(hooks)
+    pluginmanager.register(fixture_async)
+
+
+# =========================== # Collection # =========================== #
+
+MakeItemResult = Union[
+    None, pytest.Item, pytest.Collector, List[Union[pytest.Item, pytest.Collector]]
+]
+
+
+@pytest.hookimpl(specname="pytest_pycollect_makeitem", wrapper=True, trylast=True)
+def pytest_pycollect_makeitem_make_group_and_member(
+    collector: pytest.Collector, name: str, obj: object
+) -> Generator[None, MakeItemResult, MakeItemResult]:
+    ori_result = yield
+    if ori_result is None:
+        return None
+    if not isinstance(ori_result, list):
+        ori_result = [ori_result]
+
+    result = []
+    for item_or_collector in ori_result:
+        if (
+            not isinstance(item_or_collector, pytest.Function)
+            or _get_asyncio_concurrent_mark(item_or_collector) is None
+        ):
+            result.append(item_or_collector)
+            continue
+
+        item = item_or_collector
+
+        item = AsyncioConcurrentGroupMember.promote_from_function(item)
+        result.append(item)
+
+    return result
+
+
+@pytest.hookimpl(specname="pytest_itemcollected")
+def pytest_itemcollected_register_in_group(item: pytest.Item) -> None:
+    if not isinstance(item, AsyncioConcurrentGroupMember):
+        return
+
+    known_groups = item.config.stash[asyncio_concurrent_group_key]
+
+    group_name = _get_asyncio_concurrent_group(item)
+    if group_name not in known_groups:
+        known_groups[group_name] = AsyncioConcurrentGroup.from_parent(
+            parent=item.parent, originalname=f"AsyncioConcurrentGroup[{group_name}]"
+        )
+    group = known_groups[group_name]
+
+    group.add_child(item)
+
+
+# =========================== # deselect # =========================== #
+
+
+@pytest.hookimpl(specname="pytest_deselected")
+def pytest_deselected_update_group(items: Sequence[pytest.Item]) -> None:
+    """Remove item from group if deselected."""
+    for item in items:
+        if isinstance(item, AsyncioConcurrentGroupMember):
+            item.group.remove_child(item)
+
+
+# =========================== # pytest_runtestloop # =========================== #
+
+
+@pytest.hookimpl(specname="pytest_runtestloop", wrapper=True, trylast=True)
+def pytest_runtestloop_handle_async_by_group(session: pytest.Session) -> Generator[None, Any, Any]:
+    """
+    - Wrapping around pytest_runtestloop, grouping items with same group name together.
+    - Run formal pytest_runtestloop without async tests.
+    - Handle async tests by group, one at a time.
+    - Ungroup them after everything done.
+    """
+    items = session.items
+    ihook = session.ihook
+
+    asyncio_concurrent_tests = [
+        item for item in items if isinstance(item, AsyncioConcurrentGroupMember)
+    ]
+    groups: List[AsyncioConcurrentGroup] = []
+    for async_test in asyncio_concurrent_tests:
+        if async_test.group not in groups:
+            groups.append(async_test.group)
+        items.remove(async_test)
+
+    assert sum([len(group.children) for group in groups]) == len(asyncio_concurrent_tests)
+
+    result = yield
+
+    if session.config.option.collectonly:
+        return result
+
+    for i, group in enumerate(groups):
+        nextgroup = groups[i + 1] if i + 1 < len(groups) else None
+        ihook.pytest_runtest_protocol_async_group(group=group, nextgroup=nextgroup)
+
+    for group in groups:
+        for item in group.children:
+            items.append(item)
+
+    return result
+
+
+@pytest.hookimpl(specname="pytest_runtest_protocol_async_group")
+def pytest_runtest_protocol_async_group(
+    group: AsyncioConcurrentGroup, nextgroup: Optional[AsyncioConcurrentGroup]
+) -> object:
+    """
+    Handling life cycle of async group tests. Calling pytest hooks in the same order as pytest core,
+    but calling same hook on all tests in this group in batch. While for pytest_runtest_call,
+    all tests are called and gathered, and await in a single event loop, which is how tests running
+    concurrently.
+
+    Hooks order:
+    - pytest_runtest_logstart (batch)
+    - pytest_runtest_setup_async_group (reporting under first tests)
+    - pytest_runtest_setup (batch) (and reporting)
+    - pytest_runtest_call_async (batch) (and reporting)
+    - pytest_runtest_teardown (batch) (and reporting)
+    - pytest_runtest_teardown_async_group (reporting under last tests)
+    - pytest_runtest_logfinish (batch)
+    """
+
+    if not group.children_have_same_parent:
+        for child in group.children:
+            child.add_marker("skip")
+
+        warnings.warn(
+            PytestAsyncioConcurrentGroupingWarning(
+                f"""
+                Asyncio Concurrent Group [{group.name}] has children from different parents,
+                skipping all of it's children.
+                """
+            )
+        )
+
+    item_passed_setup: List[AsyncioConcurrentGroupMember] = []
+    loop = group.config.stash[event_loop_key]
+
+    for childFunc in group.children:
+        childFunc.ihook.pytest_runtest_logstart(
+            nodeid=childFunc.nodeid, location=childFunc.location
+        )
+
+        report = _call_and_report(_setup_child(childFunc), childFunc, "setup")
+        if report.passed:
+            item_passed_setup.append(childFunc)
+
+    async def run_tests():
+        return await asyncio.gather(*[_call_runtest_async(child) for child in item_passed_setup])
+
+    callinfos = loop.run_until_complete(run_tests())
+
+    for childFunc, callinfo in zip(item_passed_setup, callinfos):
+        report = childFunc.ihook.pytest_runtest_makereport(item=childFunc, call=callinfo)
+        if _check_interactive_exception(call=callinfo, report=report):
+            childFunc.ihook.pytest_exception_interact(node=childFunc, call=callinfo, report=report)
+
+        childFunc.ihook.pytest_runtest_logreport(report=report)
+
+    for childFunc in group.children:
+        _call_and_report(_teardown_child(childFunc, nextgroup=nextgroup), childFunc, "teardown")
+
+        childFunc.ihook.pytest_runtest_logfinish(
+            nodeid=childFunc.nodeid, location=childFunc.location
+        )
+
+    return True
+
+
+async def _call_runtest_async(item: AsyncioConcurrentGroupMember) -> pytest.CallInfo:
+    mark = _get_asyncio_concurrent_mark(item)
+    assert mark
+    timeout = mark.kwargs.get("timeout")
+
+    return await _async_callinfo_from_call(
+        functools.partial(item.ihook.pytest_runtest_call_async, item=item),  # type: ignore
+        timeout=timeout,
+    )
+
+
+def _setup_child(item: AsyncioConcurrentGroupMember) -> Callable[[], None]:
+    """
+    Setup flow for normal pytest tests:
+    - Push all nodes onto `SetupState`, start from furthest.
+    - Register fixture finalizers to repective node in `SetupState` according to its scope.
+    Setup flow for async pytest tests:
+    - Setup group
+        - Push all nodes onto `SetupState`, start from furthest.
+        - The node on the face will be `AsyncioConcurrentGroup`.
+    - Setup individual tests.
+        - Register each active test in SetupState with its group's finalizer list.
+        - Non-function-scoped finalizers remain on their parent node.
+    """
+
+    def inner() -> None:
+        if not item.group.has_setup:
+            item.ihook.pytest_runtest_setup_async_group(item=item.group)
+
+        item.session._setupstate.stack[item] = (item.group.children_finalizer[item], None)
+        item.config.pluginmanager.subset_hook_caller(
+            "pytest_runtest_setup", [item.config.pluginmanager.get_plugin("runner")]
+        )(item=item)
+
+    return inner
+
+
+def _teardown_child(
+    item: AsyncioConcurrentGroupMember,
+    nextgroup: Optional[AsyncioConcurrentGroup],
+) -> Callable[[], None]:
+    """
+    Similar to setup.
+    Teardown flow for normal pytest tests:
+    - Remove all nodes not used in next item from `SetupState`, start from closest.
+    - Call all finalizer on node removed.
+    Teardown flow for async pytest tests:
+    - Teardown individual tests.
+        - Remove individual test from group, and let group call their finalizers.
+    - Teardown group.
+        - Remove all nodes not used in next item from `SetupState`, start from closest.
+    """
+
+    def inner() -> None:
+        exceptions = []
+        try:
+            item.config.pluginmanager.subset_hook_caller(
+                "pytest_runtest_teardown", [item.config.pluginmanager.get_plugin("runner")]
+            )(item=item, nextitem=nextgroup)
+        except Exception as e:
+            exceptions.append(e)
+
+        try:
+            if len(item.group.children_finalizer) == 0:
+                item.ihook.pytest_runtest_teardown_async_group(item=item.group, nextitem=nextgroup)
+        except Exception as e:
+            if isinstance(e, BaseExceptionGroup):
+                exceptions.extend(e.exceptions)  # type: ignore
+            else:
+                exceptions.append(e)
+
+        if len(exceptions) == 1:
+            raise exceptions[0]
+        elif len(exceptions) > 1:
+            msg = f"errors while tearing down {item!r}"
+            raise BaseExceptionGroup(msg, exceptions)
+
+    return inner
+
+
+# =========================== # group lifcycle # =========================== #
+
+
+@pytest.hookimpl(specname="pytest_runtest_call_async")
+async def pytest_runtest_call_async(item: pytest.Function) -> object:
+    if not inspect.iscoroutinefunction(item.obj):
+        warnings.warn(
+            PytestAsyncioConcurrentInvalidMarkWarning(
+                "Marking a sync function with @asyncio_concurrent is invalid."
+            )
+        )
+
+        pytest.skip("Marking a sync function with @asyncio_concurrent is invalid.")
+
+    with hook_wrapper_entered(item.ihook.pytest_runtest_call, item=item):
+        testfunction = item.obj
+        testargs = {arg: item.funcargs[arg] for arg in item._fixtureinfo.argnames}
+        return await testfunction(**testargs)
+
+
+@pytest.hookimpl(specname="pytest_runtest_setup_async_group")
+def pytest_runtest_setup_async_group(item: AsyncioConcurrentGroup) -> None:
+    """
+    Set up the group's ancestors before registering its concurrent members.
+    """
+    assert not item.has_setup
+    item.ihook.pytest_runtest_setup(item=item)
+    item.has_setup = True
+
+
+@pytest.hookimpl(specname="pytest_runtest_teardown_async_group")
+def pytest_runtest_teardown_async_group(
+    item: "AsyncioConcurrentGroup",
+    nextitem: "AsyncioConcurrentGroup",
+) -> None:
+    assert item.has_setup
+    assert len(item.children_finalizer) == 0
+    item.ihook.pytest_runtest_teardown(item=item, nextitem=nextitem)
+    item.has_setup = False
+
+
+# =========================== # async lifcycle redirection # =========================== #
+
+
+@pytest.hookimpl(specname="pytest_runtest_setup")
+def pytest_runtest_setup_handle_async_function(item: pytest.Item) -> None:
+    """We have skipped the one in pytest.runner, but we still need setup."""
+    if not isinstance(item, AsyncioConcurrentGroupMember):
+        return
+
+    item.setup()
+
+
+@pytest.hookimpl(specname="pytest_runtest_teardown")
+def pytest_runtest_teardown_handle_async_function(
+    item: pytest.Item, nextitem: Optional[pytest.Item]
+) -> None:
+    """
+    We have skipped the one in pytest.runner,
+    redirecting to AsyncioConcurrentGroup for teardown.
+    """
+    if not isinstance(item, AsyncioConcurrentGroupMember):
+        return
+
+    item.group.teardown_child(item)
+
+
+# =========================== # Captures #===========================#
+
+
+@pytest.hookimpl(specname="pytest_runtest_protocol_async_group", wrapper=True, tryfirst=True)
+def pytest_runtest_protocol_async_group_warning(
+    group: "AsyncioConcurrentGroup", nextgroup: Optional["AsyncioConcurrentGroup"]
+) -> Generator[None, object, object]:
+    with hook_wrapper_entered(group.ihook.pytest_runtest_protocol, item=group, nextitem=nextgroup):
+        return (yield)
+
+
+# =========================== # helper #===========================#
+
+
+def _get_asyncio_concurrent_mark(item: pytest.Item) -> Optional[pytest.Mark]:
+    return item.get_closest_marker("asyncio_concurrent")
+
+
+def _get_asyncio_concurrent_group(item: AsyncioConcurrentGroupMember) -> str:
+    marker = item.get_closest_marker("asyncio_concurrent")
+    assert marker is not None
+
+    default_group_name = (
+        f"self_[{item.nodeid}]"
+        if _get_group_strategy(item.config) == "self"
+        else f"parent_[{item.parent.nodeid}]"  # type: ignore
+    )
+
+    return marker.kwargs.get("group", default_group_name)
+
+
+@functools.lru_cache(maxsize=1)
+def _get_group_strategy(config: pytest.Config) -> GroupStrategy:
+    strategy = (
+        config.getoption("--default-group-strategy")
+        or config.getini("default_group_strategy")
+        or "self"
+    ).lower()
+    assert (
+        strategy == "self" or strategy == "parent"
+    ), "group_strategy should be either self or parent"
+    return cast(GroupStrategy, strategy)
+
+
+# referencing CallInfo.from_call
+async def _async_callinfo_from_call(
+    func: Callable[[], Coroutine], timeout: Optional[int]
+) -> pytest.CallInfo:
+    """An async version of CallInfo.from_call"""
+
+    excinfo = None
+    start = timing.time()
+    precise_start = timing.perf_counter()
+    try:
+        result = await asyncio.wait_for(func(), timeout=timeout)
+    except BaseException:
+        excinfo = pytest.ExceptionInfo.from_current()
+        if isinstance(excinfo.value, outcomes.Exit) or isinstance(excinfo.value, KeyboardInterrupt):
+            raise
+        result = None
+
+    precise_stop = timing.perf_counter()
+    duration = precise_stop - precise_start
+    stop = timing.time()
+
+    callInfo: pytest.CallInfo = pytest.CallInfo(
+        start=start,
+        stop=stop,
+        duration=duration,
+        when="call",
+        result=result,
+        excinfo=excinfo,
+        _ispytest=True,
+    )
+
+    return callInfo
+
+
+# referencing runner.call_and_report
+def _call_and_report(
+    func: Callable[[], None],
+    item: pytest.Item,
+    when: Literal["setup", "teardown"],
+) -> pytest.TestReport:
+    reraise: tuple[type[BaseException], ...] = (outcomes.Exit,)
+    if not item.config.getoption("usepdb", False):
+        reraise += (KeyboardInterrupt,)
+
+    call = pytest.CallInfo.from_call(func, when=when, reraise=reraise)
+    report: pytest.TestReport = item.ihook.pytest_runtest_makereport(item=item, call=call)
+    item.ihook.pytest_runtest_logreport(report=report)
+
+    if (
+        call.excinfo
+        and not isinstance(call.excinfo.value, outcomes.Skipped)
+        and not hasattr(report, "wasxfail")
+    ):
+        item.ihook.pytest_exception_interact(node=item, call=call, report=report)
+
+    if _check_interactive_exception(call, report):
+        item.ihook.pytest_exception_interact(node=item, call=call, report=report)
+    return report
+
+
+@contextlib.contextmanager
+def hook_wrapper_entered(
+    hook: pluggy.HookCaller,
+    **kwds: Any,
+) -> Generator[None, None, Any]:
+    """
+    # Capture and logging are hard to handle without duplicating huge amount of code,
+    # so reusing defined hooks wrapper here.
+    """
+    with contextlib.ExitStack() as es:
+        for hookimpl in hook.get_hookimpls():
+            if not hookimpl.wrapper:
+                continue
+            es.enter_context(
+                contextlib.contextmanager(hookimpl.function)(  # type: ignore
+                    **{k: v for k, v in kwds.items() if k in hookimpl.argnames}
+                )
+            )
+
+        yield
+
+
+# copied from _pytest/runner
+def _check_interactive_exception(call: pytest.CallInfo[object], report: pytest.TestReport) -> bool:
+    """Check whether the call raised an exception that should be reported as
+    interactive."""
+    if call.excinfo is None:
+        # Didn't raise.
+        return False
+    if hasattr(report, "wasxfail"):
+        # Exception was expected.
+        return False
+    if isinstance(call.excinfo.value, (outcomes.Skipped, bdb.BdbQuit)):
+        # Special control flow exception.
+        return False
+    return True

pytest_asyncio_concurrent_fork-0.5.2.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.4
+Name: pytest-asyncio-concurrent-fork
+Version: 0.5.2
+Summary: Temporary pytest compatibility fork of pytest-asyncio-concurrent.
+Author-email: Zane Chen <czl970721@gmail.com>
+Maintainer-email: Zane Chen <czl970721@gmail.com>
+License: 
+        The MIT License (MIT)
+        
+        Copyright (c) 2024 Zane Chen
+        
+        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.
+        
+Project-URL: Repository, https://github.com/AnswerDotAI/pytest-asyncio-concurrent
+Project-URL: Homepage, https://github.com/AnswerDotAI/pytest-asyncio-concurrent
+Project-URL: Issues, https://github.com/AnswerDotAI/pytest-asyncio-concurrent/issues
+Classifier: Framework :: Pytest
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Testing
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: pytest>=6.2.0
+Provides-Extra: testing
+Requires-Dist: coverage>=7.6.0; extra == "testing"
+Dynamic: license-file
+
+==============================
+pytest-asyncio-concurrent-fork
+==============================
+
+This is a temporary pytest compatibility fork of `pytest-asyncio-concurrent <https://github.com/czl9707/pytest-asyncio-concurrent>`_. The intent is to return to upstream once the fixes land there.
+
+The fork registers concurrent tests as active during fixture setup and execution, as required by pytest 9.1. Async fixtures and concurrent tests share one session-owned event loop rather than relying on an implicit current loop.
+
+.. image:: https://img.shields.io/pypi/v/pytest-asyncio-concurrent-fork.svg
+    :target: https://pypi.org/project/pytest-asyncio-concurrent-fork
+    :alt: PyPI version
+
+.. image:: https://img.shields.io/pypi/pyversions/pytest-asyncio-concurrent-fork.svg
+    :target: https://pypi.org/project/pytest-asyncio-concurrent-fork
+    :alt: Python versions
+
+.. image:: https://github.com/AnswerDotAI/pytest-asyncio-concurrent/actions/workflows/main.yml/badge.svg
+    :target: https://github.com/AnswerDotAI/pytest-asyncio-concurrent/actions/workflows/main.yml
+    :alt: See Build Status on GitHub Actions
+
+
+System/Integration tests can take a really long time. 
+
+And ``pytest-asyncio-concurrent`` A pytest plugin aiming to solve this by running asynchronous tests in true parallel, enabling faster execution for high I/O or network-bound test suites. 
+
+Unlike ``pytest-asyncio``, which runs async tests **sequentially**, ``pytest-asyncio-concurrent`` takes advantage of Python's asyncio capabilities to execute tests **concurrently** by specifying **async group**.
+
+Note: This plugin would more or less `Break Test Isolation Principle` \(for none function scoped fixture\). Please make sure your tests is ok to run concurrently before you use this plugin.
+
+
+Key Features
+------------
+
+* Giving the capability to run pytest async functions.
+* Providing granular control over Concurrency -- See **Async Group** for details
+  
+  * Specifying Async Group to control tests that can run together. 
+  * Limitation: Only test functions defined under same direct parent can be put into same group.
+
+* ``asyncio_concurrent`` mark accept a ``timeout`` parameter, which would throw error when test reach the given time.
+* Compatible with ``pytest-asyncio``.
+
+Key Concept: Async Group
+------------------------
+
+The plugin control tests concurrency by putting them into different groups.
+
+* Limitation: Each group can **only** contain tests under **same direct parent**. For example, class methods within same class, or functions within same file.
+* Explicitly specify group by providing ``group`` parameter to ``asyncio_concurrent`` mark. 
+
+    * All tests marked with same group name will be executed together.
+    * All tests will be skipped if the ``Same Parent`` rule got violated.
+
+* Use default grouping strategy. The plugin accept ``--default-group-strategy`` cli parameter, or ``default_group_strategy`` in ini or toml file. Possible value: ``self``, ``parent``.
+    
+    * **self**\(default\): Each test will be executed by itself if no group provided.
+    * **parent**: Tests will grouped by their parent node. For example, all method within same class will be grouped together.
+
+Installation
+------------
+
+Replace the upstream distribution with the fork; do not install both, since they provide the same Python package and pytest plugin::
+
+    $ pip uninstall pytest-asyncio-concurrent
+    $ pip install pytest-asyncio-concurrent-fork
+
+The marker and plugin names are unchanged. With pytest 8.4 or later, projects can load only the plugins they use:
+
+.. code-block:: toml
+
+    [tool.pytest.ini_options]
+    addopts = "--disable-plugin-autoload -p asyncio-concurrent"
+
+Use plain ``@pytest.fixture`` for async fixtures owned by this plugin. If also using ``pytest-asyncio``, explicitly load ``-p asyncio`` and use its strict mode so it does not take ownership of concurrent tests.
+
+
+How this work?
+--------------
+
+This plugin extend ``pytest_runtestloop`` hook to handle async tests seperately.
+
+In the 'async loop', tests are grouped by the `group` provided in the mark. and executed one group at a time.
+
+In each group, instead of sequentially calling ``setup``, ``call``, ``teardown`` for individual test, these hooks are called for all tests in the group in batch.
+
+The fixture lifecycle within group is handled by this plugin instead of pytest core, to work around pytest sequential test execution assumption.
+
+
+Usage
+-----
+
+Run test Sequentially
+
+.. code-block:: python
+
+    @pytest.mark.asyncio_concurrent
+    async def async_test_A():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+    @pytest.mark.asyncio_concurrent
+    async def async_test_B():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+
+Run tests Concurrently
+
+.. code-block:: python
+
+    # the test below will run by itself
+    @pytest.mark.asyncio_concurrent
+    async def test_by_itself():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+    # the two tests below will run concurrently
+    @pytest.mark.asyncio_concurrent(group="my_group")
+    async def test_groupA():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+    # this one will have a 10s timeout
+    @pytest.mark.asyncio_concurrent(group="my_group", timeout=10)
+    async def test_groupB():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+
+Parametrized Tests
+
+.. code-block:: python
+
+    # the parametrized tests below will run sequential
+    @pytest.mark.asyncio_concurrent
+    @pytest.parametrize("p", [0, 1, 2])
+    async def test_parametrize_sequential(p):
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+    # the parametrized tests below will run concurrently
+    @pytest.mark.asyncio_concurrent(group="my_group")
+    @pytest.parametrize("p", [0, 1, 2])
+    async def test_parametrize_concurrent():
+        res = await wait_for_something_async()
+        assert result.is_valid()
+
+
+Contributing
+------------
+
+Contributions are very welcome. Tests can be run with ``tox``, please ensure
+the coverage at least stays the same before you submit a pull request.
+
+License
+-------
+
+Distributed under the terms of the ``MIT`` license, "pytest-asyncio-concurrent" is free and open source software

pytest_asyncio_concurrent_fork-0.5.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+pytest_asyncio_concurrent/__init__.py,sha256=TTvtXKpM6kLqa6uK4cowV8o8mhQa1qdVI-zyeYmKyVs,164
+pytest_asyncio_concurrent/fixture_async.py,sha256=bM6kZNa8QXtVAUsYBKm6m5m6S4VBVK9rHvh5tw9p8CI,4961
+pytest_asyncio_concurrent/grouping.py,sha256=P5i3k-fYUYsABVFE_9zrtE482CqwPDwcWHGeh_G-xRw,5061
+pytest_asyncio_concurrent/hooks.py,sha256=TrBCU08ZLE1DyTSR8NP9bMdWzCv_bpE2vOO96BheuVo,1135
+pytest_asyncio_concurrent/plugin.py,sha256=TGaQWyoy8dcFfm6-cIa9gGwi_ZGuTs8xNOwhbKetqVU,17534
+pytest_asyncio_concurrent_fork-0.5.2.dist-info/licenses/LICENSE,sha256=rYU59J3fLm1rl8ZZusOawdV63oDawVvKvqOQcx-kmrg,1077
+pytest_asyncio_concurrent_fork-0.5.2.dist-info/METADATA,sha256=LlIhDpfPMxB8PvLO9PYyxpziHoIwBvilVDYbUxrEV5U,8970
+pytest_asyncio_concurrent_fork-0.5.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pytest_asyncio_concurrent_fork-0.5.2.dist-info/entry_points.txt,sha256=SsXF0fcu1YweCprSYHbbVsMYRJKaZNg-hfA2HqcbaEc,65
+pytest_asyncio_concurrent_fork-0.5.2.dist-info/top_level.txt,sha256=fBFeLvQQvSL9JdjKtFSAF_VuaqEWFC25jLveZHovcQY,26
+pytest_asyncio_concurrent_fork-0.5.2.dist-info/RECORD,,

pytest_asyncio_concurrent_fork-0.5.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pytest_asyncio_concurrent_fork-0.5.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+asyncio-concurrent = pytest_asyncio_concurrent.plugin

pytest_asyncio_concurrent_fork-0.5.2.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Zane Chen
+
+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.

pytest_asyncio_concurrent_fork-0.5.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+pytest_asyncio_concurrent