12

app.py

@@ -1,149 +1,213 @@
-# app.py — PapuaTranslate (HF Spaces, Flask)
-import os, logging
-from functools import lru_cache
-from typing import Optional
-from flask import (
-    Flask, render_template, request, redirect, url_for,
-    session, flash, jsonify
-)
-from werkzeug.security import check_password_hash, generate_password_hash
-
-# --- SQLAlchemy (opsional: Supabase Postgres) ---
-from sqlalchemy import create_engine, text
-from sqlalchemy.exc import SQLAlchemyError
-
-# --- Model (lazy load) ---
-import torch
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-from peft import PeftModel
+# app.py
+import os, re, json, logging, threading
+from datetime import datetime, timezone
+from functools import wraps
+from typing import Optional, Tuple, List
+from flask import Flask, render_template, request, redirect, url_for, session, jsonify, flash
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
-log = logging.getLogger("papua-translate")
-
-# ================== ENV ==================
-SECRET_KEY     = os.getenv("SECRET_KEY", "dev-secret-please-set")
-DATABASE_URL   = os.getenv("DATABASE_URL", "")  # e.g. postgresql+psycopg2://user:pass@host:6543/postgres?sslmode=require
-BASE_MODEL_ID  = os.getenv("BASE_MODEL_ID", "google/mt5-small")
-ADAPTER_ID     = os.getenv("ADAPTER_ID", "")    # e.g. your LoRA on HF
-DISABLE_AUTH   = os.getenv("DISABLE_AUTH", "false").lower() in ("1", "true", "yes")
+log = logging.getLogger("papua-app")
 
-# ================== APP ==================
+# ==== GANTI: pakai folder 'templates' (atau pastikan file HTML ada di 'frontend') ====
 app = Flask(__name__, template_folder="templates", static_folder="static")
-app.secret_key = SECRET_KEY
 
-# Cookie settings aman untuk HF (HTTPS)
+# cookie aman di HF (HTTPS). Untuk lokal bisa set False via ENV.
+SESSION_SECURE = os.getenv("SESSION_COOKIE_SECURE", "true").lower() in ("1","true","yes")
 app.config.update(
-    SESSION_COOKIE_HTTPONLY=True,
+    SECRET_KEY=os.getenv("SECRET_KEY", "dev-secret-change-me"),
     SESSION_COOKIE_SAMESITE="Lax",
-    SESSION_COOKIE_SECURE=True,  # HF pakai HTTPS
-    PERMANENT_SESSION_LIFETIME=60*60*8,  # 8 jam
+    SESSION_COOKIE_SECURE=SESSION_SECURE,
 )
 
