@ajksunkang-aios/kgraph-linux-x64 0.1.2 → 0.1.3

package/lib/site-packages/trio/_core/_run_context.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import threading
+from typing import TYPE_CHECKING, Final
+
+if TYPE_CHECKING:
+    from ._run import Runner, Task
+
+
+class RunContext(threading.local):
+    runner: Runner
+    task: Task
+
+
+GLOBAL_RUN_CONTEXT: Final = RunContext()

package/lib/site-packages/trio/_core/_tests/test_asyncgen.py

@@ -0,0 +1,339 @@
+from __future__ import annotations
+
+import contextlib
+import sys
+import weakref
+from math import inf
+from types import AsyncGeneratorType
+from typing import TYPE_CHECKING, NoReturn
+
+import pytest
+
+from ... import _core
+from .tutil import gc_collect_harder, restore_unraisablehook
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
+
+def test_asyncgen_basics() -> None:
+    collected = []
+
+    async def example(cause: str) -> AsyncGenerator[int, None]:
+        try:
+            with contextlib.suppress(GeneratorExit):
+                yield 42
+            await _core.checkpoint()
+        except _core.Cancelled:
+            assert "exhausted" not in cause
+            task_name = _core.current_task().name
+            assert cause in task_name or task_name == "<init>"
+            assert _core.current_effective_deadline() == -inf
+            with pytest.raises(_core.Cancelled):
+                await _core.checkpoint()
+            collected.append(cause)
+        else:
+            assert "async_main" in _core.current_task().name
+            assert "exhausted" in cause
+            assert _core.current_effective_deadline() == inf
+            await _core.checkpoint()
+            collected.append(cause)
+
+    saved = []
+
+    async def async_main() -> None:
+        # GC'ed before exhausted
+        with pytest.warns(  # noqa: PT031
+            ResourceWarning,
+            match="Async generator.*collected before.*exhausted",
+        ):
+            assert await example("abandoned").asend(None) == 42
+            gc_collect_harder()
+        await _core.wait_all_tasks_blocked()
+        assert collected.pop() == "abandoned"
+
+        aiter_ = example("exhausted 1")
+        try:
+            assert await aiter_.asend(None) == 42
+        finally:
+            await aiter_.aclose()
+        assert collected.pop() == "exhausted 1"
+
+        # Also fine if you exhaust it at point of use
+        async for val in example("exhausted 2"):
+            assert val == 42
+        assert collected.pop() == "exhausted 2"
+
+        gc_collect_harder()
+
+        # No problems saving the geniter when using either of these patterns
+        aiter_ = example("exhausted 3")
+        try:
+            saved.append(aiter_)
+            assert await aiter_.asend(None) == 42
+        finally:
+            await aiter_.aclose()
+        assert collected.pop() == "exhausted 3"
+
+        # Also fine if you exhaust it at point of use
+        saved.append(example("exhausted 4"))
+        async for val in saved[-1]:
+            assert val == 42
+        assert collected.pop() == "exhausted 4"
+
+        # Leave one referenced-but-unexhausted and make sure it gets cleaned up
+        saved.append(example("outlived run"))
+        assert await saved[-1].asend(None) == 42
+        assert collected == []
+
+    _core.run(async_main)
+    assert collected.pop() == "outlived run"
+    for agen in saved:
+        assert isinstance(agen, AsyncGeneratorType)
+        assert agen.ag_frame is None  # all should now be exhausted
+
+
+async def test_asyncgen_throws_during_finalization(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    record = []
+
+    async def agen() -> AsyncGenerator[int, None]:
+        try:
+            yield 1
+        finally:
+            await _core.cancel_shielded_checkpoint()
+            record.append("crashing")
+            raise ValueError("oops")
+
+    with restore_unraisablehook():
+        await agen().asend(None)
+        gc_collect_harder()
+    await _core.wait_all_tasks_blocked()
+    assert record == ["crashing"]
+    # Following type ignore is because typing for LogCaptureFixture is wrong
+    exc_type, exc_value, _exc_traceback = caplog.records[0].exc_info  # type: ignore[misc]
+    assert exc_type is ValueError
+    assert str(exc_value) == "oops"
+    assert "during finalization of async generator" in caplog.records[0].message
+
+
+def test_firstiter_after_closing() -> None:
+    saved = []
+    record = []
+
+    async def funky_agen() -> AsyncGenerator[int, None]:
+        try:
+            yield 1
+        except GeneratorExit:
+            record.append("cleanup 1")
+            raise
+        try:
+            yield 2
+        finally:
+            record.append("cleanup 2")
+            await funky_agen().asend(None)
+
+    async def async_main() -> None:
+        aiter_ = funky_agen()
+        saved.append(aiter_)
+        assert await aiter_.asend(None) == 1
+        assert await aiter_.asend(None) == 2
+
+    _core.run(async_main)
+    assert record == ["cleanup 2", "cleanup 1"]
+
+
+def test_interdependent_asyncgen_cleanup_order() -> None:
+    saved: list[AsyncGenerator[int, None]] = []
+    record: list[int | str] = []
+
+    async def innermost() -> AsyncGenerator[int, None]:
+        try:
+            yield 1
+        finally:
+            await _core.cancel_shielded_checkpoint()
+            record.append("innermost")
+
+    async def agen(
+        label: int,
+        inner: AsyncGenerator[int, None],
+    ) -> AsyncGenerator[int, None]:
+        try:
+            yield await inner.asend(None)
+        finally:
+            # Either `inner` has already been cleaned up, or
+            # we're about to exhaust it. Either way, we wind
+            # up with `record` containing the labels in
+            # innermost-to-outermost order.
+            with pytest.raises(StopAsyncIteration):
+                await inner.asend(None)
+            record.append(label)
+
+    async def async_main() -> None:
+        # This makes a chain of 101 interdependent asyncgens:
+        # agen(99)'s cleanup will iterate agen(98)'s will iterate
+        # ... agen(0)'s will iterate innermost()'s
+        ag_chain = innermost()
+        for idx in range(100):
+            ag_chain = agen(idx, ag_chain)
+        saved.append(ag_chain)
+        assert await ag_chain.asend(None) == 1
+        assert record == []
+
+    _core.run(async_main)
+    assert record == ["innermost", *range(100)]
+
+
+@restore_unraisablehook()
+def test_last_minute_gc_edge_case() -> None:
+    saved: list[AsyncGenerator[int, None]] = []
+    record = []
+    needs_retry = True
+
+    async def agen() -> AsyncGenerator[int, None]:
+        try:
+            yield 1
+        finally:
+            record.append("cleaned up")
+
+    def collect_at_opportune_moment(token: _core._entry_queue.TrioToken) -> None:
+        runner = _core._run.GLOBAL_RUN_CONTEXT.runner
+        assert runner.system_nursery is not None
+        if runner.system_nursery._closed and isinstance(
+            runner.asyncgens.alive,
+            weakref.WeakSet,
+        ):
+            saved.clear()
+            record.append("final collection")
+            gc_collect_harder()
+            record.append("done")
+        else:
+            try:
+                token.run_sync_soon(collect_at_opportune_moment, token)
+            except _core.RunFinishedError:  # pragma: no cover
+                nonlocal needs_retry
+                needs_retry = True
+
+    async def async_main() -> None:
+        token = _core.current_trio_token()
+        token.run_sync_soon(collect_at_opportune_moment, token)
+        saved.append(agen())
+        await saved[-1].asend(None)
+
+    ATTEMPT_AMOUNT = 50
+
+    # Actually running into the edge case requires that the run_sync_soon task
+    # execute in between the system nursery's closure and the strong-ification
+    # of runner.asyncgens. There's about a 25% chance that it doesn't
+    # (if the run_sync_soon task runs before init on one tick and after init
+    # on the next tick); if we try enough times, we can make the chance of
+    # failure as small as we want.
+    for _ in range(ATTEMPT_AMOUNT):
+        needs_retry = False
+        record.clear()
+        saved.clear()
+        _core.run(async_main)
+        if needs_retry:  # pragma: no cover
+            assert record == ["cleaned up"]
+        else:
+            assert record == ["final collection", "done", "cleaned up"]
+            break
+    else:  # pragma: no cover
+        pytest.fail(
+            "Didn't manage to hit the trailing_finalizer_asyncgens case "
+            f"despite trying {ATTEMPT_AMOUNT} times",
+        )
+
+
+async def step_outside_async_context(aiter_: AsyncGenerator[int, None]) -> None:
+    # abort_fns run outside of task context, at least if they're
+    # triggered by a deadline expiry rather than a direct
+    # cancellation.  Thus, an asyncgen first iterated inside one
+    # will appear non-Trio, and since no other hooks were installed,
+    # will use the last-ditch fallback handling (that tries to mimic
+    # CPython's behavior with no hooks).
+    #
+    # NB: the strangeness with aiter being an attribute of abort_fn is
+    # to make it as easy as possible to ensure we don't hang onto a
+    # reference to aiter inside the guts of the run loop.
+    def abort_fn(_: _core.RaiseCancelT) -> _core.Abort:
+        with pytest.raises(StopIteration, match="42"):
+            abort_fn.aiter.asend(None).send(None)  # type: ignore[attr-defined]  # Callables don't have attribute "aiter"
+        del abort_fn.aiter  # type: ignore[attr-defined]
+        return _core.Abort.SUCCEEDED
+
+    abort_fn.aiter = aiter_  # type: ignore[attr-defined]
+
+    async with _core.open_nursery() as nursery:
+        nursery.start_soon(_core.wait_task_rescheduled, abort_fn)
+        await _core.wait_all_tasks_blocked()
+        nursery.cancel_scope.deadline = _core.current_time()
+
+
+async def test_fallback_when_no_hook_claims_it(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    async def well_behaved() -> AsyncGenerator[int, None]:
+        yield 42
+
+    async def yields_after_yield() -> AsyncGenerator[int, None]:
+        with pytest.raises(GeneratorExit):
+            yield 42
+        yield 100
+
+    async def awaits_after_yield() -> AsyncGenerator[int, None]:
+        with pytest.raises(GeneratorExit):
+            yield 42
+        await _core.cancel_shielded_checkpoint()
+
+    with restore_unraisablehook():
+        await step_outside_async_context(well_behaved())
+        gc_collect_harder()
+        assert capsys.readouterr().err == ""
+
+        await step_outside_async_context(yields_after_yield())
+        gc_collect_harder()
+        assert "ignored GeneratorExit" in capsys.readouterr().err
+
+        await step_outside_async_context(awaits_after_yield())
+        gc_collect_harder()
+        assert "awaited something during finalization" in capsys.readouterr().err
+
+
+def test_delegation_to_existing_hooks() -> None:
+    record = []
+
+    def my_firstiter(agen: AsyncGenerator[object, NoReturn]) -> None:
+        assert isinstance(agen, AsyncGeneratorType)
+        record.append("firstiter " + agen.ag_frame.f_locals["arg"])
+
+    def my_finalizer(agen: AsyncGenerator[object, NoReturn]) -> None:
+        assert isinstance(agen, AsyncGeneratorType)
+        record.append("finalizer " + agen.ag_frame.f_locals["arg"])
+
+    async def example(arg: str) -> AsyncGenerator[int, None]:
+        try:
+            yield 42
+        finally:
+            with pytest.raises(_core.Cancelled):
+                await _core.checkpoint()
+            record.append("trio collected " + arg)
+
+    async def async_main() -> None:
+        await step_outside_async_context(example("theirs"))
+        assert await example("ours").asend(None) == 42
+        gc_collect_harder()
+        assert record == ["firstiter theirs", "finalizer theirs"]
+        record[:] = []
+        await _core.wait_all_tasks_blocked()
+        assert record == ["trio collected ours"]
+
+    with restore_unraisablehook():
+        old_hooks = sys.get_asyncgen_hooks()
+        sys.set_asyncgen_hooks(my_firstiter, my_finalizer)
+        try:
+            _core.run(async_main)
+        finally:
+            assert sys.get_asyncgen_hooks() == (my_firstiter, my_finalizer)
+            sys.set_asyncgen_hooks(*old_hooks)

package/lib/site-packages/trio/_core/_tests/test_cancelled.py

@@ -0,0 +1,222 @@
+import pickle
+import re
+from math import inf
+
+import pytest
+
+import trio
+from trio import Cancelled
+from trio.lowlevel import current_task
+from trio.testing import wait_all_tasks_blocked
+
+from .test_ki import ki_self
+
+
+def test_Cancelled_init() -> None:
+    with pytest.raises(TypeError, match=r"^trio.Cancelled has no public constructor$"):
+        raise Cancelled
+
+    with pytest.raises(TypeError, match=r"^trio.Cancelled has no public constructor$"):
+        Cancelled(source="explicit")
+
+    # private constructor should not raise
+    Cancelled._create(source="explicit")
+
+
+async def test_Cancelled_str() -> None:
+    cancelled = Cancelled._create(source="explicit")
+    assert str(cancelled) == "cancelled due to explicit"
+    # note: repr(current_task()) is often fairly verbose
+    assert re.fullmatch(
+        r"cancelled due to deadline from task "
+        r"<Task 'trio._core._tests.test_cancelled.test_Cancelled_str' at 0x\w*>",
+        str(
+            Cancelled._create(
+                source="deadline",
+                source_task=repr(current_task()),
+            )
+        ),
+    )
+
+    assert re.fullmatch(
+        rf"cancelled due to nursery with reason 'pigs flying' from task {current_task()!r}",
+        str(
+            Cancelled._create(
+                source="nursery",
+                source_task=repr(current_task()),
+                reason="pigs flying",
+            )
+        ),
+    )
+
+
+def test_Cancelled_subclass() -> None:
+    with pytest.raises(TypeError):
+        type("Subclass", (Cancelled,), {})
+
+
+# https://github.com/python-trio/trio/issues/3248
+def test_Cancelled_pickle() -> None:
+    cancelled = Cancelled._create(source="KeyboardInterrupt")
+    pickled_cancelled = pickle.loads(pickle.dumps(cancelled))
+    assert isinstance(pickled_cancelled, Cancelled)
+    assert cancelled.source == pickled_cancelled.source
+    assert cancelled.source_task == pickled_cancelled.source_task
+    assert cancelled.reason == pickled_cancelled.reason
+
+
+async def test_cancel_reason() -> None:
+    with trio.CancelScope() as cs:
+        cs.cancel(reason="hello")
+        with pytest.raises(
+            Cancelled,
+            match=rf"^cancelled due to explicit with reason 'hello' from task {current_task()!r}$",
+        ) as excinfo:
+            await trio.lowlevel.checkpoint()
+    assert excinfo.value.source == "explicit"
+    assert excinfo.value.reason == "hello"
+    assert excinfo.value.source_task == repr(current_task())
+
+    with trio.CancelScope(deadline=-inf) as cs:
+        with pytest.raises(Cancelled, match=r"^cancelled due to deadline"):
+            await trio.lowlevel.checkpoint()
+
+    with trio.CancelScope() as cs:
+        cs.deadline = -inf
+        with pytest.raises(
+            Cancelled,
+            match=r"^cancelled due to deadline",
+        ):
+            await trio.lowlevel.checkpoint()
+
+
+match_str = r"^cancelled due to nursery with reason 'child task raised exception ValueError\(\)' from task {0!r}$"
+
+
+async def cancelled_task(
+    fail_task: trio.lowlevel.Task, task_status: trio.TaskStatus
+) -> None:
+    task_status.started()
+    with pytest.raises(Cancelled, match=match_str.format(fail_task)):
+        await trio.sleep_forever()
+    raise TypeError
+
+
+# failing_task raises before cancelled_task is started
+async def test_cancel_reason_nursery() -> None:
+    async def failing_task(task_status: trio.TaskStatus[trio.lowlevel.Task]) -> None:
+        task_status.started(current_task())
+        raise ValueError
+
+    with pytest.RaisesGroup(ValueError, TypeError):
+        async with trio.open_nursery() as nursery:
+            fail_task = await nursery.start(failing_task)
+            with pytest.raises(Cancelled, match=match_str.format(fail_task)):
+                await wait_all_tasks_blocked()
+            await nursery.start(cancelled_task, fail_task)
+
+
+# wait until both tasks are running before failing_task raises
+async def test_cancel_reason_nursery2() -> None:
+    async def failing_task(task_status: trio.TaskStatus[trio.lowlevel.Task]) -> None:
+        task_status.started(current_task())
+        await wait_all_tasks_blocked()
+        raise ValueError
+
+    with pytest.RaisesGroup(ValueError, TypeError):
+        async with trio.open_nursery() as nursery:
+            fail_task = await nursery.start(failing_task)
+            await nursery.start(cancelled_task, fail_task)
+
+
+# failing_task raises before calling task_status.started()
+async def test_cancel_reason_nursery3() -> None:
+    async def failing_task(task_status: trio.TaskStatus[None]) -> None:
+        raise ValueError
+
+    parent_task = current_task()
+
+    async def cancelled_task() -> None:
+        # We don't have a way of distinguishing that the nursery code block failed
+        # because it failed to `start()` a task.
+        with pytest.raises(
+            Cancelled,
+            match=re.escape(
+                rf"cancelled due to nursery with reason 'Code block inside nursery contextmanager raised exception ValueError()' from task {parent_task!r}"
+            ),
+        ):
+            await trio.sleep_forever()
+
+    with pytest.RaisesGroup(ValueError):
+        async with trio.open_nursery() as nursery:
+            nursery.start_soon(cancelled_task)
+            await wait_all_tasks_blocked()
+            await nursery.start(failing_task)
+
+
+async def test_cancel_reason_not_overwritten() -> None:
+    with trio.CancelScope() as cs:
+        cs.cancel()
+        with pytest.raises(
+            Cancelled,
+            match=rf"^cancelled due to explicit from task {current_task()!r}$",
+        ):
+            await trio.lowlevel.checkpoint()
+        cs.deadline = -inf
+        with pytest.raises(
+            Cancelled,
+            match=rf"^cancelled due to explicit from task {current_task()!r}$",
+        ):
+            await trio.lowlevel.checkpoint()
+
+
+async def test_cancel_reason_not_overwritten_2() -> None:
+    with trio.CancelScope() as cs:
+        cs.deadline = -inf
+        with pytest.raises(Cancelled, match=r"^cancelled due to deadline$"):
+            await trio.lowlevel.checkpoint()
+        cs.cancel()
+        with pytest.raises(Cancelled, match=r"^cancelled due to deadline$"):
+            await trio.lowlevel.checkpoint()
+
+
+async def test_nested_child_source() -> None:
+    ev = trio.Event()
+    parent_task = current_task()
+
+    async def child() -> None:
+        ev.set()
+        with pytest.raises(
+            Cancelled,
+            match=rf"^cancelled due to nursery with reason 'Code block inside nursery contextmanager raised exception ValueError\(\)' from task {parent_task!r}$",
+        ):
+            await trio.sleep_forever()
+
+    with pytest.RaisesGroup(ValueError):
+        async with trio.open_nursery() as nursery:
+            nursery.start_soon(child)
+            await ev.wait()
+            raise ValueError
+
+
+async def test_reason_delayed_ki() -> None:
+    # simplified version of test_ki.test_ki_protection_works check #2
+    parent_task = current_task()
+
+    async def sleeper(name: str) -> None:
+        with pytest.raises(
+            Cancelled,
+            match=rf"^cancelled due to KeyboardInterrupt from task {parent_task!r}$",
+        ):
+            while True:
+                await trio.lowlevel.checkpoint()
+
+    async def raiser(name: str) -> None:
+        ki_self()
+
+    with pytest.RaisesGroup(KeyboardInterrupt):
+        async with trio.open_nursery() as nursery:
+            nursery.start_soon(sleeper, "s1")
+            nursery.start_soon(sleeper, "s2")
+            nursery.start_soon(trio.lowlevel.enable_ki_protection(raiser), "r1")
+            # __aexit__ blocks, and then receives the KI

package/lib/site-packages/trio/_core/_tests/test_exceptiongroup_gc.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import gc
+import sys
+from traceback import extract_tb
+from typing import TYPE_CHECKING, NoReturn
+
+import pytest
+
+from .._concat_tb import concat_tb
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from types import TracebackType
+
+if sys.version_info < (3, 11):
+    from exceptiongroup import ExceptionGroup
+
+
+def raiser1() -> NoReturn:
+    raiser1_2()
+
+
+def raiser1_2() -> NoReturn:
+    raiser1_3()
+
+
+def raiser1_3() -> NoReturn:
+    raise ValueError("raiser1_string")
+
+
+def raiser2() -> NoReturn:
+    raiser2_2()
+
+
+def raiser2_2() -> NoReturn:
+    raise KeyError("raiser2_string")
+
+
+def get_exc(raiser: Callable[[], NoReturn]) -> Exception:
+    try:
+        raiser()
+    except Exception as exc:
+        return exc
+    raise AssertionError("raiser should always raise")  # pragma: no cover
+
+
+def get_tb(raiser: Callable[[], NoReturn]) -> TracebackType | None:
+    return get_exc(raiser).__traceback__
+
+
+def test_concat_tb() -> None:
+    tb1 = get_tb(raiser1)
+    tb2 = get_tb(raiser2)
+
+    # These return a list of (filename, lineno, fn name, text) tuples
+    # https://docs.python.org/3/library/traceback.html#traceback.extract_tb
+    entries1 = extract_tb(tb1)
+    entries2 = extract_tb(tb2)
+
+    tb12 = concat_tb(tb1, tb2)
+    assert extract_tb(tb12) == entries1 + entries2
+
+    tb21 = concat_tb(tb2, tb1)
+    assert extract_tb(tb21) == entries2 + entries1
+
+    # Check degenerate cases
+    assert extract_tb(concat_tb(None, tb1)) == entries1
+    assert extract_tb(concat_tb(tb1, None)) == entries1
+    assert concat_tb(None, None) is None
+
+    # Make sure the original tracebacks didn't get mutated by mistake
+    assert extract_tb(get_tb(raiser1)) == entries1
+    assert extract_tb(get_tb(raiser2)) == entries2
+
+
+# Unclear if this can still fail, removing the `del` from _concat_tb.copy_tb does not seem
+# to trigger it (on a platform where the `del` is executed)
+@pytest.mark.skipif(
+    sys.implementation.name != "cpython",
+    reason="Only makes sense with refcounting GC",
+)
+def test_ExceptionGroup_catch_doesnt_create_cyclic_garbage() -> None:
+    # https://github.com/python-trio/trio/pull/2063
+    gc.collect()
+    old_flags = gc.get_debug()
+
+    def make_multi() -> NoReturn:
+        raise ExceptionGroup("", [get_exc(raiser1), get_exc(raiser2)])
+
+    try:
+        gc.set_debug(gc.DEBUG_SAVEALL)
+        with pytest.raises(ExceptionGroup) as excinfo:
+            # covers ~~MultiErrorCatcher.__exit__ and~~ _concat_tb.copy_tb
+            # TODO: is the above comment true anymore? as this no longer uses MultiError.catch
+            raise make_multi()
+        for exc in excinfo.value.exceptions:
+            assert isinstance(exc, (ValueError, KeyError))
+        gc.collect()
+        assert not gc.garbage
+    finally:
+        gc.set_debug(old_flags)
+        gc.garbage.clear()