verifiers 0.3.1.dev11__tar.gz → 0.3.1.dev13__tar.gz

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.3.1.dev11
+Version: 0.3.1.dev13
 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.1.dev11 → verifiers-0.3.1.dev13}/pyproject.toml

@@ -76,10 +76,10 @@ dev = [
 # from this repo. The built-in tasksets/harnesses ship inside verifiers (verifiers/v1/...).
 examples = [
     "compact",
-    "gsm8k-v1", "glossary-v1", "deepwiki-v1", "wiki-search-v1", "code-golf-v1",
-    "proposer-solver-v1", "reverse-text-v1", "color-codeword-v1",
-    "wordle-v1", "openenv-wordle-v1", "alphabet-sort-v1", "scratchpad-v1",
-    "kuhn-poker-v1",
+    "gsm8k", "glossary", "deepwiki", "wiki-search", "code-golf",
+    "proposer-solver", "reverse-text", "color-codeword",
+    "wordle", "openenv-wordle", "alphabet-sort", "scratchpad",
+    "kuhn-poker",
 ]
 
 [project.optional-dependencies]
@@ -151,19 +151,19 @@ default = true
 
 [tool.uv.sources]
 compact = { path = "environments/compact", editable = true }
-glossary-v1 = { path = "environments/glossary_v1", editable = true }
-deepwiki-v1 = { path = "environments/deepwiki_v1", editable = true }
-wiki-search-v1 = { path = "environments/wiki_search_v1", editable = true }
-gsm8k-v1 = { path = "environments/gsm8k_v1", editable = true }
-code-golf-v1 = { path = "environments/code_golf_v1", editable = true }
-proposer-solver-v1 = { path = "environments/proposer_solver_v1", editable = true }
-reverse-text-v1 = { path = "environments/reverse_text_v1", editable = true }
-wordle-v1 = { path = "environments/wordle_v1", editable = true }
-openenv-wordle-v1 = { path = "environments/openenv_wordle_v1", editable = true }
-color-codeword-v1 = { path = "environments/color_codeword_v1", editable = true }
-alphabet-sort-v1 = { path = "environments/alphabet_sort_v1", editable = true }
-scratchpad-v1 = { path = "environments/scratchpad_v1", editable = true }
-kuhn-poker-v1 = { path = "environments/kuhn_poker_v1", editable = true }
+glossary = { path = "environments/glossary", editable = true }
+deepwiki = { path = "environments/deepwiki", editable = true }
+wiki-search = { path = "environments/wiki_search", editable = true }
+gsm8k = { path = "environments/gsm8k", editable = true }
+code-golf = { path = "environments/code_golf", editable = true }
+proposer-solver = { path = "environments/proposer_solver", editable = true }
+reverse-text = { path = "environments/reverse_text", editable = true }
+wordle = { path = "environments/wordle", editable = true }
+openenv-wordle = { path = "environments/openenv_wordle", editable = true }
+color-codeword = { path = "environments/color_codeword", editable = true }
+alphabet-sort = { path = "environments/alphabet_sort", editable = true }
+scratchpad = { path = "environments/scratchpad", editable = true }
+kuhn-poker = { path = "environments/kuhn_poker", editable = true }
 
 [tool.uv.exclude-newer-package]
 # Bounded cutoffs for the explicitly requested tool upgrades.
@@ -178,19 +178,19 @@ prime-pydantic-config = false
 renderers = false
 
 [project.scripts]
-vf-eval = "verifiers.scripts.eval:main"
 eval = "verifiers.v1.cli.eval.main:main"
 validate = "verifiers.v1.cli.validate:main"
 debug = "verifiers.v1.cli.debug:main"
 replay = "verifiers.v1.cli.replay:main"
 init = "verifiers.v1.cli.init:main"
 gepa = "verifiers.v1.cli.gepa:main"
-vf-gepa = "verifiers.scripts.gepa:main"
-vf-init = "verifiers.scripts.init:main"
-vf-install = "verifiers.scripts.install:main"
-vf-setup = "verifiers.scripts.setup:main"
-vf-build = "verifiers.scripts.build:main"
-vf-tui = "verifiers.scripts.tui:main"
+vf-eval = "verifiers.legacy.scripts.eval:main"
+vf-gepa = "verifiers.legacy.scripts.gepa:main"
+vf-init = "verifiers.legacy.scripts.init:main"
+vf-install = "verifiers.legacy.scripts.install:main"
+vf-setup = "verifiers.legacy.scripts.setup:main"
+vf-build = "verifiers.legacy.scripts.build:main"
+vf-tui = "verifiers.legacy.scripts.tui:main"
 
 # hatchling configuration
 [tool.hatch.version]
@@ -238,6 +238,12 @@ Documentation = "https://github.com/primeintellect-ai/verifiers"
 Repository = "https://github.com/primeintellect-ai/verifiers.git"
 Issues = "https://github.com/primeintellect-ai/verifiers/issues"
 
+[tool.ruff.lint.isort]
+# The legacy tree answers at both verifiers.* and verifiers.legacy.* (the
+# package-root alias); path probing would classify the moved submodules as
+# third-party, so pin the whole namespace first-party.
+known-first-party = ["verifiers"]
+
 [tool.pytest.ini_options]
 minversion = "7.0"
 testpaths = ["tests"]
@@ -300,7 +306,7 @@ redundant-cast = "ignore"
 exclude = ["environments", "verifiers/v1"]
 
 [[tool.ty.overrides]]
-include = ["verifiers/envs/experimental/composable/tasksets/**"]
+include = ["verifiers/legacy/envs/experimental/composable/tasksets/**"]
 
 [tool.ty.overrides.rules]
 unresolved-import = "ignore"

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/tests/test_imports.py

@@ -50,8 +50,9 @@ class TestImports:
 
     def test_lazy_imports_work(self):
         """Test that lazy imports work correctly."""
-        # Dynamically detect lazy imports by checking verifiers module
-        lazy_imports = getattr(verifiers, "_LAZY_IMPORTS", {})
+        # The lazy table lives on the legacy package; the root forwards its names.
+        lazy_imports = verifiers.legacy._LAZY_IMPORTS
+        assert lazy_imports, "legacy lazy-import table is empty"
 
         for name in lazy_imports.keys():
             assert name in verifiers.__all__, f"Lazy import {name} not in __all__"

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/tests/v1/conftest.py

@@ -5,8 +5,7 @@ settings that still exercise the path, then assert on the resulting `Trace`(s)
 not unit tests of individual components. They need a model API key (`PRIME_API_KEY`);
 without one the `e2e`-marked tests skip (config parsing still runs).
 
-`run_v1` / `run_v0` mirror the eval CLI's two paths (`run_eval` for a v1 taskset,
-`run_legacy_eval` for a v0 env). Placement coverage (harness x harness runtime x tool
+`run_v1` mirrors the eval CLI's server path (`run_eval`). Placement coverage (harness x harness runtime x tool
 server runtime) is PAIRWISE, not a full cross product: each test carries a curated list of
 combinations (in test_e2e.py) that hits every axis value and the cross-boundary pairs with
 distinct networking. The full cross bought flake exposure and CI minutes, not coverage — add
