Update app.py

app.py

@@ -5,8 +5,9 @@ IPLM 2025 — FINAL (NO UPLOAD) — FULL REWRITE (NO RINGKAS)
 ✅ Jenis tampil: sekolah, umum, khusus (khusus ditampilkan sebagai jenis)
 ✅ Indeks dasar per entitas: Yeo-Johnson + MinMax nasional per indikator
 ✅ Agregasi wilayah (mean) → BARU penyesuaian 68% berbasis TOTAL pengumpulan wilayah:
-   faktor_penyesuaian = (jumlah_sampel / jumlah_sampel_68%) × 100  (dibatasi maks 100)
-   Indeks_Final_Wilayah = Indeks_Dasar_Agregat × (faktor_penyesuaian/100)
+   faktor_penyesuaian_% = min((n_total_terkumpul / target_total_68) * 100, 100)
+   Indeks_Final_Wilayah = Indeks_Dasar_Agregat * (faktor_penyesuaian_% / 100)
+   => Jika n_total_terkumpul >= target_total_68 (artinya sudah >= 68% target), faktor = 100% (TIDAK kena penyesuaian)
 ✅ Detail entitas: Indeks_Final_0_100 menempel dari Indeks_Final_Wilayah (bukan per-row)
 ✅ Bell curve per JENIS berbasis indeks per entitas (row-level)
 ✅ LLM analysis + Word
@@ -18,9 +19,9 @@ PERBAIKAN UTAMA (menghilangkan NULL di pop_total/coverage):
 ✅ POP_KHUSUS: deteksi kolom target/pop; jika hanya ada target -> Pop_Total_Jenis = target/0.68
 ✅ Fallback juga diterapkan di tabel agregat (kalau join gagal) agar pop_total/coverage tidak NULL
 
-CATATAN:
-- Kalau masih ada NULL, itu biasanya karena KAB/KOTA di DM tidak match dengan POP (ejaan ekstrem).
-  Tetapi dengan norm_kab_label() + fallback agregat, kolom pop_total & coverage tetap terisi estimasi.
+CATATAN PENTING:
+- Penyesuaian TIDAK dihitung dari pop_total, tapi dari TARGET 68% (target_total_68).
+- Coverage_total_% tetap dihitung dari pop_total untuk info cakupan populasi (opsional), tapi TIDAK memengaruhi faktor penyesuaian.
 """
 
 import os
@@ -142,7 +143,6 @@ def norm_kew(v):
 
 # =========================
 # !!! PERBAIKAN MASALAH (DROPDOWN PROVINSI DOUBLE PREFIX)
-# Hanya menambah norm_prov_disp() dan mengganti norm_prov_label() agar aman jika "PROVINSI PROVINSI ..."
 # =========================
 def norm_prov_disp(s):
     """
@@ -158,14 +158,11 @@ def norm_prov_disp(s):
     t = t.replace("\u00a0", " ")
     t = " ".join(t.split())
 
-    # Samakan ejaan
     t = t.replace("PROPINSI", "PROVINSI")
 
-    # Hapus prefix berulang
     while t.startswith("PROVINSI PROVINSI "):
         t = t.replace("PROVINSI PROVINSI ", "PROVINSI ", 1)
 
-    # Pastikan format "PROVINSI <NAMA>"
     if t.startswith("PROVINSI "):
         name = t[len("PROVINSI "):].strip()
     else:
@@ -183,7 +180,6 @@ def norm_prov_label(s):
     t = str(s).strip().upper().replace("\u00a0", " ")
     t = " ".join(t.split())
     t = t.replace("PROPINSI", "PROVINSI")
-    # buang semua kemunculan kata PROVINSI (aman kalau dobel)
     t = t.replace("PROVINSI", "").strip()
     return re.sub(r"[^A-Z0-9]+", "", t)
 
@@ -207,20 +203,23 @@ def safe_div(num, den):
     return float(num) / float(den)
 
 # =========================
-# ✅ PERUBAHAN SESUAI PERMINTAAN:
-# faktor_penyesuaian = jumlah_sampel / jumlah_sampel_68% × 100  (cap 100)
+# !!! PERUBAHAN UTAMA SESUAI PERMINTAAN:
+# Faktor penyesuaian pakai TARGET 68% (target_total_68), BUKAN pop_total.
+# Jika sampel >= target_total_68 -> faktor = 100% (TIDAK kena penyesuaian).
 # =========================
-def faktor_penyesuaian_total(n_total: float, target_total: float) -> float:
+def faktor_penyesuaian_total_pct(n_total: float, target_total_68: float) -> float:
     """
-    faktor_penyesuaian(%) = min( (n_total_terkumpul / target_total_68) * 100 , 100 )
-    Jika target invalid/missing/0 -> faktor = 100 (tanpa penyesuaian)
+    faktor_penyesuaian_% = min((n_total / target_total_68) * 100, 100)
+
+    - Jika n_total >= target_total_68 -> 100% (tidak disesuaikan)
+    - Jika target invalid -> 100% (anggap tidak disesuaikan)
     """
-    if target_total is None or pd.isna(target_total) or float(target_total) <= 0:
+    if target_total_68 is None or pd.isna(target_total_68) or float(target_total_68) <= 0:
         return 100.0
     if n_total is None or pd.isna(n_total) or float(n_total) < 0:
         n_total = 0.0
-    faktor_pct = (float(n_total) / float(target_total)) * 100.0
-    return float(min(faktor_pct, 100.0))
+    pct = (float(n_total) / float(target_total_68)) * 100.0
+    return float(min(pct, 100.0))
 
 
 # ============================================================
