Update

HVU_QA/HVU_QA_tool.py

@@ -0,0 +1,1566 @@
+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())