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

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

@@ -0,0 +1,118 @@
+import pytest
+
+from trio import run
+from trio.lowlevel import RunVar, RunVarToken
+
+from ... import _core
+
+
+# scary runvar tests
+def test_runvar_smoketest() -> None:
+    t1 = RunVar[str]("test1")
+    t2 = RunVar[str]("test2", default="catfish")
+
+    assert repr(t1) == "<RunVar name='test1'>"
+
+    async def first_check() -> None:
+        with pytest.raises(LookupError):
+            t1.get()
+
+        t1.set("swordfish")
+        assert t1.get() == "swordfish"
+        assert t2.get() == "catfish"
+        assert t2.get(default="eel") == "eel"
+
+        t2.set("goldfish")
+        assert t2.get() == "goldfish"
+        assert t2.get(default="tuna") == "goldfish"
+
+    async def second_check() -> None:
+        with pytest.raises(LookupError):
+            t1.get()
+
+        assert t2.get() == "catfish"
+
+    run(first_check)
+    run(second_check)
+
+
+def test_runvar_resetting() -> None:
+    t1 = RunVar[str]("test1")
+    t2 = RunVar[str]("test2", default="dogfish")
+    t3 = RunVar[str]("test3")
+
+    async def reset_check() -> None:
+        token = t1.set("moonfish")
+        assert t1.get() == "moonfish"
+        t1.reset(token)
+
+        with pytest.raises(TypeError):
+            t1.reset(None)  # type: ignore[arg-type]
+
+        with pytest.raises(LookupError):
+            t1.get()
+
+        token2 = t2.set("catdogfish")
+        assert t2.get() == "catdogfish"
+        t2.reset(token2)
+        assert t2.get() == "dogfish"
+
+        with pytest.raises(ValueError, match=r"^token has already been used$"):
+            t2.reset(token2)
+
+        token3 = t3.set("basculin")
+        assert t3.get() == "basculin"
+
+        with pytest.raises(ValueError, match=r"^token is not for us$"):
+            t1.reset(token3)
+
+    run(reset_check)
+
+
+def test_runvar_sync() -> None:
+    t1 = RunVar[str]("test1")
+
+    async def sync_check() -> None:
+        async def task1() -> None:
+            t1.set("plaice")
+            assert t1.get() == "plaice"
+
+        async def task2(tok: RunVarToken[str]) -> None:
+            t1.reset(tok)
+
+            with pytest.raises(LookupError):
+                t1.get()
+
+            t1.set("haddock")
+
+        async with _core.open_nursery() as n:
+            token = t1.set("cod")
+            assert t1.get() == "cod"
+
+            n.start_soon(task1)
+            await _core.wait_all_tasks_blocked()
+            assert t1.get() == "plaice"
+
+            n.start_soon(task2, token)
+            await _core.wait_all_tasks_blocked()
+            assert t1.get() == "haddock"
+
+    run(sync_check)
+
+
+def test_accessing_runvar_outside_run_call_fails() -> None:
+    t1 = RunVar[str]("test1")
+
+    with pytest.raises(RuntimeError):
+        t1.set("asdf")
+
+    with pytest.raises(RuntimeError):
+        t1.get()
+
+    async def get_token() -> RunVarToken[str]:
+        return t1.set("ok")
+
+    token = run(get_token)
+
+    with pytest.raises(RuntimeError):
+        t1.reset(token)

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