@@ -367,10 +366,7 @@ def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
     - Kolom gabungan: "Propinsi/Kab/kota"
       berisi baris "PROVINSI XXX" lalu daftar "KAB. ..." / "KOTA ..."
     - Minimal 1 kolom angka.
-      Bisa berupa:
-      A) target 68% (sampel/target_total_68)
-      B) populasi (populasi/penduduk)
-      C) dua kolom sekaligus (lebih ideal)
+      Bisa berupa target 68% atau populasi, atau keduanya.
 
     Output: kab_key, Kab_Kota_Label, Provinsi_Label,
             Target68_Total_Jenis, Pop_Total_Jenis
@@ -379,7 +375,6 @@ def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
     if df is None or df.empty:
         return pd.DataFrame()
 
-    # Kolom gabungan prov/kab
     c_mix = pick_col(df, [
         "Propinsi/Kab/kota", "Propinsi/Kab/Kota", "Propinsi/Kab/kota ",
         "Provinsi/Kab/Kota", "Provinsi/Kab/kota", "Provinsi/Kabupaten/Kota",
@@ -394,7 +389,6 @@ def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
     if c_mix is None:
         raise ValueError("POP_KHUSUS: kolom gabungan Provinsi/Kab/Kota tidak ditemukan.")
 
-    # Deteksi kolom target & kolom populasi (kalau ada)
     c_target = pick_col(df, [
         "target_total_68","Target_Total_68","TARGET_68","target_68",
         "sampel_total","Sampel_total","TOTAL_SAMPEL","total_sampel",
@@ -407,7 +401,6 @@ def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
         "pop_total","Pop_Total"
     ])
 
-    # Minimal ada salah satu kolom angka
     if c_target is None and c_pop is None:
         numeric_cols = [c for c in df.columns if c != c_mix]
         if not numeric_cols:
@@ -428,10 +421,9 @@ def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
             current_prov = mm.replace("PROVINSI", "").strip()
             continue
 
-        kab_label = mm
         rows.append({
             "Provinsi_Label": current_prov or "",
-            "Kab_Kota_Label": kab_label,
+            "Kab_Kota_Label": mm,
             "Target68_Total_Jenis": tval,
             "Pop_Total_Jenis": pval
         })
@@ -446,11 +438,9 @@ def _parse_pop_khusus(path_xlsx: str) -> pd.DataFrame:
     pop["Target68_Total_Jenis"] = pd.to_numeric(pop["Target68_Total_Jenis"], errors="coerce")
     pop["Pop_Total_Jenis"] = pd.to_numeric(pop["Pop_Total_Jenis"], errors="coerce")
 
-    # fallback jika hanya ada target: pop ≈ target/0.68
     m_need_pop = pop["Pop_Total_Jenis"].isna() & pop["Target68_Total_Jenis"].notna() & (pop["Target68_Total_Jenis"] > 0)
     pop.loc[m_need_pop, "Pop_Total_Jenis"] = pop.loc[m_need_pop, "Target68_Total_Jenis"] / float(FALLBACK_TARGET_RATIO)
 
-    # fallback jika hanya ada pop: target ≈ 0.68*pop
     m_need_target = pop["Target68_Total_Jenis"].isna() & pop["Pop_Total_Jenis"].notna() & (pop["Pop_Total_Jenis"] > 0)
     pop.loc[m_need_target, "Target68_Total_Jenis"] = pop.loc[m_need_target, "Pop_Total_Jenis"] * float(FALLBACK_TARGET_RATIO)
 
@@ -479,7 +469,6 @@ def load_default_files(force=False):
             _CACHE.update({"key": key, "df_all": None, "pop_kab": None, "pop_prov": None, "pop_khusus": None, "meta": {}, "info": info})
             return None, None, None, None, {}, info
 
-    # DM multi-sheet
     fp = Path(DATA_FILE)
     xls = pd.ExcelFile(fp)
     frames = [pd.read_excel(fp, sheet_name=s) for s in xls.sheet_names]
@@ -501,7 +490,6 @@ def load_default_files(force=False):
         _CACHE.update({"key": key, "df_all": None, "pop_kab": None, "pop_prov": None, "pop_khusus": None, "meta": {}, "info": info})
         return None, None, None, None, {}, info
 
-    # mapping jenis -> sekolah / umum / khusus
     val_map_jenis = {
         "PERPUSTAKAAN SEKOLAH": "sekolah", "SEKOLAH": "sekolah",
         "PERPUSTAKAAN UMUM": "umum", "UMUM": "umum", "PERPUSTAKAAN DAERAH": "umum",
@@ -511,9 +499,7 @@ def load_default_files(force=False):
     df_raw["KEW_NORM"]  = df_raw[kew_col].apply(norm_kew)
     df_raw["_dataset"]  = df_raw[jenis_col].astype(str).str.strip().str.upper().map(val_map_jenis)
 
-    # !!! PERBAIKAN MASALAH: PROV_DISP pakai norm_prov_disp agar tidak muncul "PROVINSI PROVINSI ..."
     df_raw["PROV_DISP"] = df_raw[prov_col].apply(norm_prov_disp)
-
     df_raw["KAB_DISP"]  = df_raw[kab_col].apply(_disp_text)
 
     df_raw["prov_key"] = df_raw["PROV_DISP"].apply(norm_prov_label)
@@ -544,7 +530,6 @@ def load_default_files(force=False):
         "target_total_68","Target_Total_68","target_68","TARGET_68"
     ])
 
-    # Deteksi populasi diperluas
     c_pop_total = pick_col(pk, [
         "total_populasi","Total Populasi","POPULASI","populasi",
         "jumlah_penduduk","Jumlah Penduduk","PENDUDUK","penduduk",
@@ -568,7 +553,6 @@ def load_default_files(force=False):
     pop_kab["Pop_Total"] = pd.to_numeric(pop_kab["Pop_Total"], errors="coerce")
     pop_kab["Target68_Total"] = pd.to_numeric(pop_kab["Target68_Total"], errors="coerce")
 
-    # fallback Pop_Total = Target/0.68
     mask_need_pop = pop_kab["Pop_Total"].isna() & pop_kab["Target68_Total"].notna() & (pop_kab["Target68_Total"] > 0)
     pop_kab.loc[mask_need_pop, "Pop_Total"] = pop_kab.loc[mask_need_pop, "Target68_Total"] / float(FALLBACK_TARGET_RATIO)
 
@@ -614,7 +598,6 @@ def load_default_files(force=False):
     pop_prov["Pop_Total_Prov"] = pd.to_numeric(pop_prov["Pop_Total_Prov"], errors="coerce")
     pop_prov["Target68_Total_Prov"] = pd.to_numeric(pop_prov["Target68_Total_Prov"], errors="coerce")
 
-    # fallback Pop_Total_Prov = Target/0.68
     mask_need_pop = pop_prov["Pop_Total_Prov"].isna() & pop_prov["Target68_Total_Prov"].notna() & (pop_prov["Target68_Total_Prov"] > 0)
     pop_prov.loc[mask_need_pop, "Pop_Total_Prov"] = pop_prov.loc[mask_need_pop, "Target68_Total_Prov"] / float(FALLBACK_TARGET_RATIO)
 
@@ -635,7 +618,6 @@ def load_default_files(force=False):
         _CACHE.update({"key": key, "df_all": None, "pop_kab": None, "pop_prov": None, "pop_khusus": None, "meta": {}, "info": info})
         return None, None, None, None, {}, info
 
-    # pipeline nasional (entitas)
     df_all = prepare_global(df_raw)
 
     meta = dict(prov_col=prov_col, kab_col=kab_col, kew_col=kew_col, jenis_col=jenis_col, nama_col=nama_col)
@@ -643,9 +625,9 @@ def load_default_files(force=False):
     info = (
         f"✅ Mode NO UPLOAD (cache aktif)<br>"
         f"✅ DM: <b>{fp.name}</b> | Baris: {before} → dedup: {after}<br>"
-        f"✅ POP_KAB: <b>{Path(POP_KAB).name}</b> (n={len(pop_kab)}) — target 68% via <code>sampel_total</code> (Pop_Total auto fallback jika kosong)<br>"
-        f"✅ POP_PROV: <b>{Path(POP_PROV).name}</b> (n={len(pop_prov)}) — target 68% via <code>total _sampel</code> (Pop_Total auto fallback jika kosong)<br>"
-        f"✅ POP_KHUSUS: <b>{Path(POP_KHUSUS).name}</b> (n={len(pop_khusus)}) — format gabungan Provinsi/Kab/Kota (Target/Pop auto fallback)<br>"
+        f"✅ POP_KAB: <b>{Path(POP_KAB).name}</b> (n={len(pop_kab)}) — target 68% via <code>sampel_total</code><br>"
+        f"✅ POP_PROV: <b>{Path(POP_PROV).name}</b> (n={len(pop_prov)}) — target 68% via <code>total _sampel</code><br>"
+        f"✅ POP_KHUSUS: <b>{Path(POP_KHUSUS).name}</b> (n={len(pop_khusus)}) — format gabungan Provinsi/Kab/Kota<br>"
         f"🕒 mtime: DM={time.ctime(_mtime(DATA_FILE))} | Kab={time.ctime(_mtime(POP_KAB))} | Prov={time.ctime(_mtime(POP_PROV))} | Khusus={time.ctime(_mtime(POP_KHUSUS))}"
     )
 
@@ -660,6 +642,11 @@ def load_default_files(force=False):
 def build_agg_wilayah_total(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, pop_prov: pd.DataFrame, kew_value: str):
     """
     Output: satu baris per wilayah
+
+    Penyesuaian:
+    - faktor_penyesuaian_% dihitung dari (n_total / target_total_68)*100, cap 100
+    - Indeks_Final = Indeks_Dasar_Agregat * (faktor_penyesuaian_%/100)
+    - Jika n_total >= target_total_68 -> faktor_penyesuaian_% = 100 (tidak disesuaikan)
     """
     if df_filtered is None or df_filtered.empty:
         return pd.DataFrame()
@@ -705,17 +692,17 @@ def build_agg_wilayah_total(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, po
 
     agg = agg.rename(columns={key_col: "group_key", label_col: label_name})
 
-    # join target_total_68 & pop_total
+    # join target_total_68 & pop_total (pop_total hanya untuk info coverage, bukan untuk faktor)
     target_vals, pop_vals, label_fix = [], [], []
     for _, r in agg.iterrows():
         gk = r["group_key"]
         if gk in pop.index:
-            target_total = pop.loc[gk, target_field] if target_field in pop.columns else np.nan
+            target_total_68 = pop.loc[gk, target_field] if target_field in pop.columns else np.nan
             pop_total = pop.loc[gk, pop_field] if pop_field in pop.columns else np.nan
             nm = pop.loc[gk, name_field] if name_field in pop.columns else r[label_name]
         else:
-            target_total, pop_total, nm = np.nan, np.nan, r[label_name]
-        target_vals.append(target_total)
+            target_total_68, pop_total, nm = np.nan, np.nan, r[label_name]
+        target_vals.append(target_total_68)
         pop_vals.append(pop_total)
         label_fix.append(nm)
 
@@ -723,24 +710,29 @@ def build_agg_wilayah_total(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, po
     agg["target_total_68"] = pd.to_numeric(pd.Series(target_vals), errors="coerce")
     agg["pop_total"] = pd.to_numeric(pd.Series(pop_vals), errors="coerce")
 
-    # fallback jika pop_total masih NaN tapi target_total_68 ada
+    # fallback pop_total jika kosong, agar coverage_total_% tidak null (INFO SAJA)
     m = agg["pop_total"].isna() & agg["target_total_68"].notna() & (agg["target_total_68"] > 0)
     agg.loc[m, "pop_total"] = agg.loc[m, "target_total_68"] / float(FALLBACK_TARGET_RATIO)
 
-    # ✅ faktor_penyesuaian dalam persen (0–100)
+    # === PENYESUAIAN: PAKAI TARGET 68% (bukan pop_total) ===
     agg["faktor_penyesuaian"] = [
-    faktor_penyesuaian_total(n, p)
-    for n, p in zip(
-        pd.to_numeric(agg["n_total"], errors="coerce").fillna(0).astype(float).tolist(),
-        pd.to_numeric(agg["pop_total"], errors="coerce").tolist())
+        faktor_penyesuaian_total_pct(n, t)  # hasil persen (0..100)
+        for n, t in zip(
+            pd.to_numeric(agg["n_total"], errors="coerce").fillna(0).astype(float).tolist(),
+            pd.to_numeric(agg["target_total_68"], errors="coerce").tolist()
+        )
     ]
 
+    # coverage_total_% (INFO) tetap dari pop_total
     agg["coverage_total_%"] = [
         (safe_div(n, p) * 100) if (p is not None and not pd.isna(p) and float(p) > 0) else np.nan
-        for n, p in zip(pd.to_numeric(agg["n_total"], errors="coerce").fillna(0).astype(float).tolist(), agg["pop_total"].tolist())
+        for n, p in zip(
+            pd.to_numeric(agg["n_total"], errors="coerce").fillna(0).astype(float).tolist(),
+            agg["pop_total"].tolist()
+        )
     ]
 
-    # ✅ indeks final = indeks dasar × (faktor/100)
+    # INDEKS FINAL: faktor persen / 100
     agg["Indeks_Final_Wilayah_0_100"] = agg["Indeks_Dasar_Agregat_0_100"] * (agg["faktor_penyesuaian"] / 100.0)
 
     # rounding
@@ -755,8 +747,8 @@ def build_agg_wilayah_total(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, po
         if c in agg.columns:
             agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(0.0).apply(lambda x: round(float(x), 2))
 
-    # faktor persen
-    agg["faktor_penyesuaian"] = pd.to_numeric(agg["faktor_penyesuaian"], errors="coerce").fillna(100.0).apply(lambda x: round(float(x), 1))
+    # faktor_penyesuaian sudah persen; simpan integer/pembulatan sesuai kebutuhan tampilan
+    agg["faktor_penyesuaian"] = pd.to_numeric(agg["faktor_penyesuaian"], errors="coerce").fillna(100.0).apply(lambda x: round(float(x), 0))
     agg["coverage_total_%"] = pd.to_numeric(agg["coverage_total_%"], errors="coerce")
 
     return agg
@@ -768,7 +760,7 @@ def build_agg_wilayah_total(df_filtered: pd.DataFrame, pop_kab: pd.DataFrame, po
 
 def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, agg_total: pd.DataFrame, pop_khusus: pd.DataFrame, kew_value: str):
     """
-    Final per jenis = Indeks_Dasar_Jenis * (faktor_penyesuaian_wilayah/100) (TERMASUK KHUSUS)
+    Final per jenis = Indeks_Dasar_Jenis * (faktor_penyesuaian_wilayah% / 100)
     Referensi khusus (target/pop) ditampilkan bila tersedia dari POP_KHUSUS.
     """
     if df_filtered is None or df_filtered.empty:
@@ -807,7 +799,7 @@ def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, agg_total: pd.DataFrame,
 
     agg = agg.rename(columns={key_col: "group_key", label_col: label_name, "_dataset": "Jenis"})
 
-    # join faktor wilayah (PERSEN)
+    # join faktor wilayah (persen)
     if agg_total is None or agg_total.empty:
         agg["faktor_penyesuaian_wilayah"] = 100.0
     else:
@@ -815,7 +807,7 @@ def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, agg_total: pd.DataFrame,
         agg = agg.merge(m, on="group_key", how="left")
         agg["faktor_penyesuaian_wilayah"] = pd.to_numeric(agg["faktor_penyesuaian_wilayah"], errors="coerce").fillna(100.0)
 
-    # Final (TERMASUK KHUSUS)
+    # Final (TERMASUK KHUSUS) — faktor persen / 100
     agg["faktor_penyesuaian"] = agg["faktor_penyesuaian_wilayah"]
     agg["Indeks_Final_Agregat_0_100"] = agg["Indeks_Dasar_Agregat_0_100"] * (agg["faktor_penyesuaian"] / 100.0)
 
@@ -836,14 +828,12 @@ def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, agg_total: pd.DataFrame,
                 agg.at[i, "target_total_68_jenis"] = t
                 agg.at[i, "pop_total_jenis"] = p
 
-    # fallback jika pop_total_jenis NaN tapi target_total_68_jenis ada
     agg["target_total_68_jenis"] = pd.to_numeric(agg["target_total_68_jenis"], errors="coerce")
     agg["pop_total_jenis"] = pd.to_numeric(agg["pop_total_jenis"], errors="coerce")
 
     m = agg["pop_total_jenis"].isna() & agg["target_total_68_jenis"].notna() & (agg["target_total_68_jenis"] > 0)
     agg.loc[m, "pop_total_jenis"] = agg.loc[m, "target_total_68_jenis"] / float(FALLBACK_TARGET_RATIO)
 
-    # refresh coverage_jenis jika pop_total_jenis ada
     m2 = agg["pop_total_jenis"].notna() & (agg["pop_total_jenis"] > 0)
     agg.loc[m2, "coverage_jenis"] = (agg.loc[m2, "Jumlah"].astype(float) / agg.loc[m2, "pop_total_jenis"].astype(float)) * 100.0
 
@@ -859,9 +849,10 @@ def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, agg_total: pd.DataFrame,
         if c in agg.columns:
             agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(0.0).apply(lambda x: round(float(x), 2))
 
+    # faktor persen dibulatkan 0 desimal
     for c in ["faktor_penyesuaian_wilayah","faktor_penyesuaian"]:
         if c in agg.columns:
-            agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(100.0).apply(lambda x: round(float(x), 1))
+            agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(100.0).apply(lambda x: round(float(x), 0))
 
     agg["coverage_jenis"] = pd.to_numeric(agg["coverage_jenis"], errors="coerce")
 
@@ -994,10 +985,7 @@ def build_verif_total(agg_total: pd.DataFrame):
         "Target_68_Total": df.get("target_total_68", np.nan),
         "Sampel_Total_Terkumpul": df.get("n_total", 0),
         "Coverage_Total_%": df.get("coverage_total_%", np.nan),
-
-        # ✅ faktor sudah persen, JANGAN dikali 100 lagi
         "Faktor_Penyesuaian_(Sampel/Target68)_persen": pd.to_numeric(df.get("faktor_penyesuaian", 100.0), errors="coerce").fillna(100.0),
-
         "GAP_Ke_Target68_Total": [
             max(t - n, 0) if (t is not None and not pd.isna(t)) else 0
             for n, t in zip(pd.to_numeric(df["n_total"], errors="coerce").fillna(0).astype(float).tolist(),
@@ -1173,8 +1161,8 @@ def build_context(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, verif_to
     lines.append(f"Wilayah filter: {wilayah}")
     lines.append(f"Kewenangan: {kew}")
     lines.append("Metode: Indeks dasar dihitung per entitas (YJ+minmax nasional), lalu diagregasi per wilayah. Setelah itu dilakukan penyesuaian berbasis kecukupan sampel minimum 68% pada level wilayah.")
-    # ✅ UPDATE rumus (persen)
-    lines.append("Rumus penyesuaian: faktor(%) = min((total_terkumpul / target_total_68) × 100, 100); Indeks_Final = Indeks_Dasar_Agregat × (faktor/100).")
+    lines.append("Rumus penyesuaian: faktor(%) = min((total_terkumpul/target_total_68)*100, 100). Indeks_Final = Indeks_Dasar_Agregat × (faktor/100).")
+    lines.append("Catatan: Jika total_terkumpul >= target_total_68 -> faktor=100% (tidak ada penyesuaian).")
     lines.append("Jenis yang ditampilkan: sekolah, umum, khusus (SEMUA jenis menggunakan faktor wilayah).")
 
     if summary_jenis is not None and not summary_jenis.empty:
@@ -1193,7 +1181,7 @@ def build_context(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, verif_to
         for _, r in top.iterrows():
             wl = r.get(label_col, "(wilayah)") if label_col else "(wilayah)"
             lines.append(
-                f"- {wl}: Final={float(r['Indeks_Final_Wilayah_0_100']):.2f} | Faktor(%)={float(r.get('faktor_penyesuaian', 100.0)):.1f} | total={int(r.get('n_total', 0))}"
+                f"- {wl}: Final={float(r['Indeks_Final_Wilayah_0_100']):.2f} | Faktor%={float(r.get('faktor_penyesuaian', 100.0)):.0f} | total={int(r.get('n_total', 0))} | target68={float(r.get('target_total_68', 0)):.2f}"
             )
 
     if verif_total is not None and not verif_total.empty:
@@ -1219,7 +1207,7 @@ def generate_llm_analysis(summary_jenis, agg_total, verif_total, wilayah, kew):
         "Tugas Anda menyusun analisis berbasis data IPLM secara formal, tajam, dan operasional."
     )
     user_prompt = f"""
-DATA RINGKAS IPLM (PENYESUAIAN BERBASIS KECUKUPAN SAMPEL 68% DI LEVEL WILAYAH):
+DATA RINGKAS IPLM (PENYESUAIAN BERBASIS KECUKUPAN SAMPEL TARGET 68% DI LEVEL WILAYAH):
 
 {ctx}
 
@@ -1256,12 +1244,12 @@ def generate_word_report(agg_jenis, wilayah, kew, analysis_text):
     doc.add_paragraph(f"Kewenangan: {kew}")
     doc.add_paragraph(
         "Metode: Indeks dasar dihitung per entitas (YJ+minmax nasional), diagregasi per wilayah, "
-        "lalu dilakukan penyesuaian berbasis kecukupan sampel minimum 68% pada level wilayah."
+        "lalu dilakukan penyesuaian berbasis kecukupan sampel target 68% pada level wilayah."
     )
-    # ✅ UPDATE rumus (persen)
     doc.add_paragraph(
-        "Rumus penyesuaian: faktor(%) = min((total_terkumpul / target_total_68) × 100, 100). "
-        "Indeks_Final = Indeks_Dasar_Agregat × (faktor/100)."
+        "Rumus penyesuaian: faktor(%) = min((total_terkumpul/target_total_68)*100, 100). "
+        "Indeks_Final = Indeks_Dasar_Agregat × (faktor/100). "
+        "Jika total_terkumpul >= target_total_68 maka faktor=100% (tidak ada penyesuaian)."
     )
     doc.add_paragraph(
         "Jenis yang ditampilkan: sekolah, umum, khusus. "
@@ -1325,8 +1313,7 @@ def generate_word_report(agg_jenis, wilayah, kew, analysis_text):
                     elif "Rata2_" in str(c):
                         cells[i].text = f"{float(v):.3f}"
                     elif "faktor" in str(c).lower():
-                        # faktor sekarang persen
-                        cells[i].text = f"{float(v):.1f}"
+                        cells[i].text = f"{float(v):.0f}"  # persen
                     elif "coverage" in str(c).lower():
                         cells[i].text = f"{float(v):.2f}"
                     else:
@@ -1370,16 +1357,7 @@ def build_kpi_markdown(agg_total: pd.DataFrame) -> str:
     dasar = float(pd.to_numeric(agg_total["Indeks_Dasar_Agregat_0_100"], errors="coerce").fillna(0).mean()) if "Indeks_Dasar_Agregat_0_100" in agg_total.columns else np.nan
     final = float(pd.to_numeric(agg_total["Indeks_Final_Wilayah_0_100"], errors="coerce").fillna(0).mean()) if "Indeks_Final_Wilayah_0_100" in agg_total.columns else np.nan
 
-    n_sum = pd.to_numeric(agg_total.get("n_total", pd.Series(dtype=float)), errors="coerce").fillna(0).sum()
-    t_sum = pd.to_numeric(agg_total.get("target_total_68", pd.Series(dtype=float)), errors="coerce").fillna(0)
-    t_sum = t_sum[t_sum > 0].sum() if hasattr(t_sum, "sum") else float(t_sum)
-
-    # ✅ cakupan_pct langsung persen (0–100) cap 100
-    cakupan_pct = min((float(n_sum) / float(t_sum)) * 100.0, 100.0) if (t_sum and t_sum > 0) else 100.0
-
-    # faktor_penyesuaian sudah persen
-    faktor_mean = float(pd.to_numeric(agg_total.get("faktor_penyesuaian", 100.0), errors="coerce").fillna(100.0).mean())
-
+    faktor_mean_pct = float(pd.to_numeric(agg_total.get("faktor_penyesuaian", 100.0), errors="coerce").fillna(100.0).mean())
     dampak = (final - dasar) if (pd.notna(final) and pd.notna(dasar)) else np.nan
 
     def fmt(x, nd=2):
@@ -1401,14 +1379,14 @@ def build_kpi_markdown(agg_total: pd.DataFrame) -> str:
 
   <div style="border:1px solid #333; border-radius:10px; padding:10px 12px; min-width:220px;">
     <div style="opacity:0.8;">Cakupan Sampel (berdasarkan target 68%)</div>
-    <div style="font-size:26px; font-weight:700;">{fmt(cakupan_pct,0)}%</div>
-    <div style="opacity:0.7;">Rumus: min((total/target_68)×100, 100)</div>
+    <div style="font-size:26px; font-weight:700;">{fmt(faktor_mean_pct,0)}%</div>
+    <div style="opacity:0.7;">Rumus: min((total/target_68)*100, 100)</div>
   </div>
 
   <div style="border:1px solid #333; border-radius:10px; padding:10px 12px; min-width:220px;">
     <div style="opacity:0.8;">Penyesuaian Nilai (rata-rata)</div>
     <div style="font-size:26px; font-weight:700;">{fmt(dampak,2)} poin</div>
-    <div style="opacity:0.7;">Faktor penyesuaian (mean): {fmt(faktor_mean,1)}%</div>
+    <div style="opacity:0.7;">Faktor penyesuaian (mean): {fmt(faktor_mean_pct,0)}%</div>
   </div>
 </div>
 """.strip()
@@ -1479,10 +1457,9 @@ def run_calc(prov_value, kab_value, kew_value, df_all, pop_kab, pop_prov, pop_kh
         # Word report
         word_path = generate_word_report(agg_jenis, wilayah_txt, kew_value or "(Semua)", analysis_text)
 
-        # ✅ update msg: rumus persen
         msg = (
             f"✅ Selesai: entitas={len(detail_view)} | wilayah(keseluruhan)={len(agg_total)} | "
-            f"jenis={len(agg_jenis)} | penyesuaian=(total_terkumpul/target_total_68)*100 (cap 100)"
+            f"jenis={len(agg_jenis)} | penyesuaian berbasis target_total_68 (cap 100%)"
         )
 
         return (
@@ -1511,124 +1488,144 @@ def ui_load(force=False):
             gr.update(choices=["(Semua)"], value="(Semua)"),
         )
 
-    # !!! PERBAIKAN MASALAH: prov_choices dibuat set() agar tidak ada duplikat akibat variasi format
     prov_vals = df_all["PROV_DISP"].dropna().astype(str).tolist()
     prov_vals = [v for v in prov_vals if v and v.strip()]
     prov_choices = ["(Semua)"] + sorted(set(prov_vals))
 
     kab_choices  = ["(Semua)"] + sorted([x for x in df_all["KAB_DISP"].dropna().unique().tolist() if x])
-    kew_choices  = ["(Semua)"] + sorted([x for x in df_all["KEW_NORM"].dropna().unique().tolist() if x])
-    default_kew  = "PROVINSI" if "PROVINSI" in kew_choices else ("KAB/KOTA" if "KAB/KOTA" in kew_choices else "(Semua)")
+       kew_choices  = ["(Semua)"] + sorted([x for x in df_all["KEW_NORM"].dropna().unique().tolist() if x])
 
     return (
         df_all, pop_kab, pop_prov, pop_khusus, meta, info,
         gr.update(choices=prov_choices, value="(Semua)"),
-        gr.update(choices=kab_choices, value="(Semua)"),
-        gr.update(choices=kew_choices, value=default_kew),
+        gr.update(choices=["(Semua)"], value="(Semua)"),  # kab akan mengikuti prov
+        gr.update(choices=kew_choices, value="(Semua)"),
     )
 
-def on_prov_change(prov_value):
-    df_all, _, _, _, _, _ = load_default_files(force=False)
+
+def ui_update_kab_choices(prov_value, df_all):
     if df_all is None or df_all.empty:
         return gr.update(choices=["(Semua)"], value="(Semua)")
-    if prov_value is None or prov_value == "(Semua)":
-        vals = df_all["KAB_DISP"].dropna().unique().tolist()
-    else:
-        vals = df_all.loc[df_all["PROV_DISP"] == prov_value, "KAB_DISP"].dropna().unique().tolist()
-    vals = sorted([v for v in vals if v])
-    return gr.update(choices=["(Semua)"] + vals, value="(Semua)")
-
-
-with gr.Blocks() as demo:
-    gr.Markdown(f"""
-# IPLM 2025 — Final (Penyesuaian Berbasis Kecukupan Sampel 68%)
-**Mode NO UPLOAD (cache aktif).** File dibaca dari repo/server:
-- `DATA_FILE`   = **{DATA_FILE}**
-- `POP_KAB`     = **{POP_KAB}** (target 68%: kolom **sampel_total** / alias)
-- `POP_PROV`    = **{POP_PROV}** (target 68%: kolom **total _sampel** / alias)
-- `POP_KHUSUS`  = **{POP_KHUSUS}** (referensi jenis khusus)
-
-**Aturan penting:**
-- Hitung indeks dasar per entitas (YJ+minmax nasional) → agregasi wilayah → **baru penyesuaian 68% berbasis total wilayah**.
-- Penyesuaian 68% memakai total pengumpulan wilayah: `faktor(%) = min((n_total_terkumpul / target_total_68) × 100, 100)`.
-- Indeks_Final = Indeks_Dasar_Agregat × (faktor/100).
-- Jenis tampil: **sekolah, umum, khusus** (SEMUA jenis menggunakan faktor wilayah).
-- Referensi target/pop khusus ditampilkan bila tersedia dari POP_KHUSUS.
-- **Perbaikan NULL**: jika Pop_Total kosong/tidak ada -> fallback `Pop_Total = Target68 / 0.68` sehingga coverage tidak null.
-""")
-
-    state_df = gr.State(None)
-    state_pop_kab = gr.State(None)
-    state_pop_prov = gr.State(None)
-    state_pop_khusus = gr.State(None)
-    state_meta = gr.State({})
-
-    info_box = gr.Markdown()
+
+    if not prov_value or prov_value == "(Semua)":
+        # semua kab/kota
+        kab_list = sorted([x for x in df_all["KAB_DISP"].dropna().unique().tolist() if x])
+        return gr.update(choices=["(Semua)"] + kab_list, value="(Semua)")
+
+    # kab/kota hanya dari provinsi terpilih
+    sub = df_all[df_all["PROV_DISP"] == prov_value]
+    kab_list = sorted([x for x in sub["KAB_DISP"].dropna().unique().tolist() if x])
+    return gr.update(choices=["(Semua)"] + kab_list, value="(Semua)")
+
+
+def ui_run(prov_value, kab_value, kew_value, df_all, pop_kab, pop_prov, pop_khusus, meta):
+    return run_calc(prov_value, kab_value, kew_value, df_all, pop_kab, pop_prov, pop_khusus, meta)
+
+
+with gr.Blocks(title="IPLM 2025 — FINAL (NO UPLOAD)") as demo:
+    gr.Markdown("## IPLM 2025 — FINAL (NO UPLOAD)\n"
+                "- Penyesuaian berbasis **target_total_68** (target minimum 68%) pada level wilayah.\n"
+                "- Jika **total sampel >= target_total_68** → **faktor=100%** (tidak disesuaikan).\n"
+                "- Cakupan (coverage) dihitung dari **pop_total** hanya untuk informasi.")
+
+    st_info = gr.HTML()
+
+    # state caches
+    st_df_all     = gr.State()
+    st_pop_kab    = gr.State()
+    st_pop_prov   = gr.State()
+    st_pop_khusus = gr.State()
+    st_meta       = gr.State()
 
     with gr.Row():
         dd_prov = gr.Dropdown(label="Provinsi", choices=["(Semua)"], value="(Semua)")
         dd_kab  = gr.Dropdown(label="Kab/Kota", choices=["(Semua)"], value="(Semua)")
         dd_kew  = gr.Dropdown(label="Kewenangan", choices=["(Semua)"], value="(Semua)")
 
-    dd_prov.change(fn=on_prov_change, inputs=[dd_prov], outputs=dd_kab)
+    with gr.Row():
+        btn_reload = gr.Button("Reload (paksa baca ulang file)")
+        btn_run = gr.Button("Run Audit / Hitung")
 
-    run_btn = gr.Button("Jalankan Perhitungan")
-    msg_out = gr.Markdown()
+    kpi_md = gr.HTML()
 
-    # KPI
-    kpi_out = gr.Markdown()
+    with gr.Tabs():
+        with gr.Tab("Ringkasan (Jenis + Keseluruhan)"):
+            tbl_summary = gr.Dataframe(interactive=False)
 
-    gr.Markdown("## Ringkasan (Jenis + Keseluruhan) — sub-dimensi, dimensi, indeks final disesuaikan")
-    out_summary = gr.DataFrame(interactive=False)
+        with gr.Tab("Agregat Wilayah (Keseluruhan)"):
+            tbl_total = gr.Dataframe(interactive=False)
 
-    gr.Markdown("## Agregat Wilayah (Keseluruhan) — Final disesuaikan (faktor wilayah)")
-    out_agg_total = gr.DataFrame(interactive=False)
+        with gr.Tab("Agregat Wilayah × Jenis"):
+            tbl_jenis = gr.Dataframe(interactive=False)
 
-    gr.Markdown("## Agregat Wilayah × Jenis (Sekolah, Umum, Khusus) — Final memakai faktor wilayah + referensi khusus")
-    out_agg_jenis = gr.DataFrame(interactive=False)
+        with gr.Tab("Detail Entitas (Final menempel Wilayah)"):
+            tbl_detail = gr.Dataframe(interactive=False)
 
-    gr.Markdown("## Detail Entitas (Indeks final menempel dari wilayah; tidak ada penyesuaian per entitas)")
-    out_detail = gr.DataFrame(interactive=False)
+        with gr.Tab("Verifikasi Kecukupan Sampel (Target 68%)"):
+            tbl_verif = gr.Dataframe(interactive=False)
 
-    gr.Markdown("## Kecukupan Sampel 68% (tanpa angka koma)")
-    out_verif = gr.DataFrame(interactive=False)
+        with gr.Tab("Bell Curve (Umum)"):
+            fig_umum = gr.Plot()
 
-    gr.Markdown("## Bell Curve — per Jenis Perpustakaan (Indeks per Entitas)")
-    gr.Markdown("### Perpustakaan Umum")
-    bell_umum = gr.Plot(scale=1)
+        with gr.Tab("Bell Curve (Sekolah)"):
+            fig_sekolah = gr.Plot()
 
-    gr.Markdown("### Perpustakaan Sekolah")
-    bell_sekolah = gr.Plot(scale=1)
+        with gr.Tab("Bell Curve (Khusus)"):
+            fig_khusus = gr.Plot()
 
-    gr.Markdown("### Perpustakaan Khusus")
-    bell_khusus = gr.Plot(scale=1)
+        with gr.Tab("Analisis Naratif"):
+            txt_status = gr.Markdown()
+            txt_analysis = gr.Textbox(lines=22, label="Analisis (LLM)")
 
-    gr.Markdown("## Analisis Otomatis (LLM)")
-    analysis_out = gr.Markdown()
+        with gr.Tab("Download"):
+            f_summary = gr.File(label="Ringkasan (Jenis + Keseluruhan) — Excel")
+            f_total   = gr.File(label="Agregat Wilayah (Keseluruhan) — Excel")
+            f_jenis   = gr.File(label="Agregat Wilayah × Jenis — Excel")
+            f_detail  = gr.File(label="Detail Entitas (Final menempel Wilayah) — Excel")
+            f_word    = gr.File(label="Laporan Word (Agregat Wilayah × Jenis + Analisis)")
+            f_verif   = gr.File(label="Verifikasi Target 68% — Excel")
 
-    with gr.Row():
-        dl_summary = gr.DownloadButton(label="Download Ringkasan (.xlsx)")
-        dl_total   = gr.DownloadButton(label="Download Agregat Wilayah (.xlsx)")
-        dl_jenis   = gr.DownloadButton(label="Download Agregat Jenis (.xlsx)")
-        dl_detail  = gr.DownloadButton(label="Download Detail Entitas (.xlsx)")
-        dl_word    = gr.DownloadButton(label="Download Laporan Word (.docx)")
-
-    run_btn.click(
-        fn=run_calc,
-        inputs=[dd_prov, dd_kab, dd_kew, state_df, state_pop_kab, state_pop_prov, state_pop_khusus, state_meta],
+    # initial load
+    def _load0():
+        return ui_load(force=False)
+
+    demo.load(
+        _load0,
+        inputs=[],
         outputs=[
-            kpi_out,
-            out_summary, out_agg_total, out_agg_jenis, out_detail, out_verif,
-            dl_summary, dl_total, dl_jenis, dl_detail, dl_word,
-            bell_umum, bell_sekolah, bell_khusus,
-            msg_out, analysis_out
-        ]
+            st_df_all, st_pop_kab, st_pop_prov, st_pop_khusus, st_meta, st_info,
+            dd_prov, dd_kab, dd_kew
+        ],
     )
 
-    demo.load(
-        fn=lambda: ui_load(force=False),
+    # reload button
+    btn_reload.click(
+        fn=lambda: ui_load(force=True),
         inputs=[],
-        outputs=[state_df, state_pop_kab, state_pop_prov, state_pop_khusus, state_meta, info_box, dd_prov, dd_kab, dd_kew]
+        outputs=[
+            st_df_all, st_pop_kab, st_pop_prov, st_pop_khusus, st_meta, st_info,
+            dd_prov, dd_kab, dd_kew
+        ],
+    )
+
+    # prov -> kab update
+    dd_prov.change(
+        fn=ui_update_kab_choices,
+        inputs=[dd_prov, st_df_all],
+        outputs=[dd_kab]
+    )
+
+    # run
+    btn_run.click(
+        fn=ui_run,
+        inputs=[dd_prov, dd_kab, dd_kew, st_df_all, st_pop_kab, st_pop_prov, st_pop_khusus, st_meta],
+        outputs=[
+            kpi_md,
+            tbl_summary, tbl_total, tbl_jenis, tbl_detail, tbl_verif,
+            f_summary, f_total, f_jenis, f_detail, f_word,
+            fig_umum, fig_sekolah, fig_khusus,
+            txt_status, txt_analysis
+        ]
     )
 
-demo.launch()
+demo.queue(concurrency_count=1).launch(share=True)