| """Shared dynamic import for test check scripts. |
| |
| Each test keeps its own check script(s) in its own folder (e.g. |
| tests/WC002_biome_placement/main.py) rather than a shared |
| importable package, so loading one means importing by file path, not by |
| package name. Both harness/validate.py (the real pipeline) and |
| scripts/dry_run_regex_patterns.py (the dev tool that sanity-checks a |
| check against real data before it's trusted) need this exact same logic, |
| so it lives here once — dev scripts import it from here, not the other |
| way around. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import importlib.util |
| import sys |
| import types |
| from pathlib import Path |
|
|
| import yaml |
|
|
| REPO_ROOT = Path(__file__).resolve().parent.parent |
| TESTS_DIR = REPO_ROOT / "tests" |
|
|
|
|
| def discover_tests() -> list[dict]: |
| """Every WC* folder with a test.yaml, in ladder order (WC001, WC002, …).""" |
| tests = [] |
| for yaml_path in sorted(TESTS_DIR.glob("WC*/test.yaml")): |
| data = yaml.safe_load(yaml_path.read_text()) or {} |
| tests.append( |
| { |
| "dir_name": yaml_path.parent.name, |
| "id": data.get("id", yaml_path.parent.name), |
| "title": data.get("title", ""), |
| "checks": list(data.get("checks") or []), |
| "needs_capture": bool(data.get("needs_capture")), |
| "path": yaml_path.parent, |
| } |
| ) |
| return tests |
|
|
|
|
| def resolve_test(name: str, tests: list[dict] | None = None) -> dict: |
| """Match WC005, WC005_day_night_seasons, or the yaml id.""" |
| tests = tests if tests is not None else discover_tests() |
| key = name.strip() |
| for test in tests: |
| if key in {test["dir_name"], test["id"]}: |
| return test |
| matches = [t for t in tests if t["dir_name"].startswith(key) or t["id"] == key] |
| if len(matches) == 1: |
| return matches[0] |
| known = ", ".join(t["dir_name"] for t in tests) |
| raise ValueError(f"Unknown test {name!r}. Known: {known}") |
|
|
|
|
| def _evict_loaded_tests() -> None: |
| """Drop modules imported from a previous WC* folder. |
| |
| WC002–WC005 each ship main.py / llm.py / grade.py and do `from llm import`. |
| Loading them by filename leaves those names in sys.modules, so WC003+ |
| bind WC002's copies and never reach run_audited_check (no LangSmith span). |
| """ |
| tests_root = TESTS_DIR.resolve() |
| to_drop = [ |
| name |
| for name, mod in sys.modules.items() |
| if name == "worldbench_checks" or name.startswith("worldbench_checks.") |
| ] |
| for name, mod in sys.modules.items(): |
| file = getattr(mod, "__file__", None) |
| if not file: |
| continue |
| try: |
| resolved = Path(file).resolve() |
| except OSError: |
| continue |
| if resolved.is_relative_to(tests_root): |
| to_drop.append(name) |
| for name in to_drop: |
| sys.modules.pop(name, None) |
|
|
|
|
| def _ensure_namespace(name: str) -> None: |
| if name in sys.modules: |
| return |
| pkg = types.ModuleType(name) |
| pkg.__path__ = [] |
| pkg.__package__ = name |
| sys.modules[name] = pkg |
|
|
|
|
| def load_check(module_path: str | Path, function_name: str): |
| """Load `function_name` from the Python file at `module_path`. |
| |
| Registers the module in sys.modules before exec'ing it — required |
| for @dataclass-decorated classes in the loaded module to work; without |
| it, dataclasses' own introspection can't find the module and raises. |
| |
| Each WC* folder is loaded under a unique name (not just `main`) and |
| previous test modules are evicted so llm/grade/probe do not leak. |
| """ |
| module_path = Path(module_path) |
| _evict_loaded_tests() |
| parent = f"worldbench_checks.{module_path.parent.name}" |
| qualname = f"{parent}.{module_path.stem}" |
| _ensure_namespace("worldbench_checks") |
| _ensure_namespace(parent) |
| spec = importlib.util.spec_from_file_location(qualname, module_path) |
| module = importlib.util.module_from_spec(spec) |
| sys.modules[qualname] = module |
| spec.loader.exec_module(module) |
| return getattr(module, function_name) |
|
|
