"""The training log directory structure: `logs///`. Each of the three segments has its own source, and nowhere is the full path hardcoded: logs/ `tasks.paths.log_root_for`, decided by `--model` the registered robot id generated as a timestamp by mjlab's train entry point mjlab composes `//` (see `log_root_path` in `rl/mjlab/scripts/train.py`), so setting `--log-root` to `logs/` produces the structure wanted -- **with no change to the vendored code**. """ from __future__ import annotations from pathlib import Path import tasks from tasks.paths import LOGS_DIRNAME, NO_MODEL, log_root_for REPO = Path(__file__).resolve().parents[1] # ── logs/ ──────────────────────────────────────────────────────── def test_root_is_logs_slash_model_stem() -> None: assert log_root_for("/somewhere/robot.xml") == f"{LOGS_DIRNAME}/robot" def test_root_accepts_path_objects() -> None: assert log_root_for(Path("assets/smoke/smoke_biped.xml")) == f"{LOGS_DIRNAME}/smoke_biped" def test_no_asset_keeps_the_depth() -> None: """A task with no asset still occupies a segment, or globs like `logs/*//` stop matching.""" assert log_root_for(None) == f"{LOGS_DIRNAME}/{NO_MODEL}" def test_different_models_do_not_share_a_subtree() -> None: """Training one task against different models must split into separate subtrees -- which is why model is the outermost segment.""" assert log_root_for("a/robot.xml") != log_root_for("b/robot_v2.xml") def test_an_onboarded_robot_yields_a_three_segment_path(neutral_robot, tmp_path, monkeypatch): from tasks import registry from tasks.robot_spec import scaffold_robot_spec monkeypatch.setattr(registry, "_REGISTRY", {}) scaffold_robot_spec(neutral_robot, tasks_root=tmp_path) registry.discover_robots(tmp_path) spec = tasks.get(neutral_robot.robot_id) full = f"{log_root_for(spec.resolve_asset(None))}/{spec.id}" assert full == f"{LOGS_DIRNAME}/{neutral_robot.model_path.stem}/{neutral_robot.robot_id}" # ── train.py composes the whole path ────────────────────────────────────── def test_train_composes_all_three_segments() -> None: """`scripts/train.py` builds `logs///` itself. The log root used to be injected as `--log-root` into an argv handed to mjlab's entry point. Now train.py owns the whole path, so this checks the composition at its source rather than through an argv fixture. """ train = (REPO / "scripts" / "train.py").read_text(encoding="utf-8") assert "log_root_for(asset)" in train, "the first segment must come from log_root_for" assert "/ spec.id /" in train, "the second segment must be the task id" assert "_timestamp()" in train, "the third segment must be a timestamp" def test_no_entry_point_lives_outside_scripts() -> None: """Every command-line entry point is a script directly under `scripts/`. There used to be a second set under `scripts/bridge/` that reached mjlab's own entry points, so "how do I replay a policy" had two answers and only one of them went through this repository's backend resolution. Now there is one. The closed list gives each operation a single entry point. Train, play and export use registered tasks. Deploy builds an app. Onboard prepares and measures a new robot before task registration or app assembly. """ assert not (REPO / "scripts" / "bridge").exists(), ( "scripts/bridge/ is retired; entry points live directly under scripts/" ) entries = {p.name for p in (REPO / "scripts").glob("*.py")} assert entries == {"_cli.py", "train.py", "play.py", "export.py", "deploy.py", "onboard.py"}, entries def test_scripts_do_not_know_any_task_s_vocabulary() -> None: """Entry points discover robots and use task-provided behavior. Looking up a literal manager term in a shared entry point couples it to one task's configuration. The check inspects executable lines and allows looking up a term by a name returned from the manager. """ import re scripts = sorted((REPO / "scripts").glob("*.py")) def code(path) -> str: """The lines that run: no docstrings, no comments.""" source = path.read_text(encoding="utf-8") source = re.sub(r'"""[\s\S]*?"""', "", source) source = re.sub(r"'''[\s\S]*?'''", "", source) return "\n".join( line for line in source.splitlines() if line.strip() and not line.strip().startswith("#") ) # A direct lookup by literal key would depend on one task's configuration. reach = re.compile(r"""(get_command|get_term)\(\s*["']""") for script in scripts: found = reach.search(code(script)) assert found is None, ( f"{script.name} calls {found.group(0)!r} -- a manager indexed by a name " f"spelled here, which only one task defines. Look it up from the " f"manager, or ask the task, the way `tasks.load_play_status` does" ) # Entry points should discover registered IDs, even in a populated checkout. for script in scripts: running = code(script) hits = sorted(t for t in tasks.list_ids() if t in running) assert not hits, ( f"{script.name} names the task(s) {hits}. A script that names one " f"cannot be true of the next" )