verifiers 0.3.2.dev52__tar.gz → 0.3.2.dev53__tar.gz

{verifiers-0.3.2.dev52 → verifiers-0.3.2.dev53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev52
+Version: 0.3.2.dev53
 Summary: Verifiers: Environments for LLM Reinforcement Learning
 Project-URL: Homepage, https://github.com/primeintellect-ai/verifiers
 Project-URL: Documentation, https://github.com/primeintellect-ai/verifiers

{verifiers-0.3.2.dev52 → verifiers-0.3.2.dev53}/tests/v1/test_e2e.py

@@ -5,6 +5,9 @@ combinations a test runs — every axis value at least once plus the cross-bound
 with distinct networking — instead of fanning the full cross product. prime/modal rows
 are local-only (their marks are excluded in CI)."""
 
+import subprocess
+import sys
+
 import pytest
 
 mark = pytest.mark
@@ -675,6 +678,37 @@ async def test_multi_agent_env_server(run_v1_server, tmp_path):
         assert trace.metrics["duet"] == 1.0
 
 
+# `_request` parks a cancelled run's fire-and-forget cancel in `_cancel_tasks` with a
+# `discard` done-callback. One loop turn later the sends have finished but the callbacks
+# are still queued behind us, so `close()` meets a set of finished tasks.
+CLOSE_WITH_FINISHED_CANCELS = """
+import asyncio, uuid
+from verifiers.v1.serve.client import EnvClient
+
+async def main():
+    client = EnvClient("tcp://127.0.0.1:1")
+    for _ in range(3):
+        task = asyncio.get_running_loop().create_task(client._send_cancel(uuid.uuid4().hex))
+        client._cancel_tasks.add(task)
+        task.add_done_callback(client._cancel_tasks.discard)
+    await asyncio.sleep(0)
+    assert all(task.done() for task in client._cancel_tasks) and client._cancel_tasks
+    await client.close()
+
+asyncio.run(main())
+"""
+
+
+def test_env_client_close_drains_finished_cancels():
+    """`close()` returns once every fire-and-forget cancel has run, also when all of them
+    finished before it looked: the state Ctrl-C leaves behind in served mode. A child
+    process bounds the check, since a `close()` that never yields to the loop never lets
+    an in-loop timeout fire either."""
+    subprocess.run(
+        [sys.executable, "-c", CLOSE_WITH_FINISHED_CANCELS], check=True, timeout=30
+    )
+
+
 @pytest.mark.e2e
 async def test_replay_round_trip(run_v1, tmp_path):
     """eval -> replay -> replay-the-replay. Offline re-scoring must preserve the saved

{verifiers-0.3.2.dev52 → verifiers-0.3.2.dev53}/verifiers/v1/serve/client.py

@@ -187,8 +187,12 @@ class EnvClient:
             self._receiver = None
         # Let scheduled fire-and-forget cancels reach the socket first, or a
         # run cancelled right before close() leaves its server-side rollout
-        # running. Loop: awaiting one wave can schedule another
+        # running. Pop before awaiting: awaiting finished tasks never yields
+        # (since CPython 3.12 a gather of them completes eagerly), so their
+        # queued `discard` callbacks cannot be what empties the set
         while self._cancel_tasks:
-            await asyncio.gather(*list(self._cancel_tasks), return_exceptions=True)
+            task = self._cancel_tasks.pop()
+            with contextlib.suppress(asyncio.CancelledError):
+                await task
         self.socket.close()
         self.ctx.term()