-# ================== DB (opsional) ==================
-engine = None
-if DATABASE_URL:
-    try:
-        engine = create_engine(DATABASE_URL, pool_pre_ping=True, pool_recycle=1800)
-        with engine.connect() as conn:
-            conn.execute(text("SELECT 1"))
-        log.info("[DB] Connected OK")
-    except SQLAlchemyError as e:
-        log.error(f"[DB] Failed: {e}")
-
-# ================== AUTH MOCK ==================
-# Untuk demo: 1 user statis via ENV (atau bisa kamu simpan di DB)
-ADMIN_USER = os.getenv("ADMIN_USER", "admin@example.com")
-ADMIN_PASS_HASH = os.getenv("ADMIN_PASS_HASH", generate_password_hash(os.getenv("ADMIN_PASS", "admin123")))
-
-def is_logged_in() -> bool:
-    return bool(session.get("uid"))
-
-# ================== LAZY MODEL ==================
-@lru_cache(maxsize=1)
+# ================= DB =================
+from sqlalchemy import create_engine, Column, Integer, Text, DateTime, ForeignKey, func
+from sqlalchemy.orm import declarative_base, sessionmaker, scoped_session, relationship
+
+DATABASE_URL = os.getenv("DATABASE_URL") or os.getenv("DB_URL")
+if not DATABASE_URL:
+    DATABASE_URL = "sqlite:////tmp/app.db"
+    log.warning("[DB] DATABASE_URL tidak diset; pakai SQLite /tmp/app.db")
+else:
+    # normalisasi skema lama
+    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"
+
+engine = create_engine(DATABASE_URL, pool_pre_ping=True)
+SessionLocal = scoped_session(sessionmaker(bind=engine, autoflush=False, autocommit=False))
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True)
+    email = Column(Text, unique=True, nullable=False)
+    pass_hash = Column(Text, nullable=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+class Translation(Base):
+    __tablename__ = "translations"
+    id = Column(Integer, primary_key=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    src = Column(Text, nullable=False)
+    mt  = Column(Text, nullable=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    user = relationship("User")
+
+try:
+    Base.metadata.create_all(engine)
+    log.info("[DB] Ready: %s", DATABASE_URL)
+except Exception as e:
+    log.exception("[DB] init error: %s", e)
+
+# ================= Auth =================
+from werkzeug.security import generate_password_hash, check_password_hash
+def set_password(user: User, raw: str): user.pass_hash = generate_password_hash(raw)
+def verify_password(user: User, raw: str) -> bool:
+    try: return check_password_hash(user.pass_hash, raw)
+    except Exception: return False
+
+def login_required(fn):
+    @wraps(fn)
+    def _wrap(*args, **kwargs):
+        if not session.get("uid"):
+            return redirect(url_for("login_get"))
+        return fn(*args, **kwargs)
+    return _wrap
+
+# ================= 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",
+}
+def prenorm(text: str) -> str:
+    t = re.sub(r"\s+", " ", text.strip())
+    t = t.replace("…","...").replace("–","-").replace("—","-")
+    for pat, repl in PAPUA_MAP.items(): t = re.sub(pat, repl, t, flags=re.IGNORECASE)
+    return t
+
+# ================= Model (lazy) =================
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+from peft import PeftModel
+
+BASE_MODEL_ID = os.getenv("BASE_MODEL_ID", "amosnbn/cendol-mt5-base-inst")
+ADAPTER_ID    = os.getenv("ADAPTER_ID", "amosnbn/papua-lora-ckpt-168")
+DEVICE        = "cuda" if os.getenv("DEVICE","cpu") == "cuda" else "cpu"
+TOK = None; MODEL = None; _MODEL_LOCK = threading.Lock()
+
 def _load_model():
-    """
-    Load base mT5 + attach LoRA (jika ada). Diload sekali saat dipakai pertama kali.
-    """
-    log.info(f"[MODEL] Loading base: {BASE_MODEL_ID}")
-    tok = AutoTokenizer.from_pretrained(BASE_MODEL_ID)
+    global TOK, MODEL
+    log.info("[MODEL] loading base=%s adapter=%s", BASE_MODEL_ID, ADAPTER_ID)
+    TOK = AutoTokenizer.from_pretrained(BASE_MODEL_ID)
     base = AutoModelForSeq2SeqLM.from_pretrained(BASE_MODEL_ID)
-    if ADAPTER_ID:
-        log.info(f"[MODEL] Attaching LoRA: {ADAPTER_ID}")
-        base = PeftModel.from_pretrained(base, ADAPTER_ID)
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    base.to(device)
-    base.eval()
-    log.info(f"[MODEL] Ready on {device}")
-    return tok, base, device
-
-def translate_text(input_text: str, max_new_tokens: int = 64) -> str:
-    tok, model, device = _load_model()
-    inputs = tok(input_text, return_tensors="pt", truncation=True).to(device)
-    with torch.no_grad():
-        out = model.generate(
-            **inputs,
-            max_new_tokens=max_new_tokens,
-            num_beams=4,
-            length_penalty=1.0
-        )
-    return tok.decode(out[0], skip_special_tokens=True)
-
-# ================== ROUTES ==================
-@app.route("/")
-def home():
-    # Jika auth dimatikan, langsung ke dashboard
-    if DISABLE_AUTH or is_logged_in():
-        return redirect(url_for("dashboard"))
-    return redirect(url_for("login"))
-
-@app.route("/login", methods=["GET", "POST"])
-def login():
-    if DISABLE_AUTH:
-        session["uid"] = "debug-user"
-        return redirect(url_for("dashboard"))
-
-    if request.method == "POST":
-        email = request.form.get("email", "").strip().lower()
-        password = request.form.get("password", "")
-        if email == ADMIN_USER and check_password_hash(ADMIN_PASS_HASH, password):
-            session["uid"] = email
-            return redirect(url_for("dashboard"))
-        flash("Email atau password salah.", "error")
-        return render_template("login.html")
-    return render_template("login.html")
-
-@app.route("/logout")
-def logout():
-    session.clear()
-    flash("Anda telah keluar.", "info")
-    return redirect(url_for("login"))
-
-@app.route("/dashboard")
-def dashboard():
-    if not (DISABLE_AUTH or is_logged_in()):
-        return redirect(url_for("login"))
-    return render_template("dashboard.html")
-
-@app.route("/translate", methods=["POST"])
+    MODEL = PeftModel.from_pretrained(base, ADAPTER_ID)
+    MODEL.eval().to(DEVICE)
+    log.info("[MODEL] ready on %s", DEVICE)
+
+def get_model():
+    global MODEL
+    if MODEL is None:
+        with _MODEL_LOCK:
+            if MODEL is None: _load_model()
+    return TOK, MODEL
+
+def translate_with_model(text: str, max_new_tokens: int = 48) -> str:
+    tok, m = get_model()
+    inputs = tok([text], return_tensors="pt").to(DEVICE)
+    outputs = m.generate(
+        **inputs, max_new_tokens=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)
+
+# ================= Utilities =================
+@app.before_request
+def _log_req():
+    if request.path not in ("/health", "/ping", "/favicon.ico"):
+        log.info("[REQ] %s %s", request.method, request.path)
+
+@app.errorhandler(Exception)
+def _err(e):
+    # supaya 500 kelihatan jelas di Logs HF
+    log.exception("Unhandled error")
+    return "Internal Server Error", 500
+
+# ================= Routes =================
+@app.get("/health"); @app.get("/ping")
+def health(): return jsonify({"ok": True, "time": datetime.now(timezone.utc).isoformat()})
+
+@app.get("/login")
+def login_get(): return render_template("login.html")
+
+@app.post("/login")
+def login_post():
+    email = (request.form.get("email") or "").strip().lower()
+    pwd   = request.form.get("password") or ""
+    if not email or not pwd:
+        flash("Isi email dan password", "error"); return redirect(url_for("login_get"))
+    with SessionLocal() as s:
+        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"))
+        session["uid"], session["email"] = u.id, u.email
+        return redirect(url_for("index"))
+
+@app.get("/register")
+def register_get(): return render_template("register.html")
+
+@app.post("/register")
+def register_post():
+    email = (request.form.get("email") or "").strip().lower()
+    pwd   = request.form.get("password") or ""
+    if not email or not pwd:
+        flash("Isi email dan password", "error"); return redirect(url_for("register_get"))
+    with SessionLocal() as s:
+        if s.query(User).filter_by(email=email).first():
+            flash("Email sudah terdaftar", "error"); return redirect(url_for("register_get"))
+        u = User(email=email); set_password(u, pwd); s.add(u); s.commit()
+        session["uid"], session["email"] = u.id, u.email
+    return redirect(url_for("index"))
+
+@app.get("/logout")
+def logout(): session.clear(); return redirect(url_for("login_get"))
+
+@app.get("/")
+@login_required
+def index():
+    with SessionLocal() as s:
+        uid = session["uid"]
+        items = (s.query(Translation)
+                   .filter(Translation.user_id == uid)
+                   .order_by(Translation.id.desc()).limit(10).all())
+        data = [{"src": it.src, "mt": it.mt, "created_at": it.created_at} for it in items]
+    # ==== GANTI: kirim variabel yang dipakai template ====
+    return render_template("index.html",
+                           user=session.get("email"),
+                           data=data,
+                           device=DEVICE)
+
+@app.get("/about")
+def about_page(): return render_template("about.html")
+
+@app.post("/translate")
 def api_translate():
-    if not (DISABLE_AUTH or is_logged_in()):
-        return jsonify({"ok": False, "error": "Unauthorized"}), 401
-    data = request.get_json(silent=True) or {}
-    text = (data.get("text") or "").strip()
-    if not text:
-        return jsonify({"ok": False, "error": "Text kosong"}), 400
+    if not session.get("uid"): return jsonify({"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
     try:
-        result = translate_text(text)
-        return jsonify({"ok": True, "result": result})
+        clean = prenorm(text); mt = translate_with_model(clean, max_new_tokens=max_new)
+        with SessionLocal() as s:
+            s.add(Translation(user_id=session["uid"], src=text, mt=mt)); s.commit()
+        return jsonify({"mt": mt})
     except Exception as e:
-        log.exception("Translate error")
-        return jsonify({"ok": False, "error": str(e)}), 500
-
-@app.route("/about")
-def about():
-    return render_template("about.html")
+        log.exception("translate error")
+        return jsonify({"error": "server error"}), 500
 
-# --- local run (Spaces akan pakai gunicorn) ---
 if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 7860))
-    app.run(host="0.0.0.0", port=port, debug=False)
+    app.run(host="0.0.0.0", port=int(os.getenv("PORT","7860")), debug=False)