verifiers 0.1.15.dev10__tar.gz → 0.1.15.dev11__tar.gz

{verifiers-0.1.15.dev10 → verifiers-0.1.15.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.1.15.dev10
+Version: 0.1.15.dev11
 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
@@ -56,7 +56,7 @@ Requires-Dist: stagehand>=3.0.0; extra == 'browser'
 Provides-Extra: openenv
 Requires-Dist: openenv-core>=0.3.0; extra == 'openenv'
 Provides-Extra: renderers
-Requires-Dist: renderers>=0.1.8.dev4; extra == 'renderers'
+Requires-Dist: renderers>=0.1.8.dev28; extra == 'renderers'
 Provides-Extra: rg
 Requires-Dist: reasoning-gym; extra == 'rg'
 Provides-Extra: rl
@@ -220,19 +220,13 @@ custom harnesses, use the v1 Taskset/Harness path:
 # my_env.py
 import verifiers as vf
 
-@vf.reward(weight=1.0)
-async def contains_answer(task, state) -> float:
-    return float(task["answer"] in str(state.get("completion") or ""))
 
 class MyTasksetConfig(vf.TasksetConfig):
     split: str = "train"
 
 
-class MyTaskset(vf.Taskset):
-    config: MyTasksetConfig
-    _default_rewards = (contains_answer,)
-
-    def rows(self) -> list[dict[str, object]]:
+class MyTaskset(vf.Taskset[MyTasksetConfig]):
+    def load_tasks(self) -> vf.Tasks:
         rows = [
             {
                 "prompt": [{"role": "user", "content": "Reverse abc."}],
@@ -243,28 +237,31 @@ class MyTaskset(vf.Taskset):
         ]
         return [row for row in rows if row["split"] == self.config.split]
 
+    @vf.reward(weight=1.0)
+    async def contains_answer(self, task, state) -> float:
+        return float(task["answer"] in str(state.get("completion") or ""))
+
 
 def load_taskset(config: MyTasksetConfig) -> MyTaskset:
-    assert isinstance(config, MyTasksetConfig)
     return MyTaskset(config=config)
 
 
 def load_environment(config: vf.EnvConfig) -> vf.Env:
-    taskset_config = config.taskset
-    assert isinstance(taskset_config, MyTasksetConfig)
-    return vf.Env(taskset=load_taskset(taskset_config))
+    return vf.Env(taskset=vf.load_taskset(config=config.taskset))
 ```
 If no harness is passed, `vf.Env` uses the base endpoint-backed harness. See
 **[BYO Harness](docs/byo-harness.md)** for the advanced v1 taskset/harness API.
-Reusable taskset and harness packages live under `verifiers.v1.packages` while
-the v1 API stabilizes, and are re-exported from `verifiers.v1` for normal use.
-For example, Harbor task directories can run through the bundled OpenCode CLI
+Reusable taskset and harness packages live under `verifiers.v1.packages`. For
+example, Harbor task directories can run through the bundled OpenCode CLI
 harness with:
 
 ```python
+from verifiers.v1.packages.harnesses import OpenCode, OpenCodeConfig
+from verifiers.v1.packages.tasksets import HarborTaskset, HarborTasksetConfig
+
 env = vf.Env(
-    taskset=vf.HarborTaskset(config=vf.HarborTasksetConfig()),
-    harness=vf.OpenCode(config=vf.OpenCodeConfig()),
+    taskset=HarborTaskset(config=HarborTasksetConfig()),
+    harness=OpenCode(config=OpenCodeConfig()),
 )
 ```
 

{verifiers-0.1.15.dev10 → verifiers-0.1.15.dev11}/README.md

@@ -143,19 +143,13 @@ custom harnesses, use the v1 Taskset/Harness path:
 # my_env.py
 import verifiers as vf
 
-@vf.reward(weight=1.0)
-async def contains_answer(task, state) -> float:
-    return float(task["answer"] in str(state.get("completion") or ""))
 
 class MyTasksetConfig(vf.TasksetConfig):
     split: str = "train"
 
 
-class MyTaskset(vf.Taskset):
-    config: MyTasksetConfig
-    _default_rewards = (contains_answer,)
-
-    def rows(self) -> list[dict[str, object]]:
+class MyTaskset(vf.Taskset[MyTasksetConfig]):
+    def load_tasks(self) -> vf.Tasks:
         rows = [
             {
                 "prompt": [{"role": "user", "content": "Reverse abc."}],
@@ -166,28 +160,31 @@ class MyTaskset(vf.Taskset):
         ]
         return [row for row in rows if row["split"] == self.config.split]
 
+    @vf.reward(weight=1.0)
+    async def contains_answer(self, task, state) -> float:
+        return float(task["answer"] in str(state.get("completion") or ""))
+
 
 def load_taskset(config: MyTasksetConfig) -> MyTaskset:
-    assert isinstance(config, MyTasksetConfig)
     return MyTaskset(config=config)
 
 
 def load_environment(config: vf.EnvConfig) -> vf.Env:
-    taskset_config = config.taskset
-    assert isinstance(taskset_config, MyTasksetConfig)
-    return vf.Env(taskset=load_taskset(taskset_config))
+    return vf.Env(taskset=vf.load_taskset(config=config.taskset))
 ```
 If no harness is passed, `vf.Env` uses the base endpoint-backed harness. See
 **[BYO Harness](docs/byo-harness.md)** for the advanced v1 taskset/harness API.
-Reusable taskset and harness packages live under `verifiers.v1.packages` while
-the v1 API stabilizes, and are re-exported from `verifiers.v1` for normal use.
-For example, Harbor task directories can run through the bundled OpenCode CLI
+Reusable taskset and harness packages live under `verifiers.v1.packages`. For
+example, Harbor task directories can run through the bundled OpenCode CLI
 harness with:
 
 ```python
+from verifiers.v1.packages.harnesses import OpenCode, OpenCodeConfig
+from verifiers.v1.packages.tasksets import HarborTaskset, HarborTasksetConfig
+
 env = vf.Env(
-    taskset=vf.HarborTaskset(config=vf.HarborTasksetConfig()),
-    harness=vf.OpenCode(config=vf.OpenCodeConfig()),
+    taskset=HarborTaskset(config=HarborTasksetConfig()),
+    harness=OpenCode(config=OpenCodeConfig()),
 )
 ```
 

{verifiers-0.1.15.dev10 → verifiers-0.1.15.dev11}/pyproject.toml

@@ -74,7 +74,7 @@ dev = [
     "aiohttp>=3.9.0",
     "python-dotenv>=1.0.0",
     "nltk",
-    "renderers>=0.1.8.dev4",
+    "renderers>=0.1.8.dev28",
 ]
 policy = [
     "semgrep>=1.150.0",
@@ -97,7 +97,7 @@ openenv = [
     "openenv-core>=0.3.0",
 ]
 renderers = [
-    "renderers>=0.1.8.dev4",
+    "renderers>=0.1.8.dev28",
 ]
 rl = [
     "torch>=2.8.0,<2.9.0",

{verifiers-0.1.15.dev10 → verifiers-0.1.15.dev11}/tests/test_imports.py

@@ -4,6 +4,37 @@ import sys
 import verifiers
 
 
+PACKAGE_SYMBOLS = {
+    "HarborTaskset",
+    "HarborTasksetConfig",
+    "MiniSWEAgent",
+    "MiniSWEAgentConfig",
+    "OpenCode",
+    "OpenCodeConfig",
+    "Pi",
+    "PiConfig",
+    "RLM",
+    "RLMConfig",
+    "Terminus2",
+    "Terminus2Config",
+    "TextArenaTaskset",
+    "TextArenaTasksetConfig",
+}
+
+
+def test_package_tasksets_and_harnesses_are_not_root_exports():
+    for name in PACKAGE_SYMBOLS:
+        assert name not in verifiers.__all__
+        assert not hasattr(verifiers, name)
+
+
+def test_package_tasksets_and_harnesses_are_not_v1_exports():
+    v1 = importlib.import_module("verifiers.v1")
+    for name in PACKAGE_SYMBOLS:
+        assert name not in v1.__all__
+        assert not hasattr(v1, name)
+
+
 def test_v1_taskset_imports_do_not_import_textarena():
     textarena_module = "verifiers.v1.packages.tasksets.textarena"
     sys.modules.pop(textarena_module, None)

{verifiers-0.1.15.dev10 → verifiers-0.1.15.dev11}/tests/test_init_script.py

@@ -1,5 +1,6 @@
 from pathlib import Path
 
+import pytest
 import verifiers as vf
 from verifiers.scripts.init import init_environment
 
@@ -24,16 +25,19 @@ def test_init_v1_writes_thin_taskset_template(tmp_path: Path) -> None:
     init_environment("bar", path=str(tmp_path), v1=True)
     content = read_env_file(tmp_path, "bar")
 
-    assert 'ENV_ID = "bar"' in content
-    assert "def load_tasks():" in content
-    assert "class EnvTasksetConfig(vf.TasksetConfig):" in content
-    assert 'source: str = "bar:load_tasks"' in content
-    assert 'rewards: list[str] = ["bar:exact_answer"]' in content
-    assert "def load_taskset(config: EnvTasksetConfig) -> vf.Taskset:" in content
-    assert "vf.load_taskset(ENV_ID, config=config.taskset)" in content
+    assert "class BarTasksetConfig(vf.TasksetConfig):" in content
+    assert "class BarTaskset(vf.Taskset[BarTasksetConfig]):" in content
+    assert "def load_tasks(self) -> vf.Tasks:" in content
+    assert "def load_system_prompt(self) -> vf.SystemPrompt:" in content
+    assert "async def correct_answer(self, task: vf.Task, state: vf.State)" in content
+    assert "def load_taskset(config: BarTasksetConfig) -> BarTaskset:" in content
+    assert "return BarTaskset(config=config)" in content
+    assert "vf.load_taskset(config=config.taskset)" in content
     assert "class EnvTaskset(" not in content
     assert "_default_" not in content
     assert "assert isinstance" not in content
+    assert 'tasks: str = "load_tasks"' not in content
+    assert 'rewards: list[str] = ["correct_answer"]' not in content
 
 
 def test_init_v1_template_loads_with_vf_load_environment(
@@ -42,21 +46,19 @@ def test_init_v1_template_loads_with_vf_load_environment(
     init_environment("loadable-v1", path=str(tmp_path), v1=True)
     monkeypatch.syspath_prepend(str(tmp_path / "loadable_v1"))
 
-    env = vf.load_environment("loadable-v1")
-
-    assert isinstance(env, vf.Env)
-    assert env.taskset.rows()[0]["answer"] == "cba"
-    assert env.taskset.rewards[0].__name__ == "exact_answer"
+    with pytest.raises(RuntimeError, match="Load the system prompt"):
+        vf.load_environment("loadable-v1")
 
 
 def test_init_v1_with_harness_writes_harness_stub(tmp_path: Path) -> None:
     init_environment("baz", path=str(tmp_path), v1=True, with_harness=True)
     content = read_env_file(tmp_path, "baz")
 
-    assert "class EnvHarnessConfig(vf.HarnessConfig):" in content
-    assert "class EnvHarness(vf.Harness):" in content
-    assert "def load_harness(config: EnvHarnessConfig) -> EnvHarness:" in content
-    assert "vf.load_harness(ENV_ID, config=config.harness)" in content
+    assert "class BazTaskset(vf.Taskset[BazTasksetConfig]):" in content
+    assert "class BazHarnessConfig(vf.HarnessConfig):" in content
+    assert "class BazHarness(vf.Harness):" in content
+    assert "def load_harness(config: BazHarnessConfig) -> BazHarness:" in content
+    assert "vf.load_harness(config=config.harness)" in content
 
 
 def test_init_with_harness_without_v1_warns_and_uses_v0(tmp_path: Path, capsys) -> None:
@@ -77,4 +79,5 @@ def test_init_v1_multifile_exports_component_loaders(tmp_path: Path) -> None:
 
     assert "from .pkg_env import load_environment, load_taskset" in init_content
     assert "__all__ = ['load_environment', 'load_taskset']" in init_content
-    assert 'source: str = "pkg_env.pkg_env:load_tasks"' in env_content
+    assert "class PkgEnvTaskset(vf.Taskset[PkgEnvTasksetConfig]):" in env_content
+    assert "return PkgEnvTaskset(config=config)" in env_content

{verifiers-0.1.15.dev10 → verifiers-0.1.15.dev11}/tests/test_langchain_deep_agents_wikispeedia.py

@@ -91,8 +91,8 @@ def test_wikispeedia_env_config_reaches_taskset_and_harness(
         )
     )
 
-    train_rows = list(env.taskset.source())
-    eval_rows = list(env.taskset.eval_source())
+    train_rows = [env.taskset.to_task(row) for row in env.taskset.get_dataset()]
+    eval_rows = [env.taskset.to_task(row) for row in env.taskset.get_eval_dataset()]
 
     assert len(train_rows) == 2
     assert len(eval_rows) == 1
@@ -136,8 +136,8 @@ def test_wikispeedia_taskset_sources_use_disjoint_target_split(
         )
     )
 
-    train_rows = list(taskset.source())
-    eval_rows = list(taskset.eval_source())
+    train_rows = [taskset.to_task(row) for row in taskset.get_dataset()]
+    eval_rows = [taskset.to_task(row) for row in taskset.get_eval_dataset()]
 
     assert len(train_rows) == 2
     assert len(eval_rows) == 1
@@ -218,7 +218,7 @@ async def test_wikispeedia_tools_resolve_through_v1_runtime(
         ),
         harness=module.load_harness(config=module.WikispeediaHarnessConfig()),
     )
-    task = module.vf.Task(list(env.taskset.source())[0]).freeze()
+    task = env.taskset.to_task(env.taskset.get_dataset()[0])
     state = module.vf.State.for_task(task)
     state = await env.harness.setup_state(task, state)
 

{verifiers-0.1.15.dev10 → verifiers-0.1.15.dev11}/tests/test_mcp_search_env.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from typing import Any
 
 import pytest
-import verifiers.v1 as vf
+import verifiers as vf
 
 
 def _load_mcp_search_module() -> Any:
@@ -54,7 +54,7 @@ def test_mcp_search_env_preserves_harness_config() -> None:
 def test_mcp_search_default_taskset_has_stable_non_doc_fixture() -> None:
     module = _load_mcp_search_module()
 
-    rows = module.MCPSearchTaskset(config=module.MCPSearchTasksetConfig()).rows()
+    rows = list(module.load_tasks())
 
     assert len(rows) >= 10
     assert len({row["answer"] for row in rows}) == len(rows)
@@ -68,7 +68,7 @@ def test_mcp_search_taskset_accepts_v1_taskset_config() -> None:
     env = module.load_environment(
         config=module.MCPSearchEnvConfig(taskset={"max_turns": 3}),
     )
-    rows = env.taskset.rows()
+    rows = [env.taskset.to_task(row) for row in env.taskset.get_dataset()]
 
     assert env.taskset.config.max_turns == 3
     assert all(row["max_turns"] == 3 for row in rows)

{verifiers-0.1.15.dev10 → verifiers-0.1.15.dev11}/tests/test_opencode_harbor.py

@@ -3,7 +3,9 @@ import sys
 from pathlib import Path
 from typing import Any, cast
 
-import verifiers.v1 as vf
+import verifiers as vf
+from verifiers.v1.packages.harnesses import OpenCode, OpenCodeConfig
+from verifiers.v1.packages.tasksets import HarborTaskset
 
 
 def _load_opencode_module() -> Any:
@@ -31,14 +33,14 @@ def test_load_environment_uses_v1_taskset_and_harness() -> None:
     env = module.load_environment(config=module.OpenCodeHarborEnvConfig())
 
     assert isinstance(env, vf.Env)
-    assert isinstance(env.taskset, vf.HarborTaskset)
-    assert isinstance(env.harness, vf.OpenCode)
-    assert isinstance(env.harness.config, vf.OpenCodeConfig)
+    assert isinstance(env.taskset, HarborTaskset)
+    assert isinstance(env.harness, OpenCode)
+    assert isinstance(env.harness.config, OpenCodeConfig)
     assert not hasattr(module, "OpenCodeHarborHarnessConfig")
     assert not hasattr(module, "TERMINAL_BENCH_SAMPLE_TASKS")
     assert env.taskset.resolve_tasks_root() == Path(module.__file__).parent / "tasks"
     assert env.harness.config.max_turns == 4
-    assert env.harness.config.disabled_tools == vf.OpenCodeConfig().disabled_tools
+    assert env.harness.config.disabled_tools == OpenCodeConfig().disabled_tools
     assert "webfetch" in env.harness.config.disabled_tools
     assert "question" in env.harness.config.disabled_tools
 
@@ -53,11 +55,11 @@ def test_load_environment_accepts_v1_taskset_and_harness_config() -> None:
 
     env = module.load_environment(
         config=module.OpenCodeHarborEnvConfig(
-            taskset=module.vf.HarborTasksetConfig(
+            taskset=module.HarborTasksetConfig(
                 task_names=["task-a"],
                 cpu_cores=1.5,
             ),
-            harness=module.vf.OpenCodeConfig(
+            harness=module.OpenCodeConfig(
                 agent_workdir="/workspace",
                 disabled_tools=["webfetch"],
                 max_turns=2,

{verifiers-0.1.15.dev10 → verifiers-0.1.15.dev11}/tests/test_renderer_client.py

@@ -5,6 +5,7 @@ import pytest
 
 import verifiers as vf
 from renderers import RendererPool
+from renderers import config_from_name
 from renderers.base import ParsedResponse, RenderedTokens, create_renderer
 from verifiers.clients.renderer_client import (
     RendererClient,
@@ -24,13 +25,16 @@ from verifiers.types import (
 )
 
 
-def test_renderer_client_honors_configured_renderer_name():
+def test_renderer_client_honors_configured_renderer_config():
+    from renderers import Qwen3VLRendererConfig
+
     RendererClient._shared_pools.clear()
 
+    cfg = Qwen3VLRendererConfig()
     client = object.__new__(RendererClient)
     client._renderer = None
     client._pool_size = 1
-    client._config = vf.ClientConfig(client_type="renderer", renderer="qwen3_vl")
+    client._config = vf.ClientConfig(client_type="renderer", renderer_config=cfg)
 
     sentinel_pool = RendererPool.__new__(RendererPool)
     with patch(
@@ -42,24 +46,23 @@ def test_renderer_client_honors_configured_renderer_name():
     assert pool is sentinel_pool
     create_pool_mock.assert_called_once_with(
         "Qwen/Qwen3-VL-4B-Instruct",
-        renderer="qwen3_vl",
+        cfg,
         size=1,
-        tool_parser=None,
-        reasoning_parser=None,
-        preserve_all_thinking=False,
-        preserve_thinking_between_tool_calls=False,
     )
 
 
 def test_renderer_client_uses_renderer_model_name_override():
+    from renderers import Qwen3VLRendererConfig
+
     RendererClient._shared_pools.clear()
 
+    cfg = Qwen3VLRendererConfig()
     client = object.__new__(RendererClient)
     client._renderer = None
     client._pool_size = 1
     client._config = vf.ClientConfig(
         client_type="renderer",
-        renderer="qwen3_vl",
+        renderer_config=cfg,
         renderer_model_name="Qwen/Qwen3-VL-4B-Instruct",
     )
 
@@ -73,12 +76,8 @@ def test_renderer_client_uses_renderer_model_name_override():
     assert pool is sentinel_pool
     create_pool_mock.assert_called_once_with(
         "Qwen/Qwen3-VL-4B-Instruct",
-        renderer="qwen3_vl",
+        cfg,
         size=1,
-        tool_parser=None,
-        reasoning_parser=None,
-        preserve_all_thinking=False,
-        preserve_thinking_between_tool_calls=False,
     )
 
 
@@ -524,7 +523,7 @@ def _load_tokenizer_and_renderer(model_name: str, renderer_name: str):
     from transformers import AutoTokenizer
 
     tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
-    renderer = create_renderer(tokenizer, renderer=renderer_name)
+    renderer = create_renderer(tokenizer, config_from_name(renderer_name))
     return tokenizer, renderer
 
 

{verifiers-0.1.15.dev10 → verifiers-0.1.15.dev11}/tests/test_renderer_e2e.py

@@ -17,6 +17,7 @@ Parametrized over five model families so each renderer's render/parse paths
 are exercised. Tokenizers come from the local HF cache; no network.
 """
 
+import json
 import logging
 from typing import Any
 
@@ -24,7 +25,7 @@ import pytest
 
 import verifiers as vf
 from datasets import Dataset
-from renderers import create_renderer
+from renderers import config_from_name, create_renderer
 from verifiers.clients.renderer_client import RendererClient, _to_renderer_message
 from verifiers.types import Messages, State
 
@@ -83,7 +84,7 @@ def _load(model_name: str, renderer_name: str):
         from transformers import AutoTokenizer
 
         tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
-        renderer = create_renderer(tokenizer, renderer=renderer_name)
+        renderer = create_renderer(tokenizer, config_from_name(renderer_name))
         _renderer_cache[key] = (tokenizer, renderer)
     return _renderer_cache[key]
 
@@ -106,6 +107,13 @@ def tokenizer_and_renderer(model_family):
 # ── Scripted vLLM stand-in ───────────────────────────────────────────
 
 
+class _ScriptedResponse:
+    """httpx.Response stand-in: ``parse_generate_response`` reads ``.content`` as bytes."""
+
+    def __init__(self, payload: dict[str, Any]):
+        self.content = json.dumps(payload).encode()
+
+
 class ScriptedVLLM:
     """Fake ``AsyncOpenAI``-compatible client serving canned
     /inference/v1/generate responses (vllm 0.20 wire shape).
@@ -124,22 +132,24 @@ class ScriptedVLLM:
         assert self._completions, "ScriptedVLLM ran out of canned completions"
         completion_ids = self._completions.pop(0)
 
-        return {
-            "request_id": f"resp-{len(self.requests)}",
-            "choices": [
-                {
-                    "index": 0,
-                    "token_ids": list(completion_ids),
-                    "logprobs": {
-                        "content": [
-                            {"token": f"token_id:{tid}", "logprob": -0.1}
-                            for tid in completion_ids
-                        ]
-                    },
-                    "finish_reason": "stop",
-                }
-            ],
-        }
+        return _ScriptedResponse(
+            {
+                "request_id": f"resp-{len(self.requests)}",
+                "choices": [
+                    {
+                        "index": 0,
+                        "token_ids": list(completion_ids),
+                        "logprobs": {
+                            "content": [
+                                {"token": f"token_id:{tid}", "logprob": -0.1}
+                                for tid in completion_ids
+                            ]
+                        },
+                        "finish_reason": "stop",
+                    }
+                ],
+            }
+        )
 
     async def close(self):
         pass

{verifiers-0.1.15.dev10 → verifiers-0.1.15.dev11}/tests/test_v1_bfcl.py

@@ -1,11 +1,11 @@
 import importlib.util
+import sys
 from pathlib import Path
 from types import ModuleType
 
 import pytest
 
-import verifiers as root_vf
-import verifiers.v1 as vf
+import verifiers as vf
 
 
 def load_bfcl_module() -> ModuleType:
@@ -14,6 +14,7 @@ def load_bfcl_module() -> ModuleType:
     assert spec is not None
     assert spec.loader is not None
     module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
     spec.loader.exec_module(module)
     return module
 
@@ -109,7 +110,7 @@ def test_bfcl_loader_supports_category_groups(
     bfcl = load_bfcl_module()
     seen_harness_categories = []
 
-    def fake_source(test_category: str, **kwargs: object):
+    def fake_load_tasks(test_category: str, **kwargs: object):
         _ = kwargs
         return [{"question": test_category, "answer": "a"}]
 
@@ -118,7 +119,7 @@ def test_bfcl_loader_supports_category_groups(
         seen_harness_categories.append(config.test_category)
         return vf.Harness(config=config)
 
-    monkeypatch.setattr(bfcl.BFCLTaskset, "_default_source", fake_source)
+    monkeypatch.setattr(bfcl, "load_tasks", fake_load_tasks)
     monkeypatch.setattr(bfcl, "load_harness", fake_harness)
 
     env = bfcl.load_environment(
@@ -131,7 +132,7 @@ def test_bfcl_loader_supports_category_groups(
         )
     )
 
-    assert isinstance(env, root_vf.EnvGroup)
+    assert isinstance(env, vf.EnvGroup)
     assert env.env_names == ["simple_python", "simple_java"]
     seen_taskset_categories = [item.taskset.config.test_category for item in env.envs]
     assert seen_taskset_categories == ["simple_python", "simple_java"]