| import copy |
| import json |
| from pathlib import Path |
|
|
| import pytest |
|
|
| from odu_eval import runner |
| from odu_eval.cli import main |
| from odu_eval.core import scoring, scene, transport |
| from odu_eval.dataset import Dataset |
| from odu_eval.io import file_digest, read_jsonl, write_json, write_jsonl |
| from odu_eval.parsing import api, local |
| from odu_eval.providers import APIError, Service |
|
|
|
|
| @pytest.fixture |
| def dataset(tmp_path): |
| root = tmp_path / "data" |
| root.mkdir() |
| rows = [] |
| for index, (modality, label, clips) in enumerate([ |
| ("audio-only", "positive", 1), ("audio-only", "negative", 2), |
| ("audio-visual", "positive", 2), ("audio-visual", "negative", 1), |
| ]): |
| sid = f"example_{index}" |
| folder = root / modality / label / sid |
| folder.mkdir(parents=True) |
| ext = "wav" if modality == "audio-only" else "mp4" |
| media = [] |
| for clip in range(1, clips + 1): |
| name = f"clip_v{clip}.{ext}" |
| (folder / name).write_bytes(b"fixture-media-" + str(clip).encode()) |
| media.append(name) |
| seg = {"start_ms": 0, "end_ms": 1000, "transcript": "Turn down the volume.", |
| "structured_intent": "Reduce the volume.", "required_context": [], |
| "user_gender": "unknown", "user_age_group": "adult", |
| "key_points": [{"qid": "kp01", "point": "Reduce volume", "tiers": ["T1"], "source": "intent"}, |
| {"qid": "kp02", "point": "A television", "tiers": ["T1", "T2"], "source": "dialogue_history"}, |
| {"qid": "kp03", "point": "Background music", "tier": 2, "source": "audio"}]} |
| if modality == "audio-visual": |
| seg["user_in_frame"] = False |
| write_json(folder / "annotation_en.json", {"scene_id": sid, "evaluation_targets": { |
| "has_demand": label == "positive", "segments": [seg] if label == "positive" else []}}) |
| write_json(folder / "metadata.json", {"scene_id": sid, "agent_replies": [ |
| {"after_clip_id": "v0", "content": "excluded before first clip"}, |
| {"after_clip_id": "v1", "content": "Earlier assistant reply"}, |
| {"after_clip_id": "v2", "content": "excluded after final clip"}]}) |
| rows.append({"scene_id": sid, "modality": modality, "label": label, "source": "generated", "n_clips": clips, |
| "rel_path": folder.relative_to(root).as_posix(), "media": media, "metadata": "metadata.json", |
| "annotations": {"en": "annotation_en.json"}, "annotation": "annotation_en.json"}) |
| write_jsonl(root / "manifest.jsonl", rows) |
| write_jsonl(root / "subsets/main.jsonl", rows) |
| sums = [f"{file_digest(root / r['rel_path'] / name)} {r['rel_path']}/{name}" for r in rows for name in r["media"]] |
| (root / "checksums.sha256").write_text("\n".join(sums) + "\n") |
| return Dataset(root) |
|
|
|
|
| def test_inputs_keep_multiclip_order_without_reference_answer(dataset): |
| assert dataset.validate(checksums=True)["checksums_verified"] == 6 |
| sample = dataset.sample(dataset.rows[2]) |
| assert [m["role"] for m in sample["messages"]] == ["system", "user"] |
| parts = sample["messages"][1]["content"] |
| assert [p["clip_id"] for p in parts if p["type"] == "video"] == ["v1", "v2"] |
| text = " ".join(p["text"] for p in parts if p["type"] == "text") |
| assert "Earlier assistant reply" in text |
| assert "excluded" not in text |
| assert "local timestamps within the final video clip" in text |
| assert "key_points" not in json.dumps(sample) |
| assert all(not Path(p["path"]).is_absolute() and p["use_audio"] for p in parts if p["type"] == "video") |
|
|
|
|
| def test_dataset_escape_and_duplicate_ids_are_rejected(dataset): |
| row = copy.deepcopy(dataset.rows[0]) |
| row["media"] = ["../../escape.wav"] |
| with pytest.raises(ValueError, match="inside"): |
| dataset.sample(row) |
| rows = dataset.rows + [dataset.rows[0]] |
| write_jsonl(dataset.root / "manifest.jsonl", rows) |
| with pytest.raises(ValueError, match="unique"): |
| Dataset(dataset.root) |
|
|
|
|
| def test_parsers_keep_their_historical_difference(monkeypatch): |
| monkeypatch.setattr(api, "_JSON_REPAIR_ENABLED", False) |
| tagged = "<has_demand>false</has_demand><segments></segments>" |
| assert api.parse_model_output(tagged) is None |
| parsed, mode = local.parse_model_output_with_mode(tagged) |
| assert mode == "tagged" |
| assert parsed["evaluation_targets"] == {"has_demand": False, "segments": []} |
| raw = '<think>reasoning</think>```json\n{"has_demand":true,"segments":[{"start_ms":"1.2s","end_ms":"2.5s"}]}\n```' |
| assert api.parse_model_output(raw) == local.parse_model_output(raw) |
|
|
|
|
| def test_final_clip_scopes_each_side_independently(): |
| pred = {"has_demand": True, "segments": [{"clip_id": "v1"}, {"clip_id": "v3"}, {"transcript": "keep"}]} |
| gt = {"has_demand": True, "segments": [{"clip_id": "v2"}, {"clip_id": "v4"}]} |
| p, g, final = scoring.apply_multiturn_scope(pred, gt, "example") |
| assert final == "v4" |
| assert [x.get("clip_id") for x in p["segments"]] == ["v3", None] |
| assert g["segments"] == [{"clip_id": "v4"}] |
|
|
|
|
| def test_union_keypoints_and_judge_failures(dataset): |
| gt = dataset.gt(dataset.rows[0])["evaluation_targets"] |
| pred = copy.deepcopy(gt) |
| for seg in pred["segments"]: |
| seg.pop("key_points") |
| transport.set_llm_call(lambda **kwargs: '[{"qid":"kp01","hit":true},{"qid":"kp02","hit":true},{"qid":"kp03","hit":false}]') |
| try: |
| result = scene.evaluate_scene(pred, gt, run_m4_llm=True, audio_only=True) |
| assert result["scores"]["verification_qa"] == .6667 |
| assert result["details"]["verification_qa"]["t1_hit_rate"] == 1 |
| assert result["details"]["verification_qa"]["point_stats"] == {"hit": 2, "total": 3} |
| def fail(**kwargs): |
| raise RuntimeError("OpenAIError") |
| transport.set_llm_call(fail) |
| failed = scene.evaluate_scene(copy.deepcopy(pred), copy.deepcopy(gt), run_m4_llm=True, m4_max_retries=1, audio_only=True) |
| assert failed["overall"] is None |
| assert failed["details"]["verification_qa"]["incomplete"] |
| finally: |
| transport.set_llm_call(None) |
|
|
|
|
| def test_wire_protocols_keep_media_order(dataset, monkeypatch): |
| monkeypatch.delenv("ODU_QWEN_OMNI_MODEL", raising=False) |
| sample = dataset.sample(dataset.rows[2]) |
| qwen = Service("qwen3.5-omni-plus") |
| body = qwen.inference_payload(sample, dataset.root) |
| assert set(body) == {"model", "messages", "stream", "stream_options", "modalities"} |
| assert body["modalities"] == ["text"] and body["stream"] is True |
| assert [p["type"] for p in body["messages"][1]["content"]] == [p["type"].replace("video", "video_url") for p in sample["messages"][1]["content"]] |
| gemini = Service("gemini-3.1-pro") |
| native = gemini.inference_payload(sample, dataset.root) |
| assert set(native) == {"systemInstruction", "contents"} |
| assert native["contents"][0]["role"] == "user" |
| assert len([p for p in native["contents"][0]["parts"] if "inlineData" in p]) == 2 |
| assert "path" not in json.dumps(native) |
| audio = qwen.inference_payload(dataset.sample(dataset.rows[0]), dataset.root) |
| assert audio["messages"][1]["content"][0]["input_audio"]["data"].startswith("data:audio/") |
| assert Service("qwen3.6-flash", thinking="true").text_payload("s", "u")["enable_thinking"] is True |
| openai = Service("gpt-5.4", reasoning="high").text_payload("s", "u") |
| assert openai["reasoning_effort"] == "high" and "enable_thinking" not in openai |
|
|
|
|
| def test_streaming_collects_answer_only(monkeypatch): |
| class Response: |
| headers = {"Content-Type": "text/event-stream; charset=utf-8"} |
| def __enter__(self): return self |
| def __exit__(self, *args): return False |
| def iter_lines(self): |
| yield b'data: {"choices":[{"delta":{"reasoning_content":"hidden"}}]}' |
| yield b'data: {"choices":[{"delta":{"content":"ans"}}]}' |
| yield b'data: {"choices":[{"delta":{"content":"wer"}}]}' |
| yield b'data: {"choices":[],"usage":{"total_tokens":10}}' |
| yield b'data: [DONE]' |
| service = Service("gpt-5.4") |
| monkeypatch.setattr(service, "request", lambda *a, **k: Response()) |
| assert service.call_text("s", "u") == "answer" |
| assert service.stats["reasoning_chunks"] == 1 |
|
|
|
|
| def test_server_errors_do_not_echo_credentials(monkeypatch): |
| class Response: |
| ok, status_code = False, 401 |
| def json(self): return {"error": {"code": "invalid_api_key", "message": "secret-value https://private.example/"}} |
| def close(self): pass |
| class Session: |
| def request(self, *a, **k): return Response() |
| service = Service("gpt-5.4") |
| service.key = "test-key" |
| service._session = Session() |
| with pytest.raises(APIError) as err: |
| service.request("POST", "https://example.test") |
| assert "401" in str(err.value) |
| assert "secret-value" not in str(err.value) and "private.example" not in str(err.value) |
|
|
|
|
| def test_gemini_files_upload_wire_contract(dataset, monkeypatch): |
| service = Service("gemini-3.1-pro") |
| media = dataset.scene_file(dataset.rows[2], dataset.rows[2]["media"][0]) |
| calls = [] |
| class Response: |
| def __init__(self, body=None, headers=None): |
| self.body, self.headers = body, headers or {} |
| def __enter__(self): return self |
| def __exit__(self, *args): return False |
| def json(self): return self.body |
| def request(method, url, **kwargs): |
| calls.append((method, url, kwargs)) |
| if len(calls) == 1: |
| assert kwargs["json"] == {"file": {"display_name": "evaluation-media"}} |
| assert kwargs["headers"]["X-Goog-Upload-Protocol"] == "resumable" |
| return Response(headers={"X-Goog-Upload-URL": "https://upload.example.test/session"}) |
| if len(calls) == 2: |
| assert kwargs["headers"]["X-Goog-Upload-Command"] == "upload, finalize" |
| assert kwargs["data"].read() == media.read_bytes() |
| return Response({"file": {"name": "files/example", "state": "PROCESSING"}}) |
| return Response({"name": "files/example", "state": "ACTIVE", "uri": "https://files.example.test/example"}) |
| monkeypatch.setattr(service, "request", request) |
| monkeypatch.setattr("odu_eval.providers.time.sleep", lambda n: None) |
| uploaded = service._upload_gemini(media, "video/mp4") |
| assert uploaded["state"] == "ACTIVE" and len(calls) == 3 |
| sample = dataset.sample(dataset.rows[2]) |
| key = next(p["path"] for p in sample["messages"][1]["content"] if p["type"] == "video") |
| payload = service.inference_payload(sample, dataset.root, files={key: uploaded}) |
| files = [p["fileData"] for p in payload["contents"][0]["parts"] if "fileData" in p] |
| assert files == [{"mimeType": "video/mp4", "fileUri": uploaded["uri"]}] |
|
|
|
|
| def test_moving_dataset_keeps_inputs_and_fingerprint(dataset, tmp_path): |
| import shutil |
| destination = tmp_path / "relocated" |
| shutil.copytree(dataset.root, destination) |
| moved = Dataset(destination) |
| assert dataset.fingerprint(dataset.rows) == moved.fingerprint(moved.rows) |
| assert [dataset.sample(r) for r in dataset.rows] == [moved.sample(r) for r in moved.rows] |
|
|
|
|
| def test_readme_flow_and_offline_replay(dataset, tmp_path, monkeypatch): |
| monkeypatch.setenv("DASHSCOPE_API_KEY", "test-key") |
| def fake_infer(self, sample, root): |
| row = next(r for r in dataset.rows if r["scene_id"] == sample["scene_id"]) |
| gt = copy.deepcopy(dataset.gt(row)["evaluation_targets"]) |
| for seg in gt["segments"]: |
| seg.pop("key_points") |
| return json.dumps(gt) |
| monkeypatch.setattr(Service, "infer", fake_infer) |
| monkeypatch.setattr(Service, "call_text", lambda *a, **kw: '[{"qid":"kp01","hit":true},{"qid":"kp02","hit":true},{"qid":"kp03","hit":false}]') |
| data = ["--data-root", str(dataset.root)] |
| inputs, predictions = tmp_path / "inputs.jsonl", tmp_path / "model" |
| assert main(["validate", *data, "--checksums"]) == 0 |
| assert main(["export-inputs", *data, "--smoke", "--output", str(inputs)]) == 0 |
| command = ["infer", *data, "--smoke", "--model", "qwen3.5-omni-plus", "--output-dir", str(predictions)] |
| assert main(command) == 0 |
| assert main(command) == 0 |
| score = tmp_path / "score" |
| score_args = ["score", *data, "--predictions", str(predictions / "predictions.jsonl"), "--judge", "qwen3.6-flash"] |
| assert main([*score_args, "--output-dir", str(score)]) == 0 |
| recorded = json.loads((score / "run_manifest.json").read_text()) |
| assert len(recorded["judge_prompt_sha256"]) == 64 |
| assert recorded["protocol"]["judge_prompt_sha256"] == recorded["judge_prompt_sha256"] |
| monkeypatch.delenv("DASHSCOPE_API_KEY") |
| monkeypatch.setenv("DASHSCOPE_BASE_URL", "https://different.example/v1") |
| monkeypatch.setattr(Service, "call_text", lambda *a, **kw: pytest.fail("offline sent a request")) |
| replay = tmp_path / "replay" |
| assert main([*score_args, "--judge-cache", str(score / "judge_cache"), "--offline", "--output-dir", str(replay)]) == 0 |
| assert read_jsonl(score / "scores.jsonl") == read_jsonl(replay / "scores.jsonl") |
| assert (score / "comparison.csv").read_bytes() == (replay / "comparison.csv").read_bytes() |
| assert str(dataset.root) not in (score / "run_manifest.json").read_text() |
| assert main(["aggregate", "--runs", str(score), str(replay), "--output-dir", str(tmp_path / "report")]) == 0 |
|
|
|
|
| def test_custom_submission_and_coverage(dataset, tmp_path, monkeypatch): |
| monkeypatch.setenv("DASHSCOPE_API_KEY", "test-key") |
| monkeypatch.setattr(Service, "call_text", lambda *a, **k: pytest.fail("negative answer should not require a judge")) |
| inputs, raw, pred = tmp_path / "inputs.jsonl", tmp_path / "raw.jsonl", tmp_path / "predictions.jsonl" |
| runner.export_inputs(dataset, dataset.rows, inputs) |
| write_jsonl(raw, [{"scene_id": dataset.rows[0]["scene_id"], "raw_output": '{"has_demand":false,"segments":[]}'}]) |
| assert main(["parse", "--input", str(raw), "--inputs", str(inputs), "--output", str(pred), "--profile", "local"]) == 0 |
| out = tmp_path / "partial" |
| assert main(["score", "--data-root", str(dataset.root), "--predictions", str(pred), "--judge", "qwen3.6-flash", "--output-dir", str(out)]) == 1 |
| coverage = json.loads((out / "coverage.json").read_text()) |
| assert coverage["expected"] == 4 and coverage["missing_predictions"] == 3 |
|
|
