VLABench/test_task_visual.py

#!/usr/bin/env python3
"""简洁的任务冒烟测试脚本：批量渲染 seed_tasks 并保存关键帧。"""
from __future__ import annotations

import argparse
import importlib
import os
import pkgutil
import sys
import traceback
from pathlib import Path
from typing import Iterable, List

from PIL import Image

REPO_ROOT = Path(__file__).resolve().parent
VLABENCH_ROOT = REPO_ROOT / "VLABench"
TASK_MODULE_PREFIX = "VLABench.tasks"
REQUIRED_FRAMES = 3

if str(REPO_ROOT) not in sys.path:
    sys.path.append(str(REPO_ROOT))

os.environ.setdefault("VLABENCH_ROOT", str(VLABENCH_ROOT))
os.environ.setdefault("MUJOCO_GL", "egl")

from VLABench.envs import load_env  # noqa: E402 pylint: disable=wrong-import-position
from VLABench.robots import *  # noqa: F403,F401,E402 pylint: disable=wildcard-import,unused-wildcard-import
from VLABench.utils.register import register  # noqa: E402 pylint: disable=wrong-import-position


def import_all_task_modules() -> None:
    """导入 VLABench.tasks 包下的所有模块，确保任务已注册。"""
    try:
        package = importlib.import_module(TASK_MODULE_PREFIX)
    except ModuleNotFoundError as exc:  # pragma: no cover - 直接失败更清晰
        raise RuntimeError(f"无法导入任务包 {TASK_MODULE_PREFIX}: {exc}") from exc

    for module_info in pkgutil.walk_packages(package.__path__, prefix=f"{TASK_MODULE_PREFIX}."):
        if module_info.name in sys.modules:
            continue
        try:
            importlib.import_module(module_info.name)
        except Exception as exc:  # pylint: disable=broad-except
            print(f"导入任务模块失败：{module_info.name} -> {exc}")


def collect_task_names() -> List[str]:
    import_all_task_modules()
    return sorted(getattr(register, "_tasks").keys())


def save_frames(task_name: str, frames: List, root_dir: Path) -> None:
    task_dir = root_dir / task_name
    task_dir.mkdir(parents=True, exist_ok=True)
    for idx, frame in enumerate(frames, start=1):
        Image.fromarray(frame).save(task_dir / f"frame{idx}.png")


def run_smoke_test(task_name: str,
                   camera: int,
                   height: int,
                   width: int,
                   save_dir: Path | None,
                   skip_skills: bool,
                   task_variant: str | None) -> bool:
    env = None
    frames: List = []
    saved_path: Path | None = None
    try:
        env = load_env(task_name, task_variant=task_variant)
        env.reset()
        frames.append(env.render(camera_id=camera, height=height, width=width))

        skill_error = None
        if not skip_skills:
            skill_sequence = env.get_expert_skill_sequence()
            if skill_sequence:
                for skill in skill_sequence:
                    try:
                        skill(env)
                    except Exception as exc:  # pylint: disable=broad-except
                        skill_error = exc
                        break
                    if len(frames) < REQUIRED_FRAMES:
                        try:
                            frames.append(env.render(camera_id=camera, height=height, width=width))
                        except Exception as exc:  # pylint: disable=broad-except
                            skill_error = exc
                            break
            else:
                print(f"{task_name}: 未提供专家技能序列，仅使用初始帧。")
        else:
            print(f"{task_name}: 跳过技能执行，仅渲染初始帧。")

        if len(frames) < REQUIRED_FRAMES:
            try:
                frames.extend([
                    env.render(camera_id=camera, height=height, width=width)
                    for _ in range(REQUIRED_FRAMES - len(frames))
                ])
            except Exception as exc:  # pylint: disable=broad-except
                print(f"{task_name}: 渲染补帧失败 -> {exc}")
                return False

        if save_dir is not None:
            save_dir.mkdir(parents=True, exist_ok=True)
            save_frames(task_name, frames[:REQUIRED_FRAMES], save_dir)
            saved_path = save_dir / task_name

        if skill_error:
            print(f"{task_name}: 技能执行中断 -> {skill_error}")
            return False

        message = f"{task_name}: 完成冒烟测试，已渲染 {REQUIRED_FRAMES} 帧。"
        if saved_path is not None:
            message += f" 已保存至 {saved_path}。"
        else:
            message += " 未指定 --save-dir，未写入磁盘。"
        print(message)
        return True

    except Exception as exc:  # pylint: disable=broad-except
        print(f"{task_name}: 冒烟测试失败 -> {exc}")
        traceback.print_exc()
        return False
    finally:
        if env is not None:
            env.close()


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="渲染 seed_tasks 中的任务并保存关键帧")
    parser.add_argument("--task", help="仅渲染指定任务", default=None)
    parser.add_argument(
        "--tasks",
        nargs="+",
        help="一次渲染多个任务，空格分隔，例如 --tasks task_a task_b",
        default=None,
    )
    parser.add_argument("--list", action="store_true", help="仅列出任务名")
    parser.add_argument("--camera", type=int, default=2, help="相机编号")
    parser.add_argument("--height", type=int, default=640, help="渲染高度")
    parser.add_argument("--width", type=int, default=640, help="渲染宽度")
    parser.add_argument("--save-dir", type=Path, default=None,
                        help="保存渲染结果的目录")
    parser.add_argument("--skip-skills", action="store_true",
                        help="仅渲染初始状态，不调用专家技能")
    parser.add_argument(
        "--task-variant",
        choices=["A", "B", "C", "D"],
        default=None,
        help="可选：指定任务的 A/B/C/D 布局模式。",
    )
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    task_names = collect_task_names()

    if not task_names:
        print("未找到可用任务，请确认模块路径无误。")
        return

    if args.list:
        for name in task_names:
            print(name)
        return

    tasks: Iterable[str] = task_names
    selected: List[str] | None = None
    if args.tasks:
        missing = [name for name in args.tasks if name not in task_names]
        if missing:
            print("以下任务未找到：")
            for name in missing:
                print(f"  - {name}")
            return
        selected = args.tasks
    elif args.task:
        if args.task not in task_names:
            print(f"未找到指定任务: {args.task}")
            return
        selected = [args.task]

    if selected is not None:
        # 去重同时保持顺序
        seen = set()
        filtered = []
        for name in selected:
            if name in seen:
                continue
            seen.add(name)
            filtered.append(name)
        tasks = filtered

    total = 0
    success = 0
    failed: List[str] = []

    save_root = Path(args.save_dir) if args.save_dir else None

    for name in tasks:
        total += 1
        if run_smoke_test(name,
                           args.camera,
                           args.height,
                           args.width,
                           save_root,
                           args.skip_skills,
                           args.task_variant):
            success += 1
        else:
            failed.append(name)

    print(f"完成冒烟测试 {success}/{total} 个任务。")
    if failed:
        print("失败的任务:")
        for name in failed:
            print(f"  - {name}")


if __name__ == "__main__":
    main()