Update

HVU_QA/backend/__init__.py

@@ -1,3 +0,0 @@
-from .app import create_app
-
-__all__ = ["create_app"]

HVU_QA/backend/app.py

@@ -1,319 +0,0 @@
-from __future__ import annotations
-
-import os
-import time
-from pathlib import Path
-
-from flask import Flask, jsonify, request, send_from_directory
-
-from generate_question import (
-    APP_TITLE,
-    QUESTION_LIMIT,
-    QuestionGenerator,
-    format_questions,
-    normalize_text,
-    parse_question_count,
-    resolve_model_dir,
-)
-
-IGNORED_MODEL_DIR_NAMES = {
-    ".git",
-    ".vscode",
-    "__pycache__",
-    "backend",
-    "frontend",
-    "venv",
-}
-
-
-def project_root() -> Path:
-    return Path(__file__).resolve().parents[1]
-
-
-def build_generator(
-    model_dir: str | Path | None = None,
-    prefer_nested_model: bool = True,
-) -> QuestionGenerator:
-    root = project_root()
-    selected_model_dir = (
-        Path(model_dir).expanduser()
-        if model_dir is not None
-        else Path(os.getenv("HVU_MODEL_DIR", str(root / "t5-viet-qg-finetuned"))).expanduser()
-    )
-    if not selected_model_dir.is_absolute():
-        selected_model_dir = root / selected_model_dir
-
-    return QuestionGenerator(
-        model_dir=str(selected_model_dir),
-        task_prefix=os.getenv("HVU_TASK_PREFIX", "sinh câu hỏi"),
-        max_source_length=int(os.getenv("HVU_MAX_SOURCE_LENGTH", "512")),
-        max_new_tokens=int(os.getenv("HVU_MAX_NEW_TOKENS", "64")),
-        device=os.getenv("HVU_DEVICE", "auto"),
-        cpu_threads=_read_optional_int(os.getenv("HVU_CPU_THREADS")),
-        gpu_dtype=os.getenv("HVU_GPU_DTYPE", "auto"),
-        prefer_nested_model=prefer_nested_model,
-    )
-
-
-def _read_optional_int(value: str | None) -> int | None:
-    if value in (None, ""):
-        return None
-    return int(value)
-
-
-def _humanize_model_segment(value: str) -> str:
-    normalized = value.replace("_", "-")
-    parts: list[str] = []
-    for part in normalized.split("-"):
-        lowered = part.lower()
-        if not lowered:
-            continue
-        if lowered in {"t5", "qg", "qa", "hvu"}:
-            parts.append(lowered.upper())
-        elif lowered == "seq2seq":
-            parts.append("Seq2Seq")
-        elif lowered == "checkpoint":
-            parts.append("Checkpoint")
-        elif part.isdigit():
-            parts.append(part)
-        else:
-            parts.append(part.capitalize())
-    return "-".join(parts) or "Model"
-
-
-def _display_model_name(meta: dict[str, object]) -> str:
-    raw_name = Path(str(meta.get("model_root") or meta.get("model_dir") or "model")).name
-    return _humanize_model_segment(raw_name)
-
-
-def _model_label(relative_path: str | Path) -> str:
-    path = Path(relative_path)
-    return path.name or "model"
-
-
-def _iter_model_candidates(root: Path):
-    for child in sorted(root.iterdir(), key=lambda path: path.name.lower()):
-        if not child.is_dir() or child.name.startswith(".") or child.name in IGNORED_MODEL_DIR_NAMES:
-            continue
-
-        if (child / "config.json").exists():
-            yield {"path": child, "prefer_nested_model": False}
-
-        for nested_name in ("best-model", "final-model"):
-            nested = child / nested_name
-            if nested.is_dir() and (nested / "config.json").exists():
-                yield {"path": nested, "prefer_nested_model": False}
-
-
-def _discover_available_models(
-    root: Path,
-    active_generator: QuestionGenerator | None = None,
-) -> list[dict[str, str]]:
-    models: list[dict[str, str]] = []
-    seen_model_roots: set[str] = set()
-    root = root.resolve()
-
-    for candidate_info in _iter_model_candidates(root):
-        candidate = candidate_info["path"]
-        prefer_nested_model = bool(candidate_info["prefer_nested_model"])
-        model_key = str(candidate.resolve())
-        if model_key in seen_model_roots:
-            continue
-
-        try:
-            relative_candidate = candidate.resolve().relative_to(root)
-        except ValueError:
-            continue
-
-        seen_model_roots.add(model_key)
-        models.append(
-            {
-                "id": relative_candidate.as_posix(),
-                "label": _model_label(relative_candidate),
-                "model_root": str(candidate.resolve()),
-                "model_dir": str(resolve_model_dir(candidate, prefer_nested_model=False).resolve()),
-                "prefer_nested_model": prefer_nested_model,
-            }
-        )
-
-    if active_generator is not None:
-        current_root = active_generator.model_root.resolve()
-        current_dir = active_generator.model_dir.resolve()
-        exists = any(
-            Path(item["model_root"]).resolve() == current_root
-            or Path(item["model_dir"]).resolve() == current_dir
-            for item in models
-        )
-        if not exists:
-            models.append(
-                {
-                    "id": current_root.as_posix(),
-                    "label": _display_model_name(active_generator.metadata()),
-                    "model_root": str(current_root),
-                    "model_dir": str(current_dir),
-                    "prefer_nested_model": False,
-                }
-            )
-
-    return models
-
-
-def _selected_model_id(
-    app: Flask,
-    models: list[dict[str, str]],
-    active_generator: QuestionGenerator | None = None,
-) -> str:
-    explicit_selection = str(app.config.get("SELECTED_MODEL_ID") or "").strip()
-    if explicit_selection and any(item["id"] == explicit_selection for item in models):
-        return explicit_selection
-
-    active_generator = active_generator or _generator(app)
-    current_root = active_generator.model_root.resolve()
-    current_dir = active_generator.model_dir.resolve()
-
-    for item in models:
-        if Path(item["model_dir"]).resolve() == current_dir:
-            return item["id"]
-
-    for item in models:
-        if Path(item["model_root"]).resolve() == current_root:
-            return item["id"]
-
-    return models[0]["id"] if models else ""
-
-
-def _switch_generator(app: Flask, model_id: str) -> QuestionGenerator:
-    available_models = _discover_available_models(app.config["PROJECT_ROOT"], _generator(app))
-    selected_model = next((item for item in available_models if item["id"] == model_id), None)
-    if selected_model is None:
-        raise ValueError("Model được chọn không hợp lệ hoặc chưa tồn tại trong thư mục dự án.")
-
-    current_model_id = _selected_model_id(app, available_models)
-    if current_model_id != model_id:
-        app.config["GENERATOR"] = build_generator(
-            selected_model["model_root"],
-            prefer_nested_model=bool(selected_model.get("prefer_nested_model")),
-        )
-
-    app.config["SELECTED_MODEL_ID"] = model_id
-    return _generator(app)
-
-
-def _info_payload(app: Flask, active_generator: QuestionGenerator | None = None) -> dict[str, object]:
-    active_generator = active_generator or _generator(app)
-    meta = active_generator.metadata()
-    available_models = _discover_available_models(app.config["PROJECT_ROOT"], active_generator)
-    selected_model_id = _selected_model_id(app, available_models, active_generator)
-    model_name = next(
-        (item["label"] for item in available_models if item["id"] == selected_model_id),
-        _display_model_name(meta),
-    )
-
-    return {
-        "ok": True,
-        "title": APP_TITLE,
-        "model_name": model_name,
-        "selected_model_id": selected_model_id,
-        "available_models": [{"id": item["id"], "label": item["label"]} for item in available_models],
-        "meta": meta,
-    }
-
-
-def create_app(generator: QuestionGenerator | None = None) -> Flask:
-    root = project_root()
-    frontend_root = root / "frontend"
-
-    app = Flask(__name__, static_folder=None)
-    app.json.ensure_ascii = False
-    app.config["GENERATOR"] = generator or build_generator()
-    app.config["PROJECT_ROOT"] = root
-    app.config["FRONTEND_ROOT"] = frontend_root
-    app.config["SELECTED_MODEL_ID"] = ""
-
-    @app.get("/")
-    def index():
-        return send_from_directory(app.config["FRONTEND_ROOT"], "index.html")
-
-    @app.get("/frontend/<path:filename>")
-    def frontend_file(filename: str):
-        return send_from_directory(app.config["FRONTEND_ROOT"], filename)
-
-    @app.get("/assets/<path:filename>")
-    def asset_file(filename: str):
-        return send_from_directory(app.config["PROJECT_ROOT"], filename)
-
-    @app.get("/api/info")
-    def info():
-        return jsonify(_info_payload(app))
-
-    @app.post("/api/model")
-    def set_model():
-        payload = request.get_json(silent=True) or {}
-        model_id = str(payload.get("model_id") or "").strip()
-        if not model_id:
-            return jsonify({"ok": False, "error": "Vui lòng chọn model trước khi chuyển."}), 400
-
-        try:
-            active_generator = _switch_generator(app, model_id)
-        except ValueError as exc:
-            return jsonify({"ok": False, "error": str(exc)}), 404
-
-        return jsonify(_info_payload(app, active_generator))
-
-    @app.post("/api/generate")
-    def generate():
-        payload = request.get_json(silent=True) or {}
-        requested_model_id = str(payload.get("model_id") or "").strip()
-
-        if requested_model_id:
-            try:
-                active_generator = _switch_generator(app, requested_model_id)
-            except ValueError as exc:
-                return jsonify({"ok": False, "error": str(exc)}), 400
-        else:
-            active_generator = _generator(app)
-
-        text = normalize_text(payload.get("text"))
-        if not text:
-            return jsonify({"ok": False, "error": "Vui lòng nhập đoạn văn bản trước khi sinh câu hỏi."}), 400
-
-        raw_count = payload.get("num_questions")
-        if raw_count in (None, ""):
-            count = 100
-        else:
-            try:
-                count = int(raw_count)
-            except (TypeError, ValueError):
-                return jsonify({"ok": False, "error": "Số câu hỏi phải là số nguyên trong khoảng 1 đến 100."}), 400
-
-            if count < 1 or count > QUESTION_LIMIT:
-                return jsonify({"ok": False, "error": f"Số câu hỏi phải nằm trong khoảng 1 đến {QUESTION_LIMIT}."}), 400
-
-        started = time.perf_counter()
-        try:
-            questions = active_generator.generate(text, parse_question_count(count))
-        except Exception as exc:  # noqa: BLE001
-            return jsonify({"ok": False, "error": str(exc)}), 500
-
-        elapsed_ms = round((time.perf_counter() - started) * 1000, 2)
-        info_payload = _info_payload(app, active_generator)
-        return jsonify(
-            {
-                "ok": True,
-                "text": text,
-                "num_questions": count,
-                "questions": questions,
-                "formatted": format_questions(questions),
-                "elapsed_ms": elapsed_ms,
-                "model_name": info_payload["model_name"],
-                "selected_model_id": info_payload["selected_model_id"],
-                "meta": active_generator.metadata(),
-            }
-        )
-
-    return app
-
-
-def _generator(app: Flask) -> QuestionGenerator:
-    generator: QuestionGenerator = app.config["GENERATOR"]
-    return generator