from __future__ import annotations import argparse import csv import fnmatch import importlib.metadata import importlib.util import json import logging import os import platform 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 PLATFORM_SYSTEM = platform.system().lower() IS_WINDOWS = os.name == "nt" IS_MACOS = PLATFORM_SYSTEM == "darwin" IS_LINUX = PLATFORM_SYSTEM == "linux" 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", "packaging>=23.2,<26.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", "packaging": "packaging", "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" VC_REDIST_X64_URL = "https://aka.ms/vc14/vc_redist.x64.exe" VC_REDIST_CACHE = SCRIPT_ROOT / ".hvu_qa_cache" / "vc_redist.x64.exe" VC_REDIST_SUCCESS_CODES = {0, 1638, 3010} @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 SystemProfile: os_key: str os_label: str platform_name: str release: str machine: str processor: str python_version: str python_bits: int python_executable: str @property def is_64bit_python(self) -> bool: return self.python_bits == 64 @property def is_arm64(self) -> bool: return self.machine.lower() in {"arm64", "aarch64"} @property def is_x64(self) -> bool: return self.machine.lower() in {"amd64", "x86_64", "x64"} @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 collect_system_profile() -> SystemProfile: if IS_WINDOWS: os_key = "windows" os_label = "Windows" elif IS_MACOS: os_key = "macos" os_label = "macOS" elif IS_LINUX: os_key = "linux" os_label = "Linux" else: os_key = PLATFORM_SYSTEM or sys.platform os_label = platform.system() or sys.platform return SystemProfile( os_key=os_key, os_label=os_label, platform_name=sys.platform, release=platform.release(), machine=platform.machine() or "unknown", processor=platform.processor() or "unknown", python_version=python_version_label(), python_bits=64 if sys.maxsize > 2**32 else 32, python_executable=sys.executable, ) def system_profile_config(profile: SystemProfile) -> dict[str, object]: return { "os": profile.os_key, "os_label": profile.os_label, "platform": profile.platform_name, "release": profile.release, "machine": profile.machine, "processor": profile.processor, "python_version": profile.python_version, "python_bits": profile.python_bits, "python_executable": profile.python_executable, } def format_system_profile(profile: SystemProfile) -> str: arch_label = "ARM64" if profile.is_arm64 else ("x64" if profile.is_x64 else profile.machine) return ( f"{profile.os_label} {profile.release} ({arch_label}), " f"Python {profile.python_version} {profile.python_bits}-bit" ) def validate_system_profile(profile: SystemProfile) -> None: if profile.os_key not in {"windows", "macos", "linux"}: raise RuntimeError( f"Hệ điều hành {profile.os_label} chưa được hỗ trợ tự động. " "Tool hiện hỗ trợ Windows, macOS và Linux." ) if not profile.is_64bit_python: raise RuntimeError( "Python hiện tại là bản 32-bit nên không phù hợp để cài PyTorch/model NLP. " "Vui lòng cài Python 64-bit rồi chạy lại `python HVU_QA_tool.py`." ) 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() profile = collect_system_profile() print_step(f"Thiết bị phát hiện: {format_system_profile(profile)}.") validate_system_profile(profile) check_python_module("pip", "pip") if not args.no_venv: check_python_module("venv", "môi trường ảo") check_write_access(SCRIPT_ROOT) update_config(system_profile=system_profile_config(profile)) 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 run_command_capture(command: list[str], *, cwd: Optional[Path] = None) -> subprocess.CompletedProcess: return subprocess.run( command, cwd=str(cwd) if cwd else None, env=subprocess_env(), capture_output=True, text=True, encoding="utf-8", errors="replace", check=False, ) 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", "setuptools", "wheel"], 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 select_runtime_device(args: argparse.Namespace) -> tuple[str, list[GpuInfo]]: requested = (args.device or os.getenv("HVU_DEVICE") or "auto").strip().lower() if requested == "cpu": print_step("Đã chọn CPU theo tham số chạy.") 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"Phát hiện GPU NVIDIA CUDA, ưu tiên chạy bằng GPU: {format_gpu_list(gpus)}") update_config(device="cuda") return "cuda", 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 cpu_torch_install_commands(force_reinstall: bool) -> list[list[str]]: base_command = [sys.executable, "-m", "pip", "install", "--upgrade"] if force_reinstall: base_command.append("--force-reinstall") pypi_command = [*base_command, TORCH_REQUIREMENT] cpu_index_command = [*base_command, TORCH_REQUIREMENT, "--index-url", PYTORCH_CPU_INDEX_URL] # macOS and ARM Linux usually receive the correct CPU/MPS wheels from PyPI. # Windows/Linux x64 prefer the PyTorch CPU index to avoid pulling CUDA wheels. profile = collect_system_profile() if IS_MACOS or profile.is_arm64: return [pypi_command, cpu_index_command] return [cpu_index_command, pypi_command] def install_cpu_torch(context: RuntimeContext, force_reinstall: bool = False) -> None: commands = cpu_torch_install_commands(force_reinstall) for index, command in enumerate(commands, start=1): source_label = "PyPI" if "--index-url" not in command else "PyTorch CPU index" if index == 1: print_step(f"Đang cài PyTorch CPU từ {source_label}.") else: print_step(f"Nguồn cài trước chưa thành công, đang thử PyTorch CPU từ {source_label}.") if try_run_command(command, cwd=context.root): return raise RuntimeError( "Không cài được PyTorch CPU tự động. Hãy kiểm tra Internet, phiên bản Python 64-bit " "và thử chạy lại `python HVU_QA_tool.py`." ) def platform_runtime_note(selected_device: str) -> None: profile = collect_system_profile() if profile.os_key == "windows": print_step("Windows: tool sẽ tự xử lý virtualenv, pip, VC++ Redistributable khi cần, PyTorch CPU/CUDA.") elif profile.os_key == "macos": print_step("macOS: tool sẽ tự xử lý virtualenv, pip và PyTorch CPU/MPS wheel qua PyPI; CUDA không áp dụng.") elif profile.os_key == "linux": print_step("Linux: tool sẽ tự xử lý virtualenv, pip và PyTorch; GPU NVIDIA cần driver hệ thống đã sẵn sàng.") if selected_device == "cuda" and profile.os_key != "windows": print_step("Trên Linux, tool có thể cài PyTorch CUDA wheel nhưng không tự cài driver NVIDIA cấp hệ điều hành.") def is_torch_dll_error(torch_info: dict[str, object]) -> bool: text = str(torch_info.get("error") or "") markers = ("c10.dll", "_load_dll_libraries", "WinError 1114", "DLL initialization routine failed") return any(marker.lower() in text.lower() for marker in markers) def windows_is_admin() -> bool: if not IS_WINDOWS: return False try: import ctypes return bool(ctypes.windll.shell32.IsUserAnAdmin()) except Exception: return False def download_vc_redist() -> Path: VC_REDIST_CACHE.parent.mkdir(parents=True, exist_ok=True) if VC_REDIST_CACHE.exists() and VC_REDIST_CACHE.stat().st_size > 1_000_000: return VC_REDIST_CACHE if not internet_available(): raise RuntimeError( "Cần Internet để tải Microsoft Visual C++ Redistributable tự động." ) print_step("Đang tải Microsoft Visual C++ Redistributable 2015-2022 x64...") with urllib.request.urlopen(VC_REDIST_X64_URL, timeout=60) as response: VC_REDIST_CACHE.write_bytes(response.read()) return VC_REDIST_CACHE def run_vc_redist_installer(installer: Path) -> int: args = "/install /quiet /norestart" if windows_is_admin(): completed = run_command_capture([str(installer), "/install", "/quiet", "/norestart"]) return completed.returncode print_step("Trình cài VC++ có thể yêu cầu quyền quản trị. Nếu Windows hỏi UAC, hãy chọn Yes.") command = [ "powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", ( "$p = Start-Process " f"-FilePath {json.dumps(str(installer))} " f"-ArgumentList {json.dumps(args)} " "-Verb RunAs -Wait -PassThru; exit $p.ExitCode" ), ] completed = run_command_capture(command) return completed.returncode def ensure_windows_vc_redist() -> bool: if not IS_WINDOWS: return False if os.getenv("HVU_SKIP_VC_REDIST", "").strip().lower() in {"1", "true", "yes", "on"}: return False installer = download_vc_redist() print_step("Đang cài Microsoft Visual C++ Redistributable 2015-2022 x64...") exit_code = run_vc_redist_installer(installer) if exit_code in VC_REDIST_SUCCESS_CODES: if exit_code == 3010: print_step("VC++ Redistributable đã cài xong và Windows có thể cần khởi động lại.") else: print_step("VC++ Redistributable đã sẵn sàng.") return True raise RuntimeError( "Không cài được Microsoft Visual C++ Redistributable tự động " f"(mã lỗi {exit_code}). Hãy chạy lại bằng quyền Administrator hoặc cài thủ công rồi chạy lại." ) def repair_torch_runtime(context: RuntimeContext, reason: str) -> None: print_step("Đang sửa lỗi PyTorch/DLL trước khi chạy backend...") if IS_WINDOWS: ensure_windows_vc_redist() print_step("Đang cài lại PyTorch CPU ổn định...") install_cpu_torch(context, force_reinstall=True) torch_info = inspect_installed_torch() if not torch_info.get("installed"): raise RuntimeError( "Đã thử sửa PyTorch nhưng vẫn chưa import được. " f"Lỗi ban đầu: {reason}. Lỗi hiện tại: {torch_info.get('error')}" ) 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" error_text = str(torch_info.get("error") or "").strip() if error_text: print_step("PyTorch hiện tại bị lỗi khi import, đang cài lại bản CPU ổn định.") print_step(f"Lỗi PyTorch: {error_text}") if is_torch_dll_error(torch_info): repair_torch_runtime(context, error_text) return "cpu" else: print_step("Đang cài PyTorch CPU.") install_cpu_torch(context, force_reinstall=bool(error_text)) installed_info = inspect_installed_torch() if not installed_info.get("installed"): raise RuntimeError( "Đã cài lại PyTorch CPU nhưng vẫn không import được. " "Hãy cài Microsoft Visual C++ Redistributable 2015-2022 x64, khởi động lại máy rồi chạy lại. " f"Chi tiết PyTorch: {installed_info.get('error')}" ) return "cpu" def verify_selected_device(selected_device: str) -> str: if selected_device != "cuda": torch_info = inspect_installed_torch() if not torch_info.get("installed"): raise RuntimeError( "PyTorch chưa import được sau bước cài đặt. " f"Chi tiết: {torch_info.get('error')}" ) 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 probe_backend_import(context: RuntimeContext, env: dict[str, str]) -> subprocess.CompletedProcess: return subprocess.run( [sys.executable, "-c", "from backend import create_app; app = create_app(); print('backend-ok')"], cwd=str(context.root), env=env, capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=90, check=False, ) def validate_backend_import(context: RuntimeContext, env: dict[str, str]) -> None: probe = probe_backend_import(context, env) if probe.returncode == 0: return details = (probe.stderr or probe.stdout or "").strip() if "c10.dll" in details or "_load_dll_libraries" in details or "WinError 1114" in details: repair_torch_runtime(context, details[-1200:]) retry = probe_backend_import(context, env) if retry.returncode == 0: return retry_details = (retry.stderr or retry.stdout or "").strip() raise RuntimeError( "PyTorch vẫn không load được DLL sau khi đã tự cài VC++ Redistributable và cài lại PyTorch CPU. " "Hãy khởi động lại Windows rồi chạy lại HVU_QA_tool.py. " f"Chi tiết: {retry_details[-1200:]}" ) raise RuntimeError(f"Backend chưa import được trước khi khởi động. Chi tiết: {details[-1200:]}") 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 kiểm tra backend trước khi chạy...") validate_backend_import(context, env) 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ự ưu tiên GPU NVIDIA/CUDA, nếu không có thì dùng CPU.", ) 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) platform_runtime_note(selected_device) 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())