verifiers 0.3.2.dev59__tar.gz → 0.3.2.dev60__tar.gz

{verifiers-0.3.2.dev59 → verifiers-0.3.2.dev60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev59
+Version: 0.3.2.dev60
 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.dev59 → verifiers-0.3.2.dev60}/verifiers/v1/runtimes/base.py

@@ -316,13 +316,30 @@ class Runtime(ABC):
         """Read `path` into host memory. `max_bytes` caps the transfer, raising past
         the cap — for a file written by something we don't control, whose size we
         can't assume. The cap is enforced inside the box rather than after the
-        transfer, and base64 because `run` returns decoded text. Framework method —
-        override `_read`, not this."""
+        transfer. Framework method — override `_read`, not this."""
         if max_bytes is None:
             return await self._read(path)
+        if max_bytes < 0:
+            raise ValueError("max_bytes must be non-negative")
+        # One extra byte distinguishes an exact fit from a truncated file.
+        data = await self._read(path, max_bytes=max_bytes + 1)
+        if len(data) > max_bytes:
+            raise SandboxError(f"read {path!r}: over the {max_bytes} byte limit")
+        return data
+
+    @abstractmethod
+    async def _read(self, path: str, max_bytes: int | None = None) -> bytes:
+        """Read at most `max_bytes` bytes at the source, or the whole file if None.
+
+        Overrides must accept `max_bytes` and enforce it before transferring data.
+        The public `read` method checks for overflow using one extra byte.
+        Runtimes without bounded binary reads delegate capped reads here, using
+        base64 because `run` returns decoded text.
+        """
+        assert max_bytes is not None
         # Through a temp file, not a pipe: `head | base64` exits with base64's 0
         # even when the path is missing, and a missing file must raise here just
-        # as it does from `_read`.
+        # as it does from a native binary read.
         result = await self.run(
             [
                 "sh",
@@ -333,21 +350,14 @@ class Runtime(ABC):
                     'base64 < "$t"; rc=$?; rm -f "$t"; exit $rc'
                 ),
                 "sh",
-                str(max_bytes + 1),
+                str(max_bytes),
                 path,
             ],
             {},
         )
         if result.exit_code:
             raise SandboxError(f"read {path!r}: {result.stderr.strip()[-500:]}")
-        data = base64.b64decode(result.stdout)
-        if len(data) > max_bytes:
-            raise SandboxError(f"read {path!r}: over the {max_bytes} byte limit")
-        return data
-
-    @abstractmethod
-    async def _read(self, path: str) -> bytes:
-        """Read the whole file at `path`; `read` adds the optional transfer cap."""
+        return base64.b64decode(result.stdout)
 
     @abstractmethod
     async def write(self, path: str, data: bytes) -> None:

{verifiers-0.3.2.dev59 → verifiers-0.3.2.dev60}/verifiers/v1/runtimes/docker/__init__.py

@@ -506,19 +506,28 @@ class DockerRuntime(Runtime):
         if run.exit_code != 0:
             raise SandboxError(f"docker exec -d failed: {run.stderr.strip()}")
 
-    async def _read(self, path: str) -> bytes:
+    async def _read(self, path: str, max_bytes: int | None = None) -> bytes:
+        argv = ["cat"] if max_bytes is None else ["head", "-c", str(max_bytes)]
         proc = await asyncio.create_subprocess_exec(
             "docker",
             "exec",
             "--workdir",
             self.config.workdir,
             self._container,
-            "cat",
+            *argv,
+            "--",
             path,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
         )
-        stdout, stderr = await proc.communicate()
+        try:
+            stdout, stderr = await proc.communicate()
+        except BaseException:
+            if proc.returncode is None:
+                with contextlib.suppress(ProcessLookupError):
+                    proc.kill()
+            await run_shielded(proc.communicate())
+            raise
         if proc.returncode != 0:
             raise SandboxError(
                 f"read {path!r}: {stderr.decode(errors='replace').strip()}"

{verifiers-0.3.2.dev59 → verifiers-0.3.2.dev60}/verifiers/v1/runtimes/modal.py

@@ -279,7 +279,9 @@ class ModalRuntime(Runtime):
             return path
         return f"{self.config.workdir.rstrip('/')}/{path}"
 
-    async def _read(self, path: str) -> bytes:
+    async def _read(self, path: str, max_bytes: int | None = None) -> bytes:
+        if max_bytes is not None:
+            return await super()._read(path, max_bytes)
         try:
             return await self._sandbox.filesystem.read_bytes.aio(self._abs(path))
         except Exception as e:

{verifiers-0.3.2.dev59 → verifiers-0.3.2.dev60}/verifiers/v1/runtimes/prime.py

@@ -365,7 +365,9 @@ class PrimeRuntime(Runtime):
         except Exception as e:
             raise SandboxError(f"prime background launch failed: {e}") from e
 
-    async def _read(self, path: str) -> bytes:
+    async def _read(self, path: str, max_bytes: int | None = None) -> bytes:
+        if max_bytes is not None:
+            return await super()._read(path, max_bytes)
         # Avoid background-job log limits and base64 overhead by downloading binary data directly.
         # The temporary file is removed on every exit, and its byte read stays off the event loop.
         target = (

{verifiers-0.3.2.dev59 → verifiers-0.3.2.dev60}/verifiers/v1/runtimes/subprocess.py

@@ -5,12 +5,14 @@ import contextlib
 import os
 import shutil
 import signal
+import stat
 from collections.abc import AsyncIterator
 from pathlib import Path
 from typing import ClassVar, Literal
 
 from pydantic_config import BaseConfig
 
+from verifiers.v1.errors import SandboxError
 from verifiers.v1.runtimes.base import (
     BaseRuntimeInfo,
     ProgramResult,
@@ -161,8 +163,28 @@ class SubprocessRuntime(Runtime):
             proc
         )  # killed in stop() — a host process won't die on its own
 
-    async def _read(self, path: str) -> bytes:
-        return await asyncio.to_thread((self.workdir / path).read_bytes)
+    async def _read(self, path: str, max_bytes: int | None = None) -> bytes:
+        if max_bytes is None:
+            return await asyncio.to_thread((self.workdir / path).read_bytes)
+
+        # Leave special files to the cancellable shell path without opening a
+        # FIFO and waking its writer. A nonblocking open and descriptor check
+        # also cover a regular path being replaced by a FIFO after the stat.
+        def read() -> bytes | None:
+            target = self.workdir / path
+            if not stat.S_ISREG(target.stat().st_mode):
+                return None
+            fd = os.open(target, os.O_RDONLY | os.O_NONBLOCK)
+            with os.fdopen(fd, "rb") as file:
+                if not stat.S_ISREG(os.fstat(file.fileno()).st_mode):
+                    return None
+                return file.read(max_bytes)
+
+        try:
+            data = await asyncio.to_thread(read)
+        except OSError as exc:
+            raise SandboxError(f"read {path!r}: {exc}") from exc
+        return data if data is not None else await super()._read(path, max_bytes)
 
     async def write(self, path: str, data: bytes) -> None:
         target = self.workdir / path