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

package/lib/site-packages/trio/_tests/test_repl.py

@@ -0,0 +1,428 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import signal
+import subprocess
+import sys
+from functools import partial
+from typing import Protocol
+
+import pytest
+
+import trio._repl
+
+
+class RawInput(Protocol):
+    def __call__(self, prompt: str = "") -> str: ...
+
+
+def build_raw_input(cmds: list[str]) -> RawInput:
+    """
+    Pass in a list of strings.
+    Returns a callable that returns each string, each time its called
+    When there are not more strings to return, raise EOFError
+    """
+    cmds_iter = iter(cmds)
+    prompts = []
+
+    def _raw_helper(prompt: str = "") -> str:
+        prompts.append(prompt)
+        try:
+            return next(cmds_iter)
+        except StopIteration:
+            raise EOFError from None
+
+    return _raw_helper
+
+
+def test_build_raw_input() -> None:
+    """Quick test of our helper function."""
+    raw_input = build_raw_input(["cmd1"])
+    assert raw_input() == "cmd1"
+    with pytest.raises(EOFError):
+        raw_input()
+
+
+async def test_basic_interaction(
+    capsys: pytest.CaptureFixture[str],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """
+    Run some basic commands through the interpreter while capturing stdout.
+    Ensure that the interpreted prints the expected results.
+    """
+    console = trio._repl.TrioInteractiveConsole()
+    raw_input = build_raw_input(
+        [
+            # evaluate simple expression and recall the value
+            "x = 1",
+            "print(f'{x=}')",
+            # Literal gets printed
+            "'hello'",
+            # define and call sync function
+            "def func():",
+            "  print(x + 1)",
+            "",
+            "func()",
+            # define and call async function
+            "async def afunc():",
+            "  return 4",
+            "",
+            "await afunc()",
+            # import works
+            "import sys",
+            "sys.stdout.write('hello stdout\\n')",
+        ],
+    )
+    monkeypatch.setattr(console, "raw_input", raw_input)
+    await trio._repl.run_repl(console)
+    out, _err = capsys.readouterr()
+    assert out.splitlines() == ["x=1", "'hello'", "2", "4", "hello stdout", "13"]
+
+
+async def test_system_exits_quit_interpreter(monkeypatch: pytest.MonkeyPatch) -> None:
+    console = trio._repl.TrioInteractiveConsole()
+    raw_input = build_raw_input(
+        [
+            "raise SystemExit",
+        ],
+    )
+    monkeypatch.setattr(console, "raw_input", raw_input)
+    with pytest.raises(SystemExit):
+        await trio._repl.run_repl(console)
+
+
+async def test_KI_interrupts(
+    capsys: pytest.CaptureFixture[str],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    console = trio._repl.TrioInteractiveConsole()
+    raw_input = build_raw_input(
+        [
+            "import signal, trio, trio.lowlevel",
+            "async def f():",
+            "  trio.lowlevel.spawn_system_task("
+            "    trio.to_thread.run_sync,"
+            "    signal.raise_signal, signal.SIGINT,"
+            "  )",  # just awaiting this kills the test runner?!
+            "  await trio.sleep_forever()",
+            "  print('should not see this')",
+            "",
+            "await f()",
+            "print('AFTER KeyboardInterrupt')",
+        ],
+    )
+    monkeypatch.setattr(console, "raw_input", raw_input)
+    await trio._repl.run_repl(console)
+    out, err = capsys.readouterr()
+    assert "KeyboardInterrupt" in err
+    assert "should" not in out
+    assert "AFTER KeyboardInterrupt" in out
+
+
+async def test_system_exits_in_exc_group(
+    capsys: pytest.CaptureFixture[str],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    console = trio._repl.TrioInteractiveConsole()
+    raw_input = build_raw_input(
+        [
+            "import sys",
+            "if sys.version_info < (3, 11):",
+            "  from exceptiongroup import BaseExceptionGroup",
+            "",
+            "raise BaseExceptionGroup('', [RuntimeError(), SystemExit()])",
+            "print('AFTER BaseExceptionGroup')",
+        ],
+    )
+    monkeypatch.setattr(console, "raw_input", raw_input)
+    await trio._repl.run_repl(console)
+    out, _err = capsys.readouterr()
+    # assert that raise SystemExit in an exception group
+    # doesn't quit
+    assert "AFTER BaseExceptionGroup" in out
+
+
+async def test_system_exits_in_nested_exc_group(
+    capsys: pytest.CaptureFixture[str],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    console = trio._repl.TrioInteractiveConsole()
+    raw_input = build_raw_input(
+        [
+            "import sys",
+            "if sys.version_info < (3, 11):",
+            "  from exceptiongroup import BaseExceptionGroup",
+            "",
+            "raise BaseExceptionGroup(",
+            "  '', [BaseExceptionGroup('', [RuntimeError(), SystemExit()])])",
+            "print('AFTER BaseExceptionGroup')",
+        ],
+    )
+    monkeypatch.setattr(console, "raw_input", raw_input)
+    await trio._repl.run_repl(console)
+    out, _err = capsys.readouterr()
+    # assert that raise SystemExit in an exception group
+    # doesn't quit
+    assert "AFTER BaseExceptionGroup" in out
+
+
+async def test_base_exception_captured(
+    capsys: pytest.CaptureFixture[str],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    console = trio._repl.TrioInteractiveConsole()
+    raw_input = build_raw_input(
+        [
+            # The statement after raise should still get executed
+            "raise BaseException",
+            "print('AFTER BaseException')",
+        ],
+    )
+    monkeypatch.setattr(console, "raw_input", raw_input)
+    await trio._repl.run_repl(console)
+    out, err = capsys.readouterr()
+    assert "_threads.py" not in err
+    assert "_repl.py" not in err
+    assert "AFTER BaseException" in out
+
+
+async def test_exc_group_captured(
+    capsys: pytest.CaptureFixture[str],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    console = trio._repl.TrioInteractiveConsole()
+    raw_input = build_raw_input(
+        [
+            # The statement after raise should still get executed
+            "raise ExceptionGroup('', [KeyError()])",
+            "print('AFTER ExceptionGroup')",
+        ],
+    )
+    monkeypatch.setattr(console, "raw_input", raw_input)
+    await trio._repl.run_repl(console)
+    out, _err = capsys.readouterr()
+    assert "AFTER ExceptionGroup" in out
+
+
+async def test_base_exception_capture_from_coroutine(
+    capsys: pytest.CaptureFixture[str],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    console = trio._repl.TrioInteractiveConsole()
+    raw_input = build_raw_input(
+        [
+            "async def async_func_raises_base_exception():",
+            "  raise BaseException",
+            "",
+            # This will raise, but the statement after should still
+            # be executed
+            "await async_func_raises_base_exception()",
+            "print('AFTER BaseException')",
+        ],
+    )
+    monkeypatch.setattr(console, "raw_input", raw_input)
+    await trio._repl.run_repl(console)
+    out, err = capsys.readouterr()
+    assert "_threads.py" not in err
+    assert "_repl.py" not in err
+    assert "AFTER BaseException" in out
+
+
+def test_main_entrypoint() -> None:
+    """
+    Basic smoke test when running via the package __main__ entrypoint.
+    """
+    repl = subprocess.run([sys.executable, "-m", "trio"], input=b"exit()")
+    assert repl.returncode == 0
+
+
+def should_try_newline_injection() -> bool:
+    if sys.platform != "linux":
+        return False
+
+    sysctl = pathlib.Path("/proc/sys/dev/tty/legacy_tiocsti")
+    if not sysctl.exists():  # pragma: no cover
+        return True
+
+    else:
+        return sysctl.read_text() == "1"
+
+
+@pytest.mark.skipif(
+    not should_try_newline_injection(),
+    reason="the ioctl we use is disabled in CI",
+)
+def test_ki_newline_injection() -> None:  # TODO: test this line
+    # TODO: we want to remove this functionality, eg by using vendored
+    #       pyrepls.
+    assert sys.platform != "win32"
+
+    import pty
+
+    # NOTE: this cannot be subprocess.Popen because pty.fork
+    #       does some magic to set the controlling terminal.
+    # (which I don't know how to replicate... so I copied this
+    # structure from pty.spawn...)
+    pid, pty_fd = pty.fork()  # type: ignore[attr-defined,unused-ignore]
+    if pid == 0:
+        os.execlp(sys.executable, *[sys.executable, "-u", "-m", "trio"])
+
+    # setup:
+    buffer = b""
+    while not buffer.endswith(b"import trio\r\n>>> "):
+        buffer += os.read(pty_fd, 4096)
+
+    # sanity check:
+    print(buffer.decode())
+    buffer = b""
+    os.write(pty_fd, b'print("hello!")\n')
+    while not buffer.endswith(b">>> "):
+        buffer += os.read(pty_fd, 4096)
+
+    assert buffer.count(b"hello!") == 2
+
+    # press ctrl+c
+    print(buffer.decode())
+    buffer = b""
+    os.kill(pid, signal.SIGINT)
+    while not buffer.endswith(b">>> "):
+        buffer += os.read(pty_fd, 4096)
+
+    assert b"KeyboardInterrupt" in buffer
+
+    # press ctrl+c later
+    print(buffer.decode())
+    buffer = b""
+    os.write(pty_fd, b'print("hello!")')
+    os.kill(pid, signal.SIGINT)
+    while not buffer.endswith(b">>> "):
+        buffer += os.read(pty_fd, 4096)
+
+    assert b"KeyboardInterrupt" in buffer
+    print(buffer.decode())
+    os.close(pty_fd)
+    os.waitpid(pid, 0)[1]
+
+
+async def test_ki_in_repl() -> None:
+    async with trio.open_nursery() as nursery:
+        proc = await nursery.start(
+            partial(
+                trio.run_process,
+                [sys.executable, "-u", "-m", "trio"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                stdin=subprocess.PIPE,
+                creationflags=subprocess.CREATE_NEW_PROCESS_GROUP if sys.platform == "win32" else 0,  # type: ignore[attr-defined,unused-ignore]
+            )
+        )
+
+        async with proc.stdout:
+            # setup
+            buffer = b""
+            async for part in proc.stdout:  # pragma: no branch
+                buffer += part
+                # TODO: consider making run_process stdout have some universal newlines thing
+                if buffer.replace(b"\r\n", b"\n").endswith(b"import trio\n>>> "):
+                    break
+
+            # ensure things work
+            print(buffer.decode())
+            buffer = b""
+            await proc.stdin.send_all(b'print("hello!")\n')
+            async for part in proc.stdout:  # pragma: no branch
+                buffer += part
+                if buffer.endswith(b">>> "):
+                    break
+
+            assert b"hello!" in buffer
+            print(buffer.decode())
+
+            # this seems to be necessary on Windows for reasons
+            # (the parents of process groups ignore ctrl+c by default...)
+            if sys.platform == "win32":
+                buffer = b""
+                await proc.stdin.send_all(
+                    b"import ctypes; ctypes.windll.kernel32.SetConsoleCtrlHandler(None, False)\n"
+                )
+                async for part in proc.stdout:  # pragma: no branch
+                    buffer += part
+                    if buffer.endswith(b">>> "):
+                        break
+
+                print(buffer.decode())
+
+            # try to decrease flakiness...
+            buffer = b""
+            await proc.stdin.send_all(
+                b"import coverage; trio.lowlevel.enable_ki_protection(coverage.pytracer.PyTracer._trace)\n"
+            )
+            async for part in proc.stdout:  # pragma: no branch
+                buffer += part
+                if buffer.endswith(b">>> "):
+                    break
+
+            print(buffer.decode())
+
+            # ensure that ctrl+c on a prompt works
+            # NOTE: for some reason, signal.SIGINT doesn't work for this test.
+            # Using CTRL_C_EVENT is also why we need subprocess.CREATE_NEW_PROCESS_GROUP
+            signal_sent = signal.CTRL_C_EVENT if sys.platform == "win32" else signal.SIGINT  # type: ignore[attr-defined,unused-ignore]
+            os.kill(proc.pid, signal_sent)
+            if sys.platform == "win32":
+                # we rely on EOFError which... doesn't happen with pipes.
+                # I'm not sure how to fix it...
+                await proc.stdin.send_all(b"\n")
+            else:
+                # we test injection separately
+                await proc.stdin.send_all(b"\n")
+
+            buffer = b""
+            async for part in proc.stdout:  # pragma: no branch
+                buffer += part
+                if buffer.endswith(b">>> "):
+                    break
+
+            assert b"KeyboardInterrupt" in buffer
+
+            # ensure ctrl+c while a command runs works
+            print(buffer.decode())
+            await proc.stdin.send_all(b'print("READY"); await trio.sleep_forever()\n')
+            killed = False
+            buffer = b""
+            async for part in proc.stdout:  # pragma: no branch
+                buffer += part
+                if buffer.replace(b"\r\n", b"\n").endswith(b"READY\n") and not killed:
+                    os.kill(proc.pid, signal_sent)
+                    killed = True
+                if buffer.endswith(b">>> "):
+                    break
+
+            assert b"trio" in buffer
+            assert b"KeyboardInterrupt" in buffer
+
+            # make sure it works for sync commands too
+            # (though this would be hard to break)
+            print(buffer.decode())
+            await proc.stdin.send_all(
+                b'import time; print("READY"); time.sleep(99999)\n'
+            )
+            killed = False
+            buffer = b""
+            async for part in proc.stdout:  # pragma: no branch
+                buffer += part
+                if buffer.replace(b"\r\n", b"\n").endswith(b"READY\n") and not killed:
+                    os.kill(proc.pid, signal_sent)
+                    killed = True
+                if buffer.endswith(b">>> "):
+                    break
+
+            assert b"Traceback" in buffer
+            assert b"KeyboardInterrupt" in buffer
+
+            print(buffer.decode())
+
+        # kill the process
+        nursery.cancel_scope.cancel()

package/lib/site-packages/trio/_tests/test_scheduler_determinism.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import trio
+
+if TYPE_CHECKING:
+    import pytest
+
+
+async def scheduler_trace() -> tuple[tuple[str, int], ...]:
+    """Returns a scheduler-dependent value we can use to check determinism."""
+    trace = []
+
+    async def tracer(name: str) -> None:
+        for i in range(50):
+            trace.append((name, i))
+            await trio.lowlevel.checkpoint()
+
+    async with trio.open_nursery() as nursery:
+        for i in range(5):
+            nursery.start_soon(tracer, str(i))
+
+    return tuple(trace)
+
+
+def test_the_trio_scheduler_is_not_deterministic() -> None:
+    # At least, not yet.  See https://github.com/python-trio/trio/issues/32
+    traces = [trio.run(scheduler_trace) for _ in range(10)]
+    assert len(set(traces)) == len(traces)
+
+
+def test_the_trio_scheduler_is_deterministic_if_seeded(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(trio._core._run, "_ALLOW_DETERMINISTIC_SCHEDULING", True)
+    traces = []
+    for _ in range(10):
+        state = trio._core._run._r.getstate()
+        try:
+            trio._core._run._r.seed(0)
+            traces.append(trio.run(scheduler_trace))
+        finally:
+            trio._core._run._r.setstate(state)
+
+    assert len(traces) == 10
+    assert len(set(traces)) == 1

package/lib/site-packages/trio/_tests/test_signals.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import signal
+from typing import TYPE_CHECKING, NoReturn
+
+import pytest
+
+import trio
+
+from .. import _core
+from .._signals import _signal_handler, get_pending_signal_count, open_signal_receiver
+
+if TYPE_CHECKING:
+    from types import FrameType
+
+
+async def test_open_signal_receiver() -> None:
+    orig = signal.getsignal(signal.SIGILL)
+    with open_signal_receiver(signal.SIGILL) as receiver:
+        # Raise it a few times, to exercise signal coalescing, both at the
+        # call_soon level and at the SignalQueue level
+        signal.raise_signal(signal.SIGILL)
+        signal.raise_signal(signal.SIGILL)
+        await _core.wait_all_tasks_blocked()
+        signal.raise_signal(signal.SIGILL)
+        await _core.wait_all_tasks_blocked()
+        async for signum in receiver:  # pragma: no branch
+            assert signum == signal.SIGILL
+            break
+        assert get_pending_signal_count(receiver) == 0
+        signal.raise_signal(signal.SIGILL)
+        async for signum in receiver:  # pragma: no branch
+            assert signum == signal.SIGILL
+            break
+        assert get_pending_signal_count(receiver) == 0
+    with pytest.raises(RuntimeError):
+        await receiver.__anext__()
+    assert signal.getsignal(signal.SIGILL) is orig
+
+
+async def test_open_signal_receiver_restore_handler_after_one_bad_signal() -> None:
+    orig = signal.getsignal(signal.SIGILL)
+    with pytest.raises(
+        ValueError,
+        match=r"(signal number out of range|invalid signal value)$",
+    ):
+        with open_signal_receiver(signal.SIGILL, 1234567):
+            pass  # pragma: no cover
+    # Still restored even if we errored out
+    assert signal.getsignal(signal.SIGILL) is orig
+
+
+def test_open_signal_receiver_empty_fail() -> None:
+    with pytest.raises(TypeError, match="No signals were provided"):
+        with open_signal_receiver():
+            pass
+
+
+async def test_open_signal_receiver_restore_handler_after_duplicate_signal() -> None:
+    orig = signal.getsignal(signal.SIGILL)
+    with open_signal_receiver(signal.SIGILL, signal.SIGILL):
+        pass
+    # Still restored correctly
+    assert signal.getsignal(signal.SIGILL) is orig
+
+
+async def test_catch_signals_wrong_thread() -> None:
+    async def naughty() -> None:
+        with open_signal_receiver(signal.SIGINT):
+            pass  # pragma: no cover
+
+    with pytest.raises(RuntimeError):
+        await trio.to_thread.run_sync(trio.run, naughty)
+
+
+async def test_open_signal_receiver_conflict() -> None:
+    with pytest.RaisesGroup(trio.BusyResourceError):
+        with open_signal_receiver(signal.SIGILL) as receiver:
+            async with trio.open_nursery() as nursery:
+                nursery.start_soon(receiver.__anext__)
+                nursery.start_soon(receiver.__anext__)
+
+
+# Blocks until all previous calls to run_sync_soon(idempotent=True) have been
+# processed.
+async def wait_run_sync_soon_idempotent_queue_barrier() -> None:
+    ev = trio.Event()
+    token = _core.current_trio_token()
+    token.run_sync_soon(ev.set, idempotent=True)
+    await ev.wait()
+
+
+async def test_open_signal_receiver_no_starvation() -> None:
+    # Set up a situation where there are always 2 pending signals available to
+    # report, and make sure that instead of getting the same signal reported
+    # over and over, it alternates between reporting both of them.
+    with open_signal_receiver(signal.SIGILL, signal.SIGFPE) as receiver:
+        try:
+            print(signal.getsignal(signal.SIGILL))
+            previous = None
+            for _ in range(10):
+                signal.raise_signal(signal.SIGILL)
+                signal.raise_signal(signal.SIGFPE)
+                await wait_run_sync_soon_idempotent_queue_barrier()
+                if previous is None:
+                    previous = await receiver.__anext__()
+                else:
+                    got = await receiver.__anext__()
+                    assert got in [signal.SIGILL, signal.SIGFPE]
+                    assert got != previous
+                    previous = got
+            # Clear out the last signal so that it doesn't get redelivered
+            while get_pending_signal_count(receiver) != 0:
+                await receiver.__anext__()
+        except BaseException:  # pragma: no cover
+            # If there's an unhandled exception above, then exiting the
+            # open_signal_receiver block might cause the signal to be
+            # redelivered and give us a core dump instead of a traceback...
+            import traceback
+
+            traceback.print_exc()
+
+
+async def test_catch_signals_race_condition_on_exit() -> None:
+    delivered_directly: set[int] = set()
+
+    def direct_handler(signo: int, frame: FrameType | None) -> None:
+        delivered_directly.add(signo)
+
+    print(1)
+    # Test the version where the call_soon *doesn't* have a chance to run
+    # before we exit the with block:
+    with _signal_handler({signal.SIGILL, signal.SIGFPE}, direct_handler):
+        with open_signal_receiver(signal.SIGILL, signal.SIGFPE) as receiver:
+            signal.raise_signal(signal.SIGILL)
+            signal.raise_signal(signal.SIGFPE)
+        await wait_run_sync_soon_idempotent_queue_barrier()
+    assert delivered_directly == {signal.SIGILL, signal.SIGFPE}
+    delivered_directly.clear()
+
+    print(2)
+    # Test the version where the call_soon *does* have a chance to run before
+    # we exit the with block:
+    with _signal_handler({signal.SIGILL, signal.SIGFPE}, direct_handler):
+        with open_signal_receiver(signal.SIGILL, signal.SIGFPE) as receiver:
+            signal.raise_signal(signal.SIGILL)
+            signal.raise_signal(signal.SIGFPE)
+            await wait_run_sync_soon_idempotent_queue_barrier()
+            assert get_pending_signal_count(receiver) == 2
+    assert delivered_directly == {signal.SIGILL, signal.SIGFPE}
+    delivered_directly.clear()
+
+    # Again, but with a SIG_IGN signal:
+
+    print(3)
+    with _signal_handler({signal.SIGILL}, signal.SIG_IGN):
+        with open_signal_receiver(signal.SIGILL) as receiver:
+            signal.raise_signal(signal.SIGILL)
+        await wait_run_sync_soon_idempotent_queue_barrier()
+    # test passes if the process reaches this point without dying
+
+    print(4)
+    with _signal_handler({signal.SIGILL}, signal.SIG_IGN):
+        with open_signal_receiver(signal.SIGILL) as receiver:
+            signal.raise_signal(signal.SIGILL)
+            await wait_run_sync_soon_idempotent_queue_barrier()
+            assert get_pending_signal_count(receiver) == 1
+    # test passes if the process reaches this point without dying
+
+    # Check exception chaining if there are multiple exception-raising
+    # handlers
+    def raise_handler(signum: int, frame: FrameType | None) -> NoReturn:
+        raise RuntimeError(signum)
+
+    with _signal_handler({signal.SIGILL, signal.SIGFPE}, raise_handler):
+        with pytest.raises(RuntimeError) as excinfo:
+            with open_signal_receiver(signal.SIGILL, signal.SIGFPE) as receiver:
+                signal.raise_signal(signal.SIGILL)
+                signal.raise_signal(signal.SIGFPE)
+                await wait_run_sync_soon_idempotent_queue_barrier()
+                assert get_pending_signal_count(receiver) == 2
+        exc = excinfo.value
+        signums = {exc.args[0]}
+        assert isinstance(exc.__context__, RuntimeError)
+        signums.add(exc.__context__.args[0])
+        assert signums == {signal.SIGILL, signal.SIGFPE}