Update app.py

app.py

@@ -504,6 +504,613 @@ def create_app():
     return app
 
 
+demo = create_app()
+
+if __name__ == "__main__":
+    allowed_paths = [str(INPUT_DIR.resolve())] if INPUT_DIR.exists() else None
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        allowed_paths=allowed_paths,
+    )
+"""
+VideoEval Movie-Level 问卷应用（Hugging Face Spaces）
+仅保留 Movie-Level 评测，并支持方法级别统计输出。
+"""
+
+import json
+import os
+import threading
+from collections import defaultdict
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import gradio as gr
+from huggingface_hub import CommitScheduler, snapshot_download
+
+# 路径配置（按用户要求）
+# Spaces 推荐优先读取当前 Space 仓库内文件（app.py 同级）
+APP_DIR = Path(__file__).resolve().parent
+LOCAL_INPUT_DIR = APP_DIR / "user_study_input"
+LOCAL_OUTPUT_DIR = APP_DIR / "user_study_results"
+DATA_INPUT_DIR = Path("/data/user_study_input")
+DATA_OUTPUT_DIR = Path("/data/user_study_results")
+DATA_REPO_ID = os.environ.get("DATA_REPO_ID", "MemDirector/user_study_input")
+RESULTS_REPO_ID = os.environ.get("RESULTS_REPO_ID", "MemDirector/user_study_results")
+HF_TOKEN = os.environ.get("HF_TOKEN", None)
+SPACE_MODE = os.environ.get("SPACE_MODE", "repo_first")  # repo_first / data_first / hub_only
+
+ROOT_DIR = APP_DIR
+INPUT_DIR = LOCAL_INPUT_DIR
+OUTPUT_DIR = LOCAL_OUTPUT_DIR
+STORY_DIR = INPUT_DIR / "clip_movie_story"
+VIDEO_DIR = INPUT_DIR / "video"
+
+Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
+scheduler: Optional[CommitScheduler] = None
+
+
+def _set_paths(input_dir: Path, output_dir: Path) -> None:
+    global INPUT_DIR, OUTPUT_DIR, STORY_DIR, VIDEO_DIR, ROOT_DIR
+    INPUT_DIR = input_dir
+    OUTPUT_DIR = output_dir
+    STORY_DIR = INPUT_DIR / "clip_movie_story"
+    VIDEO_DIR = INPUT_DIR / "video"
+    ROOT_DIR = INPUT_DIR.parent
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _try_use_local_repo_layout() -> bool:
+    # Space 仓库内自带 user_study_input 时，直接读取（最符合“已放上去直接跑”）
+    if LOCAL_INPUT_DIR.exists():
+        _set_paths(LOCAL_INPUT_DIR, LOCAL_OUTPUT_DIR)
+        return True
+    return False
+
+
+def _try_use_data_volume_layout() -> bool:
+    # 如果使用 /data 持久卷，则可放在 /data/user_study_input
+    if DATA_INPUT_DIR.exists():
+        _set_paths(DATA_INPUT_DIR, DATA_OUTPUT_DIR)
+        return True
+    return False
+
+
+def _try_download_from_hub() -> bool:
+    # 最后兜底：从 dataset repo 下载
+    if not DATA_REPO_ID:
+        return False
+    hub_root = APP_DIR / ".hf_space_cache"
+    try:
+        snapshot_download(
+            repo_id=DATA_REPO_ID,
+            repo_type="dataset",
+            local_dir=str(hub_root),
+            token=HF_TOKEN,
+            allow_patterns=[
+                "clip_movie_story/**",
+                "video/**",
+                "user_study_input/**",
+                "user_study_results/**",
+            ],
+        )
+    except Exception as e:
+        print(f"[INIT] snapshot_download failed: {e}")
+        return False
+
+    # 兼容两种 dataset 结构：
+    # A) 仓库根目录直接是 clip_movie_story/ 与 video/
+    # B) 仓库里有 user_study_input/ 子目录
+    if (hub_root / "clip_movie_story").exists() and (hub_root / "video").exists():
+        hub_input = hub_root
+    elif (hub_root / "user_study_input").exists():
+        hub_input = hub_root / "user_study_input"
+    else:
+        return False
+
+    hub_output = hub_root / "user_study_results"
+    _set_paths(hub_input, hub_output)
+    return True
+
+
+def init_space_storage() -> None:
+    """
+    Hugging Face Spaces 规范：
+    - 从 dataset repo 拉取 user_study_input 与 user_study_results 到本地 ROOT_DIR
+    - 使用 CommitScheduler 持续回写 user_study_results
+    """
+    global scheduler
+
+    if SPACE_MODE == "hub_only":
+        ok = _try_download_from_hub()
+    elif SPACE_MODE == "data_first":
+        ok = _try_use_data_volume_layout() or _try_use_local_repo_layout() or _try_download_from_hub()
+    else:
+        ok = _try_use_local_repo_layout() or _try_use_data_volume_layout() or _try_download_from_hub()
+    print(f"[INIT] storage init mode={SPACE_MODE}, success={ok}, input={INPUT_DIR}, output={OUTPUT_DIR}")
+
+    if RESULTS_REPO_ID:
+        try:
+            scheduler = CommitScheduler(
+                repo_id=RESULTS_REPO_ID,
+                repo_type="dataset",
+                folder_path=str(OUTPUT_DIR),
+                path_in_repo="user_study_results",
+                every=3,
+                token=HF_TOKEN,
+            )
+            print(f"[INIT] CommitScheduler enabled: {RESULTS_REPO_ID}")
+        except Exception as e:
+            print(f"[INIT] CommitScheduler init failed: {e}")
+
+
+init_space_storage()
+
+# Movie-Level 指标定义
+MOVIE_CRITERIA: List[Tuple[str, str, str]] = [
+    ("SF", "Script Faithfulness (剧本忠实度)", "生成的视觉内容与原始剧本描述的吻合程度。"),
+    ("NC", "Narrative Coherence (叙事连贯性)", "镜头间情节发展的逻辑性，确保故事表达清晰、不破碎。"),
+    ("VQ", "Visual Quality (视觉质量)", "画面的清晰度、噪点控制、光影效果等基础图像质量。"),
+    ("CC", "Character Consistency (角色一致性)", "同一角色在不同镜头、不同角度下的外貌、服装及特征的稳定性。"),
+    ("PLC", "Physical Law Compliance (物理规律符合度)", "运动、重力、碰撞等是否符合现实物理逻辑，是否存在严重 AI 幻觉。"),
+    ("V_AQ", "Voice/Audio Quality (语音/音频质量)", "配音、背景音乐和音效的清晰度、自然度及技术品质。"),
+    ("CT", "Cinematic Techniques (电影技巧)", "镜头运动、景深控制及构图的专业性。"),
+    ("AVR", "Audio-Visual Richness (视听丰富度)", "画面细节精细度以及音频层次（音效、氛围音）的丰富程度。"),
+    ("NP", "Narrative Pacing (叙事节奏)", "镜头剪辑长短切换是否契合故事情节张力需求。"),
+    ("VAC", "Video-Audio Coordination (视听协调性)", "画面动作与音效、音乐卡点的同步率。"),
+    ("CD", "Compelling Degree (引人入胜程度)", "吸引注意力并引发情感共鸣或沉浸感的能力。"),
+    ("OQ", "Overall Quality (整体质量)", "对生成视频作为“电影作品”的综合观感评分。"),
+]
+
+BASE_METRIC_KEYS = [k for k, _, _ in MOVIE_CRITERIA]
+SAVE_LOCK = threading.Lock()
+
+CUSTOM_CSS = """
+.gradio-container {
+    max-width: 1360px !important;
+    background:
+        radial-gradient(circle at 8% 12%, rgba(80, 130, 255, 0.16) 0%, rgba(80, 130, 255, 0) 28%),
+        radial-gradient(circle at 92% 18%, rgba(103, 223, 255, 0.12) 0%, rgba(103, 223, 255, 0) 30%),
+        linear-gradient(180deg, #0a1221 0%, #0b1426 50%, #0b1324 100%);
+    padding-bottom: 18px;
+}
+#hero {
+    border: 1px solid #365087;
+    border-radius: 16px;
+    padding: 22px 24px;
+    background: linear-gradient(130deg, #101f3f 0%, #1a2f5d 55%, #153a70 100%);
+    box-shadow: 0 18px 45px rgba(5, 9, 22, 0.45);
+    margin-bottom: 12px;
+}
+#hero h1 {
+    margin: 0;
+    font-size: 1.75rem;
+    letter-spacing: 0.3px;
+}
+#hero p {
+    margin: 8px 0 0 0;
+    color: #d8e4ff;
+}
+#hero .hero-badge {
+    display: inline-flex;
+    gap: 8px;
+    align-items: center;
+    margin-top: 14px;
+    padding: 6px 12px;
+    border-radius: 999px;
+    border: 1px solid rgba(189, 217, 255, 0.4);
+    background: rgba(12, 24, 51, 0.52);
+    color: #d8e8ff;
+    font-size: 12px;
+}
+.topbar {
+    margin: 12px 0 16px 0;
+    display: grid;
+    grid-template-columns: repeat(3, minmax(120px, 1fr));
+    gap: 12px;
+}
+.metric-card {
+    border: 1px solid #2f456f;
+    border-radius: 12px;
+    padding: 12px 14px;
+    background: linear-gradient(180deg, #12203b 0%, #101b33 100%);
+    box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.06);
+}
+.metric-label {
+    font-size: 12px;
+    color: #a8bae4;
+    margin-bottom: 4px;
+}
+.metric-value {
+    color: #ecf2ff;
+    font-size: 16px;
+    font-weight: 650;
+}
+.panel {
+    border: 1px solid #2a3e65 !important;
+    border-radius: 14px !important;
+    padding: 14px !important;
+    background: linear-gradient(180deg, #101b31 0%, #0f1a2d 100%) !important;
+    box-shadow: 0 10px 25px rgba(5, 10, 24, 0.28);
+}
+.section-title {
+    margin: 0 0 10px 0;
+    font-size: 1.03rem;
+    font-weight: 620;
+    color: #dfe7ff;
+}
+.hint {
+    color: #9dafd6;
+    font-size: 0.9rem;
+}
+.toolbar-btn {
+    min-height: 42px !important;
+    border-radius: 10px !important;
+}
+.gr-button-primary {
+    background: linear-gradient(180deg, #5a84ff 0%, #446ff0 100%) !important;
+    border: 1px solid #8fa9ff !important;
+    box-shadow: 0 8px 22px rgba(61, 103, 234, 0.35) !important;
+}
+.status-box {
+    border: 1px dashed #4b6394;
+    border-radius: 10px;
+    padding: 9px 11px;
+    background: #0c1529;
+}
+.soft-input textarea,
+.soft-input input,
+.soft-input .wrap {
+    border-radius: 10px !important;
+}
+.gr-accordion {
+    border-radius: 12px !important;
+    border-color: #2d4169 !important;
+}
+"""
+
+
+def _safe_read_text(path: Path) -> str:
+    if not path.exists():
+        return ""
+    return path.read_text(encoding="utf-8-sig").strip()
+
+
+def load_dataset_index() -> List[Dict[str, Any]]:
+    """扫描输入目录，构建可评测样本列表（每个方法-故事仅保留1个视频）。"""
+    stories = {p.stem: _safe_read_text(p) for p in sorted(STORY_DIR.glob("*.txt"))}
+    samples: List[Dict[str, Any]] = []
+
+    if not VIDEO_DIR.exists():
+        return samples
+
+    for method_dir in sorted([d for d in VIDEO_DIR.iterdir() if d.is_dir()]):
+        method = method_dir.name
+        for story_dir in sorted([d for d in method_dir.iterdir() if d.is_dir()]):
+            story_name = story_dir.name
+            # 每个方法-故事只评一次：如果有多个视频，默认取排序后第一个
+            video_candidates = sorted(story_dir.glob("*.mp4"))
+            if not video_candidates:
+                continue
+            video_path = video_candidates[0]
+            sample_id = f"{method}__{story_name}__{video_path.stem}"
+            samples.append(
+                {
+                    "sample_id": sample_id,
+                    "method": method,
+                    "story_name": story_name,
+                    "video_name": video_path.name,
+                    "video_path": str(video_path.resolve()),
+                    "story_text": stories.get(story_name, ""),
+                }
+            )
+    return samples
+
+
+def load_evaluated_method_story_pairs() -> set:
+    """从结果目录读取已评估的 (method, story_name) 组合。"""
+    evaluated = set()
+    raw_root = OUTPUT_DIR / "raw_results"
+    if not raw_root.exists():
+        return evaluated
+
+    for fp in raw_root.rglob("*.json"):
+        try:
+            with open(fp, "r", encoding="utf-8-sig") as f:
+                data = json.load(f)
+        except Exception:
+            continue
+        sample = data.get("sample", {})
+        method = sample.get("method")
+        story_name = sample.get("story_name")
+        if method and story_name:
+            evaluated.add((method, story_name))
+    return evaluated
+
+
+def build_pending_samples() -> List[Dict[str, Any]]:
+    """构建待评估样本池，并分配匿名ID。"""
+    all_samples = load_dataset_index()
+    evaluated_pairs = load_evaluated_method_story_pairs()
+    pending = [
+        s for s in all_samples
+        if (s["method"], s["story_name"]) not in evaluated_pairs
+    ]
+    for i, sample in enumerate(pending, start=1):
+        sample["anon_id"] = f"id_{i:03d}"
+    return pending
+
+
+def build_data_diagnostics(samples: List[Dict[str, Any]]) -> str:
+    return (
+        f"**SPACE_MODE**: `{SPACE_MODE}`  \n"
+        f"**DATA_REPO_ID**: `{DATA_REPO_ID}`  \n"
+        f"**RESULTS_REPO_ID**: `{RESULTS_REPO_ID}`  \n"
+        f"**ROOT_DIR**: `{ROOT_DIR}`  \n"
+        f"**INPUT_DIR exists**: `{INPUT_DIR.exists()}`  \n"
+        f"**STORY_DIR exists**: `{STORY_DIR.exists()}`  \n"
+        f"**VIDEO_DIR exists**: `{VIDEO_DIR.exists()}`  \n"
+        f"**Pending samples**: `{len(samples)}`"
+    )
+
+
+def compute_derived(scores: Dict[str, float]) -> Dict[str, float]:
+    """计算 CL / CRh / AVG。"""
+    cl = (
+        (scores["SF"] + scores["NC"] + scores["VQ"] + scores["CC"] + scores["PLC"]) / 5.0
+        + 0.5 * ((scores["CT"] + scores["AVR"]) / 2.0)
+    )
+    crh = (
+        (scores["V_AQ"] + scores["NP"] + scores["VAC"] + scores["CD"] + scores["OQ"]) / 5.0
+        + 0.5 * ((scores["CT"] + scores["AVR"]) / 2.0)
+    )
+    avg = sum(scores[k] for k in BASE_METRIC_KEYS) / len(BASE_METRIC_KEYS)
+    return {"CL": cl, "CRh": crh, "AVG": avg}
+
+
+def save_single_result(sample: Dict[str, Any], evaluator_id: str, scores: Dict[str, int], reasons: Dict[str, str], summary: str) -> Path:
+    """保存单个问卷结果。"""
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    result_dir = OUTPUT_DIR / "raw_results" / sample["method"] / sample["story_name"]
+    result_dir.mkdir(parents=True, exist_ok=True)
+    out_path = result_dir / f"{sample['video_name'].replace('.mp4', '')}_{evaluator_id}_{ts}.json"
+
+    score_float = {k: float(v) for k, v in scores.items()}
+    derived = compute_derived(score_float)
+
+    payload = {
+        "timestamp": datetime.now().isoformat(),
+        "evaluator_id": evaluator_id,
+        "sample": sample,
+        "scores": scores,
+        "reasons": reasons,
+        "summary": summary,
+        "derived": derived,
+    }
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(payload, f, ensure_ascii=False, indent=2)
+    return out_path
+
+
+def recompute_method_aggregates() -> Path:
+    """
+    统计每个方法各维度均分，并输出 method_aggregates.json。
+    同时给出 CL/CRh/AVG 的方法均值。
+    """
+    raw_root = OUTPUT_DIR / "raw_results"
+    method_scores: Dict[str, Dict[str, List[float]]] = defaultdict(lambda: defaultdict(list))
+    method_count: Dict[str, int] = defaultdict(int)
+
+    if raw_root.exists():
+        for fp in raw_root.rglob("*.json"):
+            with open(fp, "r", encoding="utf-8-sig") as f:
+                data = json.load(f)
+            method = data.get("sample", {}).get("method", "UNKNOWN")
+            scores = data.get("scores", {})
+            if not all(k in scores for k in BASE_METRIC_KEYS):
+                continue
+            method_count[method] += 1
+            for k in BASE_METRIC_KEYS:
+                method_scores[method][k].append(float(scores[k]))
+
+            # 衍生指标也参与方法均值统计
+            derived = compute_derived({k: float(scores[k]) for k in BASE_METRIC_KEYS})
+            for d_key, d_val in derived.items():
+                method_scores[method][d_key].append(float(d_val))
+
+    agg = {
+        "updated_at": datetime.now().isoformat(),
+        "metric_keys": BASE_METRIC_KEYS,
+        "derived_keys": ["CL", "CRh", "AVG"],
+        "methods": {},
+    }
+    for method in sorted(method_scores.keys()):
+        metric_avg = {}
+        for key, vals in method_scores[method].items():
+            metric_avg[key] = round(sum(vals) / len(vals), 4) if vals else None
+        agg["methods"][method] = {
+            "num_submissions": method_count[method],
+            "avg_scores": metric_avg,
+        }
+
+    out_path = OUTPUT_DIR / "method_aggregates.json"
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(agg, f, ensure_ascii=False, indent=2)
+    return out_path
+
+
+def build_sample_brief(sample: Dict[str, Any], index: int, total: int) -> str:
+    story = sample.get("story_text") or "(未找到对应 story 文本，请检查 clip_movie_story 下是否有同名 txt)"
+    return (
+        f"### 当前匿名样本 {index + 1}/{total}\n"
+        f"- **Sample ID**: `{sample['anon_id']}`\n\n"
+        f"### Story Description\n{story}"
+    )
+
+
+def create_app():
+    samples = build_pending_samples()
+    sample_map = {s["anon_id"]: s for s in samples}
+
+    with gr.Blocks(
+        title="VideoEval Movie-Level Evaluation",
+        css=CUSTOM_CSS,
+        theme=gr.themes.Soft(primary_hue="blue", secondary_hue="indigo", neutral_hue="slate"),
+    ) as app:
+        gr.HTML(
+            f"""
+            <div id="hero">
+                <h1>VideoEval · Movie-Level Evaluation</h1>
+                <p>统一电影级评测问卷，支持方法级均分统计（含 CL / CRh / AVG）</p>
+                <div class="hero-badge">HF Space Ready · Gradio Blocks · Clean Review Flow</div>
+            </div>
+            <div class="topbar">
+                <div class="metric-card">
+                    <div class="metric-label">Pending Samples</div>
+                    <div class="metric-value">{len(samples)}</div>
+                </div>
+                <div class="metric-card">
+                    <div class="metric-label">Evaluation Scope</div>
+                    <div class="metric-value">Movie-Level</div>
+                </div>
+                <div class="metric-card">
+                    <div class="metric-label">Scoring Standard</div>
+                    <div class="metric-value">12 Metrics · 1~5</div>
+                </div>
+            </div>
+            """
+        )
+        gr.Markdown(
+            f"<span class='hint'>输入目录：`{INPUT_DIR}` ｜ 输出目录：`{OUTPUT_DIR}`</span>",
+        )
+        with gr.Accordion("系统诊断信息（展开查看）", open=False):
+            gr.Markdown(build_data_diagnostics(samples))
+
+        current_idx = gr.State(0)
+        evaluator_state = gr.State("anonymous")
+
+        with gr.Row():
+            with gr.Column(scale=4, elem_classes=["panel"]):
+                gr.Markdown("<div class='section-title'>1) 评测员与样本</div>")
+                with gr.Row():
+                    evaluator_input = gr.Textbox(label="Evaluator ID", value="anonymous", elem_classes=["soft-input"])
+                    sample_dropdown = gr.Dropdown(
+                        label="选择评测样本（匿名）",
+                        choices=[s["anon_id"] for s in samples],
+                        value=samples[0]["anon_id"] if samples else None,
+                        interactive=True,
+                        elem_classes=["soft-input"],
+                    )
+                with gr.Row():
+                    prev_btn = gr.Button("← Previous", elem_classes=["toolbar-btn"])
+                    next_btn = gr.Button("Next →", elem_classes=["toolbar-btn"])
+                    submit_btn = gr.Button("提交当前评分并统计", variant="primary", elem_classes=["toolbar-btn"])
+                status = gr.Markdown("<div class='status-box'>等待提交</div>")
+            with gr.Column(scale=8, elem_classes=["panel"]):
+                gr.Markdown("<div class='section-title'>2) 视频与剧情</div>")
+                movie_video = gr.Video(label="Movie Video", value=samples[0]["video_path"] if samples else None, height=460)
+                sample_info = gr.Markdown("无可用样本" if not samples else build_sample_brief(samples[0], 0, len(samples)))
+
+        gr.Markdown("## 3) Movie-Level 指标评分（1-5）")
+        gr.Markdown("<span class='hint'>先给分，再填写可选理由。未打分无法提交。</span>")
+
+        score_widgets: Dict[str, gr.Radio] = {}
+        reason_widgets: Dict[str, gr.Textbox] = {}
+        metric_groups = {
+            "I. 叙事与剧本 (NS)": ["SF", "NC"],
+            "II. 视听与技术 (AT)": ["VQ", "CC", "PLC", "V_AQ"],
+            "III. 美学与表现力 (AE)": ["CT", "AVR"],
+            "IV. 节奏与流动性 (RF)": ["NP", "VAC"],
+            "V. 情感与参与度 (EE)": ["CD"],
+            "VI. 整体体验 (OE)": ["OQ"],
+        }
+        criteria_map = {k: (name, desc) for k, name, desc in MOVIE_CRITERIA}
+
+        for section_title, keys in metric_groups.items():
+            with gr.Accordion(section_title, open=True):
+                for key in keys:
+                    name, desc = criteria_map[key]
+                    with gr.Group(elem_classes=["panel"]):
+                        gr.Markdown(f"**{key} · {name}**")
+                        gr.Markdown(f"<span class='hint'>{desc}</span>")
+                        with gr.Row():
+                            score_widgets[key] = gr.Radio(choices=[1, 2, 3, 4, 5], label=f"{key} Score", scale=1, elem_classes=["soft-input"])
+                            reason_widgets[key] = gr.Textbox(label=f"{key} Reason（可选）", lines=2, placeholder="补充评分依据", scale=2, elem_classes=["soft-input"])
+
+        final_summary = gr.Textbox(label="Final Summary（可选）", lines=4, placeholder="总结该视频的主要优缺点", elem_classes=["soft-input"])
+
+        def _sync_sample_from_dropdown(anon_id: str) -> Tuple[str, str, int]:
+            if not anon_id or anon_id not in sample_map:
+                return None, "未找到样本", 0
+            idx = next(i for i, s in enumerate(samples) if s["anon_id"] == anon_id)
+            sample = samples[idx]
+            return sample["video_path"], build_sample_brief(sample, idx, len(samples)), idx
+
+        def _go_prev(idx: int) -> Tuple[str, str, str, int]:
+            if not samples:
+                return None, "无可用样本", None, 0
+            idx = max(0, idx - 1)
+            sample = samples[idx]
+            return sample["video_path"], build_sample_brief(sample, idx, len(samples)), sample["anon_id"], idx
+
+        def _go_next(idx: int) -> Tuple[str, str, str, int]:
+            if not samples:
+                return None, "无可用样本", None, 0
+            idx = min(len(samples) - 1, idx + 1)
+            sample = samples[idx]
+            return sample["video_path"], build_sample_brief(sample, idx, len(samples)), sample["anon_id"], idx
+
+        def _submit(evaluator_id: str, anon_id: str, summary: str, *score_reason_vals):
+            if not samples:
+                return "❌ 没有可提交样本。"
+            if not anon_id or anon_id not in sample_map:
+                return "❌ 请先选择样本。"
+            sample = sample_map[anon_id]
+            evaluator_id = (evaluator_id or "anonymous").strip() or "anonymous"
+
+            # 防重复：方法-故事只允许评估一次
+            evaluated_pairs = load_evaluated_method_story_pairs()
+            if (sample["method"], sample["story_name"]) in evaluated_pairs:
+                return "⚠️ 该方法-故事已经被评估过一次，请选择其他匿名样本。"
+
+            scores: Dict[str, int] = {}
+            reasons: Dict[str, str] = {}
+            for i, key in enumerate(BASE_METRIC_KEYS):
+                score = score_reason_vals[i * 2]
+                reason = score_reason_vals[i * 2 + 1]
+                if score is None:
+                    return f"❌ 请为 `{key}` 打分。"
+                scores[key] = int(score)
+                reasons[key] = (reason or "").strip()
+
+            with SAVE_LOCK:
+                single_path = save_single_result(sample, evaluator_id, scores, reasons, summary or "")
+                agg_path = recompute_method_aggregates()
+
+            return f"✅ 已保存: `{single_path}`\n\n✅ 已更新方法统计: `{agg_path}`"
+
+        sample_dropdown.change(
+            _sync_sample_from_dropdown,
+            inputs=[sample_dropdown],
+            outputs=[movie_video, sample_info, current_idx],
+        )
+        prev_btn.click(_go_prev, inputs=[current_idx], outputs=[movie_video, sample_info, sample_dropdown, current_idx])
+        next_btn.click(_go_next, inputs=[current_idx], outputs=[movie_video, sample_info, sample_dropdown, current_idx])
+
+        submit_inputs = [evaluator_input, sample_dropdown, final_summary]
+        for key in BASE_METRIC_KEYS:
+            submit_inputs.append(score_widgets[key])
+            submit_inputs.append(reason_widgets[key])
+        submit_btn.click(_submit, inputs=submit_inputs, outputs=[status])
+
+        app.load(lambda x: x, inputs=[evaluator_input], outputs=[evaluator_state])
+
+    return app
+
+
 demo = create_app()
 
 if __name__ == "__main__":