Update app.py

app.py

@@ -1,71 +1,24 @@
 # =============================================================================
-# INDO-BLOOM PIPELINE v1.0 — INTEGRATED (SINGLE FILE)
+# INDO-BLOOM SPACE 1 — IBEX v2.4: Context Extractor
 #
-# Menggabungkan:
-#   TAB 1 — IBEX v2.4   : Ekstrak context bersih dari PDF BSE/Wikipedia
-#   TAB 2 — LocalQA v1.0: Generate QA pairs C1+C2 dari context (GPU lokal)
-#   TAB 3 — Pipeline    : Jalankan IBEX → QA sekaligus dari PDF ke corpus
+# Ekstrak context bersih (C2-ready) dari PDF BSE / Wikipedia.
+# Output: CSV yang bisa diunduh → upload ke Space 2 untuk generate QA.
 #
-# Requirements:
-#   pip install gradio pymupdf pandas transformers accelerate torch
-#
-# Kaggle: aktifkan GPU T4 di Settings → Accelerator
+# Hardware: CPU (tidak butuh GPU)
+# Requirements: gradio pymupdf pandas
 # =============================================================================
-
 import subprocess, sys
 subprocess.run([sys.executable, "-m", "pip", "install", "-q",
-                "gradio", "pymupdf", "pandas",
-                "transformers", "accelerate"], check=False)
+                "gradio", "pymupdf", "pandas"], check=False)
 
-import os, re, json, hashlib, time, tempfile
+import os, re, tempfile
 import pandas as pd
 import fitz          # PyMuPDF
 import gradio as gr
 
-# ── Lazy-load model (hanya saat Tab 2/3 dipakai) ──────────────────────────
-import torch
-_tokenizer = None
-_model     = None
-_device    = "cuda" if torch.cuda.is_available() else "cpu"
-MODEL_NAME = "Qwen/Qwen2.5-3B-Instruct"
-
-def muat_model():
-    global _tokenizer, _model
-    if _tokenizer is None:
-        from transformers import AutoTokenizer, AutoModelForCausalLM
-        print(f"🔄 Memuat {MODEL_NAME} ke {_device.upper()}...")
-        _tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
-
-        if _device == "cuda":
-            # GPU tersedia → load ke VRAM penuh, fp16
-            _model = AutoModelForCausalLM.from_pretrained(
-                MODEL_NAME,
-                torch_dtype=torch.float16,
-                device_map="cuda",
-                trust_remote_code=True,
-            )
-        else:
-            # CPU-only (HF Spaces gratis) → JANGAN pakai device_map="auto"
-            # device_map="auto" pada CPU menyebabkan layer offload ke 'meta'
-            # yang menghasilkan RuntimeError: Tensor on device cpu != meta
-            # Solusi: load ke CPU secara eksplisit tanpa device_map
-            _model = AutoModelForCausalLM.from_pretrained(
-                MODEL_NAME,
-                torch_dtype=torch.float32,   # fp32 lebih stabil di CPU
-                device_map=None,             # ← KUNCI: tidak pakai auto
-                low_cpu_mem_usage=True,      # kurangi peak RAM saat loading
-                trust_remote_code=True,
-            )
-            _model = _model.to("cpu")        # pastikan semua layer di CPU
-
-        _model.eval()
-        print(f"✅ Model siap di {_device.upper()}.")
-    return _tokenizer, _model
-
 # ══════════════════════════════════════════════════════════════════════════════
-# BAGIAN A — IBEX v2.4: KONSTANTA & FUNGSI EKSTRAKSI
+# KONSTANTA & POLA FILTER
 # ══════════════════════════════════════════════════════════════════════════════
