verifiers 0.3.2.dev59__py3-none-any.whl → 0.3.2.dev61__py3-none-any.whl

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/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/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/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 = (
@@ -382,21 +384,14 @@ class PrimeRuntime(Runtime):
             raise SandboxError(f"read {path!r}: {e}") from e
 
     async def write(self, path: str, data: bytes) -> None:
-        # Upload via the gateway (multipart) — never inline the bytes on the command line
-        # (a large file, e.g. a task tarball, overflows the exec command-length limit and
-        # fails with ENAMETOOLONG). The upload does NOT run in the workdir, so resolve a
-        # relative path against it (and mkdir its parent) — otherwise the sidecar writes
-        # it somewhere unwritable ("Operation not permitted").
+        # The gateway creates missing parents and uploads binary data without command-line
+        # limits. Resolve relative paths here because uploads do not use this runtime's workdir.
         target = (
             path
             if path.startswith("/")
             else f"{self.config.workdir.rstrip('/')}/{path}"
         )
         try:
-            await self._client.execute_command(
-                self.info.id,
-                f"mkdir -p {shlex.quote(str(PurePosixPath(target).parent))}",
-            )
             await self._client.upload_bytes(
                 self.info.id, target, data, filename=PurePosixPath(target).name
             )

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

{verifiers-0.3.2.dev59.dist-info → verifiers-0.3.2.dev61.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev59
+Version: 0.3.2.dev61
 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.dist-info → verifiers-0.3.2.dev61.dist-info}/RECORD

@@ -141,12 +141,12 @@ verifiers/v1/mcp/launch.py,sha256=K6M8ZaoOO7wt65s93wK_9Wl7bvjeQ4C8BLkrGE149DI,23
 verifiers/v1/mcp/server.py,sha256=Jqi8OMT8DnoZegXqM3UNNRzhVnbdrPEwx0DjOJo_K2A,13256
 verifiers/v1/mcp/toolset.py,sha256=G2wzNdEMGLXoQUcrwF0TartJkqokNPI3o7YUOAaaa6U,1007
 verifiers/v1/runtimes/__init__.py,sha256=ppc1R_sx-aMcuJSx4t99rTSjloUXI0M6EUj676-1PeY,2862
-verifiers/v1/runtimes/base.py,sha256=SRTUNAcdW0xJIWjfS5RcijFXqdKyXmGvp2tvV58eu58,16826
+verifiers/v1/runtimes/base.py,sha256=kPxbK-VPr4j3Ah0SYlHAMefUJpVF6jTCJkZm7TRVeAs,17376
 verifiers/v1/runtimes/limiters.py,sha256=C6cWDD4pwyFwUY4QFke3oiMXwydSNIfSbJSIglUC2kE,3062
-verifiers/v1/runtimes/modal.py,sha256=yyrqI6agpzi0lp5jR_ExqKwAq8tRgLvHVa3Sd3oh6RU,13222
-verifiers/v1/runtimes/prime.py,sha256=1IWRLKdGgscs8JmvkBdaS3au4tV0KUqv4W1gHJvOE2Q,18781
-verifiers/v1/runtimes/subprocess.py,sha256=IO82fI1wFbeTtV7T1AHSF8iTUyT9yGJFIUmCKKw6CnQ,7763
-verifiers/v1/runtimes/docker/__init__.py,sha256=K6xbJAT1F3-PtgP5Gum2UJKQ8Re1Yz90BP8Uc7Npec4,20594
+verifiers/v1/runtimes/modal.py,sha256=wUNik2Wul1YISausdABIMAoSaTA0MNDwKUayKxVLwAA,13342
+verifiers/v1/runtimes/prime.py,sha256=fbyR5s3WqsJNWki3eHJa83j4iobnqDugdJWm8GwEs7w,18494
+verifiers/v1/runtimes/subprocess.py,sha256=QmpQ235_xrX6gowrr8557VgbydOXpLbfFq0KKGfJThk,8774
+verifiers/v1/runtimes/docker/__init__.py,sha256=JN0mI10a_BKQpRRJKX_NqStAoODAEk2dAJF9mrz69ug,20972
 verifiers/v1/runtimes/docker/egress.py,sha256=iFH_1XotlEM-OCaW7GNu3TWVEq1sqesKYweyVBX8g90,14360
 verifiers/v1/serve/__init__.py,sha256=doImCSxSYZEjVDXfRafLHkhHXcXQxzA6qUGMBQ8bSko,477
 verifiers/v1/serve/client.py,sha256=biy46qOOFTjMXSIsY8W1vMEfctn7usCeNuBQsJqc2mc,7789
@@ -189,8 +189,8 @@ verifiers/v1/utils/prime.py,sha256=UTYRjp9cbjNb6CVmBHda-1wWZAIIfxNOmTyNuT7_wL4,9
 verifiers/v1/utils/retries.py,sha256=Y2ZgrAjn-qNkRKZP_RVNL_7EK0iaRcZeCa404lpGYi4,5417
 verifiers/v1/utils/score.py,sha256=493yJVMw8teCu9JxapxMFPFzI0hNUqdo0Y2nGW4kckk,6200
 verifiers/v1/utils/version.py,sha256=-obEo_-l9-D8FLef4hYxncOe-uJpxrM1g2Hig_37Sgs,1607
-verifiers-0.3.2.dev59.dist-info/METADATA,sha256=PsSfsNRgqhTgCJsBY8_ODR_rUmPRliclAgnVutS2FyY,4204
-verifiers-0.3.2.dev59.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-verifiers-0.3.2.dev59.dist-info/entry_points.txt,sha256=uqQje0TMsr7k6nXlWxlPs13Si0evb3pVCEDF6c-YL80,241
-verifiers-0.3.2.dev59.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
-verifiers-0.3.2.dev59.dist-info/RECORD,,
+verifiers-0.3.2.dev61.dist-info/METADATA,sha256=7o5tiEoE-ol4J9KtYpx1306yqLvQ6cEKtF0inhzekjQ,4204
+verifiers-0.3.2.dev61.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+verifiers-0.3.2.dev61.dist-info/entry_points.txt,sha256=uqQje0TMsr7k6nXlWxlPs13Si0evb3pVCEDF6c-YL80,241
+verifiers-0.3.2.dev61.dist-info/licenses/LICENSE,sha256=v0RrUsdV3IDoZhrRce297IXS3xMHNJ-_LdLpFAUWb9k,1072
+verifiers-0.3.2.dev61.dist-info/RECORD,,