@@ -46,9 +45,8 @@ from verifiers.v1.utils.loaders import load_environment
 
 CI_MODEL = "openai/gpt-5.6-luna"
 
-# Fixture tasksets/envs (echo-v1, echo-agentic-v1, echo-v0, echo-multi-v0) live in
-# tests/v1/fixtures, added to the path via `pythonpath` in pyproject so the v1 loader and the
-# v0 legacy bridge both resolve them by id (no install).
+# Fixture tasksets (echo-v1, echo-agentic-v1) live in tests/v1/fixtures, added to the
+# path via `pythonpath` in pyproject so the loader resolves them by id (no install).
 
 # The placement fixtures translate one parametrized value each; the combinations live on
 # the tests (`indirect=True`), so coverage is a visible, curated list — never an implicit
@@ -84,7 +82,7 @@ def pytest_configure(config) -> None:
     """Self-launching tool servers run `python -m <module>` in a fresh subprocess, which
     inherits `PYTHONPATH` but not pytest's in-process `pythonpath`. Put the fixture dir on
     `PYTHONPATH` so a fixture server module (e.g. `tool_response_image_v1`)
-    resolves there too — an installed example package (e.g. `glossary_v1`) already would."""
+    resolves there too — an installed example package (e.g. `glossary`) already would."""
     fixtures = str(Path(__file__).parent / "fixtures")
     existing = os.environ.get("PYTHONPATH", "")
     if fixtures not in existing.split(os.pathsep):
@@ -231,31 +229,3 @@ async def live_ctx():
         client=EvalClientConfig(),
         sampling=SamplingConfig(max_tokens=2048),
     )
-
-
-@pytest.fixture
-def run_v0():
-    """Run a legacy v0 env through the v1 bridge (the eval CLI's `--legacy.id` path)."""
-    from verifiers.v1.legacy import run_legacy_eval
-
-    async def _run(
-        env_id: str,
-        *,
-        output_dir: Path,
-        n: int = 1,
-        max_tokens: int = 2048,
-        args: dict | None = None,
-    ) -> list[Trace]:
-        config = EvalConfig(
-            legacy={"id": env_id, "args": args or {}},
-            model=CI_MODEL,
-            num_tasks=1,
-            num_rollouts=n,
-            sampling={"max_tokens": max_tokens},
-            rich=False,
-            output_dir=output_dir,
-        )
-        records = await run_legacy_eval(config)
-        return [t for r in records for t in r.traces]
-
-    return _run

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/tests/v1/test_color_codeword_tasks.py

@@ -1,4 +1,4 @@
-from color_codeword_v1 import taskset
+from color_codeword import taskset
 
 
 def test_color_images_are_rendered_once(monkeypatch) -> None:

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/tests/v1/test_configs.py

@@ -23,5 +23,4 @@ CONFIGS = sorted(
 @pytest.mark.parametrize("path", CONFIGS, ids=lambda p: p.name)
 def test_eval_config_parses(path: Path) -> None:
     config = EvalConfig.model_validate(tomllib.load(path.open("rb")))
-    # resolved to a v1 taskset or a v0 env id
-    assert config.env.taskset.id or config.id
+    assert config.env.taskset.id

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/tests/v1/test_e2e.py

@@ -301,7 +301,7 @@ async def test_shared_tool_isolation(
 ):
     """A shared writable tool isolates state across concurrent rollouts and runtimes."""
     traces = await run_v1_server(
-        "scratchpad-v1",
+        "scratchpad",
         harness="null",
         runtime={"type": harness_runtime},
         output_dir=tmp_path,
@@ -584,7 +584,7 @@ async def test_kuhn_poker_self_play(run_v1, tmp_path):
     """The turn-coupled proof env: one Kuhn poker hand, both seats live interactions
     of the run's own model (self-play), refereed host-side, paid out zero-sum."""
     traces = await run_v1(
-        "kuhn-poker-v1",
+        "kuhn-poker",
         harness=None,  # both seats pin the null harness themselves
         output_dir=tmp_path,
         max_turns=8,
@@ -646,7 +646,7 @@ async def test_replay_round_trip(run_v1, tmp_path):
 
     run_dir = tmp_path / "run"
     (source,) = await run_v1(
-        "reverse-text-v1",
+        "reverse-text",
         harness="null",
         runtime={"type": "subprocess"},
         output_dir=run_dir,

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/tests/v1/test_envs.py

@@ -1,6 +1,6 @@
-"""Smoke-eval every V1 example taskset in `environments/` through the `eval` CLI.
+"""Smoke-eval every example taskset in `environments/` through the `eval` CLI.
 
-Each `_v1` taskset runs with its required harness for one short, capped rollout, so a broken
+Each taskset runs with its required harness for one short, capped rollout, so a broken
 example taskset fails CI. `compact` is excluded (it's a harness, not a taskset);
 SWE/container tasksets need a docker/prime runtime and are covered by dedicated V1 e2e tests.
 """
@@ -18,15 +18,15 @@ EVAL_TIMEOUT = 600  # 10 minutes for a capped eval (-n 1 -r 1)
 ENVIRONMENTS = Path(__file__).parent.parent.parent / "environments"
 
 # V1 tasksets that aren't part of the default CI install.
-SKIP_EVAL = {"nemo_gym_weather_v1"}
+SKIP_EVAL = {"nemo_gym_weather"}
 
 # Per-run caps are seat fields; recipe envs name their own seats.
 SEATS: dict[str, tuple[str, ...]] = {
-    "code_golf_v1": ("golfer",),
-    "kuhn_poker_v1": ("player0", "player1"),
-    "openenv_wordle_v1": ("player",),
-    "proposer_solver_v1": ("proposer", "solver"),
-    "wordle_v1": ("player",),
+    "code_golf": ("golfer",),
+    "kuhn_poker": ("player0", "player1"),
+    "openenv_wordle": ("player",),
+    "proposer_solver": ("proposer", "solver"),
+    "wordle": ("player",),
 }
 
 
@@ -34,7 +34,9 @@ def v1_tasksets() -> list[str]:
     if not ENVIRONMENTS.is_dir():
         return []
     return sorted(
-        d.name for d in ENVIRONMENTS.iterdir() if d.is_dir() and d.name.endswith("_v1")
+        d.name
+        for d in ENVIRONMENTS.iterdir()
+        if d.is_dir() and d.name != "compact" and (d / "pyproject.toml").exists()
     )
 
 

verifiers-0.3.1.dev13/verifiers/__init__.py

@@ -0,0 +1,152 @@
+"""The verifiers package root.
+
+The v1 stack lives in `verifiers.v1`; the classic (v0) stack lives in
+`verifiers.legacy`. The v0 modules also answer at their historical top-level
+paths — `verifiers.envs`, `verifiers.types`, `import verifiers as vf`, ... —
+through the alias finder below, so importing this package root stays
+side-effect free (the v0 surface only loads when something touches it).
+"""
+
+import pkgutil
+import sys
+from functools import cache
+from importlib import import_module
+from importlib.abc import InspectLoader, Loader, MetaPathFinder
+from importlib.machinery import ModuleSpec
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _version
+from importlib.util import find_spec
+from typing import TYPE_CHECKING
+
+try:
+    __version__ = _version("verifiers")
+except PackageNotFoundError:  # source tree without install metadata
+    __version__ = "0.0.0+unknown"
+
+
+@cache
+def _legacy_modules() -> frozenset:
+    """Top-level modules of `verifiers.legacy`, addressable at `verifiers.<name>`.
+    Read off the package directory, without executing its `__init__`."""
+    spec = find_spec("verifiers.legacy")
+    if spec is None or spec.submodule_search_locations is None:
+        return frozenset()
+    return frozenset(
+        module.name for module in pkgutil.iter_modules(spec.submodule_search_locations)
+    )
+
+
+class LegacyAliasFinder(MetaPathFinder, Loader):
+    """Resolve `verifiers.<v0 module>` to `verifiers.legacy.<module>`.
+
+    The loaded module is the legacy module object itself (one instance, aliased
+    in `sys.modules` under both names), so `verifiers.types.State is
+    verifiers.legacy.types.State`. Installed at the *front* of `sys.meta_path`
+    so the path finder never re-executes an aliased package's children under
+    the old name.
+    """
+
+    _prefix = "verifiers."
+    _legacy_prefix = "verifiers.legacy."
+
+    def _legacy_name(self, fullname: str) -> str:
+        return self._legacy_prefix + fullname.removeprefix(self._prefix)
+
+    def find_spec(self, fullname, path=None, target=None):
+        if not fullname.startswith(self._prefix):
+            return None
+        top = fullname.removeprefix(self._prefix).split(".", 1)[0]
+        # `legacy` first: probing the membership set resolves `verifiers.legacy`
+        # through this very finder, so it must pass through before the lookup.
+        if top in ("legacy", "v1", "cli") or top not in _legacy_modules():
+            return None
+        legacy_name = self._legacy_name(fullname)
+        try:
+            legacy_spec = find_spec(legacy_name)
+        except ModuleNotFoundError as e:
+            # A miss on the probed module itself just means the alias has no
+            # target; anything else (a missing dependency raised while the
+            # legacy package initializes) is a real failure and must surface.
+            if e.name and legacy_name.startswith(e.name):
+                legacy_spec = None
+            else:
+                raise
+        if legacy_spec is None:  # unknown submodule: fail like any missing import
+            return None
+        spec = ModuleSpec(
+            fullname,
+            self,
+            origin=legacy_spec.origin,
+            is_package=legacy_spec.submodule_search_locations is not None,
+        )
+        if legacy_spec.submodule_search_locations is not None:
+            # The real search path (not a copy), so package walkers —
+            # pkgutil.iter_modules over the alias spec, child imports through
+            # the parent's __path__ — see the legacy tree.
+            spec.submodule_search_locations = legacy_spec.submodule_search_locations
+        return spec
+
+    def create_module(self, spec):
+        module = import_module(self._legacy_name(spec.name))
+        # module_from_spec is about to stamp the alias spec onto this shared
+        # module object; stash its real identity for exec_module to restore.
+        spec.loader_state = (
+            module.__dict__.get("__spec__"),
+            module.__dict__.get("__loader__"),
+        )
+        return module
+
+    def exec_module(self, module):
+        # Restore the legacy module's own __spec__/__loader__ so reload,
+        # find_spec on the module, and importlib.resources keep seeing its
+        # real identity — the alias exists only in sys.modules.
+        alias_spec = module.__dict__.get("__spec__")
+        state = getattr(alias_spec, "loader_state", None)
+        if state:
+            real_spec, real_loader = state
+            if real_spec is not None:
+                module.__spec__ = real_spec
+                module.__loader__ = real_loader or real_spec.loader
+                if real_spec.submodule_search_locations is not None:
+                    module.__path__ = real_spec.submodule_search_locations
+
+    def _inspect_loader(self, fullname: str) -> tuple[str, InspectLoader]:
+        legacy_name = self._legacy_name(fullname)
+        spec = find_spec(legacy_name)
+        if spec is None or not isinstance(spec.loader, InspectLoader):
+            raise ImportError(
+                f"no loadable source behind alias {fullname!r}", name=fullname
+            )
+        return legacy_name, spec.loader
+
+    # runpy (`python -m verifiers.<v0 module>`) executes through the loader.
+    def get_code(self, fullname):
+        legacy_name, loader = self._inspect_loader(fullname)
+        return loader.get_code(legacy_name)
+
+    def get_source(self, fullname):
+        legacy_name, loader = self._inspect_loader(fullname)
+        return loader.get_source(legacy_name)
+
+
+if not any(isinstance(finder, LegacyAliasFinder) for finder in sys.meta_path):
+    sys.meta_path.insert(0, LegacyAliasFinder())
+
+
+def __getattr__(name: str):
+    """`vf.XMLParser`-style access forwards to the v0 surface in
+    `verifiers.legacy` (loaded on first touch). `__all__` forwards too, so
+    `from verifiers import *` keeps its pre-move meaning."""
+    if name.startswith("_") and name != "__all__":
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    legacy = import_module("verifiers.legacy")
+    return getattr(legacy, name)
+
+
+def __dir__():
+    legacy = import_module("verifiers.legacy")
+    return sorted(set(globals()) | set(legacy.__all__) | _legacy_modules())
+
+
+if TYPE_CHECKING:  # static view of the forwarded surface
+    from verifiers.legacy import *

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/verifiers/cli/commands/build.py

@@ -2,7 +2,7 @@
 
 """Environment build command module for external hosts."""
 
-from verifiers.scripts.build import main
+from verifiers.legacy.scripts.build import main
 
 
 if __name__ == "__main__":

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/verifiers/cli/commands/eval.py

@@ -2,7 +2,7 @@
 
 """Evaluation command module for external hosts."""
 
-from verifiers.scripts.eval import (
+from verifiers.legacy.scripts.eval import (
     build_extra_headers,
     build_parser,
     main,

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/verifiers/cli/commands/gepa.py

@@ -2,7 +2,7 @@
 
 """GEPA command module for external hosts."""
 
-from verifiers.scripts.gepa import main
+from verifiers.legacy.scripts.gepa import main
 
 
 if __name__ == "__main__":

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/verifiers/cli/commands/init.py

@@ -2,7 +2,7 @@
 
 """Environment initialization command module for external hosts."""
 
-from verifiers.scripts.init import main
+from verifiers.legacy.scripts.init import main
 
 
 if __name__ == "__main__":

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/verifiers/cli/commands/install.py

@@ -2,7 +2,7 @@
 
 """Environment install command module for external hosts."""
 
-from verifiers.scripts.install import main
+from verifiers.legacy.scripts.install import main
 
 
 if __name__ == "__main__":

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/verifiers/cli/commands/setup.py

@@ -1,6 +1,6 @@
 """Workspace setup command module for external hosts."""
 
-from verifiers.scripts.setup import main, run_setup
+from verifiers.legacy.scripts.setup import main, run_setup
 
 __all__ = ["main", "run_setup"]
 

{verifiers-0.3.1.dev11 → verifiers-0.3.1.dev13}/verifiers/cli/tui.py

@@ -1,6 +1,6 @@
 """TUI exports for host CLIs."""
 
-from verifiers.scripts.tui import main
+from verifiers.legacy.scripts.tui import main
 
 __all__ = ["main"]
 

{verifiers-0.3.1.dev11/verifiers → verifiers-0.3.1.dev13/verifiers/legacy}/__init__.py

@@ -109,39 +109,39 @@ __all__ = [
 ]
 
 _LAZY_IMPORTS = {
-    "Client": "verifiers.clients.client:Client",
+    "Client": "verifiers.legacy.clients.client:Client",
     "AnthropicMessagesClient": (
-        "verifiers.clients.anthropic_messages_client:AnthropicMessagesClient"
+        "verifiers.legacy.clients.anthropic_messages_client:AnthropicMessagesClient"
     ),
     "OpenAIChatCompletionsClient": (
-        "verifiers.clients.openai_chat_completions_client:OpenAIChatCompletionsClient"
+        "verifiers.legacy.clients.openai_chat_completions_client:OpenAIChatCompletionsClient"
     ),
-    "RendererClient": ("verifiers.clients.renderer_client:RendererClient"),
+    "RendererClient": ("verifiers.legacy.clients.renderer_client:RendererClient"),
     "OpenAICompletionsClient": (
-        "verifiers.clients.openai_completions_client:OpenAICompletionsClient"
+        "verifiers.legacy.clients.openai_completions_client:OpenAICompletionsClient"
     ),
     "OpenAIResponsesClient": (
-        "verifiers.clients.openai_responses_client:OpenAIResponsesClient"
+        "verifiers.legacy.clients.openai_responses_client:OpenAIResponsesClient"
     ),
-    "Environment": "verifiers.envs.environment:Environment",
-    "MultiTurnEnv": "verifiers.envs.multiturn_env:MultiTurnEnv",
-    "SingleTurnEnv": "verifiers.envs.singleturn_env:SingleTurnEnv",
-    "StatefulToolEnv": "verifiers.envs.stateful_tool_env:StatefulToolEnv",
-    "ToolEnv": "verifiers.envs.tool_env:ToolEnv",
-    "EnvGroup": "verifiers.envs.env_group:EnvGroup",
-    "JudgeRubric": "verifiers.rubrics.judge_rubric:JudgeRubric",
-    "load_environment": "verifiers.utils.env_utils:load_environment",
-    "MathRubric": "verifiers.rubrics.math_rubric:MathRubric",
-    "SandboxEnv": "verifiers.envs.sandbox_env:SandboxEnv",
-    "PythonEnv": "verifiers.envs.python_env:PythonEnv",
-    "GymEnv": "verifiers.envs.experimental.gym_env:GymEnv",
-    "CliAgentEnv": "verifiers.envs.experimental.cli_agent_env:CliAgentEnv",
-    "HarborEnv": "verifiers.envs.experimental.harbor_env:HarborEnv",
-    "MCPEnv": "verifiers.envs.experimental.mcp_env:MCPEnv",
-    "ReasoningGymEnv": "verifiers.envs.integrations.reasoninggym_env:ReasoningGymEnv",
-    "TextArenaEnv": "verifiers.envs.integrations.textarena_env:TextArenaEnv",
-    "BrowserEnv": "verifiers.envs.integrations.browser_env:BrowserEnv",
-    "OpenEnvEnv": "verifiers.envs.integrations.openenv_env:OpenEnvEnv",
+    "Environment": "verifiers.legacy.envs.environment:Environment",
+    "MultiTurnEnv": "verifiers.legacy.envs.multiturn_env:MultiTurnEnv",
+    "SingleTurnEnv": "verifiers.legacy.envs.singleturn_env:SingleTurnEnv",
+    "StatefulToolEnv": "verifiers.legacy.envs.stateful_tool_env:StatefulToolEnv",
+    "ToolEnv": "verifiers.legacy.envs.tool_env:ToolEnv",
+    "EnvGroup": "verifiers.legacy.envs.env_group:EnvGroup",
+    "JudgeRubric": "verifiers.legacy.rubrics.judge_rubric:JudgeRubric",
+    "load_environment": "verifiers.legacy.utils.env_utils:load_environment",
+    "MathRubric": "verifiers.legacy.rubrics.math_rubric:MathRubric",
+    "SandboxEnv": "verifiers.legacy.envs.sandbox_env:SandboxEnv",
+    "PythonEnv": "verifiers.legacy.envs.python_env:PythonEnv",
+    "GymEnv": "verifiers.legacy.envs.experimental.gym_env:GymEnv",
+    "CliAgentEnv": "verifiers.legacy.envs.experimental.cli_agent_env:CliAgentEnv",
+    "HarborEnv": "verifiers.legacy.envs.experimental.harbor_env:HarborEnv",
+    "MCPEnv": "verifiers.legacy.envs.experimental.mcp_env:MCPEnv",
+    "ReasoningGymEnv": "verifiers.legacy.envs.integrations.reasoninggym_env:ReasoningGymEnv",
+    "TextArenaEnv": "verifiers.legacy.envs.integrations.textarena_env:TextArenaEnv",
+    "BrowserEnv": "verifiers.legacy.envs.integrations.browser_env:BrowserEnv",
+    "OpenEnvEnv": "verifiers.legacy.envs.integrations.openenv_env:OpenEnvEnv",
 }
 
 
@@ -150,7 +150,7 @@ def __getattr__(name: str):
         module, attr = _LAZY_IMPORTS[name].split(":")
         return getattr(importlib.import_module(module), attr)
     except KeyError:
-        raise AttributeError(f"module 'verifiers' has no attribute '{name}'")
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
     except ModuleNotFoundError as e:
         if name == "RendererClient":
             raise

{verifiers-0.3.1.dev11/verifiers → verifiers-0.3.1.dev13/verifiers/legacy}/clients/__init__.py

@@ -1,17 +1,19 @@
 # ruff: noqa
 
-from verifiers.clients.anthropic_messages_client import AnthropicMessagesClient
-from verifiers.clients.client import Client
-from verifiers.clients.nemorl_chat_completions_client import (
+from verifiers.legacy.clients.anthropic_messages_client import AnthropicMessagesClient
+from verifiers.legacy.clients.client import Client
+from verifiers.legacy.clients.nemorl_chat_completions_client import (
     NeMoRLChatCompletionsClient,
 )
-from verifiers.clients.openai_chat_completions_client import OpenAIChatCompletionsClient
-from verifiers.clients.openai_chat_completions_token_client import (
+from verifiers.legacy.clients.openai_chat_completions_client import (
+    OpenAIChatCompletionsClient,
+)
+from verifiers.legacy.clients.openai_chat_completions_token_client import (
     OpenAIChatCompletionsTokenClient,
 )
-from verifiers.clients.openai_completions_client import OpenAICompletionsClient
-from verifiers.clients.openai_responses_client import OpenAIResponsesClient
-from verifiers.types import ClientConfig
+from verifiers.legacy.clients.openai_completions_client import OpenAICompletionsClient
+from verifiers.legacy.clients.openai_responses_client import OpenAIResponsesClient
+from verifiers.legacy.types import ClientConfig
 
 
 def resolve_client(client_or_config: Client | ClientConfig) -> Client:
@@ -31,7 +33,7 @@ def resolve_client(client_or_config: Client | ClientConfig) -> Client:
             case "openai_responses":
                 return OpenAIResponsesClient(client_or_config)
             case "renderer":
-                from verifiers.clients.renderer_client import RendererClient
+                from verifiers.legacy.clients.renderer_client import RendererClient
 
                 return RendererClient(client_or_config)
             case "anthropic_messages":
@@ -44,10 +46,10 @@ def resolve_client(client_or_config: Client | ClientConfig) -> Client:
 
 def __getattr__(name: str):
     if name == "RendererClient":
-        from verifiers.clients.renderer_client import RendererClient
+        from verifiers.legacy.clients.renderer_client import RendererClient
 
         return RendererClient
-    raise AttributeError(f"module 'verifiers.clients' has no attribute '{name}'")
+    raise AttributeError(f"module 'verifiers.legacy.clients' has no attribute '{name}'")
 
 
 __all__ = [

{verifiers-0.3.1.dev11/verifiers → verifiers-0.3.1.dev13/verifiers/legacy}/clients/anthropic_messages_client.py

@@ -30,9 +30,9 @@ from anthropic.types import (
     ToolParam as AnthropicToolParam,
 )
 
-from verifiers.clients.client import Client
-from verifiers.errors import EmptyModelResponseError, OverlongPromptError
-from verifiers.types import (
+from verifiers.legacy.clients.client import Client
+from verifiers.legacy.errors import EmptyModelResponseError, OverlongPromptError
+from verifiers.legacy.types import (
     AssistantMessage,
     ClientConfig,
     FinishReason,
@@ -49,7 +49,7 @@ from verifiers.types import (
     Usage,
     UserMessage,
 )
-from verifiers.utils.client_utils import setup_anthropic_client
+from verifiers.legacy.utils.client_utils import setup_anthropic_client
 
 
 ANTHROPIC_ADAPTIVE_THINKING_MODELS = {

{verifiers-0.3.1.dev11/verifiers → verifiers-0.3.1.dev13/verifiers/legacy}/clients/client.py

@@ -13,8 +13,8 @@ from anthropic import (
 from openai import AuthenticationError as OpenAIAuthenticationError
 from openai import PermissionDeniedError as OpenAIPermissionDeniedError
 
-from verifiers.errors import Error, ModelError
-from verifiers.types import (
+from verifiers.legacy.errors import Error, ModelError
+from verifiers.legacy.types import (
     ClientConfig,
     Messages,
     Response,