18

app.py

@@ -1,6 +1,6 @@
 # app.py
-# PapuaTranslate — Flask + SQLAlchemy (Supabase/SQLite) + mT5-LoRA (lazy)
-import os, re, logging, threading
+# PapuaTranslate — Flask + SQLAlchemy (Supabase/SQLite) + mT5-LoRA (lazy) + diag + preload
+import os, re, logging, threading, traceback
 from datetime import datetime, timezone, timedelta
 from functools import wraps
 from flask import Flask, render_template, request, redirect, url_for, session, jsonify, flash
@@ -10,27 +10,26 @@ from werkzeug.middleware.proxy_fix import ProxyFix
 logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
 log = logging.getLogger("papua-app")
 
-# ===== Flask =====
-# Template HTML kamu ada di 'frontend/'
+# ===== Flask / Template =====
 app = Flask(__name__, template_folder="frontend", static_folder="static")
-
-# Trust reverse proxy di Hugging Face -> Flask tahu proto HTTPS & host asli (perlu untuk cookie/redirect)
 app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1)
 
-# Session config: aman untuk iframe/third-party, dan bekerja baik saat dibuka di tab langsung hf.space
 app.config.update(
     SECRET_KEY=os.getenv("SECRET_KEY", "dev-secret-change-me"),
     SESSION_COOKIE_NAME="hfspace_session",
-    SESSION_COOKIE_SAMESITE="None",   # penting untuk iframe / third-party
-    SESSION_COOKIE_SECURE=True,       # wajib True kalau SAMESITE=None
+    SESSION_COOKIE_SAMESITE="None",
+    SESSION_COOKIE_SECURE=True,
     SESSION_COOKIE_HTTPONLY=True,
     SESSION_COOKIE_PATH="/",
     PREFERRED_URL_SCHEME="https",
 )
-# Lama hidup session (untuk session.permanent=True)
 app.permanent_session_lifetime = timedelta(hours=8)
 
-# ===== DB: SQLAlchemy (Supabase Postgres / SQLite fallback) =====
+# ===== Feature flags via ENV =====
+PRELOAD_MODEL       = os.getenv("PRELOAD_MODEL", "true").lower() in ("1","true","yes")
+FALLBACK_TRANSLATE  = os.getenv("FALLBACK_TRANSLATE", "false").lower() in ("1","true","yes")
+
+# ===== DB: SQLAlchemy =====
 from sqlalchemy import create_engine, Column, Integer, Text, DateTime, ForeignKey, func
 from sqlalchemy.orm import declarative_base, sessionmaker, scoped_session, relationship
 
@@ -39,12 +38,10 @@ if not DATABASE_URL:
     DATABASE_URL = "sqlite:////tmp/app.db"
     log.warning("[DB] DATABASE_URL tidak diset; pakai SQLite /tmp/app.db")
 else:
-    # normalisasi ke psycopg2 driver
     if DATABASE_URL.startswith("postgres://"):
         DATABASE_URL = DATABASE_URL.replace("postgres://", "postgresql+psycopg2://", 1)
     elif DATABASE_URL.startswith("postgresql://"):
         DATABASE_URL = DATABASE_URL.replace("postgresql://", "postgresql+psycopg2://", 1)
-    # tambahkan sslmode kalau belum ada
     if DATABASE_URL.startswith("postgresql+psycopg2") and "sslmode=" not in DATABASE_URL:
         sep = "&" if "?" in DATABASE_URL else "?"
         DATABASE_URL = f"{DATABASE_URL}{sep}sslmode=require"
@@ -90,7 +87,7 @@ def login_required(fn):
         return fn(*args, **kwargs)
     return _wrap
 