@@ -0,0 +1,193 @@
+import time
+from math import inf
+
+import pytest
+
+from trio import sleep
+
+from ... import _core
+from .. import wait_all_tasks_blocked
+from .._mock_clock import MockClock
+from .._run import GLOBAL_RUN_CONTEXT
+from .tutil import slow
+
+
+def test_mock_clock() -> None:
+    REAL_NOW = 123.0
+    c = MockClock()
+    c._real_clock = lambda: REAL_NOW
+    repr(c)  # smoke test
+    assert c.rate == 0
+    assert c.current_time() == 0
+    c.jump(1.2)
+    assert c.current_time() == 1.2
+    with pytest.raises(ValueError, match=r"^time can't go backwards$"):
+        c.jump(-1)
+    assert c.current_time() == 1.2
+    assert c.deadline_to_sleep_time(1.1) == 0
+    assert c.deadline_to_sleep_time(1.2) == 0
+    assert c.deadline_to_sleep_time(1.3) > 999999
+
+    with pytest.raises(ValueError, match=r"^rate must be >= 0$"):
+        c.rate = -1
+    assert c.rate == 0
+
+    c.rate = 2
+    assert c.current_time() == 1.2
+    REAL_NOW += 1
+    assert c.current_time() == 3.2
+    assert c.deadline_to_sleep_time(3.1) == 0
+    assert c.deadline_to_sleep_time(3.2) == 0
+    assert c.deadline_to_sleep_time(4.2) == 0.5
+
+    c.rate = 0.5
+    assert c.current_time() == 3.2
+    assert c.deadline_to_sleep_time(3.1) == 0
+    assert c.deadline_to_sleep_time(3.2) == 0
+    assert c.deadline_to_sleep_time(4.2) == 2.0
+
+    c.jump(0.8)
+    assert c.current_time() == 4.0
+    REAL_NOW += 1
+    assert c.current_time() == 4.5
+
+    c2 = MockClock(rate=3)
+    assert c2.rate == 3
+    assert c2.current_time() < 10
+
+
+async def test_mock_clock_autojump(mock_clock: MockClock) -> None:
+    assert mock_clock.autojump_threshold == inf
+
+    mock_clock.autojump_threshold = 0
+    assert mock_clock.autojump_threshold == 0
+
+    real_start = time.perf_counter()
+
+    virtual_start = _core.current_time()
+    for i in range(10):
+        print(f"sleeping {10 * i} seconds")
+        await sleep(10 * i)
+        print("woke up!")
+        assert virtual_start + 10 * i == _core.current_time()
+        virtual_start = _core.current_time()
+
+    real_duration = time.perf_counter() - real_start
+    print(f"Slept {10 * sum(range(10))} seconds in {real_duration} seconds")
+    assert real_duration < 1
+
+    mock_clock.autojump_threshold = 0.02
+    t = _core.current_time()
+    # this should wake up before the autojump threshold triggers, so time
+    # shouldn't change
+    await wait_all_tasks_blocked()
+    assert t == _core.current_time()
+    # this should too
+    await wait_all_tasks_blocked(0.01)
+    assert t == _core.current_time()
+
+    # set up a situation where the autojump task is blocked for a long long
+    # time, to make sure that cancel-and-adjust-threshold logic is working
+    mock_clock.autojump_threshold = 10000
+    await wait_all_tasks_blocked()
+    mock_clock.autojump_threshold = 0
+    # if the above line didn't take affect immediately, then this would be
+    # bad:
+    # ignore ASYNC116, not sleep_forever, trying to test a large but finite sleep
+    await sleep(100000)  # noqa: ASYNC116
+
+
+async def test_mock_clock_autojump_interference(mock_clock: MockClock) -> None:
+    mock_clock.autojump_threshold = 0.02
+
+    mock_clock2 = MockClock()
+    # messing with the autojump threshold of a clock that isn't actually
+    # installed in the run loop shouldn't do anything.
+    mock_clock2.autojump_threshold = 0.01
+
+    # if the autojump_threshold of 0.01 were in effect, then the next line
+    # would block forever, as the autojump task kept waking up to try to
+    # jump the clock.
+    await wait_all_tasks_blocked(0.015)
+
+    # but the 0.02 limit does apply
+    # ignore ASYNC116, not sleep_forever, trying to test a large but finite sleep
+    await sleep(100000)  # noqa: ASYNC116
+
+
+def test_mock_clock_autojump_preset() -> None:
+    # Check that we can set the autojump_threshold before the clock is
+    # actually in use, and it gets picked up
+    mock_clock = MockClock(autojump_threshold=0.1)
+    mock_clock.autojump_threshold = 0.01
+    real_start = time.perf_counter()
+    _core.run(sleep, 10000, clock=mock_clock)
+    assert time.perf_counter() - real_start < 1
+
+
+async def test_mock_clock_autojump_0_and_wait_all_tasks_blocked_0(
+    mock_clock: MockClock,
+) -> None:
+    # Checks that autojump_threshold=0 doesn't interfere with
+    # calling wait_all_tasks_blocked with the default cushion=0.
+
+    mock_clock.autojump_threshold = 0
+
+    record = []
+
+    async def sleeper() -> None:
+        await sleep(100)
+        record.append("yawn")
+
+    async def waiter() -> None:
+        await wait_all_tasks_blocked()
+        record.append("waiter woke")
+        await sleep(1000)
+        record.append("waiter done")
+
+    async with _core.open_nursery() as nursery:
+        nursery.start_soon(sleeper)
+        nursery.start_soon(waiter)
+
+    assert record == ["waiter woke", "yawn", "waiter done"]
+
+
+@slow
+async def test_mock_clock_autojump_0_and_wait_all_tasks_blocked_nonzero(
+    mock_clock: MockClock,
+) -> None:
+    # Checks that autojump_threshold=0 doesn't interfere with
+    # calling wait_all_tasks_blocked with a non-zero cushion.
+
+    mock_clock.autojump_threshold = 0
+
+    record = []
+
+    async def sleeper() -> None:
+        await sleep(100)
+        record.append("yawn")
+
+    async def waiter() -> None:
+        await wait_all_tasks_blocked(1)
+        record.append("waiter done")
+
+    async with _core.open_nursery() as nursery:
+        nursery.start_soon(sleeper)
+        nursery.start_soon(waiter)
+
+    assert record == ["waiter done", "yawn"]
+
+
+async def test_initialization_doesnt_mutate_runner() -> None:
+    before = (
+        GLOBAL_RUN_CONTEXT.runner.clock,
+        GLOBAL_RUN_CONTEXT.runner.clock_autojump_threshold,
+    )
+
+    MockClock(autojump_threshold=2, rate=3)
+
+    after = (
+        GLOBAL_RUN_CONTEXT.runner.clock,
+        GLOBAL_RUN_CONTEXT.runner.clock_autojump_threshold,
+    )
+    assert before == after

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

