verifiers 0.2.1.dev1__tar.gz → 0.2.1.dev2__tar.gz

{verifiers-0.2.1.dev1 → verifiers-0.2.1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.2.1.dev1
+Version: 0.2.1.dev2
 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.2.1.dev1 → verifiers-0.2.1.dev2}/verifiers/v1/cli/dashboard/base.py

@@ -9,6 +9,8 @@ from collections.abc import Callable, Iterator
 from rich.console import Group
 from rich.live import Live
 
+from verifiers.v1.utils.interrupt import cleaning_up
+
 try:  # POSIX-only terminal control; absent on Windows, where key reading is skipped.
     import termios
     import tty
@@ -82,10 +84,17 @@ async def live_view(
     """Refresh `render()` every 0.25s until the block exits, then draw one final frame. When
     `on_key` is given, left/right arrow presses are dispatched to it (and redraw at once)."""
     with Live(render(), auto_refresh=False) as live:
+        stopping = False
 
         async def loop() -> None:
             while True:
-                await asyncio.sleep(0.25)
+                try:
+                    await asyncio.sleep(0.25)
+                except asyncio.CancelledError:
+                    # Ctrl-C cancels every task at once; keep refreshing so the cleanup notice
+                    # stays live through teardown, stopping only when live_view tears down.
+                    if stopping or not cleaning_up():
+                        raise
                 live.update(render(), refresh=True)
 
         task = asyncio.create_task(loop())
@@ -93,6 +102,7 @@ async def live_view(
             try:
                 yield
             finally:
+                stopping = True
                 task.cancel()
                 with contextlib.suppress(asyncio.CancelledError):
                     await task

{verifiers-0.2.1.dev1 → verifiers-0.2.1.dev2}/verifiers/v1/cli/dashboard/eval.py

@@ -14,6 +14,7 @@ from rich.text import Text
 
 from verifiers.v1.cli.dashboard.base import live_view
 from verifiers.v1.cli.output import output_path
+from verifiers.v1.utils.interrupt import cleaning_up
 from verifiers.v1.configs.eval import EvalConfig
 from verifiers.v1.rollout import Phase, Rollout
 from verifiers.v1.trace import Trace
@@ -110,6 +111,22 @@ def _aligned(rows: list[list[str]]) -> list[str]:
     ]
 
 
+def _interrupt_footer() -> Group | None:
+    """The graceful-shutdown notice under the rollouts once Ctrl-C has begun teardown — the
+    on-screen echo of the warning (console logging is silenced in rich mode); a further Ctrl-C
+    is ignored while it shows. Sits beside the `--push` line, mirroring its placement."""
+    if not cleaning_up():
+        return None
+    return Group(
+        Rule(style="dim"),
+        Text(
+            "interrupted — cleaning up, tearing down containers/sandboxes. "
+            "please wait; a further ctrl-c is ignored.",
+            style="yellow",
+        ),
+    )
+
+
 def _warning(config: EvalConfig) -> Text | None:
     """A local-runtime caution for a code-running harness (none for the tool-less `null`),
     shown above the overview rather than as a row in it."""
@@ -561,11 +578,11 @@ def _render(
     now = time.time()
     warning = _warning(config)
     header = Group(warning, Text(""), Overview(config)) if warning else Overview(config)
-    # The --push status line appears under the rollouts once the upload starts (None during the run
-    # / when off). Measure the fixed top (header + progress + rule) and the footer so the rollout
-    # rows fill what's left; page through them (timer / arrows) when they'd overflow (else rich
-    # truncates).
-    footer = _push_footer(push)
+    # The --push status line (and, on Ctrl-C, the cleanup notice) appear under the rollouts. Measure
+    # the fixed top (header + progress + rule) and the footer so the rollout rows fill what's left;
+    # page through them (timer / arrows) when they'd overflow (else rich truncates).
+    footers = [f for f in (_push_footer(push), _interrupt_footer()) if f is not None]
+    footer = Group(*footers) if footers else None
     top = Group(header, Progress(rollouts, start), Rule(style="dim"))
     reserved = len(_CONSOLE.render_lines(top))
     if footer is not None:

{verifiers-0.2.1.dev1 → verifiers-0.2.1.dev2}/verifiers/v1/cli/eval/main.py

@@ -2,12 +2,12 @@
 
 import asyncio
 import logging
-import signal
 import sys
 
 from pydantic_config import cli
 
 import verifiers.v1 as vf
+from verifiers.v1.utils.interrupt import install as install_interrupt
 from verifiers.v1.utils.logging import setup_logging
 from verifiers.v1.cli.output import output_path, write_config
 from verifiers.v1.cli.resolve import (
@@ -80,21 +80,30 @@ def main(argv: list[str] | None = None) -> None:
         logging.lastResort = None
     else:
         setup_logging(level, log_file=log_file, console=True)
-    # Make SIGTERM behave like Ctrl-C (SIGINT) so a killed/timed-out eval still runs each
-    # rollout's `finally` (tears down containers/sandboxes) and any worker pool it spawned.
-    signal.signal(signal.SIGTERM, lambda *_: (_ for _ in ()).throw(KeyboardInterrupt()))
+    # First Ctrl-C / SIGTERM warns and raises KeyboardInterrupt so a killed/timed-out eval still
+    # runs each rollout's `finally` (tears down containers/sandboxes) and any worker pool it
+    # spawned; further signals during that cleanup are swallowed so an impatient second Ctrl-C
+    # can't orphan those resources.
+    install_interrupt()
 
-    if config.is_legacy:  # v0 backwards-compat: run the classic env, bridged to Traces
-        from verifiers.v1.legacy import run_legacy_eval
+    try:
+        if (
+            config.is_legacy
+        ):  # v0 backwards-compat: run the classic env, bridged to Traces
+            from verifiers.v1.legacy import run_legacy_eval
 
-        traces = asyncio.run(run_legacy_eval(config))
-    elif config.server:  # opt-in: drive rollouts through the env-server worker pool
-        from verifiers.v1.cli.eval.runner import run_eval_server
+            traces = asyncio.run(run_legacy_eval(config))
+        elif config.server:  # opt-in: drive rollouts through the env-server worker pool
+            from verifiers.v1.cli.eval.runner import run_eval_server
 
-        traces = asyncio.run(run_eval_server(config))
-    else:  # in-process (default), with or without the live dashboard
-        env = vf.Environment(config)
-        traces = asyncio.run(run_eval(env, config))
+            traces = asyncio.run(run_eval_server(config))
+        else:  # in-process (default), with or without the live dashboard
+            env = vf.Environment(config)
+            traces = asyncio.run(run_eval(env, config))
+    except KeyboardInterrupt:
+        # Graceful cleanup has already run (each rollout's `finally`); partial results are on
+        # disk. Exit on the conventional Ctrl-C code without a traceback.
+        raise SystemExit(130)
     if config.push and not rich:
         from verifiers.v1.push import push_traces
 

verifiers-0.2.1.dev2/verifiers/v1/utils/interrupt.py

@@ -0,0 +1,33 @@
+"""Graceful-shutdown signal handling for the eval CLI: the first Ctrl-C/SIGTERM warns and
+raises KeyboardInterrupt so asyncio unwinds each rollout's teardown `finally`; further signals
+are swallowed so a second Ctrl-C can't orphan containers/sandboxes mid-cleanup."""
+
+import logging
+import signal
+
+logger = logging.getLogger(__name__)
+
+_cleaning_up = False
+
+
+def cleaning_up() -> bool:
+    """Whether a shutdown signal has begun graceful cleanup (read by the dashboard)."""
+    return _cleaning_up
+
+
+def install() -> None:
+    """Route SIGINT/SIGTERM through the graceful-shutdown handler."""
+
+    def handle(*_) -> None:
+        global _cleaning_up
+        first, _cleaning_up = not _cleaning_up, True
+        logger.warning(
+            "interrupted — cleaning up, please wait..."
+            if first
+            else "cleanup in progress — please wait (ctrl-c ignored)"
+        )
+        if first:
+            raise KeyboardInterrupt
+
+    signal.signal(signal.SIGINT, handle)
+    signal.signal(signal.SIGTERM, handle)