Delete HVU_QA/HVU_QA_tool.py

HVU_QA/HVU_QA_tool.py

@@ -1,2003 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import fnmatch
-import importlib.util
-import os
-import shutil
-import subprocess
-import sys
-import textwrap
-from dataclasses import dataclass
-from pathlib import Path
-
-SCRIPT_ROOT = Path(__file__).resolve().parent
-IS_WINDOWS = os.name == "nt"
-TOOL_VENV_DIR = SCRIPT_ROOT / ".hvu_qa_tool_venv"
-TOOL_VENV_PYTHON = TOOL_VENV_DIR / ("Scripts/python.exe" if IS_WINDOWS else "bin/python")
-
-HF_DATASET_REPO_ID = "DANGDOCAO/GeneratingQuestions"
-HF_DATASET_REVISION = "main"
-HF_PROJECT_SUBDIR = "HVU_QA"
-HF_MODEL_SUBDIR = f"{HF_PROJECT_SUBDIR}/t5-viet-qg-finetuned"
-HF_BEST_MODEL_SUBDIR = f"{HF_MODEL_SUBDIR}/best-model"
-
-HF_HUB_REQUIREMENT = "huggingface_hub>=0.23.0,<1.0.0"
-RUNTIME_REQUIREMENTS = [
-    "Flask>=3.0.0,<4.0.0",
-    HF_HUB_REQUIREMENT,
-    "numpy>=1.26.0,<3.0.0",
-    "safetensors>=0.4.3,<1.0.0",
-    "sentencepiece>=0.2.0,<1.0.0",
-    "torch>=2.2.0,<3.0.0",
-    "transformers>=4.41.0,<5.0.0",
-]
-LOCAL_PROJECT_MARKERS = [
-    "main.py",
-    "backend/app.py",
-    "frontend/index.html",
-    "generate_question.py",
-]
-DEPENDENCY_IMPORTS = {
-    "Flask": "flask",
-    "numpy": "numpy",
-    "torch": "torch",
-    "transformers": "transformers",
-    "sentencepiece": "sentencepiece",
-    "safetensors": "safetensors",
-    "huggingface_hub": "huggingface_hub",
-}
-MODEL_IGNORE_PATTERNS = [
-    f"{HF_MODEL_SUBDIR}/checkpoint-*/**",
-    f"{HF_MODEL_SUBDIR}/all_results.json",
-    f"{HF_MODEL_SUBDIR}/eval_results.json",
-    f"{HF_MODEL_SUBDIR}/train_results.json",
-    f"{HF_MODEL_SUBDIR}/trainer_state.json",
-    f"{HF_MODEL_SUBDIR}/training_summary.json",
-    f"{HF_MODEL_SUBDIR}/training_args.bin",
-    f"{HF_BEST_MODEL_SUBDIR}/training_args.bin",
-]
-
-
-@dataclass(frozen=True)
-class RuntimeContext:
-    root: Path
-    main_file: Path
-    requirements_file: Path
-    local_model_dir: Path
-    local_best_model_dir: Path
-    standalone_mode: bool
-
-
-def print_step(message: str) -> None:
-    print(f"[HVU_QA_tool] {message}")
-
-
-def module_exists(module_name: str) -> bool:
-    return importlib.util.find_spec(module_name) is not None
-
-
-def run_command(
-    command: list[str],
-    *,
-    cwd: Path | None = None,
-    env: dict[str, str] | None = None,
-) -> None:
-    subprocess.check_call(command, cwd=str(cwd) if cwd else None, env=env)
-
-
-def is_running_in_virtualenv() -> bool:
-    return sys.prefix != getattr(sys, "base_prefix", sys.prefix) or bool(os.getenv("VIRTUAL_ENV"))
-
-
-def format_bytes(size: int) -> str:
-    units = ["B", "KB", "MB", "GB", "TB"]
-    value = float(size)
-    for unit in units:
-        if value < 1024 or unit == units[-1]:
-            if unit == "B":
-                return f"{int(value)} {unit}"
-            return f"{value:.1f} {unit}"
-        value /= 1024
-    return f"{size} B"
-
-
-def render_progress_bar(current: int, total: int, width: int = 28) -> str:
-    if total <= 0:
-        return "[----------------------------] 0.0%"
-
-    ratio = max(0.0, min(1.0, current / total))
-    filled = int(ratio * width)
-    bar = "#" * filled + "-" * (width - filled)
-    percent = ratio * 100
-    return f"[{bar}] {percent:5.1f}%"
-
-
-def matches_any_pattern(path: str, patterns: list[str]) -> bool:
-    normalized = path.replace("\\", "/")
-    return any(fnmatch.fnmatch(normalized, pattern) for pattern in patterns)
-
-
-def build_allow_patterns(best_model_only: bool) -> list[str]:
-    if best_model_only:
-        return [f"{HF_BEST_MODEL_SUBDIR}/**"]
-    return [f"{HF_MODEL_SUBDIR}/**"]
-
-
-def has_local_project(root: Path) -> bool:
-    return all((root / marker).exists() for marker in LOCAL_PROJECT_MARKERS)
-
-
-def build_runtime_requirements_text() -> str:
-    lines = [
-        "# Runtime dependencies for standalone HVU_QA launcher.",
-        "# Nếu dùng GPU NVIDIA, hãy cài đúng bản torch theo CUDA của máy nếu cần.",
-        *RUNTIME_REQUIREMENTS,
-        "",
-    ]
-    return "\n".join(lines)
-
-
-def build_runtime_file_map() -> dict[str, str]:
-    requirements_text = build_runtime_requirements_text()
-    return {
-        "requirements.txt": requirements_text,
-        "main.py": textwrap.dedent(
-            """
-            from __future__ import annotations
-
-            import os
-            import threading
-            import webbrowser
-
-            from backend import create_app
-
-            app = create_app()
-
-
-            def _as_bool(value: str | None, default: bool) -> bool:
-                if value is None:
-                    return default
-                return value.strip().lower() not in {"0", "false", "no", "off"}
-
-
-            def _open_browser_later(host: str, port: int) -> None:
-                if not _as_bool(os.getenv("HVU_OPEN_BROWSER"), True):
-                    return
-                target_host = "127.0.0.1" if host in {"0.0.0.0", "::"} else host
-                url = f"http://{target_host}:{port}"
-                threading.Timer(1.2, lambda: webbrowser.open(url)).start()
-
-
-            if __name__ == "__main__":
-                host = os.getenv("HVU_HOST", "127.0.0.1")
-                port = int(os.getenv("HVU_PORT", "5000"))
-                debug = _as_bool(os.getenv("HVU_DEBUG"), False)
-                _open_browser_later(host, port)
-                app.run(host=host, port=port, debug=debug, use_reloader=False)
-            """
-        ).strip()
-        + "\n",
-        "backend/__init__.py": 'from .app import create_app\n\n__all__ = ["create_app"]\n',
-        "backend/app.py": textwrap.dedent(
-            """
-            from __future__ import annotations
-
-            import os
-            import time
-            from pathlib import Path
-
-            from flask import Flask, jsonify, request, send_from_directory
-
-            from generate_question import (
-                APP_TITLE,
-                QUESTION_LIMIT,
-                QuestionGenerator,
-                format_questions,
-                normalize_text,
-                parse_question_count,
-                resolve_model_dir,
-            )
-
-            IGNORED_MODEL_DIR_NAMES = {
-                ".git",
-                ".vscode",
-                "__pycache__",
-                "backend",
-                "frontend",
-                "venv",
-                ".hvu_qa_tool_venv",
-                "HVU_QA_runtime",
-            }
-
-
-            def project_root() -> Path:
-                return Path(__file__).resolve().parents[1]
-
-
-            def _read_optional_int(value: str | None) -> int | None:
-                if value in (None, ""):
-                    return None
-                return int(value)
-
-
-            def build_generator(
-                model_dir: str | Path | None = None,
-                prefer_nested_model: bool = True,
-            ) -> QuestionGenerator:
-                root = project_root()
-                selected_model_dir = (
-                    Path(model_dir).expanduser()
-                    if model_dir is not None
-                    else Path(os.getenv("HVU_MODEL_DIR", str(root / "t5-viet-qg-finetuned"))).expanduser()
-                )
-                if not selected_model_dir.is_absolute():
-                    selected_model_dir = root / selected_model_dir
-
-                return QuestionGenerator(
-                    model_dir=str(selected_model_dir),
-                    task_prefix=os.getenv("HVU_TASK_PREFIX", "sinh câu hỏi"),
-                    max_source_length=int(os.getenv("HVU_MAX_SOURCE_LENGTH", "512")),
-                    max_new_tokens=int(os.getenv("HVU_MAX_NEW_TOKENS", "64")),
-                    device=os.getenv("HVU_DEVICE", "auto"),
-                    cpu_threads=_read_optional_int(os.getenv("HVU_CPU_THREADS")),
-                    gpu_dtype=os.getenv("HVU_GPU_DTYPE", "auto"),
-                    prefer_nested_model=prefer_nested_model,
-                )
-
-
-            def _model_label(relative_path: str | Path) -> str:
-                path = Path(relative_path)
-                return path.name or "model"
-
-
-            def _iter_model_candidates(root: Path):
-                for child in sorted(root.iterdir(), key=lambda path: path.name.lower()):
-                    if not child.is_dir() or child.name.startswith(".") or child.name in IGNORED_MODEL_DIR_NAMES:
-                        continue
-
-                    if (child / "config.json").exists():
-                        yield {"path": child, "prefer_nested_model": False}
-
-                    for nested_name in ("best-model", "final-model"):
-                        nested = child / nested_name
-                        if nested.is_dir() and (nested / "config.json").exists():
-                            yield {"path": nested, "prefer_nested_model": False}
-
-
-            def _discover_available_models(
-                root: Path,
-                active_generator: QuestionGenerator | None = None,
-            ) -> list[dict[str, str]]:
-                models: list[dict[str, str]] = []
-                seen_roots: set[str] = set()
-                root = root.resolve()
-
-                for candidate_info in _iter_model_candidates(root):
-                    candidate = candidate_info["path"]
-                    model_key = str(candidate.resolve())
-                    if model_key in seen_roots:
-                        continue
-
-                    try:
-                        relative_candidate = candidate.resolve().relative_to(root)
-                    except ValueError:
-                        continue
-
-                    seen_roots.add(model_key)
-                    models.append(
-                        {
-                            "id": relative_candidate.as_posix(),
-                            "label": _model_label(relative_candidate),
-                            "model_root": str(candidate.resolve()),
-                            "model_dir": str(resolve_model_dir(candidate, prefer_nested_model=False).resolve()),
-                            "prefer_nested_model": bool(candidate_info["prefer_nested_model"]),
-                        }
-                    )
-
-                if active_generator is not None:
-                    current_root = active_generator.model_root.resolve()
-                    current_dir = active_generator.model_dir.resolve()
-                    exists = any(
-                        Path(item["model_root"]).resolve() == current_root
-                        or Path(item["model_dir"]).resolve() == current_dir
-                        for item in models
-                    )
-                    if not exists:
-                        models.append(
-                            {
-                                "id": current_root.as_posix(),
-                                "label": current_root.name,
-                                "model_root": str(current_root),
-                                "model_dir": str(current_dir),
-                                "prefer_nested_model": False,
-                            }
-                        )
-
-                return models
-
-
-            def _selected_model_id(
-                app: Flask,
-                models: list[dict[str, str]],
-                active_generator: QuestionGenerator | None = None,
-            ) -> str:
-                explicit_selection = str(app.config.get("SELECTED_MODEL_ID") or "").strip()
-                if explicit_selection and any(item["id"] == explicit_selection for item in models):
-                    return explicit_selection
-
-                active_generator = active_generator or _generator(app)
-                current_root = active_generator.model_root.resolve()
-                current_dir = active_generator.model_dir.resolve()
-
-                for item in models:
-                    if Path(item["model_dir"]).resolve() == current_dir:
-                        return item["id"]
-
-                for item in models:
-                    if Path(item["model_root"]).resolve() == current_root:
-                        return item["id"]
-
-                return models[0]["id"] if models else ""
-
-
-            def _switch_generator(app: Flask, model_id: str) -> QuestionGenerator:
-                available_models = _discover_available_models(app.config["PROJECT_ROOT"], _generator(app))
-                selected_model = next((item for item in available_models if item["id"] == model_id), None)
-                if selected_model is None:
-                    raise ValueError("Model được chọn không hợp lệ hoặc chưa tồn tại trong thư mục runtime.")
-
-                current_model_id = _selected_model_id(app, available_models)
-                if current_model_id != model_id:
-                    app.config["GENERATOR"] = build_generator(
-                        selected_model["model_root"],
-                        prefer_nested_model=bool(selected_model.get("prefer_nested_model")),
-                    )
-
-                app.config["SELECTED_MODEL_ID"] = model_id
-                return _generator(app)
-
-
-            def _info_payload(app: Flask, active_generator: QuestionGenerator | None = None) -> dict[str, object]:
-                active_generator = active_generator or _generator(app)
-                available_models = _discover_available_models(app.config["PROJECT_ROOT"], active_generator)
-                selected_model_id = _selected_model_id(app, available_models, active_generator)
-                model_name = next(
-                    (item["label"] for item in available_models if item["id"] == selected_model_id),
-                    Path(active_generator.model_dir).name,
-                )
-                return {
-                    "ok": True,
-                    "title": APP_TITLE,
-                    "model_name": model_name,
-                    "selected_model_id": selected_model_id,
-                    "available_models": [{"id": item["id"], "label": item["label"]} for item in available_models],
-                    "meta": active_generator.metadata(),
-                }
-
-
-            def create_app(generator: QuestionGenerator | None = None) -> Flask:
-                root = project_root()
-                frontend_root = root / "frontend"
-
-                app = Flask(__name__, static_folder=None)
-                app.json.ensure_ascii = False
-                app.config["GENERATOR"] = generator or build_generator()
-                app.config["PROJECT_ROOT"] = root
-                app.config["FRONTEND_ROOT"] = frontend_root
-                app.config["SELECTED_MODEL_ID"] = ""
-
-                @app.get("/")
-                def index():
-                    return send_from_directory(app.config["FRONTEND_ROOT"], "index.html")
-
-                @app.get("/frontend/<path:filename>")
-                def frontend_file(filename: str):
-                    return send_from_directory(app.config["FRONTEND_ROOT"], filename)
-
-                @app.get("/api/info")
-                def info():
-                    return jsonify(_info_payload(app))
-
-                @app.post("/api/model")
-                def set_model():
-                    payload = request.get_json(silent=True) or {}
-                    model_id = str(payload.get("model_id") or "").strip()
-                    if not model_id:
-                        return jsonify({"ok": False, "error": "Vui lòng chọn model trước khi chuyển."}), 400
-
-                    try:
-                        active_generator = _switch_generator(app, model_id)
-                    except ValueError as exc:
-                        return jsonify({"ok": False, "error": str(exc)}), 404
-
-                    return jsonify(_info_payload(app, active_generator))
-
-                @app.post("/api/generate")
-                def generate():
-                    payload = request.get_json(silent=True) or {}
-                    requested_model_id = str(payload.get("model_id") or "").strip()
-
-                    if requested_model_id:
-                        try:
-                            active_generator = _switch_generator(app, requested_model_id)
-                        except ValueError as exc:
-                            return jsonify({"ok": False, "error": str(exc)}), 400
-                    else:
-                        active_generator = _generator(app)
-
-                    text = normalize_text(payload.get("text"))
-                    if not text:
-                        return jsonify({"ok": False, "error": "Vui lòng nhập đoạn văn bản trước khi sinh câu hỏi."}), 400
-
-                    raw_count = payload.get("num_questions")
-                    if raw_count in (None, ""):
-                        count = 5
-                    else:
-                        try:
-                            count = int(raw_count)
-                        except (TypeError, ValueError):
-                            return jsonify({"ok": False, "error": "Số câu hỏi phải là số nguyên trong khoảng 1 đến 100."}), 400
-
-                        if count < 1 or count > QUESTION_LIMIT:
-                            return jsonify({"ok": False, "error": f"Số câu hỏi phải nằm trong khoảng 1 đến {QUESTION_LIMIT}."}), 400
-
-                    started = time.perf_counter()
-                    try:
-                        questions = active_generator.generate(text, parse_question_count(count))
-                    except Exception as exc:  # noqa: BLE001
-                        return jsonify({"ok": False, "error": str(exc)}), 500
-
-                    elapsed_ms = round((time.perf_counter() - started) * 1000, 2)
-                    info_payload = _info_payload(app, active_generator)
-                    return jsonify(
-                        {
-                            "ok": True,
-                            "text": text,
-                            "num_questions": count,
-                            "questions": questions,
-                            "formatted": format_questions(questions),
-                            "elapsed_ms": elapsed_ms,
-                            "model_name": info_payload["model_name"],
-                            "selected_model_id": info_payload["selected_model_id"],
-                            "meta": active_generator.metadata(),
-                        }
-                    )
-
-                return app
-
-
-            def _generator(app: Flask) -> QuestionGenerator:
-                generator: QuestionGenerator = app.config["GENERATOR"]
-                return generator
-            """
-        ).strip()
-        + "\n",
-        "generate_question.py": textwrap.dedent(
-            """
-            from __future__ import annotations
-
-            import argparse
-            import json
-            import os
-            import re
-            import sys
-            import threading
-            from pathlib import Path
-            from typing import Any
-
-            os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
-            os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
-
-
-            def raise_missing_dependency_error(exc: ModuleNotFoundError) -> None:
-                root = Path(__file__).resolve().parent
-                requirements = root / "requirements.txt"
-                message = [
-                    f"Thiếu thư viện Python: {exc.name}",
-                    f"Interpreter hiện tại: {sys.executable}",
-                ]
-                if requirements.exists():
-                    message.extend(
-                        [
-                            "Cài đặt dependencies bằng lệnh:",
-                            f"{sys.executable} -m pip install -r {requirements}",
-                        ]
-                    )
-                raise SystemExit("\\n".join(message)) from exc
-
-
-            try:
-                import torch
-                from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
-            except ModuleNotFoundError as exc:
-                raise_missing_dependency_error(exc)
-
-
-            APP_TITLE = "HVU_QA Tool - Sinh câu hỏi"
-            TASK_PREFIX = "sinh câu hỏi"
-            QUESTION_LIMIT = 100
-            GENERATION_PASSES = (
-                (0.9, 0.95, 1, 4),
-                (1.0, 0.97, 1, 5),
-                (1.08, 0.99, 2, 6),
-            )
-
-
-            def normalize_text(text: Any) -> str:
-                return " ".join(str(text or "").split())
-
-
-            def unique_text(items: list[str]) -> list[str]:
-                seen: set[str] = set()
-                output: list[str] = []
-                for item in items:
-                    value = normalize_text(item)
-                    key = value.lower()
-                    if key and key not in seen:
-                        seen.add(key)
-                        output.append(value)
-                return output
-
-
-            def parse_question_count(value: Any, default: int = 5) -> int:
-                try:
-                    parsed = int(value)
-                except (TypeError, ValueError):
-                    parsed = default
-                return max(1, min(parsed, QUESTION_LIMIT))
-
-
-            def format_questions(items: list[str]) -> str:
-                if not items:
-                    return "Không sinh được câu hỏi phù hợp."
-                return "\\n".join(f"{index}. {item}" for index, item in enumerate(items, 1))
-
-
-            def resolve_model_dir(model_dir: str | Path, prefer_nested_model: bool = True) -> Path:
-                model_root = Path(model_dir).expanduser().resolve()
-                nested_candidates = [model_root / "best-model", model_root / "final-model"]
-                candidates = [*nested_candidates, model_root] if prefer_nested_model else [model_root, *nested_candidates]
-                for candidate in candidates:
-                    if candidate.is_dir() and (candidate / "config.json").exists():
-                        return candidate
-                raise FileNotFoundError(f"Không tìm thấy thư mục mô hình hợp lệ: {model_root}")
-
-
-            def parse_dtype(value: str) -> torch.dtype:
-                normalized = value.strip().lower()
-                mapping = {
-                    "float16": torch.float16,
-                    "fp16": torch.float16,
-                    "float32": torch.float32,
-                    "fp32": torch.float32,
-                    "bfloat16": torch.bfloat16,
-                    "bf16": torch.bfloat16,
-                }
-                if normalized not in mapping:
-                    raise ValueError(f"Không hỗ trợ gpu_dtype={value}")
-                return mapping[normalized]
-
-
-            class QuestionGenerator:
-                def __init__(
-                    self,
-                    model_dir: str | Path = "t5-viet-qg-finetuned",
-                    task_prefix: str = TASK_PREFIX,
-                    max_source_length: int = 512,
-                    max_new_tokens: int = 64,
-                    device: str = "auto",
-                    cpu_threads: int | None = None,
-                    gpu_dtype: str = "auto",
-                    prefer_nested_model: bool = True,
-                ) -> None:
-                    self.model_root = Path(model_dir).expanduser().resolve()
-                    self.model_dir = resolve_model_dir(model_dir, prefer_nested_model=prefer_nested_model)
-                    self.task_prefix = task_prefix
-                    self.max_source_length = max_source_length
-                    self.max_new_tokens = max_new_tokens
-                    self.requested_device = device
-                    self.cpu_threads = cpu_threads
-                    self.gpu_dtype = gpu_dtype
-                    self.device: torch.device | None = None
-                    self.dtype: torch.dtype | None = None
-                    self.tokenizer = None
-                    self.model = None
-                    self._load_lock = threading.Lock()
-
-                def _resolve_device(self) -> torch.device:
-                    requested = self.requested_device.lower()
-                    if requested == "cpu":
-                        return torch.device("cpu")
-                    if requested == "cuda":
-                        if not torch.cuda.is_available():
-                            raise RuntimeError("Bạn đã chọn device=cuda nhưng máy hiện tại không có CUDA.")
-                        return torch.device("cuda")
-                    return torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-                def _resolve_dtype(self) -> torch.dtype:
-                    if self.device is None or self.device.type != "cuda":
-                        return torch.float32
-                    if self.gpu_dtype == "auto":
-                        if hasattr(torch.cuda, "is_bf16_supported") and torch.cuda.is_bf16_supported():
-                            return torch.bfloat16
-                        return torch.float16
-                    return parse_dtype(self.gpu_dtype)
-
-                def _configure_runtime(self) -> None:
-                    if self.device is None:
-                        return
-                    if self.device.type == "cpu":
-                        if self.cpu_threads:
-                            torch.set_num_threads(max(1, int(self.cpu_threads)))
-                            if hasattr(torch, "set_num_interop_threads"):
-                                torch.set_num_interop_threads(max(1, min(int(self.cpu_threads), 4)))
-                        return
-
-                    if hasattr(torch.backends, "cuda") and hasattr(torch.backends.cuda, "matmul"):
-                        torch.backends.cuda.matmul.allow_tf32 = True
-                    if hasattr(torch.backends, "cudnn"):
-                        torch.backends.cudnn.allow_tf32 = True
-                        torch.backends.cudnn.benchmark = True
-
-                def load(self) -> None:
-                    if self.model is not None and self.tokenizer is not None:
-                        return
-
-                    with self._load_lock:
-                        if self.model is not None and self.tokenizer is not None:
-                            return
-
-                        self.device = self._resolve_device()
-                        self.dtype = self._resolve_dtype()
-                        self._configure_runtime()
-
-                        model_kwargs: dict[str, Any] = {}
-                        if self.device.type == "cuda":
-                            model_kwargs["torch_dtype"] = self.dtype
-                            model_kwargs["low_cpu_mem_usage"] = True
-
-                        self.tokenizer = AutoTokenizer.from_pretrained(str(self.model_dir), use_fast=True)
-                        self.model = AutoModelForSeq2SeqLM.from_pretrained(str(self.model_dir), **model_kwargs)
-                        self.model.to(self.device)
-                        self.model.eval()
-
-                def metadata(self) -> dict[str, Any]:
-                    active_device = self.device.type if self.device is not None else None
-                    predicted_device = "cuda" if torch.cuda.is_available() and self.requested_device != "cpu" else "cpu"
-                    return {
-                        "title": APP_TITLE,
-                        "model_root": str(self.model_root),
-                        "model_dir": str(self.model_dir),
-                        "requested_device": self.requested_device,
-                        "active_device": active_device,
-                        "predicted_device": predicted_device,
-                        "loaded": self.model is not None,
-                        "gpu_available": torch.cuda.is_available(),
-                        "gpu_dtype": None if self.dtype is None else str(self.dtype).replace("torch.", ""),
-                        "cpu_threads": torch.get_num_threads(),
-                    }
-
-                def _candidate_answers(self, text: str, limit: int) -> list[str]:
-                    text = normalize_text(text)
-                    if not text:
-                        return []
-
-                    candidates: list[str] = []
-                    split_pattern = r"(?<=[.!?])\\s+|\\n+"
-                    for sentence in [normalize_text(part) for part in re.split(split_pattern, text) if normalize_text(part)]:
-                        if 3 <= len(sentence.split()) <= 30:
-                            candidates.append(sentence)
-                        for clause in (normalize_text(part) for part in re.split(r"\\s*[,;:]\\s*", sentence)):
-                            if 3 <= len(clause.split()) <= 20:
-                                candidates.append(clause)
-
-                    if not candidates:
-                        words = text.split()
-                        candidates = [" ".join(words[: min(12, len(words))])] if words else [text]
-
-                    ranked = sorted(unique_text(candidates), key=lambda item: (abs(len(item.split()) - 10), len(item)))
-                    return ranked[:limit]
-
-                def _build_prompt(self, context: str, answer: str) -> str:
-                    return f"{self.task_prefix}:\\nngữ cảnh: {context}\\nđáp án: {answer}"
-
-                @torch.inference_mode()
-                def _sample(self, context: str, answer: str, count: int, temperature: float, top_p: float) -> list[str]:
-                    if self.tokenizer is None or self.model is None or self.device is None:
-                        raise RuntimeError("Model chưa được load.")
-
-                    inputs = self.tokenizer(
-                        self._build_prompt(context, answer),
-                        return_tensors="pt",
-                        truncation=True,
-                        max_length=self.max_source_length,
-                    ).to(self.device)
-                    outputs = self.model.generate(
-                        **inputs,
-                        max_new_tokens=self.max_new_tokens,
-                        do_sample=True,
-                        temperature=temperature,
-                        top_p=top_p,
-                        num_return_sequences=max(1, min(count, 6)),
-                        no_repeat_ngram_size=3,
-                        repetition_penalty=1.1,
-                    )
-                    questions: list[str] = []
-                    for token_ids in outputs:
-                        question = normalize_text(self.tokenizer.decode(token_ids, skip_special_tokens=True))
-                        if question:
-                            questions.append(question if question.endswith("?") else f"{question}?")
-                    return [question for question in unique_text(questions) if len(question.split()) >= 3]
-
-                def generate(self, text: str, num_questions: int = 5) -> list[str]:
-                    clean_text = normalize_text(text)
-                    requested_count = parse_question_count(num_questions)
-                    if not clean_text:
-                        return []
-
-                    self.load()
-                    answers = self._candidate_answers(clean_text, limit=max(requested_count * 3, 8))
-                    questions: list[str] = []
-
-                    for temperature, top_p, candidate_step, sample_count in GENERATION_PASSES:
-                        for index, answer in enumerate(answers):
-                            generated = self._sample(
-                                clean_text,
-                                answer,
-                                count=min(sample_count + requested_count, requested_count + 2),
-                                temperature=temperature,
-                                top_p=top_p,
-                            )
-                            questions.extend(generated)
-                            questions = unique_text(questions)
-                            if len(questions) >= requested_count:
-                                return questions[:requested_count]
-                            if candidate_step and (index + 1) % candidate_step == 0 and len(questions) >= requested_count:
-                                return questions[:requested_count]
-
-                    return questions[:requested_count]
-
-
-            def _read_text_from_args(args: argparse.Namespace) -> str:
-                if args.text:
-                    return normalize_text(args.text)
-                if args.input_file:
-                    return normalize_text(Path(args.input_file).read_text(encoding="utf-8"))
-                raise SystemExit("Vui lòng truyền --text hoặc --input_file.")
-
-
-            def build_parser() -> argparse.ArgumentParser:
-                parser = argparse.ArgumentParser(description="Sinh câu hỏi từ một đoạn văn bản bằng model T5 tiếng Việt.")
-                parser.add_argument("--text", help="Đoạn văn bản đầu vào.")
-                parser.add_argument("--input_file", help="Đọc đoạn văn bản từ file UTF-8.")
-                parser.add_argument("--num_questions", type=int, default=5, help="Số câu hỏi cần sinh.")
-                parser.add_argument("--model_dir", default=os.getenv("HVU_MODEL_DIR", "t5-viet-qg-finetuned"))
-                parser.add_argument("--task_prefix", default=os.getenv("HVU_TASK_PREFIX", TASK_PREFIX))
-                parser.add_argument("--device", default=os.getenv("HVU_DEVICE", "auto"), choices=["auto", "cpu", "cuda"])
-                parser.add_argument("--cpu_threads", type=int, default=None)
-                parser.add_argument("--gpu_dtype", default=os.getenv("HVU_GPU_DTYPE", "auto"))
-                parser.add_argument("--max_source_length", type=int, default=int(os.getenv("HVU_MAX_SOURCE_LENGTH", "512")))
-                parser.add_argument("--max_new_tokens", type=int, default=int(os.getenv("HVU_MAX_NEW_TOKENS", "64")))
-                parser.add_argument("--output_format", choices=["text", "json"], default="text")
-                return parser
-
-
-            def main() -> int:
-                if hasattr(sys.stdout, "reconfigure"):
-                    sys.stdout.reconfigure(encoding="utf-8")
-                if hasattr(sys.stderr, "reconfigure"):
-                    sys.stderr.reconfigure(encoding="utf-8")
-
-                args = build_parser().parse_args()
-                text = _read_text_from_args(args)
-                generator = QuestionGenerator(
-                    model_dir=args.model_dir,
-                    task_prefix=args.task_prefix,
-                    max_source_length=args.max_source_length,
-                    max_new_tokens=args.max_new_tokens,
-                    device=args.device,
-                    cpu_threads=args.cpu_threads,
-                    gpu_dtype=args.gpu_dtype,
-                )
-                questions = generator.generate(text, args.num_questions)
-                payload = {
-                    "ok": True,
-                    "text": text,
-                    "num_questions": parse_question_count(args.num_questions),
-                    "questions": questions,
-                    "formatted": format_questions(questions),
-                    "meta": generator.metadata(),
-                }
-
-                if args.output_format == "json":
-                    print(json.dumps(payload, ensure_ascii=False, indent=2))
-                else:
-                    print(payload["formatted"])
-                return 0
-
-
-            if __name__ == "__main__":
-                raise SystemExit(main())
-            """
-        ).strip()
-        + "\n",
-        "frontend/index.html": textwrap.dedent(
-            """
-            <!doctype html>
-            <html lang="vi">
-            <head>
-              <meta charset="utf-8">
-              <meta name="viewport" content="width=device-width, initial-scale=1">
-              <title>HVU_QA Tool</title>
-              <link rel="stylesheet" href="/frontend/style.css">
-            </head>
-            <body>
-              <div class="page-shell">
-                <header class="hero">
-                  <span class="hero-badge">HVU_QA Tool</span>
-                  <h1>Sinh câu hỏi từ văn bản</h1>
-                  <p>Launcher nhẹ dành cho người dùng cuối. Chỉ cần một file tool để dựng runtime, tải model và chạy ứng dụng.</p>
-                </header>
-
-                <div class="layout">
-                  <aside class="sidebar">
-                    <section class="panel">
-                      <div class="panel-heading">
-                        <h2>Trạng thái model</h2>
-                        <span id="readyBadge" class="badge badge-soft">Đang tải</span>
-                      </div>
-
-                      <label class="field-label" for="modelSelect">Model đang dùng</label>
-                      <select id="modelSelect" class="select-field"></select>
-
-                      <dl class="status-list">
-                        <div>
-                          <dt>Tên hiển thị</dt>
-                          <dd id="modelName">-</dd>
-                        </div>
-                        <div>
-                          <dt>Thiết bị</dt>
-                          <dd id="deviceStatus">-</dd>
-                        </div>
-                        <div>
-                          <dt>Trạng thái nạp</dt>
-                          <dd id="loadedStatus">-</dd>
-                        </div>
-                      </dl>
-                    </section>
-
-                    <section class="panel">
-                      <div class="panel-heading">
-                        <h2>Ví dụ mẫu</h2>
-                      </div>
-                      <p class="panel-hint">Bấm vào một văn bản luật mẫu để chèn nhanh nội dung thử nghiệm.</p>
-                      <div id="sampleList" class="sample-list"></div>
-                    </section>
-                  </aside>
-
-                  <main class="main-panel">
-                    <section class="composer panel">
-                      <label class="field-label" for="sourceText">Đoạn văn bản đầu vào</label>
-                      <textarea id="sourceText" class="text-input" placeholder="Nhập đoạn văn bản ..."></textarea>
-
-                      <div class="composer-footer">
-                        <div class="count-field">
-                          <span class="field-label">Số câu hỏi</span>
-                          <div class="count-controls">
-                            <button id="decreaseCount" type="button" class="count-button">-</button>
-                            <input id="questionCount" class="count-input" type="number" min="1" max="100" value="5">
-                            <button id="increaseCount" type="button" class="count-button">+</button>
-                          </div>
-                        </div>
-
-                        <button id="generateButton" type="button" class="primary-button">
-                          <span id="generateButtonText">Sinh câu hỏi</span>
-                        </button>
-                      </div>
-
-                      <p id="formMessage" class="form-message"></p>
-                    </section>
-
-                    <section id="resultPanel" class="result-panel panel">
-                      <div id="resultPlaceholder" class="result-placeholder">
-                        Nhập văn bản và nhấn <strong>Sinh câu hỏi</strong> để xem kết quả.
-                      </div>
-
-                      <div id="resultContent" class="result-content hidden">
-                        <div class="result-header">
-                          <div>
-                            <h2>Kết quả sinh câu hỏi</h2>
-                            <p id="resultStats" class="result-stats"></p>
-                          </div>
-                          <button id="copyButton" type="button" class="secondary-button">Sao chép</button>
-                        </div>
-
-                        <ol id="resultList" class="result-list"></ol>
-                        <pre id="formattedOutput" class="formatted-output"></pre>
-                      </div>
-                    </section>
-                  </main>
-                </div>
-              </div>
-
-              <script src="/frontend/app.js"></script>
-            </body>
-            </html>
-            """
-        ).strip()
-        + "\n",
-        "frontend/app.js": textwrap.dedent(
-            """
-            const sampleTexts = [
-              {
-                title: 'Luật Giáo dục đại học',
-                text: 'Cơ sở giáo dục đại học có nhiệm vụ tổ chức đào tạo, nghiên cứu khoa học, chuyển giao công nghệ và phục vụ cộng đồng theo quy định của pháp luật.'
-              },
-              {
-                title: 'Bộ luật Lao động',
-                text: 'Người lao động là người làm việc cho người sử dụng lao động theo thỏa thuận, được trả lương và chịu sự quản lý, điều hành, giám sát của người sử dụng lao động.'
-              },
-              {
-                title: 'Luật An toàn thông tin mạng',
-                text: 'An toàn thông tin mạng là sự bảo vệ thông tin, hệ thống thông tin trên mạng khỏi bị truy nhập, sử dụng, tiết lộ, gián đoạn, sửa đổi hoặc phá hoại trái phép.'
-              }
-            ];
-
-            const state = {
-              info: null,
-              loading: false,
-              count: 5,
-              lastFormatted: ''
-            };
-
-            const elements = {
-              modelSelect: document.getElementById('modelSelect'),
-              readyBadge: document.getElementById('readyBadge'),
-              modelName: document.getElementById('modelName'),
-              deviceStatus: document.getElementById('deviceStatus'),
-              loadedStatus: document.getElementById('loadedStatus'),
-              sampleList: document.getElementById('sampleList'),
-              sourceText: document.getElementById('sourceText'),
-              decreaseCount: document.getElementById('decreaseCount'),
-              increaseCount: document.getElementById('increaseCount'),
-              questionCount: document.getElementById('questionCount'),
-              generateButton: document.getElementById('generateButton'),
-              generateButtonText: document.getElementById('generateButtonText'),
-              formMessage: document.getElementById('formMessage'),
-              resultPanel: document.getElementById('resultPanel'),
-              resultPlaceholder: document.getElementById('resultPlaceholder'),
-              resultContent: document.getElementById('resultContent'),
-              resultStats: document.getElementById('resultStats'),
-              resultList: document.getElementById('resultList'),
-              formattedOutput: document.getElementById('formattedOutput'),
-              copyButton: document.getElementById('copyButton')
-            };
-
-            function normalizeCount(value) {
-              const parsed = Number.parseInt(value, 10);
-              if (Number.isNaN(parsed)) {
-                return 1;
-              }
-              return Math.max(1, Math.min(100, parsed));
-            }
-
-            function setCount(value) {
-              state.count = normalizeCount(value);
-              elements.questionCount.value = String(state.count);
-            }
-
-            function setMessage(text, tone = 'muted') {
-              elements.formMessage.textContent = text || '';
-              elements.formMessage.dataset.tone = tone;
-            }
-
-            function setLoading(loading) {
-              state.loading = loading;
-              elements.generateButton.disabled = loading;
-              elements.modelSelect.disabled = loading;
-              elements.generateButtonText.textContent = loading ? 'Đang xử lý...' : 'Sinh câu hỏi';
-              elements.readyBadge.textContent = loading ? 'Đang chạy' : 'Sẵn sàng';
-              elements.readyBadge.classList.toggle('badge-busy', loading);
-            }
-
-            async function fetchJson(url, options = {}) {
-              const response = await fetch(url, options);
-              const payload = await response.json().catch(() => ({}));
-              if (!response.ok || payload.ok === false) {
-                throw new Error(payload.error || `Yêu cầu thất bại (${response.status})`);
-              }
-              return payload;
-            }
-
-            function renderSamples() {
-              elements.sampleList.innerHTML = '';
-              sampleTexts.forEach((sample) => {
-                const button = document.createElement('button');
-                button.type = 'button';
-                button.className = 'sample-card';
-                button.innerHTML = `<strong>${sample.title}</strong><span>${sample.text}</span>`;
-                button.addEventListener('click', () => {
-                  elements.sourceText.value = sample.text;
-                  setMessage(`Đã chèn mẫu: ${sample.title}`, 'muted');
-                  elements.sourceText.focus();
-                });
-                elements.sampleList.appendChild(button);
-              });
-            }
-
-            function renderInfo(info) {
-              state.info = info;
-              const models = Array.isArray(info.available_models) ? info.available_models : [];
-              const selectedId = info.selected_model_id || models[0]?.id || '';
-
-              elements.modelSelect.innerHTML = '';
-              if (!models.length) {
-                const option = document.createElement('option');
-                option.value = '';
-                option.textContent = 'Không có model khả dụng';
-                elements.modelSelect.appendChild(option);
-              } else {
-                models.forEach((model) => {
-                  const option = document.createElement('option');
-                  option.value = model.id;
-                  option.textContent = model.label;
-                  elements.modelSelect.appendChild(option);
-                });
-                elements.modelSelect.value = selectedId;
-              }
-
-              const meta = info.meta || {};
-              elements.modelName.textContent = info.model_name || '-';
-              elements.deviceStatus.textContent = meta.active_device
-                ? meta.active_device.toUpperCase()
-                : (meta.predicted_device ? `Dự đoán: ${String(meta.predicted_device).toUpperCase()}` : '-');
-              elements.loadedStatus.textContent = meta.loaded ? 'Đã nạp' : 'Chưa nạp';
-              elements.readyBadge.textContent = 'Sẵn sàng';
-              elements.readyBadge.classList.remove('badge-busy');
-            }
-
-            function renderResult(result) {
-              const questions = Array.isArray(result.questions) ? result.questions : [];
-              elements.resultPlaceholder.classList.add('hidden');
-              elements.resultContent.classList.remove('hidden');
-              elements.resultList.innerHTML = '';
-
-              questions.forEach((question) => {
-                const item = document.createElement('li');
-                item.textContent = question;
-                elements.resultList.appendChild(item);
-              });
-
-              state.lastFormatted = result.formatted || '';
-              elements.formattedOutput.textContent = state.lastFormatted;
-              elements.resultStats.textContent = `${questions.length} câu hỏi • ${result.model_name || 'Không rõ model'} • ${result.elapsed_ms || 0} ms`;
-            }
-
-            async function loadInfo() {
-              const info = await fetchJson('/api/info');
-              renderInfo(info);
-              setMessage('Sẵn sàng để sinh câu hỏi.', 'muted');
-            }
-
-            async function changeModel() {
-              const modelId = elements.modelSelect.value;
-              if (!modelId) {
-                return;
-              }
-              setLoading(true);
-              setMessage('Đang chuyển model...', 'muted');
-              try {
-                const info = await fetchJson('/api/model', {
-                  method: 'POST',
-                  headers: { 'Content-Type': 'application/json' },
-                  body: JSON.stringify({ model_id: modelId })
-                });
-                renderInfo(info);
-                setMessage(`Đã chuyển sang model: ${info.model_name}`, 'muted');
-              } catch (error) {
-                setMessage(error.message, 'error');
-              } finally {
-                setLoading(false);
-              }
-            }
-
-            async function generateQuestions() {
-              const text = elements.sourceText.value.trim();
-              if (!text) {
-                setMessage('Vui lòng nhập đoạn văn bản trước khi sinh câu hỏi.', 'error');
-                elements.sourceText.focus();
-                return;
-              }
-
-              setLoading(true);
-              setMessage('Đang sinh câu hỏi từ nội dung đã nhập...', 'muted');
-
-              try {
-                const payload = await fetchJson('/api/generate', {
-                  method: 'POST',
-                  headers: { 'Content-Type': 'application/json' },
-                  body: JSON.stringify({
-                    text,
-                    num_questions: state.count,
-                    model_id: elements.modelSelect.value || undefined
-                  })
-                });
-                renderResult(payload);
-                setMessage(`Đã sinh xong ${payload.questions.length} câu hỏi.`, 'muted');
-              } catch (error) {
-                setMessage(error.message, 'error');
-              } finally {
-                setLoading(false);
-              }
-            }
-
-            async function copyOutput() {
-              if (!state.lastFormatted) {
-                setMessage('Chưa có nội dung để sao chép.', 'error');
-                return;
-              }
-
-              try {
-                await navigator.clipboard.writeText(state.lastFormatted);
-                setMessage('Đã sao chép kết quả vào clipboard.', 'muted');
-              } catch (error) {
-                setMessage('Không thể sao chép tự động. Hãy sao chép thủ công.', 'error');
-              }
-            }
-
-            function bindEvents() {
-              elements.decreaseCount.addEventListener('click', () => setCount(state.count - 1));
-              elements.increaseCount.addEventListener('click', () => setCount(state.count + 1));
-              elements.questionCount.addEventListener('change', (event) => setCount(event.target.value));
-              elements.modelSelect.addEventListener('change', changeModel);
-              elements.generateButton.addEventListener('click', generateQuestions);
-              elements.copyButton.addEventListener('click', copyOutput);
-            }
-
-            async function init() {
-              renderSamples();
-              setCount(5);
-              bindEvents();
-              try {
-                await loadInfo();
-              } catch (error) {
-                setMessage(error.message || 'Không thể kết nối backend.', 'error');
-                elements.readyBadge.textContent = 'Lỗi';
-              }
-            }
-
-            document.addEventListener('DOMContentLoaded', init);
-            """
-        ).strip()
-        + "\n",
-        "frontend/style.css": textwrap.dedent(
-            """
-            :root {
-              --bg-start: #f8f5ff;
-              --bg-end: #eef4ff;
-              --panel: rgba(255, 255, 255, 0.82);
-              --border: rgba(103, 102, 181, 0.18);
-              --text: #23244d;
-              --muted: #6c6d9a;
-              --primary-start: #6b73ff;
-              --primary-end: #d96ba2;
-              --shadow: 0 22px 60px rgba(52, 56, 121, 0.14);
-            }
-
-            * {
-              box-sizing: border-box;
-            }
-
-            body {
-              margin: 0;
-              min-height: 100vh;
-              font-family: "Be Vietnam Pro", "Segoe UI", sans-serif;
-              color: var(--text);
-              background:
-                radial-gradient(circle at top left, rgba(123, 135, 255, 0.14), transparent 28%),
-                radial-gradient(circle at bottom right, rgba(217, 107, 162, 0.18), transparent 25%),
-                linear-gradient(135deg, var(--bg-start), var(--bg-end));
-            }
-
-            button,
-            input,
-            textarea,
-            select {
-              font: inherit;
-            }
-
-            .page-shell {
-              width: min(1200px, calc(100% - 32px));
-              margin: 24px auto;
-            }
-
-            .hero {
-              padding: 32px;
-              border: 1px solid var(--border);
-              border-radius: 28px;
-              background: var(--panel);
-              box-shadow: var(--shadow);
-              backdrop-filter: blur(18px);
-            }
-
-            .hero-badge {
-              display: inline-flex;
-              padding: 8px 14px;
-              border-radius: 999px;
-              background: rgba(107, 115, 255, 0.12);
-              color: #5058d9;
-              font-size: 13px;
-              font-weight: 700;
-              letter-spacing: 0.04em;
-              text-transform: uppercase;
-            }
-
-            .hero h1 {
-              margin: 18px 0 10px;
-              font-size: clamp(34px, 5vw, 56px);
-              line-height: 1.04;
-            }
-
-            .hero p {
-              margin: 0;
-              max-width: 760px;
-              color: var(--muted);
-              font-size: 18px;
-              line-height: 1.65;
-            }
-
-            .layout {
-              display: grid;
-              grid-template-columns: 320px minmax(0, 1fr);
-              gap: 20px;
-              margin-top: 20px;
-            }
-
-            .panel {
-              border: 1px solid var(--border);
-              border-radius: 24px;
-              background: var(--panel);
-              box-shadow: var(--shadow);
-              backdrop-filter: blur(18px);
-            }
-
-            .sidebar,
-            .main-panel {
-              display: grid;
-              gap: 20px;
-              align-content: start;
-            }
-
-            .panel-heading {
-              display: flex;
-              align-items: center;
-              justify-content: space-between;
-              gap: 12px;
-              margin-bottom: 16px;
-            }
-
-            .panel h2 {
-              margin: 0;
-              font-size: 18px;
-            }
-
-            .sidebar .panel,
-            .composer,
-            .result-panel {
-              padding: 22px;
-            }
-
-            .badge {
-              display: inline-flex;
-              align-items: center;
-              justify-content: center;
-              min-width: 92px;
-              padding: 8px 12px;
-              border-radius: 999px;
-              font-size: 13px;
-              font-weight: 700;
-            }
-
-            .badge-soft {
-              background: rgba(39, 179, 112, 0.14);
-              color: #218b59;
-            }
-
-            .badge-busy {
-              background: rgba(238, 160, 59, 0.16);
-              color: #b86a00;
-            }
-
-            .field-label {
-              display: inline-block;
-              margin-bottom: 10px;
-              color: var(--muted);
-              font-size: 13px;
-              font-weight: 700;
-              letter-spacing: 0.02em;
-            }
-
-            .select-field,
-            .text-input,
-            .count-input {
-              width: 100%;
-              border: 1px solid rgba(103, 102, 181, 0.14);
-              border-radius: 18px;
-              background: rgba(255, 255, 255, 0.92);
-              color: var(--text);
-            }
-
-            .select-field {
-              min-height: 52px;
-              padding: 0 16px;
-            }
-
-            .status-list {
-              display: grid;
-              gap: 14px;
-              margin: 18px 0 0;
-            }
-
-            .status-list div {
-              padding: 14px 16px;
-              border-radius: 18px;
-              background: rgba(104, 109, 208, 0.07);
-            }
-
-            .status-list dt {
-              margin: 0 0 6px;
-              color: var(--muted);
-              font-size: 12px;
-              font-weight: 700;
-              text-transform: uppercase;
-              letter-spacing: 0.04em;
-            }
-
-            .status-list dd {
-              margin: 0;
-              font-size: 15px;
-              font-weight: 600;
-              word-break: break-word;
-            }
-
-            .panel-hint {
-              margin: 0 0 14px;
-              color: var(--muted);
-              line-height: 1.6;
-            }
-
-            .sample-list {
-              display: grid;
-              gap: 12px;
-            }
-
-            .sample-card {
-              display: grid;
-              gap: 8px;
-              width: 100%;
-              padding: 16px;
-              border: 1px solid rgba(103, 102, 181, 0.14);
-              border-radius: 18px;
-              background: rgba(255, 255, 255, 0.92);
-              text-align: left;
-              color: var(--text);
-              cursor: pointer;
-              transition: transform 0.18s ease, border-color 0.18s ease, box-shadow 0.18s ease;
-            }
-
-            .sample-card:hover {
-              transform: translateY(-2px);
-              border-color: rgba(86, 98, 218, 0.32);
-              box-shadow: 0 16px 30px rgba(61, 70, 154, 0.12);
-            }
-
-            .sample-card span {
-              color: var(--muted);
-              line-height: 1.55;
-            }
-
-            .text-input {
-              min-height: 250px;
-              padding: 18px 20px;
-              resize: vertical;
-              line-height: 1.7;
-            }
-
-            .composer-footer {
-              display: flex;
-              align-items: end;
-              justify-content: space-between;
-              gap: 18px;
-              margin-top: 18px;
-            }
-
-            .count-field {
-              min-width: 230px;
-            }
-
-            .count-controls {
-              display: grid;
-              grid-template-columns: 48px 92px 48px;
-              gap: 10px;
-              align-items: center;
-            }
-
-            .count-button,
-            .secondary-button {
-              min-height: 48px;
-              border: 1px solid rgba(103, 102, 181, 0.16);
-              border-radius: 16px;
-              background: rgba(255, 255, 255, 0.92);
-              color: var(--text);
-              cursor: pointer;
-            }
-
-            .count-button {
-              font-size: 22px;
-              font-weight: 700;
-            }
-
-            .count-input {
-              min-height: 48px;
-              padding: 0 12px;
-              text-align: center;
-              font-weight: 700;
-            }
-
-            .primary-button {
-              min-width: 220px;
-              min-height: 56px;
-              padding: 0 24px;
-              border: none;
-              border-radius: 18px;
-              background: linear-gradient(135deg, var(--primary-start), var(--primary-end));
-              color: white;
-              font-size: 16px;
-              font-weight: 800;
-              cursor: pointer;
-              box-shadow: 0 18px 34px rgba(95, 105, 220, 0.24);
-            }
-
-            .primary-button:disabled,
-            .secondary-button:disabled {
-              cursor: not-allowed;
-              opacity: 0.7;
-            }
-
-            .form-message {
-              min-height: 22px;
-              margin: 14px 0 0;
-              color: var(--muted);
-            }
-
-            .form-message[data-tone="error"] {
-              color: #c33b5f;
-            }
-
-            .result-panel {
-              min-height: 320px;
-            }
-
-            .result-placeholder {
-              display: grid;
-              place-items: center;
-              min-height: 260px;
-              padding: 24px;
-              border: 1px dashed rgba(103, 102, 181, 0.24);
-              border-radius: 20px;
-              color: var(--muted);
-              text-align: center;
-              line-height: 1.7;
-            }
-
-            .result-content.hidden,
-            .result-placeholder.hidden {
-              display: none;
-            }
-
-            .result-header {
-              display: flex;
-              align-items: start;
-              justify-content: space-between;
-              gap: 16px;
-              margin-bottom: 18px;
-            }
-
-            .result-header h2 {
-              margin: 0 0 8px;
-            }
-
-            .result-stats {
-              margin: 0;
-              color: var(--muted);
-            }
-
-            .result-list {
-              margin: 0;
-              padding-left: 20px;
-              display: grid;
-              gap: 12px;
-              line-height: 1.65;
-            }
-
-            .formatted-output {
-              margin: 20px 0 0;
-              padding: 18px;
-              border-radius: 18px;
-              background: rgba(104, 109, 208, 0.07);
-              white-space: pre-wrap;
-              word-break: break-word;
-              line-height: 1.65;
-            }
-
-            @media (max-width: 980px) {
-              .layout {
-                grid-template-columns: 1fr;
-              }
-            }
-
-            @media (max-width: 640px) {
-              .page-shell {
-                width: min(100% - 16px, 1000px);
-                margin: 16px auto;
-              }
-
-              .hero,
-              .sidebar .panel,
-              .composer,
-              .result-panel {
-                padding: 18px;
-              }
-
-              .composer-footer,
-              .result-header {
-                flex-direction: column;
-                align-items: stretch;
-              }
-
-              .count-field,
-              .primary-button,
-              .secondary-button {
-                width: 100%;
-              }
-            }
-            """
-        ).strip()
-        + "\n",
-    }
-
-
-def sync_text_file(destination_file: Path, content: str, force_write: bool) -> bool:
-    destination_file.parent.mkdir(parents=True, exist_ok=True)
-    if destination_file.exists() and not force_write:
-        current = destination_file.read_text(encoding="utf-8")
-        if current == content:
-            return False
-    destination_file.write_text(content, encoding="utf-8")
-    return True
-
-
-def materialize_standalone_runtime(runtime_root: Path, force_refresh: bool) -> None:
-    runtime_files = build_runtime_file_map()
-    created = 0
-    reused = 0
-
-    for relative_path, content in runtime_files.items():
-        destination = runtime_root / relative_path
-        if sync_text_file(destination, content, force_write=force_refresh):
-            created += 1
-        else:
-            reused += 1
-
-    print_step(
-        f"Đã chuẩn bị runtime standalone tại {runtime_root}. "
-        f"File mới/cập nhật: {created}, file giữ nguyên: {reused}."
-    )
-
-
-def resolve_runtime_context(args: argparse.Namespace) -> RuntimeContext:
-    use_local_project = has_local_project(SCRIPT_ROOT) and not args.force_standalone_runtime
-    if use_local_project:
-        runtime_root = SCRIPT_ROOT
-        standalone_mode = False
-    else:
-        requested_runtime_dir = Path(args.runtime_dir).expanduser()
-        if not requested_runtime_dir.is_absolute():
-            requested_runtime_dir = SCRIPT_ROOT / requested_runtime_dir
-        runtime_root = requested_runtime_dir.resolve()
-        standalone_mode = True
-        materialize_standalone_runtime(runtime_root, force_refresh=args.force_runtime_refresh)
-
-    context = RuntimeContext(
-        root=runtime_root,
-        main_file=runtime_root / "main.py",
-        requirements_file=runtime_root / "requirements.txt",
-        local_model_dir=runtime_root / "t5-viet-qg-finetuned",
-        local_best_model_dir=runtime_root / "t5-viet-qg-finetuned" / "best-model",
-        standalone_mode=standalone_mode,
-    )
-    mode_label = "standalone" if standalone_mode else "full project"
-    print_step(f"Runtime mode: {mode_label}")
-    print_step(f"Runtime root: {context.root}")
-    return context
-
-
-def maybe_bootstrap_tool_venv(args: argparse.Namespace) -> int | None:
-    if args.no_venv or is_running_in_virtualenv():
-        return None
-
-    if not TOOL_VENV_PYTHON.exists():
-        print_step("Không phát hiện virtualenv hiện tại. Đang tạo môi trường riêng cho launcher...")
-        run_command([sys.executable, "-m", "venv", str(TOOL_VENV_DIR)], cwd=SCRIPT_ROOT)
-        run_command([str(TOOL_VENV_PYTHON), "-m", "pip", "install", "--upgrade", "pip"], cwd=SCRIPT_ROOT)
-
-    relaunch_env = os.environ.copy()
-    relaunch_env["HVU_QA_TOOL_BOOTSTRAPPED"] = "1"
-    relaunch_command = [str(TOOL_VENV_PYTHON), str(Path(__file__).resolve()), *sys.argv[1:]]
-
-    print_step("Đang chuyển sang môi trường Python riêng của launcher...")
-    return subprocess.call(relaunch_command, cwd=str(SCRIPT_ROOT), env=relaunch_env)
-
-
-def ensure_huggingface_hub(skip_install: bool, context: RuntimeContext) -> None:
-    if module_exists("huggingface_hub"):
-        return
-
-    if skip_install:
-        install_hint = (
-            f"{sys.executable} -m pip install {HF_HUB_REQUIREMENT}"
-            if not context.requirements_file.exists()
-            else f"{sys.executable} -m pip install -r {context.requirements_file}"
-        )
-        raise RuntimeError(
-            "Thiếu huggingface_hub. Hãy chạy "
-            f"`{install_hint}` hoặc bỏ `--skip-install`."
-        )
-
-    print_step("Thiếu huggingface_hub. Đang cài tự động...")
-    if context.requirements_file.exists():
-        run_command([sys.executable, "-m", "pip", "install", "-r", str(context.requirements_file)], cwd=context.root)
-    else:
-        run_command([sys.executable, "-m", "pip", "install", HF_HUB_REQUIREMENT], cwd=context.root)
-
-
-def find_missing_dependencies() -> list[str]:
-    missing: list[str] = []
-    for package_name, module_name in DEPENDENCY_IMPORTS.items():
-        if not module_exists(module_name):
-            missing.append(package_name)
-    return missing
-
-
-def ensure_runtime_dependencies(skip_install: bool, context: RuntimeContext) -> None:
-    missing = find_missing_dependencies()
-    if not missing:
-        print_step("Môi trường Python đã có đủ dependency cần thiết.")
-        return
-
-    if skip_install:
-        missing_text = ", ".join(missing)
-        install_hint = (
-            f"{sys.executable} -m pip install -r {context.requirements_file}"
-            if context.requirements_file.exists()
-            else f"{sys.executable} -m pip install {' '.join(RUNTIME_REQUIREMENTS)}"
-        )
-        raise RuntimeError(
-            f"Thiếu dependency: {missing_text}. "
-            f"Hãy chạy `{install_hint}` hoặc bỏ `--skip-install`."
-        )
-
-    if context.requirements_file.exists():
-        print_step(f"Đang cài dependency còn thiếu: {', '.join(missing)}")
-        run_command([sys.executable, "-m", "pip", "install", "-r", str(context.requirements_file)], cwd=context.root)
-        return
-
-    print_step(f"Đang cài dependency runtime còn thiếu: {', '.join(missing)}")
-    run_command([sys.executable, "-m", "pip", "install", *RUNTIME_REQUIREMENTS], cwd=context.root)
-
-
-def select_repo_files(repo_files: list[str], best_model_only: bool) -> list[str]:
-    allow_patterns = build_allow_patterns(best_model_only)
-    selected: list[str] = []
-
-    for repo_file in repo_files:
-        normalized = repo_file.replace("\\", "/")
-        if not matches_any_pattern(normalized, allow_patterns):
-            continue
-        if matches_any_pattern(normalized, MODEL_IGNORE_PATTERNS):
-            continue
-        selected.append(normalized)
-
-    return sorted(selected)
-
-
-def get_target_destination(context: RuntimeContext, repo_file: str) -> Path:
-    relative_path = Path(repo_file).relative_to(HF_MODEL_SUBDIR)
-    return context.local_model_dir / relative_path
-
-
-def resolve_repo_files(repo_id: str, revision: str, best_model_only: bool) -> list[dict[str, int | str | None]]:
-    from huggingface_hub import HfApi
-
-    api = HfApi()
-    repo_files = api.list_repo_tree(repo_id=repo_id, repo_type="dataset", revision=revision, recursive=True)
-
-    file_entries: list[str] = []
-    size_map: dict[str, int | None] = {}
-    for entry in repo_files:
-        entry_path = str(getattr(entry, "path", "")).replace("\\", "/")
-        if not entry_path or entry_path.endswith("/"):
-            continue
-        file_entries.append(entry_path)
-        size_map[entry_path] = getattr(entry, "size", None)
-
-    selected_paths = select_repo_files(file_entries, best_model_only=best_model_only)
-    if not selected_paths:
-        scope = "best-model" if best_model_only else "model"
-        raise FileNotFoundError(
-            f"Không tìm thấy file {scope} hợp lệ trong repo {repo_id}@{revision}. "
-            "Hãy kiểm tra lại cấu trúc repo trên Hugging Face."
-        )
-
-    return [{"path": path, "size": size_map.get(path)} for path in selected_paths]
-
-
-def sync_single_file(source_file: Path, destination_file: Path, force_copy: bool) -> tuple[bool, int]:
-    destination_file.parent.mkdir(parents=True, exist_ok=True)
-    size = source_file.stat().st_size
-
-    if (
-        destination_file.exists()
-        and not force_copy
-        and destination_file.stat().st_size == size
-    ):
-        return False, size
-
-    shutil.copy2(source_file, destination_file)
-    return True, size
-
-
-def download_and_sync_model(
-    context: RuntimeContext,
-    repo_id: str,
-    revision: str,
-    force_download: bool,
-    best_model_only: bool,
-) -> tuple[int, int, int, int]:
-    from huggingface_hub import hf_hub_download
-
-    repo_files = resolve_repo_files(repo_id=repo_id, revision=revision, best_model_only=best_model_only)
-    total_files = len(repo_files)
-    total_bytes = sum(int(item["size"] or 0) for item in repo_files)
-
-    copied_files = 0
-    skipped_files = 0
-    copied_bytes = 0
-    skipped_bytes = 0
-    processed_bytes = 0
-    download_scope = "best-model" if best_model_only else "toàn bộ model"
-
-    print_step(f"Tìm thấy {total_files} file cần đồng bộ cho {download_scope}.")
-
-    for index, repo_item in enumerate(repo_files, start=1):
-        repo_file = str(repo_item["path"])
-        destination_path = get_target_destination(context, repo_file)
-        relative_label = destination_path.relative_to(context.root).as_posix()
-        print_step(f"[{index}/{total_files}] Đang tải {relative_label}")
-
-        cached_file = hf_hub_download(
-            repo_id=repo_id,
-            repo_type="dataset",
-            revision=revision,
-            filename=repo_file,
-            force_download=force_download,
-            local_files_only=False,
-        )
-
-        copied, size = sync_single_file(Path(cached_file), destination_path, force_copy=force_download)
-        if copied:
-            copied_files += 1
-            copied_bytes += size
-            print_step(f"    Đã đồng bộ {relative_label} ({format_bytes(size)})")
-        else:
-            skipped_files += 1
-            skipped_bytes += size
-            print_step(f"    Giữ nguyên {relative_label} ({format_bytes(size)})")
-
-        processed_bytes += size
-        if processed_bytes > total_bytes:
-            total_bytes = processed_bytes
-
-        print_step(
-            "    Tổng tiến độ "
-            f"{render_progress_bar(processed_bytes, total_bytes)} "
-            f"({format_bytes(processed_bytes)}/{format_bytes(total_bytes)})"
-        )
-
-    return copied_files, skipped_files, copied_bytes, skipped_bytes
-
-
-def required_model_files(context: RuntimeContext, best_model_only: bool) -> list[Path]:
-    if best_model_only:
-        model_dir = context.local_best_model_dir
-    else:
-        model_dir = context.local_model_dir
-
-    return [
-        model_dir / "config.json",
-        model_dir / "generation_config.json",
-        model_dir / "model.safetensors",
-        model_dir / "tokenizer_config.json",
-        model_dir / "special_tokens_map.json",
-        model_dir / "spiece.model",
-    ]
-
-
-def validate_local_model_dir(context: RuntimeContext, best_model_only: bool) -> None:
-    missing_files = [
-        str(path.relative_to(context.root))
-        for path in required_model_files(context, best_model_only)
-        if not path.exists()
-    ]
-    if missing_files:
-        raise FileNotFoundError(
-            "Model chưa đầy đủ sau khi tải về. Thiếu các file: " + ", ".join(missing_files)
-        )
-
-
-def prepare_model(
-    context: RuntimeContext,
-    repo_id: str,
-    revision: str,
-    force_download: bool,
-    skip_download: bool,
-    best_model_only: bool,
-) -> None:
-    if skip_download:
-        print_step("Bỏ qua bước tải model theo yêu cầu `--skip-download`.")
-        validate_local_model_dir(context, best_model_only=best_model_only)
-        return
-
-    copied_files, skipped_files, copied_bytes, skipped_bytes = download_and_sync_model(
-        context=context,
-        repo_id=repo_id,
-        revision=revision,
-        force_download=force_download,
-        best_model_only=best_model_only,
-    )
-    validate_local_model_dir(context, best_model_only=best_model_only)
-
-    scope = "best-model" if best_model_only else "toàn bộ model"
-    print_step(
-        f"Đồng bộ {scope} xong. "
-        f"File mới/cập nhật: {copied_files} ({format_bytes(copied_bytes)}), "
-        f"file giữ nguyên: {skipped_files} ({format_bytes(skipped_bytes)})."
-    )
-
-
-def build_runtime_env(context: RuntimeContext, args: argparse.Namespace) -> dict[str, str]:
-    env = os.environ.copy()
-
-    if args.host:
-        env["HVU_HOST"] = args.host
-    if args.port is not None:
-        env["HVU_PORT"] = str(args.port)
-    if args.device:
-        env["HVU_DEVICE"] = args.device
-    if args.debug:
-        env["HVU_DEBUG"] = "1"
-    if args.no_browser:
-        env["HVU_OPEN_BROWSER"] = "0"
-
-    env["HVU_MODEL_DIR"] = str(context.local_model_dir)
-    return env
-
-
-def launch_app(context: RuntimeContext, args: argparse.Namespace) -> int:
-    if not context.main_file.exists():
-        raise FileNotFoundError(f"Không tìm thấy file chạy ứng dụng: {context.main_file}")
-
-    env = build_runtime_env(context, args)
-    command = [sys.executable, str(context.main_file)]
-
-    print_step("Đang chạy ứng dụng web...")
-    print_step(
-        "Mở trình duyệt tại "
-        f"http://{env.get('HVU_HOST', '127.0.0.1')}:{env.get('HVU_PORT', '5000')}"
-    )
-    return subprocess.call(command, cwd=str(context.root), env=env)
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description=(
-            "Launcher cho HVU_QA: có thể chạy full project nếu đang đứng trong repo, "
-            "hoặc tự dựng runtime standalone khi chỉ có file HVU_QA_tool.py."
-        ),
-    )
-    parser.add_argument("--repo-id", default=HF_DATASET_REPO_ID, help="Repo dataset trên Hugging Face.")
-    parser.add_argument("--revision", default=HF_DATASET_REVISION, help="Revision trên Hugging Face.")
-    parser.add_argument("--host", default=None, help="Host chạy Flask. Mặc định dùng HVU_HOST hoặc 127.0.0.1.")
-    parser.add_argument("--port", type=int, default=None, help="Port chạy Flask. Mặc định dùng HVU_PORT hoặc 5000.")
-    parser.add_argument(
-        "--device",
-        choices=["auto", "cpu", "cuda"],
-        default=None,
-        help="Thiết bị chạy model. Mặc định dùng HVU_DEVICE hoặc auto.",
-    )
-    parser.add_argument("--debug", action="store_true", help="Bật Flask debug.")
-    parser.add_argument("--no-browser", action="store_true", help="Không tự mở trình duyệt.")
-    parser.add_argument("--no-venv", action="store_true", help="Không tự tạo virtualenv riêng cho launcher.")
-    parser.add_argument("--force-download", action="store_true", help="Tải lại model và ghi đè file local.")
-    parser.add_argument(
-        "--best-model-only",
-        action="store_true",
-        help="Chỉ tải thư mục best-model. Lệnh này chỉ dùng được khi repo thật sự có best-model.",
-    )
-    parser.add_argument("--skip-download", action="store_true", help="Bỏ qua bước tải model từ Hugging Face.")
-    parser.add_argument("--skip-install", action="store_true", help="Không tự cài dependency còn thiếu.")
-    parser.add_argument("--skip-run", action="store_true", help="Chỉ chuẩn bị môi trường và model, không chạy app.")
-    parser.add_argument(
-        "--runtime-dir",
-        default="HVU_QA_runtime",
-        help="Thư mục runtime standalone sẽ được tạo nếu không có full project hoặc khi ép standalone.",
-    )
-    parser.add_argument(
-        "--force-standalone-runtime",
-        action="store_true",
-        help="Luôn dựng runtime standalone, kể cả khi đang đứng trong full project.",
-    )
-    parser.add_argument(
-        "--force-runtime-refresh",
-        action="store_true",
-        help="Ghi đè lại các file runtime standalone được nhúng sẵn trong launcher.",
-    )
-    parser.add_argument(
-        "--prepare-runtime-only",
-        action="store_true",
-        help="Chỉ dựng runtime standalone hoặc kiểm tra full project hiện tại, không cài dependency, không tải model.",
-    )
-    return parser
-
-
-def main() -> int:
-    if hasattr(sys.stdout, "reconfigure"):
-        sys.stdout.reconfigure(encoding="utf-8")
-    if hasattr(sys.stderr, "reconfigure"):
-        sys.stderr.reconfigure(encoding="utf-8")
-
-    parser = build_parser()
-    args = parser.parse_args()
-
-    bootstrap_exit_code = maybe_bootstrap_tool_venv(args)
-    if bootstrap_exit_code is not None:
-        return bootstrap_exit_code
-
-    print_step("Bắt đầu chuẩn bị dự án HVU_QA...")
-    context = resolve_runtime_context(args)
-
-    if args.prepare_runtime_only:
-        print_step("Đã chuẩn bị xong runtime. Bỏ qua các bước tiếp theo theo `--prepare-runtime-only`.")
-        return 0
-
-    ensure_huggingface_hub(skip_install=args.skip_install, context=context)
-    prepare_model(
-        context=context,
-        repo_id=args.repo_id,
-        revision=args.revision,
-        force_download=args.force_download,
-        skip_download=args.skip_download,
-        best_model_only=args.best_model_only,
-    )
-    ensure_runtime_dependencies(skip_install=args.skip_install, context=context)
-
-    if args.skip_run:
-        print_step("Đã chuẩn bị xong model và dependency. Bỏ qua chạy app theo `--skip-run`.")
-        return 0
-
-    return launch_app(context, args)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())