-# ===== Prenorm (heuristik ringan) =====
+# ===== Prenorm =====
 PAPUA_MAP = {
     r"\bsa\b": "saya", r"\bko\b": "kamu", r"\btra\b": "tidak", r"\bndak\b": "tidak",
     r"\bmo\b": "mau", r"\bpu\b": "punya", r"\bsu\b": "sudah", r"\bkong\b": "kemudian",
@@ -101,30 +98,45 @@ def prenorm(text: str) -> str:
     for pat, repl in PAPUA_MAP.items(): t = re.sub(pat, repl, t, flags=re.IGNORECASE)
     return t
 
-# ===== Model (lazy-load LoRA) =====
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-from peft import PeftModel
-
-# Mulai dengan model kecil untuk uji UI; setelah lancar, ganti ke model kamu
-BASE_MODEL_ID = os.getenv("BASE_MODEL_ID", "google/mt5-small")
-ADAPTER_ID    = os.getenv("ADAPTER_ID", "")
+# ===== Model (lazy) =====
+BASE_MODEL_ID = os.getenv("BASE_MODEL_ID", "google/mt5-small")  # kecil dulu untuk uji
+ADAPTER_ID    = os.getenv("ADAPTER_ID", "")                     # kosongkan dulu
 DEVICE        = "cuda" if os.getenv("DEVICE", "cpu") == "cuda" else "cpu"
 
 TOK = None
 MODEL = None
 _MODEL_LOCK = threading.Lock()
+_MODEL_READY = False
+_MODEL_ERROR = None
 
 def _load_model():
-    global TOK, MODEL
-    log.info("[MODEL] loading base=%s adapter=%s", BASE_MODEL_ID, ADAPTER_ID or "-")
-    TOK = AutoTokenizer.from_pretrained(BASE_MODEL_ID)
-    base = AutoModelForSeq2SeqLM.from_pretrained(BASE_MODEL_ID)
-    MODEL = PeftModel.from_pretrained(base, ADAPTER_ID) if ADAPTER_ID else base
-    MODEL.eval().to(DEVICE)
-    log.info("[MODEL] ready on %s", DEVICE)
+    global TOK, MODEL, _MODEL_READY, _MODEL_ERROR
+    try:
+        log.info("[MODEL] loading base=%s adapter=%s", BASE_MODEL_ID, ADAPTER_ID or "-")
+        # import di sini agar error import terlihat di /diag
+        import torch
+        from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+        from peft import PeftModel
+
+        TOK = AutoTokenizer.from_pretrained(BASE_MODEL_ID)
+        base = AutoModelForSeq2SeqLM.from_pretrained(BASE_MODEL_ID)
+
+        if ADAPTER_ID:
+            MODEL = PeftModel.from_pretrained(base, ADAPTER_ID)
+        else:
+            MODEL = base
+
+        MODEL.eval().to(DEVICE)
+        _MODEL_READY = True
+        _MODEL_ERROR = None
+        log.info("[MODEL] ready on %s", DEVICE)
+    except Exception as e:
+        _MODEL_READY = False
+        _MODEL_ERROR = f"{type(e).__name__}: {e}"
+        log.exception("[MODEL] load error")
 
 def get_model():
-    global MODEL
+    global MODEL, _MODEL_READY
     if MODEL is None:
         with _MODEL_LOCK:
             if MODEL is None:
@@ -132,17 +144,36 @@ def get_model():
     return TOK, MODEL
 
 def translate_with_model(text: str, max_new_tokens: int = 48) -> str:
+    import torch
     tok, m = get_model()
-    inputs = tok([text], return_tensors="pt").to(DEVICE)
-    outputs = m.generate(
-        **inputs,
-        max_new_tokens=max_new_tokens,
+    if not _MODEL_READY or m is None:
+        raise RuntimeError(f"Model not ready: {_MODEL_ERROR or 'unknown error'}")
+
+    # guard panjang input agar tidak OOM
+    enc = tok([text], return_tensors="pt", truncation=True, max_length=256)
+    enc = {k: v.to(DEVICE) for k, v in enc.items()}
+
+    log.info("[GEN] start (len=%d)", int(enc["input_ids"].shape[-1]))
+    out = m.generate(
+        **enc,
+        max_new_tokens=int(max_new_tokens),
         num_beams=4,
         length_penalty=0.9,
         no_repeat_ngram_size=3,
         early_stopping=True,
     )
-    return tok.decode(outputs[0], skip_special_tokens=True)
+    log.info("[GEN] done")
+    return tok.decode(out[0], skip_special_tokens=True)
+
+# preload (opsional) supaya request pertama nggak lama
+def _preload_thread():
+    try:
+        _load_model()
+    except Exception:
+        pass
+
+if PRELOAD_MODEL:
+    threading.Thread(target=_preload_thread, daemon=True).start()
 
 # ===== Utils / logging =====
 @app.before_request
@@ -155,7 +186,30 @@ def _err(e):
     log.exception("Unhandled error")
     return "Internal Server Error", 500
 
-# ===== Debug endpoints (cek cookie session) =====
+# ===== Debug / Diag =====
+@app.get("/diag")
+def diag():
+    import sys
+    try:
+        import torch, transformers, peft
+        torch_v = torch.__version__
+        tf_v = transformers.__version__
+        peft_v = peft.__version__
+    except Exception as e:
+        torch_v = tf_v = peft_v = f"import error: {e}"
+
+    return jsonify({
+        "ok": True,
+        "time": datetime.now(timezone.utc).isoformat(),
+        "device": DEVICE,
+        "base_model": BASE_MODEL_ID,
+        "adapter": ADAPTER_ID or None,
+        "model_ready": _MODEL_READY,
+        "model_error": _MODEL_ERROR,
+        "versions": {"python": sys.version, "torch": torch_v, "transformers": tf_v, "peft": peft_v},
+        "preload": PRELOAD_MODEL,
+    })
+
 @app.get("/debug/session/set")
 def dbg_set():
     session.permanent = True
@@ -187,11 +241,8 @@ def login_post():
         u = s.query(User).filter_by(email=email).first()
         if not u or not verify_password(u, pwd):
             flash("Email atau password salah", "error"); return redirect(url_for("login_get"))
-
-        # penting: buat session 'permanent' supaya cookie ditulis dengan benar
         session.permanent = True
         session["uid"], session["email"] = u.id, u.email
-
     return redirect(url_for("index"))
 
 @app.get("/register")
@@ -237,23 +288,34 @@ def about_page():
 @app.post("/translate")
 def api_translate():
     if not session.get("uid"):
-        return jsonify({"error": "Unauthorized"}), 401
+        return jsonify({"ok": False, "error": "Unauthorized"}), 401
+
     payload = request.get_json(silent=True) or {}
     text = (payload.get("text") or "").strip()
     max_new = int(payload.get("max_new_tokens", 48))
     if not text:
-        return jsonify({"error": "Empty text"}), 400
+        return jsonify({"ok": False, "error": "Empty text"}), 400
+
     try:
         clean = prenorm(text)
-        mt = translate_with_model(clean, max_new_tokens=max_new)
+
+        # Jika ingin memastikan alur UI/DB dulu tanpa model:
+        if FALLBACK_TRANSLATE:
+            mt = f"[FAKE] {clean}"
+        else:
+            mt = translate_with_model(clean, max_new_tokens=max_new)
+
+        # simpan riwayat
         with SessionLocal() as s:
             s.add(Translation(user_id=session["uid"], src=text, mt=mt))
             s.commit()
-        return jsonify({"mt": mt})
-    except Exception:
-        log.exception("translate error")
-        return jsonify({"error": "server error"}), 500
+
+        return jsonify({"ok": True, "result": mt})
+    except Exception as e:
+        log.error("[API] translate error: %s", e)
+        log.error(traceback.format_exc())
+        # kirim error yang lebih informatif
+        return jsonify({"ok": False, "error": f"{type(e).__name__}: {e}"}), 500
 
 if __name__ == "__main__":
-    # Jalankan lokal: python app.py, atau di HF pakai gunicorn
     app.run(host="0.0.0.0", port=int(os.getenv("PORT", "7860")), debug=False)