verifiers 0.2.2.dev37__tar.gz → 0.2.2.dev39__tar.gz

{verifiers-0.2.2.dev37 → verifiers-0.2.2.dev39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.2.2.dev37
+Version: 0.2.2.dev39
 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.2.dev37 → verifiers-0.2.2.dev39}/tests/v1/conftest.py

@@ -17,7 +17,8 @@ one without `indirect=True` fails loudly.
 Every combination carries its axes' pytest marks, so subsets select with `-m`:
 
     uv run pytest tests/v1 -n auto                                # everything (needs modal setup)
-    uv run pytest tests/v1 -n auto -m "not prime and not modal"  # the CI set (host + docker only)
+    uv run pytest tests/v1 -n auto -m "not e2e"                   # deterministic CI matrix
+    uv run pytest tests/v1 -n auto -m "e2e and not prime and not modal"  # live CI job
     uv run pytest tests/v1 -n auto -m docker                      # any case touching the docker runtime
     uv run pytest tests/v1 -n auto -m bash                        # only the bash harness
     uv run pytest tests/v1 -n auto -m prime                       # only prime (real sandboxes; local)
@@ -27,8 +28,8 @@ Marks: runtimes `subprocess` / `docker` / `prime` / `modal`, placement `colocate
 harnesses `null` / `bash` / `rlm` / `kimi_code` / `pi` / `pool` / `codex` / `claude_code`.
 A mark is applied per axis, so it selects every case touching that value on ANY axis; for one exact
 combination use `-k` on the test id (e.g. `-k "harness-in-docker-with-tool-in-subprocess"`).
-prime/modal provision real remote sandboxes (slow, infra-flaky, need setup), so they're local-only
-— CI runs `-m "not prime and not modal"`.
+prime/modal provision real remote sandboxes (slow, infra-flaky, need setup), so they're local-only.
+CI runs deterministic tests across the Python matrix and the remaining live E2Es once.
 """
 
 import os

{verifiers-0.2.2.dev37 → verifiers-0.2.2.dev39}/verifiers/v1/runtimes/base.py

@@ -13,7 +13,7 @@ from dataclasses import dataclass
 from pathlib import PurePosixPath
 from typing import ClassVar, Self
 
-from pydantic import Field
+from pydantic import Field, model_validator
 from pydantic_config import BaseConfig
 
 from verifiers.v1.errors import SandboxError
@@ -100,15 +100,32 @@ class NetworkPolicyConfig(BaseConfig):
     """Shared execution-time policy surface for runtimes that support it."""
 
     allow: list[str] = Field(default_factory=lambda: ["*"])
-    """Destinations allowed during execution; `*` leaves egress unrestricted."""
+    """Destinations allowed during execution; `*` is unrestricted and `[]` is
+    framework-only."""
     block: list[str] = Field(default_factory=list)
-    """Destinations denied during execution."""
+    """Destinations denied during execution; any `*` makes the policy framework-only."""
+
+    @model_validator(mode="after")
+    def _validate_network_policy(self) -> Self:
+        if not self.allow or "*" in self.block:
+            # Empty allowlists and wildcard blocks both mean framework-only access.
+            self.allow = []
+            self.block = ["*"]
+        elif self.allow != ["*"] and self.block:
+            raise ValueError(
+                "non-empty concrete allow and block egress lists are mutually exclusive"
+            )
+        return self
 
     @property
     def network_restricted(self) -> bool:
         return "*" not in self.allow or bool(self.block)
 
     def with_task_network_policy(self, allow: list[str], block: list[str]) -> Self:
+        values = self.model_dump()
+        if not allow or not self.allow or "*" in block:
+            # Framework-only access is absorbing; composition cannot widen either side.
+            return type(self).model_validate({**values, "allow": [], "block": ["*"]})
         if "*" not in allow:
             allow = (
                 allow
@@ -118,9 +135,7 @@ class NetworkPolicyConfig(BaseConfig):
         else:
             allow = self.allow
         block = list(dict.fromkeys([*block, *self.block]))
-        return type(self).model_validate(
-            {**self.model_dump(), "allow": allow, "block": block}
-        )
+        return type(self).model_validate({**values, "allow": allow, "block": block})
 
 
 class BaseRuntimeInfo(BaseConfig):
@@ -285,7 +300,7 @@ class Runtime(ABC):
 
     async def prepare_execution(self, routes: list[str]) -> None:
         """Last setup step, right before the agent starts. Restricted runtimes enforce
-        their policy here while keeping the interception and MCP `routes` reachable."""
+        their policy here; `routes` identifies the interception and MCP endpoints."""
 
     @property
     def network_restricted(self) -> bool:

{verifiers-0.2.2.dev37 → verifiers-0.2.2.dev39}/verifiers/v1/runtimes/prime.py

@@ -16,6 +16,7 @@ from pathlib import Path, PurePosixPath
 from typing import ClassVar, Literal
 from urllib.parse import urlsplit
 
+from prime_sandboxes.models import validate_egress_lists
 from pydantic import Field, model_validator
 
 from verifiers.v1.errors import SandboxError
@@ -75,12 +76,12 @@ class PrimeConfig(NetworkPolicyConfig):
             raise ValueError(
                 "Prime allow/block egress lists require a VM sandbox (vm=true)"
             )
-        from prime_sandboxes.models import validate_egress_lists
-
-        allow = None if self.allow == ["*"] else self.allow
-        block = self.block or None
-        if allow is not None or block != ["*"]:
-            validate_egress_lists(allow, block)
+        if not self.allow:
+            return self
+        validate_egress_lists(
+            None if self.allow == ["*"] else self.allow,
+            self.block or None,
+        )
         return self
 
     @model_validator(mode="after")
@@ -185,13 +186,15 @@ class PrimeRuntime(Runtime):
         if not self.network_restricted:
             return
         try:
+            hosts = list(
+                dict.fromkeys(
+                    h for h in (urlsplit(route).hostname for route in routes) if h
+                )
+            )
             if self.config.allow == ["*"]:
                 policy = {"deny": self.config.block}
             else:
-                hosts = [h for h in (urlsplit(route).hostname for route in routes) if h]
                 entries = list(dict.fromkeys([*hosts, *self.config.allow]))
-                from prime_sandboxes.models import validate_egress_lists
-
                 validate_egress_lists(entries, None)
                 policy = {"allow": entries} if entries else {"deny": ["*"]}
             status = await self._client.set_network(self.info.id, **policy)

{verifiers-0.2.2.dev37 → verifiers-0.2.2.dev39}/verifiers/v1/task.py

@@ -120,7 +120,8 @@ class TaskData(StrictBaseModel):
     entries. Prime runtimes accept host-level entries and require `vm=true`."""
     network_block: list[str] = Field(default_factory=list)
     """Execution-time destinations denied by this task and combined with runtime
-    blocks. Prime runtimes cannot combine an allowlist and a blocklist."""
+    blocks. Non-empty concrete allowlists cannot be combined with blocklists. Docker
+    framework routes take precedence; ordinary Prime deny rules pass through unchanged."""
     timeout: TaskTimeout = TaskTimeout()
     resources: TaskResources = TaskResources()