verifiers 0.1.15.dev160__tar.gz → 0.1.15.dev161__tar.gz

{verifiers-0.1.15.dev160 → verifiers-0.1.15.dev161}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.1.15.dev160
+Version: 0.1.15.dev161
 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.1.15.dev160 → verifiers-0.1.15.dev161}/tests/test_v1_config_extension.py

@@ -2738,68 +2738,6 @@ def test_load_environment_validates_typed_env_config_arg(
     }
 
 
-def test_load_environment_accepts_top_level_taskset_harness_shorthand(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    module_name = "typed_env_config_shorthand"
-    module = types.ModuleType(module_name)
-    seen: dict[str, object] = {}
-
-    def load_environment(split: str = "train", *, config: EnvConfig) -> Env:
-        seen["split"] = split
-        seen["config"] = config
-        return Env(
-            taskset=make_taskset(config=config.taskset),
-            harness=make_harness(config=config.harness),
-        )
-
-    module.load_environment = load_environment
-    monkeypatch.setitem(sys.modules, module_name, module)
-
-    env = vf.load_environment(
-        "typed-env-config-shorthand",
-        split="test",
-        taskset={"taskset_id": "top-level"},
-        harness={"model": {"name": "top-level-model"}},
-    )
-
-    assert seen["split"] == "test"
-    config = seen["config"]
-    assert isinstance(config, EnvConfig)
-    assert config.taskset.taskset_id == "top-level"
-    assert config.harness.model.name == "top-level-model"
-    assert env.taskset.config.taskset_id == "top-level"
-    assert env.harness.config.model.name == "top-level-model"
-    assert env.env_args == {
-        "split": "test",
-        "taskset": {"taskset_id": "top-level"},
-        "harness": {"model": {"name": "top-level-model"}},
-    }
-
-
-def test_load_environment_rejects_duplicate_top_level_config_shorthand(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    module_name = "typed_env_config_duplicate_shorthand"
-    module = types.ModuleType(module_name)
-
-    def load_environment(config: EnvConfig) -> Env:
-        return Env(
-            taskset=make_taskset(config=config.taskset),
-            harness=make_harness(config=config.harness),
-        )
-
-    module.load_environment = load_environment
-    monkeypatch.setitem(sys.modules, module_name, module)
-
-    with pytest.raises(RuntimeError, match="not both"):
-        vf.load_environment(
-            "typed-env-config-duplicate-shorthand",
-            config={"taskset": {"taskset_id": "nested"}},
-            taskset={"taskset_id": "top-level"},
-        )
-
-
 def test_load_environment_validates_env_config_subclass_sections(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -3161,36 +3099,6 @@ def test_load_environment_composes_component_package_without_root_loader(
     assert env.harness.config.max_turns == 3
 
 
-def test_load_environment_component_package_accepts_top_level_config_shorthand(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    module_name = "component_only_taskset_shorthand"
-    module = types.ModuleType(module_name)
-
-    class LocalTasksetConfig(TasksetConfig):
-        answer: str = "configured"
-
-    class LocalTaskset(Taskset[LocalTasksetConfig]):
-        def load_tasks(self, split: vf.TaskSplit = "train") -> vf.Tasks:
-            return [{"prompt": [], "answer": f"{split}:{self.config.answer}"}]
-
-    def load_taskset(config: LocalTasksetConfig) -> LocalTaskset:
-        return LocalTaskset(config=config)
-
-    module.load_taskset = load_taskset
-    monkeypatch.setitem(sys.modules, module_name, module)
-
-    env = vf.load_environment(
-        "component-only-taskset-shorthand",
-        taskset={"answer": "top-level"},
-        harness={"max_turns": 2},
-    )
-
-    assert env.taskset.get_dataset()[0]["answer"] == "train:top-level"
-    assert type(env.harness) is Harness
-    assert env.harness.config.max_turns == 2
-
-
 def test_load_environment_delegates_missing_child_loaders_by_config_id(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:

{verifiers-0.1.15.dev160 → verifiers-0.1.15.dev161}/verifiers/utils/env_utils.py

@@ -14,8 +14,6 @@ from verifiers.v1.harness import Harness, HarnessConfig
 from verifiers.v1.taskset import Taskset, TasksetConfig
 from verifiers.v1.utils.config_utils import coerce_config, explicit_config_data
 
-ENV_CONFIG_SHORTHAND_FIELDS = ("taskset", "harness")
-
 
 def load_environment(env_id: str, **env_args) -> Environment:
     logger = logging.getLogger("verifiers.utils.env_utils")
@@ -205,7 +203,11 @@ def prepare_typed_env_config(
     if config_type is None:
         return env_args
 
-    config, call_env_args = normalize_env_config_args(env_args, config_type)
+    config = env_args.get("config", {})
+    if config is None:
+        raise TypeError("load_environment config must be a concrete EnvConfig object.")
+
+    call_env_args = dict(env_args)
     call_env_args["config"] = load_env_config(module, config_type, config)
     return call_env_args
 
@@ -214,62 +216,19 @@ def load_environment_from_components(
     module: ModuleType,
     env_args: dict,
 ) -> Env:
-    config, call_env_args = normalize_env_config_args(env_args, EnvConfig)
-    extra_args = set(call_env_args)
+    extra_args = set(env_args) - {"config"}
     if extra_args:
         raise TypeError(
             "Default Taskset/Harness environment loading only accepts config; "
             f"got {sorted(extra_args)}."
         )
-    config = load_env_config(module, EnvConfig, config)
+    config = load_env_config(module, EnvConfig, env_args.get("config", {}))
     return Env(
         taskset=load_taskset_from_module(module, config=config.taskset),
         harness=load_harness_from_module(module, config=config.harness),
     )
 
 
-def normalize_env_config_args(
-    env_args: Mapping[str, object],
-    config_type: type[EnvConfig],
-) -> tuple[object, dict[str, object]]:
-    call_env_args = dict(env_args)
-    config = call_env_args.pop("config", {})
-    if config is None:
-        raise TypeError("load_environment config must be a concrete EnvConfig object.")
-
-    shorthand = {
-        field_name: call_env_args.pop(field_name)
-        for field_name in ENV_CONFIG_SHORTHAND_FIELDS
-        if field_name in call_env_args
-    }
-    if not shorthand:
-        return config, call_env_args
-
-    config_data: dict[str, object]
-    if isinstance(config, config_type):
-        config_data = dict(explicit_config_data(config))
-    elif isinstance(config, BaseModel):
-        raise TypeError(
-            f"load_environment config must be {config_type.__name__}; "
-            f"got {type(config).__name__}."
-        )
-    elif isinstance(config, Mapping):
-        config_data = dict(explicit_config_data(config))
-    else:
-        raise TypeError("load_environment config must be a mapping or EnvConfig.")
-
-    duplicate_fields = sorted(set(config_data) & set(shorthand))
-    if duplicate_fields:
-        raise TypeError(
-            "Specify load_environment taskset/harness settings either under config "
-            f"or at top level, not both: {duplicate_fields}."
-        )
-
-    for field_name, value in shorthand.items():
-        config_data[field_name] = value
-    return config_data, call_env_args
-
-
 def env_config_annotation(
     env_load_func: Callable[..., Environment],
     sig: inspect.Signature,