verifiers 0.2.2.dev46__tar.gz → 0.2.2.dev48__tar.gz

{verifiers-0.2.2.dev46 → verifiers-0.2.2.dev48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.2.2.dev46
+Version: 0.2.2.dev48
 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.dev46 → verifiers-0.2.2.dev48}/tests/test_install_utils.py

@@ -1,5 +1,5 @@
-import sys
-from unittest.mock import MagicMock, patch
+from importlib.metadata import PackageNotFoundError
+from unittest.mock import patch
 
 import pytest
 
@@ -80,58 +80,32 @@ class TestIsHubEnv:
 
 
 class TestIsInstalled:
-    @patch("verifiers.utils.install_utils.subprocess.run")
-    def test_installed_no_version_check(self, mock_run):
-        mock_run.return_value = MagicMock(
-            returncode=0, stdout="Name: gsm8k\nVersion: 1.0.0\n"
-        )
+    @patch("verifiers.utils.install_utils.package_version", return_value="1.0.0")
+    def test_installed_no_version_check(self, mock_version):
         assert is_installed("gsm8k") is True
-        mock_run.assert_called_once_with(
-            ["uv", "pip", "show", "--python", sys.executable, "gsm8k"],
-            capture_output=True,
-            text=True,
-        )
-
-    @patch("verifiers.utils.install_utils.subprocess.run")
-    def test_not_installed(self, mock_run):
-        mock_run.return_value = MagicMock(returncode=1, stdout="")
+        mock_version.assert_called_once_with("gsm8k")
+
+    @patch("verifiers.utils.install_utils.package_version")
+    def test_not_installed(self, mock_version):
+        mock_version.side_effect = PackageNotFoundError("gsm8k")
         assert is_installed("gsm8k") is False
 
-    @patch("verifiers.utils.install_utils.subprocess.run")
-    def test_installed_version_matches(self, mock_run):
-        mock_run.return_value = MagicMock(
-            returncode=0, stdout="Name: gsm8k\nVersion: 1.0.0\n"
-        )
+    @patch("verifiers.utils.install_utils.package_version", return_value="1.0.0")
+    def test_installed_version_matches(self, mock_version):
         assert is_installed("gsm8k", version="1.0.0") is True
 
-    @patch("verifiers.utils.install_utils.subprocess.run")
-    def test_installed_version_mismatch(self, mock_run):
-        mock_run.return_value = MagicMock(
-            returncode=0, stdout="Name: gsm8k\nVersion: 1.0.0\n"
-        )
+    @patch("verifiers.utils.install_utils.package_version", return_value="1.0.0")
+    def test_installed_version_mismatch(self, mock_version):
         assert is_installed("gsm8k", version="2.0.0") is False
 
-    @patch("verifiers.utils.install_utils.subprocess.run")
-    def test_latest_version_skips_check(self, mock_run):
-        mock_run.return_value = MagicMock(
-            returncode=0, stdout="Name: gsm8k\nVersion: 1.0.0\n"
-        )
+    @patch("verifiers.utils.install_utils.package_version", return_value="1.0.0")
+    def test_latest_version_skips_check(self, mock_version):
         assert is_installed("gsm8k", version="latest") is True
 
-    @patch("verifiers.utils.install_utils.subprocess.run")
-    def test_normalizes_package_name(self, mock_run):
-        mock_run.return_value = MagicMock(returncode=0, stdout="")
+    @patch("verifiers.utils.install_utils.package_version", return_value="1.0.0")
+    def test_normalizes_package_name(self, mock_version):
         is_installed("my-package")
-        mock_run.assert_called_once_with(
-            ["uv", "pip", "show", "--python", sys.executable, "my_package"],
-            capture_output=True,
-            text=True,
-        )
-
-    @patch("verifiers.utils.install_utils.subprocess.run")
-    def test_exception_returns_false(self, mock_run):
-        mock_run.side_effect = Exception("subprocess error")
-        assert is_installed("gsm8k") is False
+        mock_version.assert_called_once_with("my_package")
 
 
 class TestCheckHubEnvInstalled:

{verifiers-0.2.2.dev46 → verifiers-0.2.2.dev48}/verifiers/utils/install_utils.py

@@ -4,6 +4,7 @@ import importlib
 import logging
 import subprocess
 import sys
+from importlib.metadata import PackageNotFoundError, version as package_version
 from pathlib import Path
 from typing import Optional
 from urllib.parse import urlparse
