Update

HVU_QA/HVU_QA_tool.py

@@ -1,1566 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import csv
-import fnmatch
-import importlib.metadata
-import importlib.util
-import json
-import logging
-import os
-import socket
-import shutil
-import subprocess
-import sys
-import time
-import traceback
-import urllib.error
-import urllib.request
-import webbrowser
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional
-
-SCRIPT_ROOT = Path(__file__).resolve().parent
-IS_WINDOWS = os.name == "nt"
-MIN_PYTHON = (3, 10)
-TOOL_VENV_DIR = SCRIPT_ROOT / ".hvu_qa_env"
-TOOL_VENV_PYTHON = TOOL_VENV_DIR / ("Scripts/python.exe" if IS_WINDOWS else "bin/python")
-CONFIG_FILE = SCRIPT_ROOT / ".hvu_qa_config.json"
-LOG_DIR = SCRIPT_ROOT / "logs"
-LOG_FILE = LOG_DIR / "HVU_QA_tool.log"
-
-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"
-TORCH_REQUIREMENT = "torch>=2.2.0,<3.0.0"
-RUNTIME_REQUIREMENTS = [
-    "accelerate>=1.1.0,<2.0.0",
-    "Flask>=3.0.0,<4.0.0",
-    "flask-cors>=4.0.0,<7.0.0",
-    HF_HUB_REQUIREMENT,
-    "numpy>=1.26.0,<2.0.0",
-    "requests>=2.31.0,<3.0.0",
-    "safetensors>=0.4.3,<1.0.0",
-    "sentencepiece>=0.2.0,<1.0.0",
-    TORCH_REQUIREMENT,
-    "tqdm>=4.66.0,<5.0.0",
-    "transformers>=4.41.0,<4.42.0",
-]
-DEPENDENCY_IMPORTS = {
-    "accelerate": "accelerate",
-    "Flask": "flask",
-    "flask-cors": "flask_cors",
-    "huggingface_hub": "huggingface_hub",
-    "numpy": "numpy",
-    "requests": "requests",
-    "safetensors": "safetensors",
-    "sentencepiece": "sentencepiece",
-    "tqdm": "tqdm",
-    "transformers": "transformers",
-}
-LOCAL_PROJECT_MARKERS = [
-    "main.py",
-    "backend/app.py",
-    "frontend/index.html",
-    "generate_question.py",
-]
-RUNTIME_REQUIRED_FILES = [
-    "requirements.txt",
-    "main.py",
-    "backend/app.py",
-    "generate_question.py",
-    "frontend/index.html",
-]
-RUNTIME_ALLOW_PATTERNS = [
-    f"{HF_PROJECT_SUBDIR}/requirements.txt",
-    f"{HF_PROJECT_SUBDIR}/main.py",
-    f"{HF_PROJECT_SUBDIR}/generate_question.py",
-    f"{HF_PROJECT_SUBDIR}/backend/**",
-    f"{HF_PROJECT_SUBDIR}/frontend/**",
-]
-RUNTIME_IGNORE_PATTERNS = [
-    f"{HF_PROJECT_SUBDIR}/**/__pycache__/**",
-    f"{HF_PROJECT_SUBDIR}/**/*.pyc",
-]
-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",
-]
-PYTORCH_CPU_INDEX_URL = "https://download.pytorch.org/whl/cpu"
-
-
-@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
-
-
-@dataclass(frozen=True)
-class GpuInfo:
-    name: str
-    driver_version: Optional[str] = None
-    compute_capability: Optional[str] = None
-    vendor: str = "NVIDIA"
-
-
-@dataclass(frozen=True)
-class PytorchCudaWheel:
-    tag: str
-    index_url: str
-    min_driver_major: int
-    min_driver_minor: int = 0
-    torch_requirement: str = TORCH_REQUIREMENT
-    companion_requirements: tuple[str, ...] = ()
-
-
-# Ordered from newest to oldest. The launcher chooses the newest CUDA wheel
-# that the detected NVIDIA driver can run.
-PYTORCH_CUDA_WHEELS = [
-    PytorchCudaWheel("cu128", "https://download.pytorch.org/whl/cu128", 572, 0),
-    PytorchCudaWheel("cu126", "https://download.pytorch.org/whl/cu126", 560, 0),
-    PytorchCudaWheel("cu118", "https://download.pytorch.org/whl/cu118", 522, 0),
-    PytorchCudaWheel(
-        "cu117",
-        "https://download.pytorch.org/whl/cu117",
-        516,
-        1,
-        "torch==2.0.1+cu117",
-        ("numpy>=1.26.0,<2.0.0", "transformers>=4.41.0,<4.42.0"),
-    ),
-]
-
-
-def setup_logging() -> None:
-    LOG_DIR.mkdir(parents=True, exist_ok=True)
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s [%(levelname)s] %(message)s",
-        handlers=[
-            logging.FileHandler(LOG_FILE, encoding="utf-8"),
-        ],
-    )
-
-
-def print_step(message: str) -> None:
-    text = f"[HVU_QA_tool] {message}"
-    logging.info(message)
-    try:
-        print(text)
-    except UnicodeEncodeError:
-        encoding = getattr(sys.stdout, "encoding", None) or "utf-8"
-        safe_text = text.encode(encoding, errors="backslashreplace").decode(encoding, errors="ignore")
-        print(safe_text)
-
-
-def load_config() -> dict[str, object]:
-    if not CONFIG_FILE.exists():
-        return {}
-    try:
-        payload = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return {}
-    return payload if isinstance(payload, dict) else {}
-
-
-def save_config(config: dict[str, object]) -> None:
-    CONFIG_FILE.write_text(json.dumps(config, ensure_ascii=False, indent=2), encoding="utf-8")
-
-
-def update_config(**values: object) -> None:
-    config = load_config()
-    config.update(values)
-    save_config(config)
-
-
-def python_version_label() -> str:
-    return ".".join(str(part) for part in sys.version_info[:3])
-
-
-def check_python_version() -> None:
-    if sys.version_info >= MIN_PYTHON:
-        return
-    required = ".".join(str(part) for part in MIN_PYTHON)
-    raise RuntimeError(
-        f"Python hiện tại là {python_version_label()}, chưa phù hợp. "
-        f"Vui lòng cài Python {required} trở lên rồi chạy lại `python HVU_QA_tool.py`."
-    )
-
-
-def check_python_module(module_name: str, friendly_name: str) -> None:
-    completed = subprocess.run(
-        [sys.executable, "-m", module_name, "--help"],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-        check=False,
-    )
-    if completed.returncode != 0:
-        raise RuntimeError(
-            f"Python hiện tại chưa dùng được module `{module_name}` ({friendly_name}). "
-            "Hãy cài lại Python và bật tùy chọn pip/venv khi cài đặt."
-        )
-
-
-def check_write_access(path: Path) -> None:
-    path.mkdir(parents=True, exist_ok=True)
-    probe = path / ".hvu_write_test"
-    try:
-        probe.write_text("ok", encoding="utf-8")
-        probe.unlink(missing_ok=True)
-    except OSError as exc:
-        raise RuntimeError(f"Không có quyền ghi vào thư mục {path}: {exc}") from exc
-
-
-def has_complete_runtime(context: RuntimeContext) -> bool:
-    return all((context.root / relative).exists() for relative in RUNTIME_REQUIRED_FILES)
-
-
-def has_complete_model(context: RuntimeContext, best_model_only: bool) -> bool:
-    return all(path.exists() for path in required_model_files(context, best_model_only))
-
-
-def internet_available(url: str = "https://huggingface.co", timeout: int = 8) -> bool:
-    try:
-        with urllib.request.urlopen(url, timeout=timeout):
-            return True
-    except (OSError, urllib.error.URLError):
-        return False
-
-
-def check_internet_if_needed(context: RuntimeContext, args: argparse.Namespace) -> None:
-    needs_runtime = args.force_download or args.force_runtime_refresh or not has_complete_runtime(context)
-    needs_model = args.force_download or not has_complete_model(context, args.best_model_only)
-    if not needs_runtime and not needs_model:
-        print_step("Runtime và model đã có sẵn, không cần tải thêm từ Internet.")
-        return
-    print_step("Đang kiểm tra kết nối Internet...")
-    if internet_available():
-        return
-    raise RuntimeError(
-        "Không kết nối được tới Hugging Face. Hãy kiểm tra Internet/proxy rồi chạy lại."
-    )
-
-
-def check_disk_space(path: Path, min_free_gb: float) -> None:
-    free_bytes = shutil.disk_usage(path).free
-    required_bytes = int(min_free_gb * 1024**3)
-    if free_bytes < required_bytes:
-        raise RuntimeError(
-            f"Dung lượng trống tại {path} chỉ còn {format_bytes(free_bytes)}. "
-            f"Cần tối thiểu khoảng {min_free_gb:g} GB để tải và chạy hệ thống."
-        )
-    print_step(f"Dung lượng trống khả dụng: {format_bytes(free_bytes)}.")
-
-
-def run_base_preflight(args: argparse.Namespace) -> None:
-    print_step("Đang kiểm tra môi trường...")
-    check_python_version()
-    print_step(f"Python hiện tại: {python_version_label()}.")
-    check_python_module("pip", "pip")
-    if not args.no_venv:
-        check_python_module("venv", "môi trường ảo")
-    print_step(f"Hệ điều hành: {sys.platform}.")
-    check_write_access(SCRIPT_ROOT)
-
-
-def module_exists(module_name: str) -> bool:
-    return importlib.util.find_spec(module_name) is not None
-
-
-def subprocess_env(env: Optional[dict[str, str]] = None) -> dict[str, str]:
-    merged = os.environ.copy()
-    merged.setdefault("PYTHONIOENCODING", "utf-8")
-    merged.setdefault("PYTHONUTF8", "1")
-    merged.setdefault("PIP_NO_COLOR", "1")
-    merged.setdefault("PIP_DISABLE_PIP_VERSION_CHECK", "1")
-    if env:
-        merged.update(env)
-    return merged
-
-
-def run_command(
-    command: list[str],
-    *,
-    cwd: Optional[Path] = None,
-    env: Optional[dict[str, str]] = None,
-) -> None:
-    subprocess.check_call(command, cwd=str(cwd) if cwd else None, env=subprocess_env(env))
-
-
-def try_run_command(
-    command: list[str],
-    *,
-    cwd: Optional[Path] = None,
-    env: Optional[dict[str, str]] = None,
-) -> bool:
-    try:
-        run_command(command, cwd=cwd, env=env)
-    except subprocess.CalledProcessError:
-        return False
-    return True
-
-
-def is_running_in_virtualenv() -> bool:
-    return sys.prefix != getattr(sys, "base_prefix", sys.prefix) or bool(os.getenv("VIRTUAL_ENV"))
-
-
-def is_running_in_tool_venv() -> bool:
-    try:
-        return Path(sys.executable).resolve() == TOOL_VENV_PYTHON.resolve()
-    except OSError:
-        return False
-
-
-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)
-    return f"[{'#' * filled}{'-' * (width - filled)}] {ratio * 100: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 has_local_project(root: Path) -> bool:
-    return all((root / marker).exists() for marker in LOCAL_PROJECT_MARKERS)
-
-
-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
-
-    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) -> Optional[int]:
-    if args.no_venv or is_running_in_tool_venv():
-        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_env = subprocess_env(relaunch_env)
-    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() -> None:
-    if module_exists("huggingface_hub"):
-        return
-
-    if not internet_available():
-        raise RuntimeError(
-            "Thiếu huggingface_hub và không có Internet để cài tự động. "
-            f"Vui lòng kết nối mạng rồi chạy lại: {sys.executable} HVU_QA_tool.py"
-        )
-    print_step("Thiếu huggingface_hub. Đang cài tự động...")
-    run_command([sys.executable, "-m", "pip", "install", HF_HUB_REQUIREMENT], cwd=SCRIPT_ROOT)
-
-
-def dependency_install_needs_internet(selected_device: str, context: RuntimeContext) -> bool:
-    if pending_non_torch_requirement_specs(context):
-        return True
-    torch_info = inspect_installed_torch()
-    if not torch_info.get("installed"):
-        return True
-    return selected_device == "cuda" and not torch_info.get("cuda_available")
-
-
-def check_dependency_internet_if_needed(selected_device: str, context: RuntimeContext) -> None:
-    if not dependency_install_needs_internet(selected_device, context):
-        return
-    print_step("Đang kiểm tra Internet trước khi cài thư viện...")
-    if internet_available():
-        return
-    raise RuntimeError(
-        "Cần Internet để cài hoặc cập nhật thư viện Python. "
-        "Hãy kết nối mạng rồi chạy lại."
-    )
-
-
-def requirement_name(spec: str) -> str:
-    cleaned = spec.split("#", 1)[0].strip()
-    chars: list[str] = []
-    for char in cleaned:
-        if char.isalnum() or char in {"_", "-"}:
-            chars.append(char)
-            continue
-        break
-    return "".join(chars).lower().replace("_", "-")
-
-
-def read_requirement_specs(context: RuntimeContext) -> list[str]:
-    specs: list[str] = []
-    for line in RUNTIME_REQUIREMENTS:
-        stripped = line.strip()
-        if stripped and not stripped.startswith("#"):
-            specs.append(stripped)
-    return specs
-
-
-def non_torch_requirement_specs(context: RuntimeContext) -> list[str]:
-    return [
-        spec
-        for spec in read_requirement_specs(context)
-        if requirement_name(spec) not in {"torch", "torchvision", "torchaudio"}
-    ]
-
-
-def pending_non_torch_requirement_specs(context: RuntimeContext) -> list[str]:
-    pending: list[str] = []
-    for spec in non_torch_requirement_specs(context):
-        package_name = requirement_name(spec)
-        module_name = DEPENDENCY_IMPORTS.get(package_name)
-        if module_name and not module_exists(module_name):
-            pending.append(spec)
-            continue
-        if not requirement_satisfied(spec):
-            pending.append(spec)
-    return pending
-
-
-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 install_non_torch_dependencies(context: RuntimeContext) -> None:
-    specs = pending_non_torch_requirement_specs(context)
-    if not specs:
-        print_step("Môi trường Python đã có đủ dependency runtime ngoài PyTorch.")
-        return
-
-    print_step("Đang cài/cập nhật dependency runtime: " + ", ".join(specs))
-    run_command([sys.executable, "-m", "pip", "install", "--upgrade", *specs], cwd=context.root)
-
-
-def inspect_installed_torch() -> dict[str, object]:
-    probe_code = r"""
-import json
-
-try:
-    import torch
-except Exception as exc:
-    print(json.dumps({"installed": False, "error": str(exc)}))
-    raise SystemExit(0)
-
-cuda_available = False
-gpu_names = []
-try:
-    cuda_available = bool(torch.cuda.is_available())
-    if cuda_available:
-        gpu_names = [torch.cuda.get_device_name(index) for index in range(torch.cuda.device_count())]
-except Exception:
-    cuda_available = False
-
-print(json.dumps({
-    "installed": True,
-    "version": getattr(torch, "__version__", ""),
-    "cuda_version": getattr(getattr(torch, "version", None), "cuda", None),
-    "cuda_available": cuda_available,
-    "gpu_names": gpu_names,
-}))
-"""
-    completed = subprocess.run(
-        [sys.executable, "-c", probe_code],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-        check=False,
-    )
-    if completed.returncode != 0 or not completed.stdout.strip():
-        return {"installed": False, "error": completed.stderr.strip()}
-
-    try:
-        payload = json.loads(completed.stdout.strip().splitlines()[-1])
-    except json.JSONDecodeError as exc:
-        return {"installed": False, "error": str(exc)}
-
-    return payload if isinstance(payload, dict) else {"installed": False, "error": "Invalid torch probe output"}
-
-
-def parse_driver_version(value: Optional[str]) -> Optional[tuple[int, int]]:
-    if not value:
-        return None
-    parts = value.strip().split(".")
-    if not parts or not parts[0].isdigit():
-        return None
-    major = int(parts[0])
-    minor = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else 0
-    return major, minor
-
-
-def detect_nvidia_gpus() -> list[GpuInfo]:
-    command = [
-        "nvidia-smi",
-        "--query-gpu=name,driver_version,compute_cap",
-        "--format=csv,noheader,nounits",
-    ]
-    try:
-        completed = subprocess.run(
-            command,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            timeout=8,
-            check=False,
-        )
-    except (FileNotFoundError, subprocess.SubprocessError):
-        return detect_windows_nvidia_gpus()
-
-    if completed.returncode != 0 or not completed.stdout.strip():
-        return detect_windows_nvidia_gpus()
-
-    gpus: list[GpuInfo] = []
-    for row in csv.reader(completed.stdout.splitlines()):
-        if not row:
-            continue
-        name = row[0].strip()
-        driver_version = row[1].strip() if len(row) > 1 and row[1].strip() else None
-        compute_capability = row[2].strip() if len(row) > 2 and row[2].strip() else None
-        gpus.append(GpuInfo(name=name, driver_version=driver_version, compute_capability=compute_capability))
-    return gpus
-
-
-def detect_windows_nvidia_gpus() -> list[GpuInfo]:
-    if not IS_WINDOWS:
-        return []
-
-    command = [
-        "powershell",
-        "-NoProfile",
-        "-Command",
-        (
-            "Get-CimInstance Win32_VideoController | "
-            "Where-Object { $_.Name -match 'NVIDIA' } | "
-            "Select-Object Name,DriverVersion | ConvertTo-Json -Compress"
-        ),
-    ]
-    try:
-        completed = subprocess.run(
-            command,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            timeout=8,
-            check=False,
-        )
-    except (FileNotFoundError, subprocess.SubprocessError):
-        return []
-
-    if completed.returncode != 0:
-        return []
-
-    raw = completed.stdout.strip()
-    if not raw:
-        return []
-
-    try:
-        payload = json.loads(raw)
-    except json.JSONDecodeError:
-        names = [line.strip() for line in completed.stdout.splitlines() if line.strip()]
-        return [GpuInfo(name=name) for name in names if "nvidia" in name.lower()]
-
-    items = payload if isinstance(payload, list) else [payload]
-    gpus: list[GpuInfo] = []
-    for item in items:
-        if not isinstance(item, dict):
-            continue
-        name = str(item.get("Name") or "").strip()
-        if not name or "nvidia" not in name.lower():
-            continue
-        gpus.append(GpuInfo(name=name, driver_version=normalize_windows_driver_version(item.get("DriverVersion"))))
-    return gpus
-
-
-def normalize_windows_driver_version(value: object) -> Optional[str]:
-    text = str(value or "").strip()
-    if not text:
-        return None
-    parts = text.split(".")
-    if len(parts) >= 4 and parts[-1].isdigit():
-        tail = parts[-1]
-        if len(tail) >= 5:
-            return f"{int(tail[:-2])}.{tail[-2:]}"
-    return text
-
-
-def format_gpu_list(gpus: list[GpuInfo]) -> str:
-    labels: list[str] = []
-    for index, gpu in enumerate(gpus):
-        details: list[str] = []
-        if gpu.driver_version:
-            details.append(f"driver {gpu.driver_version}")
-        if gpu.compute_capability:
-            details.append(f"compute {gpu.compute_capability}")
-        suffix = f" ({', '.join(details)})" if details else ""
-        labels.append(f"GPU {index}: {gpu.name}{suffix}")
-    return "; ".join(labels)
-
-
-def prompt_yes_no(question: str, default: bool) -> bool:
-    if not sys.stdin.isatty():
-        return default
-
-    while True:
-        try:
-            answer = input(question).strip().lower()
-        except EOFError:
-            return default
-        if answer in {"y", "yes"}:
-            return True
-        if answer in {"n", "no"}:
-            return False
-        print("Vui lòng nhập y hoặc n.")
-
-
-def select_runtime_device(args: argparse.Namespace) -> tuple[str, list[GpuInfo]]:
-    saved_device = str(load_config().get("device") or "").strip().lower()
-    requested = (args.device or os.getenv("HVU_DEVICE") or saved_device or "auto").strip().lower()
-    if requested == "cpu":
-        print_step("Đã chọn CPU theo cấu hình.")
-        return "cpu", []
-
-    gpus = detect_nvidia_gpus()
-    if requested == "cuda":
-        if gpus:
-            print_step(f"Đang sử dụng GPU: {format_gpu_list(gpus)}")
-        else:
-            print_step("Đã chọn CUDA nhưng chưa phát hiện GPU NVIDIA bằng nvidia-smi/WMI.")
-        return "cuda", gpus
-
-    if not gpus:
-        print_step("Không phát hiện GPU NVIDIA CUDA. Chương trình sẽ dùng CPU.")
-        update_config(device="cpu")
-        return "cpu", []
-
-    print_step(f"Đang sử dụng GPU: {format_gpu_list(gpus)}")
-    use_gpu = prompt_yes_no("Bạn có muốn dùng GPU không? (y/n): ", default=True)
-    if use_gpu:
-        update_config(device="cuda")
-        return "cuda", gpus
-
-    print_step("Bạn đã chọn không dùng GPU. Chương trình sẽ chuyển qua CPU.")
-    update_config(device="cpu")
-    return "cpu", gpus
-
-
-def cuda_wheel_candidates(gpus: list[GpuInfo]) -> list[PytorchCudaWheel]:
-    override_url = os.getenv("HVU_PYTORCH_CUDA_INDEX_URL")
-    if override_url:
-        override_tag = os.getenv("HVU_PYTORCH_CUDA_TAG", "custom")
-        override_requirement = os.getenv("HVU_PYTORCH_TORCH_REQUIREMENT", TORCH_REQUIREMENT)
-        return [PytorchCudaWheel(override_tag, override_url, 0, 0, override_requirement)]
-
-    driver = parse_driver_version(next((gpu.driver_version for gpu in gpus if gpu.driver_version), None))
-    if driver is None:
-        return PYTORCH_CUDA_WHEELS[:]
-
-    return [
-        wheel
-        for wheel in PYTORCH_CUDA_WHEELS
-        if driver >= (wheel.min_driver_major, wheel.min_driver_minor)
-    ]
-
-
-def describe_cuda_selection(gpus: list[GpuInfo], candidates: list[PytorchCudaWheel]) -> None:
-    driver_text = next((gpu.driver_version for gpu in gpus if gpu.driver_version), None)
-    if driver_text:
-        if candidates:
-            print_step(
-                f"Driver NVIDIA {driver_text}; chọn CUDA wheel tương thích cao nhất: "
-                f"{candidates[0].tag}."
-            )
-        else:
-            print_step(f"Driver NVIDIA {driver_text}; chưa có CUDA wheel PyTorch tương thích trực tiếp.")
-        return
-
-    if candidates:
-        print_step(
-            "Không đọc được phiên bản driver NVIDIA. Tool sẽ thử các CUDA wheel từ mới đến cũ."
-        )
-
-
-def winget_available() -> bool:
-    try:
-        completed = subprocess.run(
-            ["winget", "--version"],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            timeout=20,
-            check=False,
-        )
-    except (FileNotFoundError, subprocess.SubprocessError):
-        return False
-    return completed.returncode == 0
-
-
-def try_install_nvidia_cuda_support() -> bool:
-    if not IS_WINDOWS or not winget_available():
-        return False
-
-    print_step(
-        "Không có CUDA wheel phù hợp với driver hiện tại. "
-        "Đang thử cài NVIDIA CUDA Toolkit chính thức qua winget để bổ sung/cập nhật hỗ trợ CUDA..."
-    )
-    base_command = [
-        "winget",
-        "install",
-        "--id",
-        "Nvidia.CUDA",
-        "--source",
-        "winget",
-        "--accept-package-agreements",
-        "--accept-source-agreements",
-        "--silent",
-        "--disable-interactivity",
-    ]
-    if try_run_command(base_command, cwd=SCRIPT_ROOT):
-        return True
-
-    print_step("Cài NVIDIA CUDA Toolkit qua winget chưa thành công. Thử lệnh upgrade nếu gói đã tồn tại.")
-    upgrade_command = [
-        "winget",
-        "upgrade",
-        "--id",
-        "Nvidia.CUDA",
-        "--source",
-        "winget",
-        "--accept-package-agreements",
-        "--accept-source-agreements",
-        "--silent",
-        "--disable-interactivity",
-    ]
-    return try_run_command(upgrade_command, cwd=SCRIPT_ROOT)
-
-
-def companion_requirements_for_torch(torch_info: dict[str, object]) -> tuple[str, ...]:
-    version = str(torch_info.get("version") or "")
-    if version.startswith("2.0."):
-        return ("numpy>=1.26.0,<2.0.0", "transformers>=4.41.0,<4.42.0")
-    return ()
-
-
-def requirement_satisfied(spec: str) -> bool:
-    try:
-        from packaging.requirements import Requirement
-    except Exception:
-        return False
-
-    try:
-        requirement = Requirement(spec)
-        installed_version = importlib.metadata.version(requirement.name)
-    except Exception:
-        return False
-
-    if not requirement.specifier:
-        return True
-    return installed_version in requirement.specifier
-
-
-def ensure_companion_requirements(requirements: tuple[str, ...], context: RuntimeContext) -> None:
-    specs = tuple(dict.fromkeys(spec for spec in requirements if spec))
-    if not specs:
-        return
-
-    pending_specs = tuple(spec for spec in specs if not requirement_satisfied(spec))
-    if not pending_specs:
-        return
-
-    print_step("Dang cai dependency tuong thich voi PyTorch CUDA: " + ", ".join(pending_specs))
-    run_command([sys.executable, "-m", "pip", "install", "--upgrade", *pending_specs], cwd=context.root)
-
-
-def ensure_pytorch_for_device(
-    selected_device: str,
-    context: RuntimeContext,
-    gpus: list[GpuInfo],
-) -> str:
-    torch_info = inspect_installed_torch()
-    if selected_device == "cuda":
-        if torch_info.get("cuda_available"):
-            ensure_companion_requirements(companion_requirements_for_torch(torch_info), context)
-            print_step(f"PyTorch CUDA đã dùng được ({torch_info.get('version')}).")
-            return "cuda"
-
-        candidates = cuda_wheel_candidates(gpus)
-        describe_cuda_selection(gpus, candidates)
-        if not candidates:
-            if try_install_nvidia_cuda_support():
-                gpus = detect_nvidia_gpus()
-                candidates = cuda_wheel_candidates(gpus)
-                describe_cuda_selection(gpus, candidates)
-            if not candidates:
-                gpu_label = format_gpu_list(gpus) if gpus else "không đọc được thông tin GPU"
-                raise RuntimeError(
-                    "Tool chưa tự chuẩn bị được CUDA cho GPU hiện tại. "
-                    f"GPU/driver phát hiện: {gpu_label}."
-                )
-
-        if torch_info.get("installed"):
-            print_step(
-                f"PyTorch hiện tại là {torch_info.get('version')} "
-                f"(cuda={torch_info.get('cuda_version')}). Đang cài lại bản CUDA phù hợp."
-            )
-
-        for wheel in candidates:
-            print_step(
-                f"Đang cài PyTorch GPU phù hợp: {wheel.torch_requirement} "
-                f"({wheel.tag}) từ {wheel.index_url}"
-            )
-            command = [
-                sys.executable,
-                "-m",
-                "pip",
-                "install",
-                "--upgrade",
-                "--force-reinstall",
-                wheel.torch_requirement,
-                "--index-url",
-                wheel.index_url,
-            ]
-            installed_ok = try_run_command(command, cwd=context.root)
-            if installed_ok:
-                installed_info = inspect_installed_torch()
-                if installed_info.get("cuda_available"):
-                    ensure_companion_requirements(wheel.companion_requirements, context)
-                    print_step(f"PyTorch CUDA {wheel.tag} đã dùng được.")
-                    return "cuda"
-                print_step(
-                    f"Đã cài {wheel.tag} nhưng PyTorch vẫn chưa dùng được CUDA "
-                    f"(version={installed_info.get('version')}, cuda={installed_info.get('cuda_version')}). "
-                    "Tool sẽ thử CUDA wheel thấp hơn nếu có."
-                )
-            else:
-                print_step(f"Cài PyTorch {wheel.tag} không thành công. Thử CUDA wheel thấp hơn nếu có.")
-
-        raise RuntimeError(
-            "Tool không cài được PyTorch CUDA phù hợp sau khi đã thử các phiên bản tương thích."
-        )
-
-    if torch_info.get("installed"):
-        print_step(f"PyTorch đã sẵn sàng ({torch_info.get('version')}).")
-        ensure_companion_requirements(companion_requirements_for_torch(torch_info), context)
-        return "cpu"
-
-    print_step("Đang cài PyTorch CPU.")
-    run_command(
-        [sys.executable, "-m", "pip", "install", TORCH_REQUIREMENT, "--index-url", PYTORCH_CPU_INDEX_URL],
-        cwd=context.root,
-    )
-    return "cpu"
-
-
-def verify_selected_device(selected_device: str) -> str:
-    if selected_device != "cuda":
-        return "cpu"
-
-    torch_info = inspect_installed_torch()
-    if torch_info.get("cuda_available"):
-        gpu_names = ", ".join(str(name) for name in torch_info.get("gpu_names", []))
-        suffix = f": {gpu_names}" if gpu_names else ""
-        print_step(f"PyTorch CUDA đã sẵn sàng{suffix}.")
-        return "cuda"
-
-    raise RuntimeError(
-        "Bạn đã chọn dùng GPU nhưng PyTorch chưa truy cập được CUDA sau khi cài đặt. "
-        f"Thông tin PyTorch: version={torch_info.get('version')}, cuda={torch_info.get('cuda_version')}, "
-        f"cuda_available={torch_info.get('cuda_available')}."
-    )
-
-
-def ensure_runtime_dependencies(
-    selected_device: str,
-    context: RuntimeContext,
-    gpus: list[GpuInfo],
-) -> str:
-    install_non_torch_dependencies(context=context)
-    selected_device = ensure_pytorch_for_device(
-        selected_device=selected_device,
-        context=context,
-        gpus=gpus,
-    )
-    return verify_selected_device(selected_device)
-
-
-def resolve_repo_files(
-    repo_id: str,
-    revision: str,
-    allow_patterns: list[str],
-    ignore_patterns: list[str],
-) -> list[dict[str, object]]:
-    from huggingface_hub import HfApi
-
-    api = HfApi()
-    repo_files = api.list_repo_tree(repo_id=repo_id, repo_type="dataset", revision=revision, recursive=True)
-
-    selected: list[dict[str, object]] = []
-    for entry in repo_files:
-        path = str(getattr(entry, "path", "")).replace("\\", "/")
-        size = getattr(entry, "size", None)
-        if not path or path.endswith("/") or size is None:
-            continue
-        if not matches_any_pattern(path, allow_patterns):
-            continue
-        if matches_any_pattern(path, ignore_patterns):
-            continue
-        selected.append({"path": path, "size": size})
-
-    return sorted(selected, key=lambda item: str(item["path"]))
-
-
-def runtime_relative_path(repo_file: str) -> Optional[Path]:
-    normalized = repo_file.replace("\\", "/")
-    prefix = f"{HF_PROJECT_SUBDIR}/"
-    if matches_any_pattern(normalized, RUNTIME_ALLOW_PATTERNS):
-        return Path(normalized[len(prefix) :])
-    return None
-
-
-def model_destination(context: RuntimeContext, repo_file: str) -> Path:
-    normalized = repo_file.replace("\\", "/")
-    relative_path = Path(normalized).relative_to(HF_MODEL_SUBDIR)
-    return context.local_model_dir / relative_path
-
-
-def sync_single_file(
-    source_file: Path,
-    destination_file: Path,
-    force_copy: bool,
-    *,
-    verify_content: bool = False,
-) -> 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:
-        if not verify_content or destination_file.read_bytes() == source_file.read_bytes():
-            return False, size
-
-    shutil.copy2(source_file, destination_file)
-    return True, size
-
-
-def download_and_sync_files(
-    context: RuntimeContext,
-    repo_id: str,
-    revision: str,
-    allow_patterns: list[str],
-    ignore_patterns: list[str],
-    force_download: bool,
-    scope_label: str,
-) -> tuple[int, int, int, int]:
-    from huggingface_hub import snapshot_download
-
-    repo_files = resolve_repo_files(
-        repo_id=repo_id,
-        revision=revision,
-        allow_patterns=allow_patterns,
-        ignore_patterns=ignore_patterns,
-    )
-    if not repo_files:
-        raise FileNotFoundError(
-            f"Không tìm thấy file {scope_label} hợp lệ trong repo {repo_id}@{revision}. "
-            "Hãy kiểm tra lại cấu trúc dataset trên Hugging Face."
-        )
-
-    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
-
-    print_step(f"Tìm thấy {total_files} file cần đồng bộ cho {scope_label}.")
-    print_step(f"Đang tải {scope_label} bằng snapshot_download, bỏ qua file huấn luyện/log không cần thiết...")
-    snapshot_dir = Path(
-        snapshot_download(
-            repo_id=repo_id,
-            repo_type="dataset",
-            revision=revision,
-            allow_patterns=allow_patterns,
-            ignore_patterns=ignore_patterns,
-            force_download=force_download,
-            local_files_only=False,
-        )
-    )
-
-    for index, repo_item in enumerate(repo_files, start=1):
-        repo_file = str(repo_item["path"])
-        runtime_path = runtime_relative_path(repo_file)
-        if runtime_path is not None:
-            destination_path = context.root / runtime_path
-            verify_content = True
-        else:
-            destination_path = model_destination(context, repo_file)
-            verify_content = False
-
-        relative_label = destination_path.relative_to(context.root).as_posix()
-        expected_size = int(repo_item["size"] or 0)
-        if (
-            not force_download
-            and not verify_content
-            and expected_size > 0
-            and destination_path.exists()
-            and destination_path.stat().st_size == expected_size
-        ):
-            skipped_files += 1
-            skipped_bytes += expected_size
-            processed_bytes += expected_size
-            if processed_bytes > total_bytes:
-                total_bytes = processed_bytes
-            print_step(f"[{index}/{total_files}] Giữ nguyên {relative_label} ({format_bytes(expected_size)})")
-            print_step(
-                "    Tổng tiến độ "
-                f"{render_progress_bar(processed_bytes, total_bytes)} "
-                f"({format_bytes(processed_bytes)}/{format_bytes(total_bytes)})"
-            )
-            continue
-
-        print_step(f"[{index}/{total_files}] Đang đồng bộ {relative_label}")
-        cached_file = snapshot_dir / repo_file
-        if not cached_file.exists():
-            raise FileNotFoundError(f"snapshot_download thiếu file đã chọn: {repo_file}")
-
-        copied, size = sync_single_file(
-            cached_file,
-            destination_path,
-            force_copy=force_download,
-            verify_content=verify_content,
-        )
-        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 validate_runtime_files(context: RuntimeContext) -> None:
-    missing_files = [relative for relative in RUNTIME_REQUIRED_FILES if not (context.root / relative).exists()]
-    if missing_files:
-        raise FileNotFoundError(
-            "Runtime chưa đầy đủ sau khi tải về. Thiếu các file: " + ", ".join(missing_files)
-        )
-
-
-def patch_generate_question_runtime(context: RuntimeContext) -> None:
-    if context.requirements_file.exists():
-        requirements_text = context.requirements_file.read_text(encoding="utf-8")
-        patched_requirements = (
-            requirements_text.replace("numpy>=1.26.0,<3.0.0", "numpy>=1.26.0,<2.0.0")
-            .replace("transformers>=4.41.0,<5.0.0", "transformers>=4.41.0,<4.42.0")
-        )
-        if patched_requirements != requirements_text:
-            context.requirements_file.write_text(patched_requirements, encoding="utf-8")
-
-    target = context.root / "generate_question.py"
-    if not target.exists():
-        return
-
-    text = target.read_text(encoding="utf-8")
-    original_text = text
-
-    import_insertions = {
-        "import argparse\n": "import argparse\nimport hashlib\n",
-        "import re\n": "import re\nimport shutil\n",
-        "import sys\n": "import sys\nimport tempfile\n",
-    }
-    for anchor, replacement in import_insertions.items():
-        imported_name = replacement.splitlines()[-1]
-        if imported_name not in text and anchor in text:
-            text = text.replace(anchor, replacement, 1)
-
-    if "TOKENIZER_FILES = (" not in text and "QUESTION_LIMIT = 100\n" in text:
-        text = text.replace(
-            "QUESTION_LIMIT = 100\n",
-            "QUESTION_LIMIT = 100\n"
-            "TOKENIZER_FILES = (\n"
-            "    \"config.json\",\n"
-            "    \"special_tokens_map.json\",\n"
-            "    \"spiece.model\",\n"
-            "    \"tokenizer.json\",\n"
-            "    \"tokenizer_config.json\",\n"
-            "    \"added_tokens.json\",\n"
-            ")\n",
-            1,
-        )
-
-    if "def resolve_tokenizer_dir(" not in text and "\ndef parse_dtype(value: str) -> torch.dtype:\n" in text:
-        helper_block = """
-def path_needs_ascii_mirror(path: Path) -> bool:
-    try:
-        str(path).encode("ascii")
-    except UnicodeEncodeError:
-        return True
-    return False
-
-
-def resolve_tokenizer_dir(model_dir: Path) -> Path:
-    if not path_needs_ascii_mirror(model_dir):
-        return model_dir
-
-    digest = hashlib.sha1(str(model_dir).encode("utf-8")).hexdigest()[:16]
-    cache_base = Path(os.getenv("LOCALAPPDATA") or tempfile.gettempdir())
-    tokenizer_dir = cache_base / "HVU_QA" / "tokenizer_cache" / digest
-    tokenizer_dir.mkdir(parents=True, exist_ok=True)
-
-    copied = False
-    for filename in TOKENIZER_FILES:
-        source = model_dir / filename
-        if not source.exists():
-            continue
-        destination = tokenizer_dir / filename
-        if destination.exists() and destination.stat().st_size == source.stat().st_size:
-            continue
-        shutil.copy2(source, destination)
-        copied = True
-
-    if copied:
-        marker = tokenizer_dir / "source_model_dir.txt"
-        marker.write_text(str(model_dir), encoding="utf-8")
-
-    return tokenizer_dir
-
-"""
-        text = text.replace(
-            "\ndef parse_dtype(value: str) -> torch.dtype:\n",
-            "\n" + helper_block + "def parse_dtype(value: str) -> torch.dtype:\n",
-            1,
-        )
-
-    method_start = text.find("    def _load_tokenizer(self):")
-    method_end = text.find("\n    def load(self)", method_start)
-    if method_start != -1 and method_end != -1:
-        method_block = text[method_start:method_end]
-        if "tokenizer_dir = resolve_tokenizer_dir(self.model_dir)" not in method_block:
-            new_method = """    def _load_tokenizer(self):
-        use_fast = as_bool(os.getenv("HVU_USE_FAST_TOKENIZER"), default=False)
-        tokenizer_dir = resolve_tokenizer_dir(self.model_dir)
-        try:
-            return AutoTokenizer.from_pretrained(str(tokenizer_dir), use_fast=use_fast)
-        except Exception:
-            if use_fast:
-                return AutoTokenizer.from_pretrained(str(tokenizer_dir), use_fast=False)
-            if (tokenizer_dir / "tokenizer.json").exists():
-                try:
-                    return AutoTokenizer.from_pretrained(str(tokenizer_dir), use_fast=True)
-                except Exception:
-                    pass
-            return AutoTokenizer.from_pretrained(str(tokenizer_dir), use_fast=False)
-"""
-            text = text[:method_start] + new_method + text[method_end:]
-
-    if text != original_text:
-        target.write_text(text, encoding="utf-8")
-        print_step("Da cap nhat tuong thich tokenizer trong runtime generate_question.py.")
-
-
-def prepare_runtime(
-    context: RuntimeContext,
-    repo_id: str,
-    revision: str,
-    force_download: bool,
-) -> None:
-    if not force_download and has_complete_runtime(context):
-        patch_generate_question_runtime(context)
-        print_step("Backend/frontend runtime đã có sẵn.")
-        return
-
-    copied_files, skipped_files, copied_bytes, skipped_bytes = download_and_sync_files(
-        context=context,
-        repo_id=repo_id,
-        revision=revision,
-        allow_patterns=RUNTIME_ALLOW_PATTERNS,
-        ignore_patterns=RUNTIME_IGNORE_PATTERNS,
-        force_download=force_download,
-        scope_label="backend/frontend runtime",
-    )
-    validate_runtime_files(context)
-    patch_generate_question_runtime(context)
-    print_step(
-        "Đồng bộ backend/frontend runtime 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 required_model_files(context: RuntimeContext, best_model_only: bool) -> list[Path]:
-    root_files = [
-        context.local_model_dir / "config.json",
-        context.local_model_dir / "generation_config.json",
-        context.local_model_dir / "model.safetensors",
-        context.local_model_dir / "tokenizer_config.json",
-        context.local_model_dir / "special_tokens_map.json",
-        context.local_model_dir / "spiece.model",
-    ]
-    best_model_files = [
-        context.local_best_model_dir / "config.json",
-        context.local_best_model_dir / "generation_config.json",
-        context.local_best_model_dir / "model.safetensors",
-        context.local_best_model_dir / "tokenizer_config.json",
-        context.local_best_model_dir / "special_tokens_map.json",
-        context.local_best_model_dir / "spiece.model",
-    ]
-    if best_model_only:
-        return best_model_files
-    return [*root_files, *best_model_files]
-
-
-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,
-    best_model_only: bool,
-) -> None:
-    if not force_download and has_complete_model(context, best_model_only):
-        scope = "best-model" if best_model_only else "toàn bộ model"
-        print_step(f"{scope} đã có sẵn, không cần tải lại.")
-        return
-
-    allow_patterns = [f"{HF_BEST_MODEL_SUBDIR}/**"] if best_model_only else [f"{HF_MODEL_SUBDIR}/**"]
-    copied_files, skipped_files, copied_bytes, skipped_bytes = download_and_sync_files(
-        context=context,
-        repo_id=repo_id,
-        revision=revision,
-        allow_patterns=allow_patterns,
-        ignore_patterns=MODEL_IGNORE_PATTERNS,
-        force_download=force_download,
-        scope_label="best-model" if best_model_only else "toàn bộ model",
-    )
-    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 = subprocess_env()
-    env["HVU_HOST"] = args.host or "127.0.0.1"
-    env["HVU_PORT"] = str(args.port)
-    if args.device:
-        env["HVU_DEVICE"] = args.device
-    if args.debug:
-        env["HVU_DEBUG"] = "1"
-    env["HVU_OPEN_BROWSER"] = "0"
-
-    env["HVU_MODEL_DIR"] = str(context.local_model_dir)
-    return env
-
-
-def port_available(host: str, port: int) -> bool:
-    try:
-        with socket.create_connection((host, port), timeout=0.4):
-            return False
-    except OSError:
-        return True
-
-
-def choose_port(host: str, requested_port: Optional[int]) -> int:
-    if requested_port is not None:
-        if port_available(host, requested_port):
-            return requested_port
-        print_step(f"Port {requested_port} đang bận, đang tìm port khác...")
-
-    for port in range(5000, 5101):
-        if port_available(host, port):
-            return port
-
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-        sock.bind((host, 0))
-        return int(sock.getsockname()[1])
-
-
-def wait_for_backend(url: str, process: subprocess.Popen, timeout: int = 45) -> None:
-    deadline = time.time() + timeout
-    last_error = ""
-    while time.time() < deadline:
-        if process.poll() is not None:
-            raise RuntimeError(f"Backend dừng sớm với mã lỗi {process.returncode}.")
-        try:
-            with urllib.request.urlopen(url, timeout=2) as response:
-                if 200 <= response.status < 500:
-                    return
-        except Exception as exc:  # noqa: BLE001
-            last_error = str(exc)
-        time.sleep(0.8)
-    raise RuntimeError(f"Backend chưa sẵn sàng sau {timeout} giây. Lỗi gần nhất: {last_error}")
-
-
-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}")
-
-    args.host = args.host or "127.0.0.1"
-    args.port = choose_port(args.host, args.port)
-    update_config(last_host=args.host, last_port=args.port)
-    env = build_runtime_env(context, args)
-    command = [sys.executable, str(context.main_file)]
-    url = f"http://{env['HVU_HOST']}:{env['HVU_PORT']}"
-    print_step("Đang khởi động backend...")
-    process = subprocess.Popen(
-        command,
-        cwd=str(context.root),
-        env=env,
-        stdout=None,
-        stderr=None,
-    )
-    wait_for_backend(url, process)
-    print_step(f"Backend đã chạy tại {url}")
-    if not args.no_browser:
-        print_step("Đang mở giao diện hệ thống...")
-        webbrowser.open(url)
-    print_step("Hoàn tất, Hệ thống sinh câu hỏi đã sẵn sàng.")
-    return process.wait()
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description=(
-            "Launcher cho HVU_QA. Chạy không cần tham số để tự tải backend/frontend thật, "
-            "tải model từ dataset Hugging Face, chuẩn bị CPU/GPU và mở giao diện web."
-        ),
-    )
-    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 tự quét GPU và hỏi người dùng.",
-    )
-    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 runtime/model và ghi đè file local.")
-    parser.add_argument("--min-free-gb", type=float, default=6.0, help="Dung lượng trống tối thiểu cần kiểm tra.")
-    parser.set_defaults(best_model_only=False)
-    parser.add_argument(
-        "--best-model-only",
-        dest="best_model_only",
-        action="store_true",
-        help="Chỉ tải thư mục best-model nếu muốn runtime nhẹ và chỉ hiện 1 model.",
-    )
-    parser.add_argument(
-        "--full-model",
-        dest="best_model_only",
-        action="store_false",
-        help="Tải đủ model gốc và best-model để giao diện hiện 2 lựa chọn (mặc định).",
-    )
-    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="Tải lại backend/frontend từ Hugging Face và ghi đè runtime local.",
-    )
-    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()
-
-    run_base_preflight(args)
-    bootstrap_exit_code = maybe_bootstrap_tool_venv(args)
-    if bootstrap_exit_code is not None:
-        return bootstrap_exit_code
-
-    print_step("Đang chuẩn bị Hệ thống sinh câu hỏi...")
-    context = resolve_runtime_context(args)
-    check_write_access(context.root)
-    check_disk_space(context.root, args.min_free_gb)
-    ensure_huggingface_hub()
-    check_internet_if_needed(context, args)
-    prepare_runtime(
-        context=context,
-        repo_id=args.repo_id,
-        revision=args.revision,
-        force_download=args.force_download or args.force_runtime_refresh,
-    )
-
-    selected_device, detected_gpus = select_runtime_device(args)
-    check_dependency_internet_if_needed(selected_device, context)
-    try:
-        selected_device = ensure_runtime_dependencies(
-            selected_device=selected_device,
-            context=context,
-            gpus=detected_gpus,
-        )
-    except RuntimeError as exc:
-        if selected_device != "cuda":
-            raise
-        print_step(f"GPU/CUDA chưa dùng được ({exc}). Hệ thống sẽ chuyển sang CPU.")
-        selected_device = ensure_runtime_dependencies(
-            selected_device="cpu",
-            context=context,
-            gpus=detected_gpus,
-        )
-    args.device = selected_device
-    update_config(
-        device=selected_device,
-        runtime_root=str(context.root),
-        model_dir=str(context.local_model_dir),
-        last_port=args.port,
-    )
-
-    prepare_model(
-        context=context,
-        repo_id=args.repo_id,
-        revision=args.revision,
-        force_download=args.force_download,
-        best_model_only=args.best_model_only,
-    )
-
-    return launch_app(context, args)
-
-
-def pause_on_error() -> None:
-    if not IS_WINDOWS:
-        return
-    if os.getenv("HVU_NO_PAUSE_ON_ERROR", "").strip().lower() in {"1", "true", "yes", "on"}:
-        return
-    try:
-        input("Nhấn Enter để thoát...")
-    except EOFError:
-        os.system("pause")
-
-
-def write_error_log(exc: BaseException) -> Path:
-    LOG_DIR.mkdir(parents=True, exist_ok=True)
-    log_file = LOG_DIR / "HVU_QA_tool_error.log"
-    details = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
-    log_file.write_text(details, encoding="utf-8")
-    return log_file
-
-
-def run_main() -> int:
-    setup_logging()
-    try:
-        return main()
-    except KeyboardInterrupt:
-        print_step("Đã dừng theo yêu cầu người dùng.")
-        return 130
-    except Exception as exc:  # noqa: BLE001
-        print_step(f"Lỗi: {exc}")
-        logging.exception("Launcher failed")
-        log_file = write_error_log(exc)
-        print_step(f"Đã ghi log lỗi tại: {log_file}")
-        print_step("Chi tiết lỗi:")
-        traceback.print_exc()
-        pause_on_error()
-        return 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(run_main())