-
 NOISE_BSE = [
     r'tujuan pembelajaran', r'setelah mempelajari',
     r'diharapkan (mampu|dapat)', r'kata kunci', r'pemetaan pikiran',
@@ -109,11 +62,12 @@ KALIMAT_INSTRUKSIONAL = [
     r'kalian\s+telah\s+(mengetahui|mempelajari|memahami)\s+bahwa',
     r'apa\s+yang\s+dimaksud.{0,80}\?$',
 ]
-KALIMAT_PATTERNS  = [re.compile(p, re.IGNORECASE) for p in KALIMAT_INSTRUKSIONAL]
-HEADER_BAB_PAT    = re.compile(r'bab\s+\d+\s*\|\s*[\w\s]+\d+', re.IGNORECASE)
-_MAPEL            = (r'sosiologi|matematika|fisika|kimia|biologi|sejarah|geografi|'
-                     r'ekonomi|pkn|pendidikan|prakarya|seni|bahasa')
-KATA_KUNCI_C2     = [
+KALIMAT_PATTERNS = [re.compile(p, re.IGNORECASE) for p in KALIMAT_INSTRUKSIONAL]
+HEADER_BAB_PAT   = re.compile(r'bab\s+\d+\s*\|\s*[\w\s]+\d+', re.IGNORECASE)
+_MAPEL = (r'sosiologi|matematika|fisika|kimia|biologi|sejarah|geografi|'
+          r'ekonomi|pkn|pendidikan|prakarya|seni|bahasa')
+
+KATA_KUNCI_C2 = [
     'karena','menyebabkan','berdampak','sehingga','mengakibatkan','berakibat',
     'oleh karena','disebabkan','bertujuan','berfungsi','berperan','berguna',
     'tujuan','fungsi','manfaat','peran','kegunaan','mekanisme','tahapan',
@@ -121,6 +75,9 @@ KATA_KUNCI_C2     = [
     'keterkaitan','mengapa','bagaimana','jelaskan','uraikan',
 ]
 
+# ══════════════════════════════════════════════════════��═══════════════════════
+# FUNGSI INTI IBEX
+# ══════════════════════════════════════════════════════════════════════════════
 def hitung_noise(t):
     return sum(1 for p in NOISE_PATTERNS if p.search(t))
 
@@ -162,10 +119,6 @@ def bersihkan_kalimat(teks):
 
 def ekstrak_context_dari_pdf(pdf_path, hal_mulai, hal_selesai,
                               chunk_size, batas_noise, nama_sumber="BSE"):
-    """
-    Core extractor IBEX v2.4.
-    Return: (df_chunks, pesan_status, tmp_csv_path)
-    """
     hal_mulai   = int(hal_mulai)
     hal_selesai = int(hal_selesai)
     chunk_size  = int(chunk_size)
@@ -180,7 +133,7 @@ def ekstrak_context_dari_pdf(pdf_path, hal_mulai, hal_selesai,
     if start >= end:
         return None, f"❌ Rentang tidak valid. PDF punya {total} halaman.", None
 
-    # Ekstrak teks
+    # Ekstrak teks per halaman
     teks_per_hal = []
     for num in range(start, end):
         page = doc.load_page(num)
@@ -209,9 +162,9 @@ def ekstrak_context_dari_pdf(pdf_path, hal_mulai, hal_selesai,
         while j < len(kalimat_list) and len(buf) < chunk_size:
             buf.extend(kalimat_list[j].split())
             j += 1
-        pot   = " ".join(buf)
-        wc    = len(buf)
-        noise = hitung_noise(pot)
+        pot    = " ".join(buf)
+        wc     = len(buf)
+        noise  = hitung_noise(pot)
         ada_c2 = any(k in pot.lower() for k in KATA_KUNCI_C2)
 
         if wc >= 50 and ada_c2:
@@ -239,163 +192,31 @@ def ekstrak_context_dari_pdf(pdf_path, hal_mulai, hal_selesai,
     if not chunk_meta:
         return None, (
             f"⚠️ Tidak ada context C2 bersih.\n"
-            f"   Dibuang L1: {bng_l1} | Dibuang L2: {bng_pendek}\n"
+            f"   Dibuang L1 (chunk): {bng_l1}\n"
+            f"   Dibuang L2 (kata) : {bng_pendek}\n"
             "   Coba perluas halaman atau naikkan toleransi noise."
         ), None
 
-    df = pd.DataFrame(chunk_meta)
-    tmp = os.path.join(tempfile.gettempdir(),
-                       f"IBEX_{nama.replace('.pdf','')}_hal{hal_mulai}-{hal_selesai}.csv")
+    df  = pd.DataFrame(chunk_meta)
+    tmp = os.path.join(
+        tempfile.gettempdir(),
+        f"IBEX_{nama.replace('.pdf','')}_hal{hal_mulai}-{hal_selesai}.csv"
+    )
     df.to_csv(tmp, index=False, encoding="utf-8-sig")
 
     pesan = (
-        f"✅ {end-start} hal dari '{nama}'\n"
-        f"🔍 Chunk bersih   : {len(chunk_meta)}\n"
-        f"🗑️  Buang L1 (chunk): {bng_l1}\n"
-        f"✂️  Buang L2 (kata) : {sum(r['kata_dibuang_l2'] for r in chunk_meta)}\n"
-        f"📊 Total kata     : {len(teks_gabung.split()):,}\n"
+        f"✅ Selesai! {end - start} halaman dari '{nama}'\n"
+        f"🔍 Chunk bersih       : {len(chunk_meta)}\n"
+        f"🗑️  Buang L1 (noise)  : {bng_l1}\n"
+        f"✂️  Buang L2 (kata)   : {sum(r['kata_dibuang_l2'] for r in chunk_meta)}\n"
+        f"📊 Total kata input   : {len(teks_gabung.split()):,}\n"
         f"💾 CSV siap diunduh."
     )
     return df, pesan, tmp
 
-
-# ══════════════════════════════════════════════════════════════════════════════
-# BAGIAN B — LOCAL QA: FUNGSI GENERATE
-# ══════════════════════════════════════════════════════════════════════════════
-
-SYSTEM_MSG = (
-    "Anda adalah pakar pembuatan soal Taksonomi Bloom Bahasa Indonesia. "
-    "Tugas Anda membuat soal yang tepat sesuai level kognitif yang diminta. "
-    "Selalu kembalikan output dalam format JSON yang valid."
-)
-
-def prompt_c1(konteks, n):
-    return (
-        f'Bacalah teks berikut:\n"""{konteks}"""\n\n'
-        f"Buat {n} pasang soal-jawaban level C1 (Mengingat).\n"
-        "Ketentuan C1:\n"
-        "- Pertanyaan diawali: apa, siapa, kapan, di mana, atau berapa\n"
-        "- Jawaban berupa fakta eksplisit dari teks (maks 15 kata)\n\n"
-        'Output JSON (tanpa teks lain):\n{"c1": [{"question": "...", "answer": "..."}, ...]}'
-    )
-
-def prompt_c2(konteks, n):
-    return (
-        f'Bacalah teks berikut:\n"""{konteks}"""\n\n'
-        f"Buat {n} pasang soal-jawaban level C2 (Memahami).\n"
-        "Ketentuan C2:\n"
-        "- Pertanyaan WAJIB diawali: mengapa atau bagaimana\n"
-        "- Jawaban menjelaskan sebab-akibat/proses, min 20 kata\n"
-        "- Jawaban HARUS mengandung: karena/sehingga/mengakibatkan/berdampak\n"
-        "- Jawaban dengan bahasa sendiri, BUKAN copy-paste teks\n\n"
-        'Output JSON (tanpa teks lain):\n{"c2": [{"question": "...", "answer": "..."}, ...]}'
-    )
-
-def generate_json(user_prompt):
-    tok, mdl = muat_model()
-    messages = [
-        {"role": "system", "content": SYSTEM_MSG},
-        {"role": "user",   "content": user_prompt},
-    ]
-    text   = tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    inputs = tok([text], return_tensors="pt").to(_device)
-    with torch.no_grad():
-        out = mdl.generate(
-            **inputs,
-            max_new_tokens=600,
-            temperature=0.7,
-            do_sample=True,
-            pad_token_id=tok.eos_token_id,
-        )
-    gen = out[0][inputs["input_ids"].shape[-1]:]
-    raw = tok.decode(gen, skip_special_tokens=True).strip()
-    s, e = raw.find('{'), raw.rfind('}') + 1
-    if s == -1:
-        return None
-    try:
-        return json.loads(raw[s:e])
-    except json.JSONDecodeError:
-        cleaned = re.sub(r',\s*([}\]])', r'\1', raw[s:e])
-        try:
-            return json.loads(cleaned)
-        except Exception:
-            return None
-
-def validasi_c1(q, a):
-    if not any(q.lower().startswith(s)
-               for s in ["apa","siapa","kapan","di mana","dimana","berapa"]):
-        return False, f"Tidak diawali kata tanya C1 ('{q[:30]}')"
-    if not (2 <= len(a.split()) <= 20):
-        return False, f"Jawaban {len(a.split())} kata (harusnya 2-20)"
-    return True, "OK"
-
-def validasi_c2(q, a):
-    if not any(q.lower().startswith(k) for k in ["mengapa","bagaimana"]):
-        return False, f"Tidak diawali 'Mengapa'/'Bagaimana' ('{q[:30]}')"
-    if len(a.split()) < 20:
-        return False, f"Jawaban terlalu pendek ({len(a.split())} kata)"
-    kausal = ['karena','sehingga','mengakibatkan','berdampak',
-              'akibatnya','dampaknya','disebabkan','mendorong','menyebabkan']
-    if not any(k in a.lower() for k in kausal):
-        return False, "Tidak ada penanda kausal"
-    return True, "OK"
-
-def proses_chunk_qa(chunk_id, konteks, n_c1, n_c2, source_type):
-    uid   = hashlib.md5(konteks.encode()).hexdigest()[:8]
-    valid, errors = [], []
-
-    prefix = "BSE" if "bse" in source_type.lower() else "WIKI"
-
-    for level, pfn, vfn, key, atype, label in [
-        ("C1", prompt_c1, validasi_c1, "c1", "extractive",  "Mengingat (Remembering)"),
-        ("C2", prompt_c2, validasi_c2, "c2", "abstractive", "Memahami (Understanding)"),
-    ]:
-        n = n_c1 if level == "C1" else n_c2
-        data = generate_json(pfn(konteks, n))
-        if data and key in data:
-            for item in data[key]:
-                q = item.get("question","").strip()
-                a = item.get("answer","").strip()
-                ok, alasan = vfn(q, a)
-                if ok:
-                    valid.append({
-                        "id"          : f"{prefix}-{chunk_id}-{uid}-{level}",
-                        "chunk_id"    : chunk_id,
-                        "source_type" : source_type,
-                        "bloom_level" : level,
-                        "bloom_label" : label,
-                        "answer_type" : atype,
-                        "question"    : q,
-                        "answer"      : a,
-                        "answer_words": len(a.split()),
-                        "context"     : konteks,
-                    })
-                else:
-                    errors.append({"chunk_id":chunk_id,"level":level,
-                                   "alasan":alasan,"q":q[:100],"a":a[:100]})
-        else:
-            errors.append({"chunk_id":chunk_id,"level":level,
-                           "alasan":f"Gagal parse JSON / key '{key}' tidak ada",
-                           "q":"","a":""})
-    return valid, errors
-
-def muat_output_csv(path):
-    if not os.path.exists(path) or os.path.getsize(path) == 0:
-        return set(), []
-    try:
-        df = pd.read_csv(path)
-        if df.empty or "chunk_id" not in df.columns:
-            return set(), []
-        print(f"♻️  Resume: {len(df)} baris sudah ada.")
-        return set(df["chunk_id"].tolist()), df.to_dict("records")
-    except Exception:
-        return set(), []
-
-
 # ══════════════════════════════════════════════════════════════════════════════
-# HANDLER GRADIO — TAB 1: IBEX EXTRACTOR
+# HANDLER GRADIO
 # ══════════════════════════════════════════════════════════════════════════════
-
 def handler_ekstrak(file_pdf, hal_mulai, hal_selesai,
                     chunk_size, batas_noise, sumber_tipe):
     if file_pdf is None:
@@ -410,388 +231,99 @@ def handler_ekstrak(file_pdf, hal_mulai, hal_selesai,
         )
         if df is None:
             return pesan, pd.DataFrame(), None
-        return pesan, df[["chunk_id","source_type","page_range",
-                           "word_count","noise_score","context"]], tmp
+        preview = df[["chunk_id", "source_type", "page_range",
+                       "word_count", "noise_score", "context"]]
+        return pesan, preview, tmp
     except Exception as ex:
         return f"❌ Error: {ex}", pd.DataFrame(), None
 
-def handler_unduh_ibex(pesan, df, path):
-    ada = path is not None and df is not None and not df.empty
-    return pesan, df, gr.update(visible=ada, value=path if ada else None)
-
-
-# ══════════════════════════════════════════════════════════════════════════════
-# HANDLER GRADIO — TAB 2: QA GENERATOR
-# ══════════════════════════════════════════════════════════════════════════════
-
-def handler_generate_qa(file_csv, n_c1, n_c2, chunk_mulai, chunk_selesai):
-    if file_csv is None:
-        return "❌ Harap unggah CSV hasil IBEX.", pd.DataFrame(), None
-
-    csv_path = file_csv if isinstance(file_csv, str) else file_csv.name
-    try:
-        df_in = pd.read_csv(csv_path)
-    except Exception as ex:
-        return f"❌ Gagal baca CSV: {ex}", pd.DataFrame(), None
-
-    if "context" not in df_in.columns:
-        return "❌ Kolom 'context' tidak ada. Pastikan file dari IBEX.", pd.DataFrame(), None
-
-    n_c1, n_c2 = int(n_c1), int(n_c2)
-    idx_start  = max(0, int(chunk_mulai) - 1)
-    idx_end    = min(len(df_in), int(chunk_selesai))
-    df_proses  = df_in.iloc[idx_start:idx_end].reset_index(drop=True)
-
-    out_path = os.path.join(tempfile.gettempdir(), "IndoBloom_QA_output.csv")
-    err_path = os.path.join(tempfile.gettempdir(), "IndoBloom_QA_errors.csv")
-    processed_ids, all_rows = muat_output_csv(out_path)
-    err_rows, logs = [], []
-
-    sisa = len(df_proses) - sum(1 for r in df_proses.itertuples()
-                                 if str(r.chunk_id) in processed_ids)
-    logs.append(f"⏱️  {sisa} chunk akan diproses (~{sisa*30//60} menit di GPU T4)")
-
-    for idx, row in df_proses.iterrows():
-        chunk_id    = str(row["chunk_id"])
-        konteks     = str(row["context"])
-        source_type = str(row.get("source_type", "BSE"))
-
-        if chunk_id in processed_ids:
-            logs.append(f"[{idx+1}] {chunk_id} — dilewati.")
-            continue
-
-        logs.append(f"[{idx+1}/{len(df_proses)}] {chunk_id}...")
-        t0 = time.time()
-        valid, errors = proses_chunk_qa(chunk_id, konteks, n_c1, n_c2, source_type)
-        elapsed = time.time() - t0
-
-        all_rows.extend(valid)
-        err_rows.extend(errors)
-        processed_ids.add(chunk_id)
-
-        c1ok = sum(1 for r in valid  if r["bloom_level"]=="C1")
-        c2ok = sum(1 for r in valid  if r["bloom_level"]=="C2")
-        c1er = sum(1 for e in errors if e["level"]=="C1")
-        c2er = sum(1 for e in errors if e["level"]=="C2")
-        logs.append(f"  ✅ C1:{c1ok}(✗{c1er}) C2:{c2ok}(✗{c2er}) | {elapsed:.0f}s")
-        for r in valid:
-            logs.append(f"     [{r['bloom_level']}] Q: {r['question'][:70]}")
-            logs.append(f"           A: {r['answer'][:70]}")
-
-        if len(all_rows) % 5 == 0 and all_rows:
-            pd.DataFrame(all_rows).to_csv(out_path, index=False, encoding="utf-8-sig")
-            logs.append(f"  💾 Checkpoint: {len(all_rows)} QA.")
-
-    if not all_rows:
-        return "❌ Tidak ada QA yang berhasil digenerate.", pd.DataFrame(), None
-
-    df_out = pd.DataFrame(all_rows)
-    df_out.to_csv(out_path, index=False, encoding="utf-8-sig")
-    if err_rows:
-        pd.DataFrame(err_rows).to_csv(err_path, index=False, encoding="utf-8-sig")
-
-    c1t = len(df_out[df_out["bloom_level"]=="C1"])
-    c2t = len(df_out[df_out["bloom_level"]=="C2"])
-    pesan = "\n".join([
-        f"✅ SELESAI — {len(df_out)} QA dihasilkan",
-        f"   C1: {c1t} | C2: {c2t}",
-        f"   Rata-rata jawaban: {df_out['answer_words'].mean():.1f} kata",
-        f"   Error: {len(err_rows)}",
-        "─" * 40,
-        *logs[-30:],   # tampilkan 30 log terakhir
-    ])
-    preview = df_out[["chunk_id","bloom_level","question","answer"]].head(20)
-    return pesan, preview, out_path
-
-def handler_unduh_qa(pesan, df, path):
+def handler_unduh(pesan, df, path):
     ada = path is not None and df is not None and not df.empty
     return pesan, df, gr.update(visible=ada, value=path if ada else None)
 
-
-# ══════════════════════════════════════════════════════════════════════════════
-# HANDLER GRADIO — TAB 3: PIPELINE (PDF → CONTEXT → QA)
-# ══════════════════════════════════════════════════════════════════════════════
-
-def handler_pipeline(file_pdf, hal_mulai, hal_selesai, chunk_size,
-                     batas_noise, sumber_tipe, n_c1, n_c2):
-    if file_pdf is None:
-        return "❌ Harap unggah file PDF.", pd.DataFrame(), None
-
-    logs = ["🚀 PIPELINE DIMULAI", "─"*40]
-
-    # STEP 1: Ekstrak context
-    logs.append("📄 STEP 1: Ekstrak context dari PDF...")
-    try:
-        pdf_path = file_pdf if isinstance(file_pdf, str) else file_pdf.name
-        df_ctx, pesan_ibex, _ = ekstrak_context_dari_pdf(
-            pdf_path, hal_mulai, hal_selesai,
-            chunk_size, batas_noise, sumber_tipe
-        )
-    except Exception as ex:
-        return f"❌ Gagal ekstrak: {ex}", pd.DataFrame(), None
-
-    if df_ctx is None:
-        return f"❌ Ekstrak gagal:\n{pesan_ibex}", pd.DataFrame(), None
-
-    logs.append(pesan_ibex)
-    logs.append(f"✅ {len(df_ctx)} chunk siap di-generate")
-    logs.append("─"*40)
-
-    # STEP 2: Generate QA
-    logs.append("🧠 STEP 2: Generate QA pairs (C1+C2)...")
-    all_rows, err_rows = [], []
-    n_c1, n_c2 = int(n_c1), int(n_c2)
-
-    for idx, row in df_ctx.iterrows():
-        chunk_id    = str(row["chunk_id"])
-        konteks     = str(row["context"])
-        source_type = str(row.get("source_type", sumber_tipe))
-
-        logs.append(f"[{idx+1}/{len(df_ctx)}] {chunk_id}...")
-        t0 = time.time()
-        valid, errors = proses_chunk_qa(chunk_id, konteks, n_c1, n_c2, source_type)
-        elapsed = time.time() - t0
-
-        all_rows.extend(valid)
-        err_rows.extend(errors)
-
-        c1ok = sum(1 for r in valid if r["bloom_level"]=="C1")
-        c2ok = sum(1 for r in valid if r["bloom_level"]=="C2")
-        logs.append(f"  ✅ C1:{c1ok} C2:{c2ok} | {elapsed:.0f}s")
-        for r in valid:
-            logs.append(f"     [{r['bloom_level']}] {r['question'][:65]}")
-
-    if not all_rows:
-        return "❌ Tidak ada QA berhasil.", pd.DataFrame(), None
-
-    df_out = pd.DataFrame(all_rows)
-    out_path = os.path.join(
-        tempfile.gettempdir(),
-        f"IndoBloom_Pipeline_{os.path.basename(pdf_path).replace('.pdf','')}.csv"
-    )
-    df_out.to_csv(out_path, index=False, encoding="utf-8-sig")
-
-    c1t = len(df_out[df_out["bloom_level"]=="C1"])
-    c2t = len(df_out[df_out["bloom_level"]=="C2"])
-    logs += [
-        "─"*40,
-        f"✅ PIPELINE SELESAI",
-        f"   Total QA : {len(df_out)} pairs",
-        f"   C1       : {c1t} | C2: {c2t}",
-        f"   Error    : {len(err_rows)}",
-        f"   Output   : {out_path}",
-    ]
-    pesan  = "\n".join(logs)
-    preview = df_out[["chunk_id","bloom_level","question","answer"]].head(20)
-    return pesan, preview, out_path
-
-def handler_unduh_pipeline(pesan, df, path):
-    ada = path is not None and df is not None and not df.empty
-    return pesan, df, gr.update(visible=ada, value=path if ada else None)
-
-
 # ══════════════════════════════════════════════════════════════════════════════
-# ANTARMUKA GRADIO
+# UI GRADIO
 # ══════════════════════════════════════════════════════════════════════════════
-
-with gr.Blocks(title="Indo-Bloom Pipeline v1.0") as app:
+with gr.Blocks(title="IBEX v2.4 — Indo-Bloom Context Extractor") as app:
+    csv_state = gr.State(None)
 
     gr.Markdown("""
-    # 🌿 Indo-Bloom Pipeline v1.0
-    **PDF → Context Extractor → QA Generator | Tanpa API Key | GPU Lokal**
+    # 📄 IBEX v2.4 — Indo-Bloom Context Extractor
+    Ekstrak teks eksplanatori **(C2-ready)** dari PDF BSE Kemendikbud atau Wikipedia.
+    Filter 2 level: buang chunk noise → bersihkan kalimat instruksional per kalimat.
 
-    Pipeline terintegrasi untuk membangun corpus AQG Bloom's Taxonomy Bahasa Indonesia.
-    Mendukung sumber **BSE Kemendikbud** dan **Wikipedia** (PDF).
+    **Alur kerja:**
+    `Upload PDF` → `Atur parameter` → `Ekstrak` → `Unduh CSV` → *upload ke Space QA Generator*
     """)
 
-    # ── Shared State ─────────────────────────────────────────────────────
-    ibex_csv_state     = gr.State(None)
-    qa_csv_state       = gr.State(None)
-    pipeline_csv_state = gr.State(None)
-
-    with gr.Tabs():
-
-        # ════════════════════════════════════════════════════════════════
-        # TAB 1 — IBEX EXTRACTOR
-        # ════════════════════════════════════════════════════════════════
-        with gr.TabItem("📄 Tab 1 — IBEX: Ekstrak Context"):
-            gr.Markdown("""
-            ### IBEX v2.4 — Indo-Bloom Context Extractor
-            Ekstrak teks eksplanatori (C2-ready) dari **PDF BSE atau Wikipedia**.
-            Filter 2 level: buang noise BSE + bersihkan kalimat instruksional.
-            """)
-            with gr.Row():
-                with gr.Column(scale=1):
-                    t1_pdf    = gr.File(label="📂 Upload PDF", file_types=[".pdf"])
-                    t1_sumber = gr.Radio(
-                        choices=["BSE", "Wikipedia", "Lainnya"],
-                        value="BSE", label="Tipe Sumber"
-                    )
-                    with gr.Row():
-                        t1_hal1 = gr.Number(label="Hal. Mulai",   value=1,  precision=0, minimum=1)
-                        t1_hal2 = gr.Number(label="Hal. Selesai", value=20, precision=0, minimum=1)
-                    t1_chunk = gr.Slider(50, 300, value=150, step=10,
-                                         label="Kata per Chunk",
-                                         info="Rekomendasi 100–200. Overlap 25% otomatis.")
-                    t1_noise = gr.Slider(1, 6, value=2, step=1,
-                                         label="Toleransi Noise",
-                                         info="1–2=ketat | 3–4=sedang | 5–6=longgar")
-                    t1_btn   = gr.Button("🚀 Ekstrak Context", variant="primary", size="lg")
-
-                with gr.Column(scale=2):
-                    t1_status = gr.Textbox(label="Status", lines=7, interactive=False)
-                    t1_unduh  = gr.DownloadButton("⬇️ Unduh CSV Context",
-                                                   variant="secondary", visible=False)
-                    t1_tabel  = gr.Dataframe(label="Preview Chunks", interactive=False, wrap=True)
-
-            t1_btn.click(
-                fn=handler_ekstrak,
-                inputs=[t1_pdf, t1_hal1, t1_hal2, t1_chunk, t1_noise, t1_sumber],
-                outputs=[t1_status, t1_tabel, ibex_csv_state]
-            ).then(
-                fn=handler_unduh_ibex,
-                inputs=[t1_status, t1_tabel, ibex_csv_state],
-                outputs=[t1_status, t1_tabel, t1_unduh]
+    with gr.Row():
+        # ── Kolom kiri: kontrol ──────────────────────────────────────────────
+        with gr.Column(scale=1):
+            pdf_input  = gr.File(label="📂 Upload PDF (BSE / Wikipedia)", file_types=[".pdf"])
+            sumber_tipe = gr.Radio(
+                choices=["BSE", "Wikipedia", "Lainnya"],
+                value="BSE", label="Tipe Sumber"
             )
-
-        # ════════════════════════════════════════════════════════════════
-        # TAB 2 — QA GENERATOR
-        # ════════════════════════════════════════════════════════════════
-        with gr.TabItem("🧠 Tab 2 — QA Generator (GPU Lokal)"):
-            gr.Markdown("""
-            ### Local QA Generator v1.0
-            Generate pasangan **Q&A level C1 + C2** dari CSV context hasil IBEX.
-            Model: **Qwen2.5-3B-Instruct** — lokal, tanpa API key, tanpa rate limit.
-            > ⚠️ Aktifkan **GPU T4** di Kaggle: Settings → Accelerator → GPU T4
-            """)
             with gr.Row():
-                with gr.Column(scale=1):
-                    t2_csv = gr.File(label="📂 Upload CSV Hasil IBEX", file_types=[".csv"])
-                    with gr.Row():
-                        t2_c1 = gr.Slider(1, 5, value=2, step=1, label="QA C1 per Chunk")
-                        t2_c2 = gr.Slider(1, 5, value=2, step=1, label="QA C2 per Chunk")
-                    with gr.Row():
-                        t2_cm = gr.Number(label="Chunk Mulai",   value=1, precision=0, minimum=1)
-                        t2_cs = gr.Number(label="Chunk Selesai", value=999, precision=0, minimum=1)
-                    t2_btn = gr.Button("🚀 Generate QA", variant="primary", size="lg")
-                    gr.Markdown("*~30s/chunk di GPU T4. Resume otomatis jika terganggu.*")
-
-                with gr.Column(scale=2):
-                    t2_status = gr.Textbox(label="Log & Status", lines=12, interactive=False)
-                    t2_unduh  = gr.DownloadButton("⬇️ Unduh CSV QA Corpus",
-                                                   variant="secondary", visible=False)
-                    t2_tabel  = gr.Dataframe(label="Preview QA Pairs", interactive=False, wrap=True)
-
-            t2_btn.click(
-                fn=handler_generate_qa,
-                inputs=[t2_csv, t2_c1, t2_c2, t2_cm, t2_cs],
-                outputs=[t2_status, t2_tabel, qa_csv_state]
-            ).then(
-                fn=handler_unduh_qa,
-                inputs=[t2_status, t2_tabel, qa_csv_state],
-                outputs=[t2_status, t2_tabel, t2_unduh]
-            )
+                hal_mulai   = gr.Number(label="Hal. Mulai",   value=1,  precision=0, minimum=1)
+                hal_selesai = gr.Number(label="Hal. Selesai", value=20, precision=0, minimum=1)
+            chunk_size  = gr.Slider(50, 300, value=150, step=10,
+                                    label="Kata per Chunk",
+                                    info="Rekomendasi 100–200. Overlap 25% otomatis.")
+            batas_noise = gr.Slider(1, 6, value=2, step=1,
+                                    label="Toleransi Noise",
+                                    info="1–2=ketat (BSE) | 3–4=sedang | 5–6=longgar (Wiki)")
+            btn_ekstrak = gr.Button("🚀 Ekstrak Context", variant="primary", size="lg")
 
-        # ════════════════════════════════════════════════════════════════
-        # TAB 3 — FULL PIPELINE
-        # ════════════════════════════════════════════════════════════════
-        with gr.TabItem("⚡ Tab 3 — Full Pipeline (PDF → QA)"):
             gr.Markdown("""
-            ### Full Pipeline: PDF → Context → QA Corpus (Satu Klik)
-            Jalankan **IBEX + QA Generator** sekaligus dari file PDF.
-            Cocok untuk batch processing banyak halaman BSE/Wikipedia.
+            ---
+            ### 💡 Tips
+            | Sumber | Noise | Chunk |
+            |--------|-------|-------|
+            | BSE Kemendikbud | 2 | 150 |
+            | Wikipedia PDF   | 4 | 200 |
+
+            Setelah unduh CSV, upload ke **Space QA Generator** untuk generate soal C1+C2.
             """)
-            with gr.Row():
-                with gr.Column(scale=1):
-                    t3_pdf    = gr.File(label="📂 Upload PDF", file_types=[".pdf"])
-                    t3_sumber = gr.Radio(
-                        choices=["BSE", "Wikipedia", "Lainnya"],
-                        value="BSE", label="Tipe Sumber"
-                    )
-                    gr.Markdown("**⚙️ Pengaturan Ekstraksi**")
-                    with gr.Row():
-                        t3_hal1 = gr.Number(label="Hal. Mulai",   value=1,  precision=0, minimum=1)
-                        t3_hal2 = gr.Number(label="Hal. Selesai", value=20, precision=0, minimum=1)
-                    t3_chunk = gr.Slider(50, 300, value=150, step=10, label="Kata per Chunk")
-                    t3_noise = gr.Slider(1, 6, value=2, step=1, label="Toleransi Noise")
-                    gr.Markdown("**🧠 Pengaturan Generate**")
-                    with gr.Row():
-                        t3_c1 = gr.Slider(1, 5, value=2, step=1, label="QA C1 per Chunk")
-                        t3_c2 = gr.Slider(1, 5, value=2, step=1, label="QA C2 per Chunk")
-                    t3_btn = gr.Button("⚡ Jalankan Full Pipeline",
-                                        variant="primary", size="lg")
-
-                with gr.Column(scale=2):
-                    t3_status = gr.Textbox(label="Log Pipeline", lines=14, interactive=False)
-                    t3_unduh  = gr.DownloadButton("⬇️ Unduh QA Corpus Final",
-                                                   variant="secondary", visible=False)
-                    t3_tabel  = gr.Dataframe(label="Preview Hasil", interactive=False, wrap=True)
-
-            t3_btn.click(
-                fn=handler_pipeline,
-                inputs=[t3_pdf, t3_hal1, t3_hal2, t3_chunk,
-                        t3_noise, t3_sumber, t3_c1, t3_c2],
-                outputs=[t3_status, t3_tabel, pipeline_csv_state]
-            ).then(
-                fn=handler_unduh_pipeline,
-                inputs=[t3_status, t3_tabel, pipeline_csv_state],
-                outputs=[t3_status, t3_tabel, t3_unduh]
+
+        # ── Kolom kanan: output ──────────────────────────────────────────────
+        with gr.Column(scale=2):
+            status_box = gr.Textbox(label="Status Ekstraksi", lines=8, interactive=False)
+            unduh_btn  = gr.DownloadButton(
+                "⬇️ Unduh CSV Context (upload ke Space QA Generator)",
+                variant="secondary", visible=False
+            )
+            preview    = gr.Dataframe(
+                label="Preview Chunks (10 pertama)", interactive=False, wrap=True
             )
 
-        # ════════════════════════════════════════════════════════════════
-        # TAB 4 — PANDUAN
-        # ════════════════════════════════════════════════════════════════
-        with gr.TabItem("ℹ️ Panduan"):
-            gr.Markdown("""
-            ## 🗺️ Alur Kerja Indo-Bloom Pipeline
-
-            ```
-            PDF (BSE/Wikipedia)
-                ↓
-            [Tab 1 — IBEX v2.4]  ←  Filter noise BSE, bersihkan kalimat instruksional
-                ↓ CSV Context Bersih
-            [Tab 2 — QA Generator]  ←  Qwen2.5-3B-Instruct, GPU lokal, tanpa API
-                ↓ CSV QA Corpus
-            Indo-Bloom Silver Corpus (C1 + C2)
-
-            Atau gunakan [Tab 3 — Full Pipeline] untuk satu klik dari PDF ke QA.
-            ```
-
-            ## 📋 Format Output CSV
-
-            | Kolom | Keterangan |
-            |---|---|
-            | `id` | ID unik sampel (prefix sumber + hash) |
-            | `chunk_id` | ID chunk dari IBEX |
-            | `source_type` | BSE / Wikipedia / Lainnya |
-            | `bloom_level` | C1 atau C2 |
-            | `bloom_label` | Label lengkap Bloom |
-            | `answer_type` | extractive (C1) / abstractive (C2) |
-            | `question` | Pertanyaan Bahasa Indonesia |
-            | `answer` | Jawaban berdasarkan konteks |
-            | `answer_words` | Jumlah kata jawaban |
-            | `context` | Teks sumber (untuk validasi) |
-
-            ## 🎚️ Tips Penggunaan
-
-            **Untuk BSE (Buku Sekolah Elektronik):**
-            - Toleransi Noise: **2** (default) — ketat untuk menyaring instruksi siswa
-            - Chunk size: **150 kata** — cukup untuk context C2
-
-            **Untuk Wikipedia (PDF):**
-            - Toleransi Noise: **4** — Wikipedia lebih bersih, bisa lebih longgar
-            - Chunk size: **200 kata** — paragraf Wikipedia biasanya lebih panjang
-            - Pilih **"Wikipedia"** di Tipe Sumber agar ID corpus tercatat benar
-
-            ## ⚠️ Catatan GPU
-            Model Qwen2.5-3B-Instruct membutuhkan GPU untuk kecepatan optimal.
-            Di Kaggle: **Settings → Accelerator → GPU T4** sebelum menjalankan Tab 2/3.
-            Di CPU: tetap berjalan tapi ~5-10x lebih lambat per chunk.
-            """)
+    btn_ekstrak.click(
+        fn=handler_ekstrak,
+        inputs=[pdf_input, hal_mulai, hal_selesai, chunk_size, batas_noise, sumber_tipe],
+        outputs=[status_box, preview, csv_state]
+    ).then(
+        fn=handler_unduh,
+        inputs=[status_box, preview, csv_state],
+        outputs=[status_box, preview, unduh_btn]
+    )
+
+    gr.Markdown("""
+    ---
+    ### 📋 Format Kolom Output CSV
+    | Kolom | Keterangan |
+    |---|---|
+    | `chunk_id` | ID unik chunk (chunk_0001, dst.) |
+    | `source_file` | Nama file PDF asal |
+    | `source_type` | BSE / Wikipedia / Lainnya |
+    | `page_range` | Rentang halaman yang diekstrak |
+    | `word_count` | Jumlah kata setelah dibersihkan |
+    | `noise_score` | Skor noise akhir (idealnya < batas) |
+    | `kata_dibuang_l2` | Kata yang dibuang di filter L2 |
+    | `context` | Teks context bersih siap di-generate |
+    """)
 
 if __name__ == "__main__":
     app.launch(
         share=False,
         theme=gr.themes.Soft(primary_hue="teal"),
-        css=".tab-nav button { font-size: 15px; font-weight: 600; }"
     )