code backup: tests

tests/test_calibration/test_report.py

@@ -0,0 +1,95 @@
+"""Tests for calibration/report.py -- budget stats and the recommendation rule."""
+
+import json
+
+from calibration import report as calibration_report
+
+
+def _record(question_id, score, forced=False, reasoning_tokens=100, seconds=1.0):
+    return {
+        "question_id": question_id,
+        "question_type": "object_counting",
+        "answer_expected": "4",
+        "metric": "MRA:.5:.95:.05",
+        "score": score,
+        "forced": forced,
+        "reasoning_token_count": reasoning_tokens,
+        "generation_seconds": seconds,
+    }
+
+
+def test_cell_stats_counts_forced_and_natural_lengths():
+    stats = calibration_report.cell_stats(
+        [
+            _record(1, 1.0, forced=False, reasoning_tokens=50),
+            _record(2, 0.0, forced=True, reasoning_tokens=512),
+        ]
+    )
+    assert stats["count"] == 2
+    assert stats["forced_rate"] == 0.5
+    # Forced records are excluded from the natural-stop length mean.
+    assert stats["natural_reasoning_tokens_mean"] == 50
+
+
+def test_report_scores_only_the_shared_question_intersection():
+    grid = {
+        "m": {
+            256: {1: _record(1, 0.0), 2: _record(2, 1.0)},
+            512: {1: _record(1, 1.0)},  # never answered q2
+        }
+    }
+    result = calibration_report.report(grid)
+    assert result["m"]["questions"] == 1
+    assert result["m"]["budgets"][256]["count"] == 1
+
+
+def test_recommendation_picks_smallest_saturated_low_forced_budget():
+    grid = {
+        "m": {
+            256: {1: _record(1, 0.0, forced=True)},
+            512: {1: _record(1, 1.0, forced=False)},
+            2048: {1: _record(1, 1.0, forced=False)},
+        }
+    }
+    result = calibration_report.report(grid, tolerance=1.0, max_forced_rate=0.15)
+    assert result["m"]["recommended"] == 512
+
+
+def test_recommendation_rejects_high_forced_rate_even_at_best_accuracy():
+    grid = {
+        "m": {
+            256: {1: _record(1, 1.0, forced=True)},   # accurate but 100% forced
+            1024: {1: _record(1, 1.0, forced=False)},
+        }
+    }
+    result = calibration_report.report(grid, max_forced_rate=0.15)
+    assert result["m"]["recommended"] == 1024
+
+
+def test_load_grid_reads_the_full_config_layout(tmp_path):
+    cell = (
+        tmp_path / "qwen3.5-2b" / "explicit" / "metric" / "tracking"
+        / "selective" / "64" / "512" / "scene_a"
+    )
+    cell.mkdir(parents=True)
+    (cell / "7.json").write_text(json.dumps(_record(7, 1.0)))
+    grid = calibration_report.load_grid(tmp_path)
+    assert grid == {
+        "qwen3.5-2b/explicit/metric/tracking/selective/64": {
+            512: {7: json.loads((cell / "7.json").read_text())}
+        }
+    }
+
+
+def test_load_grid_does_not_mistake_frame_count_dirs_for_budgets(tmp_path):
+    # The "64" frame-count level is numeric too -- only the budget leaf (whose
+    # children are scene folders with JSONs) may be treated as a budget.
+    cell = (
+        tmp_path / "qwen3.5-2b" / "explicit" / "metric" / "tracking"
+        / "selective" / "64" / "512" / "scene_a"
+    )
+    cell.mkdir(parents=True)
+    (cell / "7.json").write_text(json.dumps(_record(7, 1.0)))
+    grid = calibration_report.load_grid(tmp_path)
+    assert list(grid) == ["qwen3.5-2b/explicit/metric/tracking/selective/64"]
+    assert list(grid["qwen3.5-2b/explicit/metric/tracking/selective/64"]) == [512]

tests/test_calibration/test_run.py

@@ -0,0 +1,81 @@
+"""Tests for calibration/run.py -- operator-specified budget-grid orchestration."""
+
+import pytest
+
+from calibration import run as calibration_run
+
+
+def test_results_dir_isolates_every_pilot_axis():
+    base = ("qwen3.5-4b", "explicit", "metric", "tracking", "selective", 32, 512)
+    variants = {calibration_run.results_dir_for(*base)}
+    for index, value in [
+        (0, "qwen3.5-2b"), (1, "compact"), (2, "relative"), (3, "no tracking"),
+        (4, "uniform"), (5, 64), (6, 1024),
+    ]:
+        changed = list(base)
+        changed[index] = value
+        variants.add(calibration_run.results_dir_for(*changed))
+    assert len(variants) == 8
+
+
+def test_build_plan_orders_cheapest_budget_first():
+    plan = calibration_run.build_plan(["m1", "m2"], [2048, 256])
+    assert plan == [("m1", 256), ("m2", 256), ("m1", 2048), ("m2", 2048)]
+
+
+def test_scenes_for_derives_scenes_and_rejects_unknown_ids(monkeypatch):
+    rows = [
+        {"id": 1, "scene_name": "scene_a"},
+        {"id": 2, "scene_name": "scene_b"},
+        {"id": 3, "scene_name": "scene_a"},
+    ]
+    monkeypatch.setattr(calibration_run, "load_questions", lambda: list(rows))
+    assert calibration_run.scenes_for({1, 2, 3}) == ["scene_a", "scene_b"]
+    with pytest.raises(ValueError):
+        calibration_run.scenes_for({1, 999})
+
+
+def test_run_grid_passes_budget_questions_and_isolated_dir(monkeypatch):
+    launched = []
+    monkeypatch.setattr(calibration_run, "scenes_for", lambda ids: ["scene_a"])
+    monkeypatch.setattr(
+        calibration_run.harness_b_launch, "launch",
+        lambda model, fmt, sel, frames, scenes, **kwargs: launched.append(
+            (model, fmt, kwargs["reasoning_budget"], str(kwargs["results_dir"]),
+             kwargs["question_ids"], scenes)
+        ),
+    )
+    calibration_run.run_grid(
+        ["qwen3.5-2b"], [256, 512], [1, 2], "compact",
+        "metric", "tracking", "selective", 64,
+    )
+    assert [(m, f, b) for m, f, b, _, _, _ in launched] == [
+        ("qwen3.5-2b", "compact", 256), ("qwen3.5-2b", "compact", 512),
+    ]
+    assert launched[0][3] != launched[1][3]
+    assert launched[0][4] == {1, 2}
+    assert launched[0][5] == ["scene_a"]
+
+
+def test_cli_requires_exactly_one_question_source(monkeypatch, capsys):
+    monkeypatch.setattr(
+        "sys.argv",
+        ["run", "--models", "qwen3.5-2b", "--budgets", "256",
+         "--spatial-code-format", "explicit", "--depth", "metric",
+         "--tracking", "tracking", "--input-selection", "selective", "--frames", "32"],
+    )
+    with pytest.raises(SystemExit):
+        calibration_run.main()
+    assert "exactly one of" in capsys.readouterr().err
+
+
+def test_cli_rejects_nonpositive_budget(monkeypatch, capsys):
+    monkeypatch.setattr(
+        "sys.argv",
+        ["run", "--models", "qwen3.5-2b", "--budgets", "0", "--questions", "1",
+         "--spatial-code-format", "explicit", "--depth", "metric",
+         "--tracking", "tracking", "--input-selection", "selective", "--frames", "32"],
+    )
+    with pytest.raises(SystemExit):
+        calibration_run.main()
+    assert "must be positive" in capsys.readouterr().err