@@ -0,0 +1,389 @@
+from __future__ import annotations
+
+import re
+from typing import TypeVar
+
+import pytest
+
+import trio
+from trio.lowlevel import (
+    add_parking_lot_breaker,
+    current_task,
+    remove_parking_lot_breaker,
+)
+
+from ... import _core
+from ...testing import wait_all_tasks_blocked
+from .._parking_lot import ParkingLot
+from .tutil import check_sequence_matches
+
+T = TypeVar("T")
+
+
+async def test_parking_lot_basic() -> None:
+    record = []
+
+    async def waiter(i: int, lot: ParkingLot) -> None:
+        record.append(f"sleep {i}")
+        await lot.park()
+        record.append(f"wake {i}")
+
+    async with _core.open_nursery() as nursery:
+        lot = ParkingLot()
+        assert not lot
+        assert len(lot) == 0
+        assert lot.statistics().tasks_waiting == 0
+        for i in range(3):
+            nursery.start_soon(waiter, i, lot)
+        await wait_all_tasks_blocked()
+        assert len(record) == 3
+        assert bool(lot)
+        assert len(lot) == 3
+        assert lot.statistics().tasks_waiting == 3
+        lot.unpark_all()
+        assert lot.statistics().tasks_waiting == 0
+        await wait_all_tasks_blocked()
+        assert len(record) == 6
+
+    check_sequence_matches(
+        record,
+        [{"sleep 0", "sleep 1", "sleep 2"}, {"wake 0", "wake 1", "wake 2"}],
+    )
+
+    async with _core.open_nursery() as nursery:
+        record = []
+        for i in range(3):
+            nursery.start_soon(waiter, i, lot)
+            await wait_all_tasks_blocked()
+        assert len(record) == 3
+        for _ in range(3):
+            lot.unpark()
+            await wait_all_tasks_blocked()
+        # 1-by-1 wakeups are strict FIFO
+        assert record == [
+            "sleep 0",
+            "sleep 1",
+            "sleep 2",
+            "wake 0",
+            "wake 1",
+            "wake 2",
+        ]
+
+    # It's legal (but a no-op) to try and unpark while there's nothing parked
+    lot.unpark()
+    lot.unpark(count=1)
+    lot.unpark(count=100)
+
+    # Check unpark with count
+    async with _core.open_nursery() as nursery:
+        record = []
+        for i in range(3):
+            nursery.start_soon(waiter, i, lot)
+            await wait_all_tasks_blocked()
+        lot.unpark(count=2)
+        await wait_all_tasks_blocked()
+        check_sequence_matches(
+            record,
+            ["sleep 0", "sleep 1", "sleep 2", {"wake 0", "wake 1"}],
+        )
+        lot.unpark_all()
+
+    with pytest.raises(
+        ValueError,
+        match=r"^Cannot pop a non-integer number of tasks\.$",
+    ):
+        lot.unpark(count=1.5)
+
+
+async def cancellable_waiter(
+    name: T,
+    lot: ParkingLot,
+    scopes: dict[T, _core.CancelScope],
+    record: list[str],
+) -> None:
+    with _core.CancelScope() as scope:
+        scopes[name] = scope
+        record.append(f"sleep {name}")
+        try:
+            await lot.park()
+        except _core.Cancelled:
+            record.append(f"cancelled {name}")
+        else:
+            record.append(f"wake {name}")
+
+
+async def test_parking_lot_cancel() -> None:
+    record: list[str] = []
+    scopes: dict[int, _core.CancelScope] = {}
+
+    async with _core.open_nursery() as nursery:
+        lot = ParkingLot()
+        nursery.start_soon(cancellable_waiter, 1, lot, scopes, record)
+        await wait_all_tasks_blocked()
+        nursery.start_soon(cancellable_waiter, 2, lot, scopes, record)
+        await wait_all_tasks_blocked()
+        nursery.start_soon(cancellable_waiter, 3, lot, scopes, record)
+        await wait_all_tasks_blocked()
+        assert len(record) == 3
+
+        scopes[2].cancel()
+        await wait_all_tasks_blocked()
+        assert len(record) == 4
+        lot.unpark_all()
+        await wait_all_tasks_blocked()
+        assert len(record) == 6
+
+    check_sequence_matches(
+        record,
+        ["sleep 1", "sleep 2", "sleep 3", "cancelled 2", {"wake 1", "wake 3"}],
+    )
+
+
+async def test_parking_lot_repark() -> None:
+    record: list[str] = []
+    scopes: dict[int, _core.CancelScope] = {}
+    lot1 = ParkingLot()
+    lot2 = ParkingLot()
+
+    with pytest.raises(TypeError):
+        lot1.repark([])  # type: ignore[arg-type]
+
+    async with _core.open_nursery() as nursery:
+        nursery.start_soon(cancellable_waiter, 1, lot1, scopes, record)
+        await wait_all_tasks_blocked()
+        nursery.start_soon(cancellable_waiter, 2, lot1, scopes, record)
+        await wait_all_tasks_blocked()
+        nursery.start_soon(cancellable_waiter, 3, lot1, scopes, record)
+        await wait_all_tasks_blocked()
+        assert len(record) == 3
+
+        assert len(lot1) == 3
+        lot1.repark(lot2)
+        assert len(lot1) == 2
+        assert len(lot2) == 1
+        lot2.unpark_all()
+        await wait_all_tasks_blocked()
+        assert len(record) == 4
+        assert record == ["sleep 1", "sleep 2", "sleep 3", "wake 1"]
+
+        lot1.repark_all(lot2)
+        assert len(lot1) == 0
+        assert len(lot2) == 2
+
+        scopes[2].cancel()
+        await wait_all_tasks_blocked()
+        assert len(lot2) == 1
+        assert record == [
+            "sleep 1",
+            "sleep 2",
+            "sleep 3",
+            "wake 1",
+            "cancelled 2",
+        ]
+
+        lot2.unpark_all()
+        await wait_all_tasks_blocked()
+        assert record == [
+            "sleep 1",
+            "sleep 2",
+            "sleep 3",
+            "wake 1",
+            "cancelled 2",
+            "wake 3",
+        ]
+
+
+async def test_parking_lot_repark_with_count() -> None:
+    record: list[str] = []
+    scopes: dict[int, _core.CancelScope] = {}
+    lot1 = ParkingLot()
+    lot2 = ParkingLot()
+    async with _core.open_nursery() as nursery:
+        nursery.start_soon(cancellable_waiter, 1, lot1, scopes, record)
+        await wait_all_tasks_blocked()
+        nursery.start_soon(cancellable_waiter, 2, lot1, scopes, record)
+        await wait_all_tasks_blocked()
+        nursery.start_soon(cancellable_waiter, 3, lot1, scopes, record)
+        await wait_all_tasks_blocked()
+        assert len(record) == 3
+
+        assert len(lot1) == 3
+        assert len(lot2) == 0
+        lot1.repark(lot2, count=2)
+        assert len(lot1) == 1
+        assert len(lot2) == 2
+        while lot2:
+            lot2.unpark()
+            await wait_all_tasks_blocked()
+        assert record == [
+            "sleep 1",
+            "sleep 2",
+            "sleep 3",
+            "wake 1",
+            "wake 2",
+        ]
+        lot1.unpark_all()
+
+
+async def dummy_task(
+    task_status: _core.TaskStatus[_core.Task] = trio.TASK_STATUS_IGNORED,
+) -> None:
+    task_status.started(_core.current_task())
+    await trio.sleep_forever()
+
+
+async def test_parking_lot_breaker_basic() -> None:
+    """Test basic functionality for breaking lots."""
+    lot = ParkingLot()
+    task = current_task()
+
+    # defaults to current task
+    lot.break_lot()
+    assert lot.broken_by == [task]
+
+    # breaking the lot again with the same task appends another copy in `broken_by`
+    lot.break_lot()
+    assert lot.broken_by == [task, task]
+
+    # trying to park in broken lot errors
+    broken_by_str = re.escape(str([task, task]))
+    with pytest.raises(
+        _core.BrokenResourceError,
+        match=f"^Attempted to park in parking lot broken by {broken_by_str}$",
+    ):
+        await lot.park()
+
+
+async def test_parking_lot_break_parking_tasks() -> None:
+    """Checks that tasks currently waiting to park raise an error when the breaker exits."""
+
+    async def bad_parker(lot: ParkingLot, scope: _core.CancelScope) -> None:
+        add_parking_lot_breaker(current_task(), lot)
+        with scope:
+            await trio.sleep_forever()
+
+    lot = ParkingLot()
+    cs = _core.CancelScope()
+
+    # check that parked task errors
+    with pytest.RaisesGroup(
+        pytest.RaisesExc(_core.BrokenResourceError, match="^Parking lot broken by"),
+    ):
+        async with _core.open_nursery() as nursery:
+            nursery.start_soon(bad_parker, lot, cs)
+            await wait_all_tasks_blocked()
+
+            nursery.start_soon(lot.park)
+            await wait_all_tasks_blocked()
+
+            cs.cancel()
+
+
+async def test_parking_lot_breaker_registration() -> None:
+    lot = ParkingLot()
+    task = current_task()
+
+    with pytest.raises(
+        RuntimeError,
+        match="Attempted to remove task as breaker for a lot it is not registered for",
+    ):
+        remove_parking_lot_breaker(task, lot)
+
+    # check that a task can be registered as breaker for the same lot multiple times
+    add_parking_lot_breaker(task, lot)
+    add_parking_lot_breaker(task, lot)
+    remove_parking_lot_breaker(task, lot)
+    remove_parking_lot_breaker(task, lot)
+
+    with pytest.raises(
+        RuntimeError,
+        match="Attempted to remove task as breaker for a lot it is not registered for",
+    ):
+        remove_parking_lot_breaker(task, lot)
+
+    # registering a task as breaker on an already broken lot is fine
+    lot.break_lot()
+    child_task: _core.Task | None = None
+    async with trio.open_nursery() as nursery:
+        child_task = await nursery.start(dummy_task)
+        assert isinstance(child_task, _core.Task)
+        add_parking_lot_breaker(child_task, lot)
+        nursery.cancel_scope.cancel()
+    assert lot.broken_by == [task, child_task]
+
+    # manually breaking a lot with an already exited task is fine
+    lot = ParkingLot()
+    lot.break_lot(child_task)
+    assert lot.broken_by == [child_task]
+
+
+async def test_parking_lot_breaker_rebreak() -> None:
+    lot = ParkingLot()
+    task = current_task()
+    lot.break_lot()
+
+    # breaking an already broken lot with a different task is allowed
+    # The nursery is only to create a task we can pass to lot.break_lot
+    async with trio.open_nursery() as nursery:
+        child_task = await nursery.start(dummy_task)
+        lot.break_lot(child_task)
+        nursery.cancel_scope.cancel()
+
+    assert lot.broken_by == [task, child_task]
+
+
+async def test_parking_lot_multiple_breakers_exit() -> None:
+    # register multiple tasks as lot breakers, then have them all exit
+    lot = ParkingLot()
+    async with trio.open_nursery() as nursery:
+        child_task1 = await nursery.start(dummy_task)
+        child_task2 = await nursery.start(dummy_task)
+        child_task3 = await nursery.start(dummy_task)
+        assert isinstance(child_task1, _core.Task)
+        assert isinstance(child_task2, _core.Task)
+        assert isinstance(child_task3, _core.Task)
+        add_parking_lot_breaker(child_task1, lot)
+        add_parking_lot_breaker(child_task2, lot)
+        add_parking_lot_breaker(child_task3, lot)
+        nursery.cancel_scope.cancel()
+
+    # I think the order is guaranteed currently, but doesn't hurt to be safe.
+    assert set(lot.broken_by) == {child_task1, child_task2, child_task3}
+
+
+async def test_parking_lot_breaker_register_exited_task() -> None:
+    lot = ParkingLot()
+    child_task: _core.Task | None = None
+    async with trio.open_nursery() as nursery:
+        value = await nursery.start(dummy_task)
+        assert isinstance(value, _core.Task)
+        child_task = value
+        nursery.cancel_scope.cancel()
+    # trying to register an exited task as lot breaker errors
+    with pytest.raises(
+        trio.BrokenResourceError,
+        match=r"^Attempted to add already exited task as lot breaker.$",
+    ):
+        add_parking_lot_breaker(child_task, lot)
+
+
+async def test_parking_lot_break_itself() -> None:
+    """Break a parking lot, where the breakee is parked.
+    Doing this is weird, but should probably be supported.
+    """
+
+    async def return_me_and_park(
+        lot: ParkingLot,
+        *,
+        task_status: _core.TaskStatus[_core.Task] = trio.TASK_STATUS_IGNORED,
+    ) -> None:
+        task_status.started(_core.current_task())
+        await lot.park()
+
+    lot = ParkingLot()
+    with pytest.RaisesGroup(
+        pytest.RaisesExc(_core.BrokenResourceError, match="^Parking lot broken by"),
+    ):
+        async with _core.open_nursery() as nursery:
+            child_task = await nursery.start(return_me_and_park, lot)
+            lot.break_lot(child_task)