@@ -66,26 +67,10 @@ def is_installed(env_name: str, version: Optional[str] = None) -> bool:
         True if installed (and version matches if specified)
     """
     try:
-        pkg_name = normalize_package_name(env_name)
-        result = subprocess.run(
-            _uv_pip_cmd("show", pkg_name),
-            capture_output=True,
-            text=True,
-        )
-
-        if result.returncode != 0:
-            return False
-
-        if version and version != "latest":
-            for line in result.stdout.splitlines():
-                if line.startswith("Version:"):
-                    installed_version = line.split(":", 1)[1].strip()
-                    return installed_version == version
-            return False
-
-        return True
-    except Exception:
+        installed_version = package_version(normalize_package_name(env_name))
+    except PackageNotFoundError:
         return False
+    return not version or version == "latest" or installed_version == version
 
 
 def check_hub_env_installed(env_id: str) -> bool:

{verifiers-0.2.2.dev46 → verifiers-0.2.2.dev48}/verifiers/v1/cli/debug.py

@@ -18,6 +18,7 @@ import verifiers.v1 as vf
 from verifiers.v1.cli.output import append_trace, save_config
 from verifiers.v1.cli.resolve import (
     extract_id,
+    narrow_taskset_config,
     plugin_errors,
     references_config_file,
     with_positional_taskset,
@@ -43,15 +44,7 @@ USAGE = (
 
 def _narrow(argv: list[str]) -> type[DebugConfig]:
     """`DebugConfig` with `taskset` narrowed to the config type of the id on the CLI."""
-    taskset_id = extract_id(argv, "taskset")
-    if not taskset_id:
-        return DebugConfig
-    ftype = vf.taskset_config_type(taskset_id)
-    return type(
-        DebugConfig.__name__,
-        (DebugConfig,),
-        {"__annotations__": {"taskset": ftype}, "taskset": ftype(id=taskset_id)},
-    )
+    return narrow_taskset_config(DebugConfig, extract_id(argv, "taskset"))
 
 
 def output_path(config: DebugConfig) -> Path:

{verifiers-0.2.2.dev46 → verifiers-0.2.2.dev48}/verifiers/v1/cli/replay.py

@@ -27,6 +27,7 @@ from verifiers.v1.cli.output import (
     save_config,
     write_config,
 )
+from verifiers.v1.cli.resolve import narrow_taskset_config
 from verifiers.v1.configs.agent import WireAgentConfig
 from verifiers.v1.configs.cli.replay import ReplayConfig
 from verifiers.v1.state import state_cls
@@ -49,14 +50,7 @@ def _narrow(config_path: Path) -> type[ReplayConfig]:
     data = tomllib.loads(config_path.read_text())
     taskset = data.get("taskset") or (data.get("env") or {}).get("taskset") or {}
     taskset_id = taskset.get("id")
-    if not taskset_id:
-        return ReplayConfig
-    ftype = vf.taskset_config_type(taskset_id)
-    return type(
-        "ReplayConfig",
-        (ReplayConfig,),
-        {"__annotations__": {"taskset": ftype}, "taskset": ftype(id=taskset_id)},
-    )
+    return narrow_taskset_config(ReplayConfig, taskset_id)
 
 
 def output_dir(config: ReplayConfig) -> Path:

{verifiers-0.2.2.dev46 → verifiers-0.2.2.dev48}/verifiers/v1/cli/resolve.py

@@ -8,9 +8,14 @@ states explicitly is pre-narrowed — never to a type a config file could contra
 """
 
 import contextlib
+from typing import TypeVar
+
+from pydantic import BaseModel, create_model
 
 import verifiers.v1 as vf
 
+ConfigT = TypeVar("ConfigT", bound=BaseModel)
+
 
 @contextlib.contextmanager
 def plugin_errors():
@@ -68,7 +73,19 @@ def extract_id(argv: list[str], field: str, default: str = "") -> str:
     return found[0] if found else default
 
 
-def narrow_config(base: type, argv: list[str]) -> type:
+def narrow_taskset_config(base: type[ConfigT], taskset_id: str | None) -> type[ConfigT]:
+    """Narrow a CLI config's taskset field to the selected plugin config."""
+    if not taskset_id:
+        return base
+    taskset_type = vf.taskset_config_type(taskset_id)
+    return create_model(
+        base.__name__,
+        __base__=base,
+        taskset=(taskset_type, taskset_type(id=taskset_id)),
+    )
+
+
+def narrow_config(base: type[ConfigT], argv: list[str]) -> type[ConfigT]:
     """`base` with its `env` field narrowed to the config class of the env the CLI
     names (`--env.id`, else the taskset's own env, else the single-agent env),
     including its `taskset` sub-field. Ids a config file may set are left to the
@@ -81,18 +98,10 @@ def narrow_config(base: type, argv: list[str]) -> type:
     env_type = vf.env_config_type(taskset_id, env_id)
     if taskset_id:
         # Nested narrowing: `--env.taskset.<knob>` parses typed and renders in -h.
-        taskset_type = vf.taskset_config_type(taskset_id)
-        env_type = type(
-            env_type.__name__,
-            (env_type,),
-            {
-                "__annotations__": {"taskset": taskset_type},
-                "taskset": taskset_type(id=taskset_id),
-            },
-        )
+        env_type = narrow_taskset_config(env_type, taskset_id)
     default = env_type(id=env_id) if env_id else env_type()
-    return type(
+    return create_model(
         base.__name__,
-        (base,),
-        {"__annotations__": {"env": env_type}, "env": default},
+        __base__=base,
+        env=(env_type, default),
     )

{verifiers-0.2.2.dev46 → verifiers-0.2.2.dev48}/verifiers/v1/cli/validate.py

@@ -14,6 +14,7 @@ import verifiers.v1 as vf
 from verifiers.v1.cli.dashboard import TaskProgress, validate_dashboard
 from verifiers.v1.cli.resolve import (
     extract_id,
+    narrow_taskset_config,
     plugin_errors,
     references_config_file,
     with_positional_taskset,
@@ -41,15 +42,7 @@ def _narrow(argv: list[str]) -> type[ValidateConfig]:
     """`ValidateConfig` with `taskset` narrowed to the config type of the id on the CLI — so
     the single `cli()` parse stays typed and `-h` renders the taskset's fields. Absent an id
     (a `@ file.toml` may carry it) the base type is left for the validator to resolve."""
-    taskset_id = extract_id(argv, "taskset")
-    if not taskset_id:
-        return ValidateConfig
-    ftype = vf.taskset_config_type(taskset_id)
-    return type(
-        ValidateConfig.__name__,
-        (ValidateConfig,),
-        {"__annotations__": {"taskset": ftype}, "taskset": ftype(id=taskset_id)},
-    )
+    return narrow_taskset_config(ValidateConfig, extract_id(argv, "taskset"))
 
 
 ResultRow = dict[str, Any]