simcord 2.2.0__tar.gz → 2.2.1__tar.gz

{simcord-2.2.0 → simcord-2.2.1}/CHANGELOG.md

@@ -4,6 +4,13 @@ This changelog is generated with [towncrier](https://towncrier.readthedocs.io/).
 
 <!-- towncrier release notes start -->
 
+## 2.2.1 (2026-09-24)
+
+### Bug fixes
+
+- Fixed View/Modal expiry recognition for views that never reach the store's dispatch tables — a view whose dispatchable items are all `DynamicItem`s (e.g. a `LayoutView` built only from patterned custom IDs) registered a live expiry task that settlement never recognized, so its `timeout=` blocked actor operations and fired on the wall clock. Expiry tasks are now identified by the coroutine they run (`BaseView.__timeout_task_impl`), which covers every registered view regardless of how the store indexes it.
+
+
 ## 2.2.0 (2026-09-23)
 
 ### Features

{simcord-2.2.0 → simcord-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simcord
-Version: 2.2.0
+Version: 2.2.1
 Summary: Offline discord.py bot testing with pytest. No network, token, or test server.
 Project-URL: Homepage, https://github.com/SilentHacks/simcord
 Project-URL: Documentation, https://simcord.readthedocs.io/

{simcord-2.2.0 → simcord-2.2.1}/docs/concepts.md

@@ -95,13 +95,16 @@ assert channel.last_message.content == "Pong!"   # the reply is already here
 
 Bot-owned work stays bot-owned across parking, timeout, cancellation, later actions, startup,
 and restart. Recognized waits — `Client.wait_for` (including its `timeout=`), View/Modal
-completion, store-registered View/Modal expiry timers, `discord.ext.tasks` loop intervals,
+completion, View/Modal expiry timers, `discord.ext.tasks` loop intervals,
 composed `gather`/`shield`/`wait`/`TaskGroup`, explicit `env.external_wait(...)`, and verified
 far-future sleeps — may remain. A timer whose only job is resuming a recognized wait — a
 `wait_for` deadline on a listener, a View/Modal expiry, a loop interval, a wake-up timer
 scheduled inside `external_wait` — is virtual: it fires only via `env.advance_time()` or the
 awaited input, never the wall clock. Verified far-future sleeps keep their real fallback, and
 a View sent with no dispatchable items never registers (its expiry keeps real-time behavior).
+Views whose dispatchable items are all `DynamicItem`s are covered too — expiry is identified
+from the task's coroutine, not the store's dispatch table; `view.wait()` on such a view is not
+recognized, so `await env.external_wait(view.wait(), reason="...")` if a bot awaits one.
 Unknown waits remain active and time out. Use a reasoned, scoped declaration for external
 input:
 

{simcord-2.2.0 → simcord-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "simcord"
-version = "2.2.0"
+version = "2.2.1"
 description = "Offline discord.py bot testing with pytest. No network, token, or test server."
 readme = "README.md"
 license = "MIT"

{simcord-2.2.0 → simcord-2.2.1}/src/simcord/_dpy_internals.py

@@ -77,6 +77,13 @@ def verify() -> None:
     for suffix in ("__stopped", "__timeout_task"):
         if not any(name.endswith(suffix) for name in vars(view_probe)):  # pragma: no cover
             problems.append(f"BaseView.{suffix}")
+    impl_probe = getattr(_view.BaseView, "_BaseView__timeout_task_impl", None)
+    if (
+        impl_probe is None
+        or not asyncio.iscoroutinefunction(impl_probe)
+        or "self" not in impl_probe.__code__.co_varnames
+    ):  # pragma: no cover
+        problems.append("BaseView._BaseView__timeout_task_impl coroutine")
     if not hasattr(asyncio.timeouts.Timeout(0.0), "_task"):  # pragma: no cover
         problems.append("Timeout._task")
 
@@ -197,7 +204,16 @@ def is_wakeup_callback(callback: Any, args: tuple[Any, ...], waiter: Any, task:
 
 
 def _view_timeout_task_identity(client: discord.Client, task: asyncio.Task[Any]) -> bool:
-    """True when task is some store-registered View/Modal's expiry task."""
+    """True when task is a registered View/Modal's expiry task."""
+    coro = task.get_coro()
+    impl = getattr(_view.BaseView, "_BaseView__timeout_task_impl", None)
+    if impl is not None and getattr(coro, "cr_code", None) is getattr(impl, "__code__", None):
+        owner = getattr(getattr(coro, "cr_frame", None), "f_locals", {}).get("self")
+        if isinstance(owner, _view.BaseView):
+            for name, value in vars(owner).items():
+                if name.endswith("__stopped") and isinstance(value, asyncio.Future) and value.done():
+                    return False
+            return True
     store = getattr(get_state(client), "_view_store", None)
     if store is None:
         return False

{simcord-2.2.0 → simcord-2.2.1}/tests/integration/test_settlement_contract.py

@@ -1074,6 +1074,53 @@ async def test_view_button_click_before_expiry_is_joined():
         assert timeouts == 0
 
 
+@pytest.mark.asyncio
+async def test_fully_dynamic_view_expiry_is_virtual_only():
+    """A LayoutView whose only dispatchable item is a DynamicItem lands solely
+    in the store's pattern table — no ``_views`` entry — yet its expiry task is
+    still a recognized wait: the verb returns promptly, the real clock never
+    fires it, and advance_time() runs on_timeout exactly once."""
+    bot = create_bot()
+    timeouts = 0
+
+    class ApproveButton(discord.ui.DynamicItem[discord.ui.Button], template=r"approve:\d+"):
+        def __init__(self) -> None:
+            super().__init__(discord.ui.Button(label="Approve", custom_id="approve:1"))
+
+        async def callback(self, interaction: discord.Interaction) -> None:
+            await interaction.response.send_message("approved")
+
+    class OfferView(discord.ui.LayoutView):
+        def __init__(self) -> None:
+            super().__init__(timeout=0.3)
+            row = discord.ui.ActionRow()
+            row.add_item(ApproveButton())
+            self.add_item(row)
+
+        async def on_timeout(self) -> None:
+            nonlocal timeouts
+            timeouts += 1
+
+    @bot.tree.command(name="dynamic-offer")
+    async def dynamic_offer(interaction: discord.Interaction) -> None:
+        await interaction.response.send_message(view=OfferView())
+
+    async with simcord.run(bot, settle_timeout=1.0) as env:
+        guild = env.create_guild()
+        alice = guild.add_member(env.create_user("alice"))
+        channel = guild.create_text_channel("general")
+        started = time.monotonic()
+        result = await alice.slash(channel, "dynamic-offer")
+        assert time.monotonic() - started < 0.25
+        assert result.response is not None
+        await asyncio.sleep(0.4)  # past the timeout on the real clock
+        assert timeouts == 0
+        await env.advance_time(0.3)
+        assert timeouts == 1
+        await env.advance_time(0.3)
+        assert timeouts == 1
+
+
 @pytest.mark.asyncio
 async def test_external_wait_covers_timed_awaitable():
     """A declared external_wait around a timed awaitable is fully virtual:

{simcord-2.2.0 → simcord-2.2.1}/tests/unit/test_dpy_internals.py

@@ -143,6 +143,65 @@ async def test_view_timeout_task_identity_handles_missing_store() -> None:
     assert not _dpy_internals._view_timeout_task_identity(client, _fake_task())
 
 
+def _impl_coro_task(view: Any, waiter: Any = None) -> tuple[Any, Any]:
+    """A fake task running the view's real ``__timeout_task_impl`` coroutine."""
+    task = _fake_task(waiter)
+    coro = view._BaseView__timeout_task_impl()  # never awaited; caller closes it
+    task.get_coro = lambda: coro
+    return task, coro
+
+
+async def test_view_timeout_task_identity_matches_impl_coroutine() -> None:
+    """A fully-dynamic view lands in no store container; the coroutine itself
+    still identifies its expiry task."""
+    view = discord.ui.LayoutView(timeout=5)
+    task, coro = _impl_coro_task(view)
+    try:
+        assert _dpy_internals._view_timeout_task_identity(_store_client(), task)
+    finally:
+        coro.close()
+
+
+async def test_view_timeout_task_identity_rejects_stopped_impl_owner() -> None:
+    view = discord.ui.LayoutView(timeout=5)
+    task, coro = _impl_coro_task(view)
+    stopped: asyncio.Future[Any] = asyncio.Future()
+    stopped.set_result(None)
+    stopped_name = next(name for name in vars(view) if name.endswith("__stopped"))
+    vars(view)[stopped_name] = stopped
+    try:
+        assert not _dpy_internals._view_timeout_task_identity(_store_client(), task)
+    finally:
+        coro.close()
+
+
+async def test_view_timeout_task_identity_rejects_foreign_coroutine() -> None:
+    task = _fake_task()
+    task.get_coro = lambda: SimpleNamespace(cr_code=object(), cr_frame=None)
+    assert not _dpy_internals._view_timeout_task_identity(_store_client(), task)
+
+
+async def test_view_timeout_task_identity_ignores_closed_impl_coroutine() -> None:
+    """A finished impl coroutine has no live frame, so no owner to match."""
+    view = discord.ui.LayoutView(timeout=5)
+    coro = view._BaseView__timeout_task_impl()
+    coro.close()
+    task = _fake_task()
+    task.get_coro = lambda: coro
+    assert not _dpy_internals._view_timeout_task_identity(_store_client(), task)
+
+
+async def test_is_intentional_wait_wakeup_impl_coroutine() -> None:
+    view = discord.ui.LayoutView(timeout=5)
+    task, coro = _impl_coro_task(view)
+    try:
+        assert _dpy_internals.is_intentional_wait_wakeup(
+            _store_client(), _set_result_unless_cancelled, (), task
+        )
+    finally:
+        coro.close()
+
+
 async def test_view_expiry_task_requires_pending_waiter() -> None:
     view = discord.ui.View(timeout=5)
     task = _task_with_timeout(view)
@@ -454,6 +513,19 @@ async def test_park_reason_names_view_expiry_and_loop_interval(env: Any) -> None
     assert env._park_reason(loop_task, 5.0) == "discord.ext.tasks loop interval"
 
 
+async def test_park_reason_names_unregistered_view_expiry(env: Any) -> None:
+    """A fully-dynamic view occupies no store container; its expiry task is
+    still a recognized wait, identified by the coroutine it runs."""
+    view = discord.ui.LayoutView(timeout=60)
+    waiter: asyncio.Future[Any] = asyncio.Future()
+    task, coro = _impl_coro_task(view, waiter)
+    try:
+        _record(env, _set_result_unless_cancelled, (waiter,), 10.0)
+        assert env._park_reason(task, 5.0) == "discord View/Modal expiry timer"
+    finally:
+        coro.close()
+
+
 async def test_park_reason_composed_and_sleep_waits(env: Any) -> None:
     listener: asyncio.Future[Any] = asyncio.Future()
     env.bot._listeners.setdefault("on_message", []).append((listener, None))

{simcord-2.2.0 → simcord-2.2.1}/uv.lock

@@ -1780,7 +1780,7 @@ wheels = [
 
 [[package]]
 name = "simcord"
-version = "2.2.0"
+version = "2.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "discord-py" },