verifiers 0.3.2.dev104__tar.gz → 0.3.2.dev106__tar.gz

{verifiers-0.3.2.dev104 → verifiers-0.3.2.dev106}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev104
+Version: 0.3.2.dev106
 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.dev104 → verifiers-0.3.2.dev106}/verifiers/v1/cli/dashboard/eval.py

@@ -297,10 +297,10 @@ def _push_footer(push: "PushState | None") -> Group | None:
         line.append(f"  not closed out: {push.error}", style="red")
     elif push.error:
         line = Text(f"Trace push failed ({push.error})", style="red", overflow="fold")
-    elif push.incomplete and push.url:
-        # Closed out, but the uploader lost records: what landed is there, say what didn't.
-        line = Text(f"Traces pushed ({push.url})", style="white", overflow="fold")
-        line.append(f"  incomplete: {push.incomplete}", style="red")
+    elif (incomplete := push.incomplete) and push.url:
+        label = "Traces pushed" if push.finished else "Pushing traces"
+        line = Text(f"{label} ({push.url})", style="white", overflow="fold")
+        line.append(f"  incomplete: {incomplete}", style="red")
     elif not push.finished:
         line = Text(f"Pushing traces ({push.url})", style="dim", overflow="fold")
     else:

{verifiers-0.3.2.dev104 → verifiers-0.3.2.dev106}/verifiers/v1/runtimes/docker/__init__.py

@@ -4,6 +4,7 @@ import array
 import asyncio
 import contextlib
 import logging
+import re
 import shlex
 import socket
 import subprocess
@@ -41,8 +42,9 @@ class DockerConfig(NetworkPolicyConfig):
     memory: float | None = None
     """Hard memory limit in GB (docker `--memory`). None = unlimited."""
     gpu: str | None = None
-    """GPU spec, e.g. "A100" or "2" (docker `--gpus` uses the count; needs the nvidia
-    container toolkit). None = none."""
+    """GPU type[:count] or count only; Docker selects by count. A requested type is
+    checked with nvidia-smi inside the container (case-insensitive, whitespace/hyphen
+    boundaries). Requires the NVIDIA Container Toolkit. None = none."""
     disk: float | None = None
     """Advisory disk request in GB. Docker has no portable per-container size limit, so
     this is accepted (so a task can declare it without a warning) but not enforced."""
@@ -212,7 +214,7 @@ class DockerRuntime(Runtime):
             limits += ["--cpus", str(self.config.cpu)]
         if self.config.memory is not None:
             limits += ["--memory", f"{self.config.memory}g"]
-        _, gpu_count = parse_gpu(self.config.gpu)
+        gpu_type, gpu_count = parse_gpu(self.config.gpu)
         if gpu_count:
             limits += ["--gpus", str(gpu_count)]
         restricted = self.network_restricted
@@ -258,6 +260,29 @@ class DockerRuntime(Runtime):
         self.info.id = run.stdout.strip()[
             :12
         ]  # `docker run -d` prints the container id
+        if gpu_type and gpu_count:
+            # Check the devices Docker actually exposed, including on remote daemons.
+            gpus = await docker(
+                "exec",
+                self._container,
+                "nvidia-smi",
+                "--query-gpu=name",
+                "--format=csv,noheader",
+            )
+            if gpus.exit_code != 0:
+                raise SandboxError(
+                    f"Cannot verify Docker GPU type: {(gpus.stderr or gpus.stdout).strip()}"
+                )
+            names = gpus.stdout.strip().splitlines()
+            if len(names) != gpu_count or any(
+                not re.search(
+                    rf"(?:^|[\s-]){re.escape(gpu_type)}(?:$|[\s-])", name, re.IGNORECASE
+                )
+                for name in names
+            ):
+                raise SandboxError(
+                    f"Requested {self.config.gpu!r}, but Docker exposed: {', '.join(names) or 'no GPUs'}"
+                )
         if restricted:
             # Setup is trusted; colocated servers fetch their task from host interception
             # before the final framework routes are known.

{verifiers-0.3.2.dev104 → verifiers-0.3.2.dev106}/verifiers/v1/utils/platform.py

@@ -24,9 +24,11 @@ class PushState:
 
     run: pr.Run | None = None
     error: str | None = None
-    incomplete: str | None = None
-    """Set when the run closed out but the uploader lost records on the way: the run
-    exists and holds what did land, so the footer says so rather than "failed"."""
+
+    @property
+    def incomplete(self) -> str | None:
+        """Current upload errors and record losses, including while the run is active."""
+        return _losses(self.run) if self.run is not None else None
 
     @property
     def url(self) -> str | None:
@@ -157,9 +159,8 @@ def _close(
         if state.error is None:
             state.error = f"{type(e).__name__}: {e}"
     else:
-        state.incomplete = _losses(run)
-        if state.incomplete:
-            logger.warning("--push: %s, but %s", status.value, state.incomplete)
+        if incomplete := state.incomplete:
+            logger.warning("--push: %s, but %s", status.value, incomplete)
         if run.url:
             # The run's own status: `finish()` is a no-op once another caller closed it.
             logger.info("--push: %s -> %s", run.status.value, run.url)

{verifiers-0.3.2.dev104 → verifiers-0.3.2.dev106}/verifiers/v1/mcp/launch.py

@@ -366,8 +366,8 @@ async def _serve(
             runtime = harness_runtime
         else:
             runtime = make_runtime(cfg.runtime)
-            await runtime.start()
             stack.push_async_callback(runtime.stop)
+            await runtime.start()
         # Only consumers outside the server runtime need its fixed published port. Colocated tools
         # use independent OS-assigned ports, avoiding clashes on the runtime's service port.
         exposed = runtime is not harness_runtime