SignX/viser_backend.py

#!/usr/bin/env python3
"""
SignX 插件的后端处理器
通过 WebSocket plugin_message 机制处理视频列表和推理请求
"""

import os
import subprocess
import time
import threading
import uuid
import traceback
from pathlib import Path
from typing import Dict, List, Any, Optional, Tuple

# SignX 插件路径
SIGNX_PLUGIN_DIR = Path(__file__).parent
INFERENCE_SCRIPT = SIGNX_PLUGIN_DIR / "inference.sh"
TEST_DATA_DIR = SIGNX_PLUGIN_DIR / "eval" / "tiny_test_data"
INFERENCE_OUTPUT_DIR = SIGNX_PLUGIN_DIR / "inference_output"
INFERENCE_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)


# 使用 PluginBackend 作为类名，这样会被主程序自动识别
class PluginBackend:
    """SignX 后端处理类"""

    def __init__(self, viser_server=None):
        """
        初始化 SignX 后端

        Args:
            viser_server: Viser 服务器实例（可选）
        """
        self.viser_server = viser_server
        self.name = "signx"  # 插件标识符（用于 WebSocket 通信）
        print("✅ SignX 后端已初始化")
        
        # 任务管理
        self.jobs: Dict[str, Dict[str, Any]] = {}
        self.jobs_lock = threading.Lock()

    def handle_message(self, message: Dict[str, Any]) -> Dict[str, Any]:
        """
        处理来自前端的 WebSocket 消息

        Args:
            message: 包含 plugin, action, data 的消息字典

        Returns:
            处理结果字典
        """
        action = message.get('action', '')
        data = message.get('data', {})

        print(f"📨 SignX 收到消息: action={action}")

        # 根据 action 分发到不同的处理函数
        if action == 'list_videos':
            return self.list_videos(data)
        if action == 'run_inference':
            return self.run_inference(data)
        if action == 'get_job_status':
            return self.get_job_status(data)
        return {
            'status': 'error',
            'message': f'未知的 action: {action}'
        }

    def list_videos(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """列出指定文件夹中的视频文件"""
        folder = data.get('folder', 'good_videos')
        folder_path = TEST_DATA_DIR / folder

        if not folder_path.exists():
            return {
                "status": "error",
                "message": f"文件夹不存在: {folder}"
            }

        videos = []
        for video_file in sorted(folder_path.glob("*.mp4")):
            videos.append({
                "name": video_file.name,
                "path": str(video_file)
            })

        print(f"📂 找到 {len(videos)} 个视频文件")

        return {
            "status": "success",
            "videos": videos,
            "count": len(videos)
        }

    def run_inference(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """启动异步 SignX 推理任务（支持实时日志轮询）"""
        video_path = (data.get('video_path') or '').strip()

        if not video_path:
            return {"status": "error", "message": "未提供视频路径"}

        if not os.path.exists(video_path):
            return {
                "status": "error",
                "message": f"视频文件不存在: {video_path}"
            }

        if not INFERENCE_SCRIPT.exists():
            return {
                "status": "error",
                "message": f"推理脚本不存在: {INFERENCE_SCRIPT}"
            }

        job = self._create_job(video_path)
        self._append_job_log(job["id"], f"🎬 开始推理: {video_path}")

        thread = threading.Thread(
            target=self._execute_inference_job,
            args=(job["id"], video_path),
            name=f"signx-job-{job['id']}",
            daemon=True
        )
        job["thread"] = thread
        thread.start()

        return {
            "status": "running",
            "job_id": job["id"],
            "message": "SignX 推理任务已启动"
        }

    def get_job_status(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """获取指定任务的当前状态与增量日志"""
        job_id = data.get('job_id')
        if not job_id:
            return {"status": "error", "message": "缺少 job_id"}

        job = self._get_job(job_id)
        if not job:
            return {"status": "error", "message": f"未找到任务: {job_id}"}

        last_index = data.get('last_index', 0)
        try:
            last_index = int(last_index)
            if last_index < 0:
                last_index = 0
        except (TypeError, ValueError):
            last_index = 0

        logs = job["logs"][last_index:]
        response: Dict[str, Any] = {
            "status": "success",
            "job_id": job_id,
            "job_status": job["status"],
            "logs": logs,
            "next_index": last_index + len(logs),
            "finished": job["status"] in ("success", "error"),
            "started_at": job.get("created_at"),
        }

        if job["status"] == "success" and job.get("result"):
            response["result"] = job["result"]
        elif job["status"] == "error":
            response["error_message"] = job.get("error") or "任务失败"

        return response

    def _create_job(self, video_path: str) -> Dict[str, Any]:
        job_id = f"signx_{int(time.time() * 1000)}_{uuid.uuid4().hex[:6]}"
        job = {
            "id": job_id,
            "video_path": video_path,
            "status": "running",
            "created_at": time.time(),
            "updated_at": time.time(),
            "logs": [],
            "result": None,
            "error": None,
            "thread": None
        }
        with self.jobs_lock:
            self.jobs[job_id] = job
        return job

    def _get_job(self, job_id: str) -> Optional[Dict[str, Any]]:
        with self.jobs_lock:
            return self.jobs.get(job_id)

    def _append_job_log(self, job_id: str, line: str):
        if not line:
            return
        job = self._get_job(job_id)
        if not job:
            return
        job["logs"].append(line)
        job["updated_at"] = time.time()
        # 限制日志长度，防止无限增长
        if len(job["logs"]) > 2000:
            job["logs"] = job["logs"][-2000:]

    def _finalize_job(self, job_id: str, status: str, *, result: Optional[Dict[str, Any]] = None, error: Optional[str] = None):
        job = self._get_job(job_id)
        if not job:
            return
        job["status"] = status
        job["result"] = result
        job["error"] = error
        job["finished_at"] = time.time()
        job["updated_at"] = job["finished_at"]
        self._cleanup_jobs()

    def _cleanup_jobs(self, ttl_seconds: int = 1800, max_finished: int = 10):
        with self.jobs_lock:
            now = time.time()
            # 清理超时任务
            expired = [
                job_id for job_id, job in self.jobs.items()
                if job.get("finished_at") and now - job["finished_at"] > ttl_seconds
            ]
            for job_id in expired:
                self.jobs.pop(job_id, None)

            # 限制历史任务数量
            finished_jobs = [job for job in self.jobs.values() if job.get("finished_at")]
            if len(finished_jobs) > max_finished:
                finished_jobs.sort(key=lambda job: job.get("finished_at", now))
                for job in finished_jobs[:-max_finished]:
                    self.jobs.pop(job["id"], None)

    def _find_latest_analysis_dir(self, since_ts: Optional[float] = None) -> Optional[Path]:
        latest_dir = None
        search_roots = []
        if INFERENCE_OUTPUT_DIR.exists():
            search_roots.append(INFERENCE_OUTPUT_DIR)
        search_roots.append(SIGNX_PLUGIN_DIR)

        for root in search_roots:
            for item in root.iterdir():
                if not item.is_dir() or not item.name.startswith("detailed_prediction_"):
                    continue
                if since_ts and item.stat().st_mtime < since_ts - 5:
                    continue
                if latest_dir is None or item.stat().st_mtime > latest_dir.stat().st_mtime:
                    latest_dir = item
        return latest_dir

    def _iter_sample_dirs(self, analysis_dir: Optional[Path]) -> List[Path]:
        if not analysis_dir or not analysis_dir.exists():
            return []
        sample_dirs = [d for d in analysis_dir.iterdir() if d.is_dir()]
        sample_dirs.sort(key=lambda p: p.stat().st_mtime, reverse=False)
        return sample_dirs

    def _resolve_output_location(self, original_path: Path, analysis_dir: Optional[Path]) -> Optional[Path]:
        if original_path.exists():
            return original_path

        search_roots = []
        if analysis_dir:
            search_roots.append(analysis_dir)
        if INFERENCE_OUTPUT_DIR.exists():
            search_roots.append(INFERENCE_OUTPUT_DIR)
        search_roots.append(SIGNX_PLUGIN_DIR)

        for root in search_roots:
            for candidate in root.rglob(original_path.name):
                if candidate.is_file():
                    return candidate
        return None

    def _read_translation_file(self, sample_dir: Path) -> Tuple[str, str]:
        translation_path = sample_dir / "translation.txt"
        with_bpe = ""
        clean = ""
        if not translation_path.exists():
            return with_bpe, clean

        try:
            with open(translation_path, 'r', encoding='utf-8') as f:
                for line in f:
                    if line.startswith("With BPE:"):
                        with_bpe = line.split(":", 1)[1].strip()
                    elif line.startswith("Clean:"):
                        clean = line.split(":", 1)[1].strip()
        except Exception as exc:  # pylint: disable=broad-except
            print(f"⚠️ 读取 translation.txt 失败: {exc}")
        return with_bpe, clean

    def _execute_inference_job(self, job_id: str, video_path: str):
        """后台线程：实际执行推理并写入日志/结果"""
        output_file = SIGNX_PLUGIN_DIR / f"inference_output_{job_id}.txt"
        output_file_clean = SIGNX_PLUGIN_DIR / f"inference_output_{job_id}.txt.clean"
        start_time = time.time()
        process = None

        try:
            process = subprocess.Popen(
                ["bash", str(INFERENCE_SCRIPT), video_path, str(output_file)],
                cwd=str(SIGNX_PLUGIN_DIR),
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                bufsize=1
            )

            if process.stdout:
                for line in process.stdout:
                    line = line.rstrip()
                    if line:
                        self._append_job_log(job_id, line)
                        print(f"  {line}")

            process.wait(timeout=600)

        except subprocess.TimeoutExpired:
            if process:
                process.kill()
            self._append_job_log(job_id, "⏱️ 推理超时")
            self._finalize_job(job_id, "error", error="推理超时（超过10分钟）")
            return
        except Exception as exc:  # pylint: disable=broad-except
            self._append_job_log(job_id, f"❌ 推理出错: {exc}")
            traceback.print_exc()
            self._finalize_job(job_id, "error", error=f"推理过程出错: {exc}")
            return

        execution_time = time.time() - start_time

        if process and process.returncode != 0:
            self._append_job_log(job_id, f"❌ 推理失败，返回码 {process.returncode}")
            self._finalize_job(job_id, "error", error="推理失败")
            return

        # 查找详细分析目录
        analysis_dir = self._find_latest_analysis_dir(start_time)
        analysis_images: List[Dict[str, Any]] = []
        primary_sample_dir: Optional[Path] = None

        if analysis_dir:
            sample_dirs = self._iter_sample_dirs(analysis_dir)
            if sample_dirs:
                primary_sample_dir = sample_dirs[0]
                analysis_files = []

                image_files = [
                    ("attention_heatmap.png", "Attention Heatmap"),
                    ("frame_alignment.png", "Word-Frame Alignment (Full)"),
                    ("frame_alignment_short.png", "Word-Frame Alignment (Compact)"),
                    ("gloss_to_frames.png", "Gloss to Video Frames"),
                ]

                for img_file, display_name in image_files:
                    img_path = primary_sample_dir / img_file
                    if img_path.exists():
                        rel_path = img_path.relative_to(SIGNX_PLUGIN_DIR)
                        web_url = f"/plugins/SignX/{rel_path}"
                        analysis_files.append({
                            "name": display_name,
                            "type": "image",
                            "url": web_url,
                            "filename": img_file
                        })

                html_path = primary_sample_dir / "interactive_alignment.html"
                if html_path.exists():
                    rel_path = html_path.relative_to(SIGNX_PLUGIN_DIR)
                    web_url = f"/plugins/SignX/{rel_path}"
                    analysis_files.append({
                        "name": "Interactive Alignment",
                        "type": "html",
                        "url": web_url,
                        "filename": "interactive_alignment.html"
                    })

                keyframes_dir = primary_sample_dir / "attention_keyframes"
                if keyframes_dir.exists():
                    index_file = keyframes_dir / "keyframes_index.txt"
                    keyframe_info = None
                    if index_file.exists():
                        with open(index_file, 'r', encoding='utf-8') as f:
                            keyframe_info = f.read()

                    rel_path = keyframes_dir.relative_to(SIGNX_PLUGIN_DIR)
                    web_url = f"/plugins/SignX/{rel_path}"

                    keyframe_previews = []
                    for kf in sorted(keyframes_dir.glob("keyframe_*.png"))[:6]:
                        kf_rel = kf.relative_to(SIGNX_PLUGIN_DIR)
                        keyframe_previews.append({
                            "url": f"/plugins/SignX/{kf_rel}",
                            "name": kf.stem
                        })

                    analysis_files.append({
                        "name": "Attention Keyframes",
                        "type": "keyframes",
                        "url": web_url,
                        "info": keyframe_info,
                        "previews": keyframe_previews,
                        "count": len(list(keyframes_dir.glob("keyframe_*.png")))
                    })

                analysis_images = analysis_files

        # 读取输出文件（支持新的存储位置）
        output_text = ""
        output_clean = ""

        resolved_output = self._resolve_output_location(output_file, analysis_dir)
        if resolved_output and resolved_output.exists():
            output_file = resolved_output
            with open(output_file, 'r', encoding='utf-8') as f:
                output_text = f.read()

        resolved_clean = self._resolve_output_location(output_file_clean, analysis_dir)
        if resolved_clean and resolved_clean.exists():
            output_file_clean = resolved_clean
            with open(output_file_clean, 'r', encoding='utf-8') as f:
                output_clean = f.read()

        translation_text = ""
        translation_clean = ""
        translation_path = None
        if primary_sample_dir:
            translation_text, translation_clean = self._read_translation_file(primary_sample_dir)
            if translation_text or translation_clean:
                translation_path = primary_sample_dir / "translation.txt"

        job = self._get_job(job_id)
        logs_snapshot = list(job["logs"]) if job else []

        final_bpe = translation_text or output_text
        final_clean = translation_clean or output_clean or translation_text

        result = {
            "status": "success",
            "output": final_bpe,
            "output_clean": final_clean,
            "execution_time": execution_time,
            "analysis_dir": str(analysis_dir) if analysis_dir else None,
            "analysis_images": analysis_images,
            "video_path": video_path,
            "logs": logs_snapshot,
            "translation_path": str(translation_path) if translation_path else None
        }

        self._append_job_log(job_id, f"✅ 推理完成，耗时 {execution_time:.2f} 秒")
        self._finalize_job(job_id, "success", result=result)