Update app.py

app.py

@@ -638,180 +638,207 @@ def load_default_files(force=False):
 
 
 # ============================================================
-# 6) FAKTOR WILAYAH (TOTAL) — hanya untuk faktor/target/pop/coverage
-# UPDATE: pop_total & target_total_68 wilayah ditambah data KHUSUS (POP_KHUSUS)
-#         TANPA ubah logika faktor (tetap min(n_total/target,1))
+# 6) FAKTOR WILAYAH — PER JENIS (PATCH UTAMA)
+#    faktor_jenis = min(n_jenis / target68_jenis, 1.0)
+#    target/pop sekolah & umum diambil dari POP_KAB/POP_PROV jika tersedia
+#    target/pop khusus diambil dari POP_KHUSUS (gabungan)
 # ============================================================
 
-def build_faktor_wilayah(
+def _read_target_pop_per_jenis_from_pop(pop_df: pd.DataFrame, mode: str):
+    """
+    Mengambil mapping target/pop PER JENIS untuk sekolah & umum dari POP_KAB/POP_PROV
+    jika file populasi kamu memang punya kolom per jenis.
+
+    Return:
+      dict: {
+        "sekolah": (target_col, pop_col),
+        "umum":    (target_col, pop_col),
+      }
+    Kalau tidak ketemu, return None untuk kolom tersebut -> nanti dianggap 0.
+    """
+    if pop_df is None or pop_df.empty:
+        return {"sekolah": (None, None), "umum": (None, None)}
+
+    # Kandidat kolom target/pop per jenis (buat fleksibel)
+    # Silakan tambahkan alias kolom kamu di sini bila beda penamaan
+    sekolah_target = pick_col(pop_df, [
+        "TARGET_SEKOLAH_68", "Target_Sekolah_68", "target_sekolah_68",
+        "SAMPEL_SEKOLAH_68", "Sampel_Sekolah_68", "sampel_sekolah_68",
+        "target68_sekolah", "Target68_Sekolah"
+    ])
+    sekolah_pop = pick_col(pop_df, [
+        "POP_SEKOLAH", "Pop_Sekolah", "pop_sekolah",
+        "POPULASI_SEKOLAH", "Populasi_Sekolah"
+    ])
+
+    umum_target = pick_col(pop_df, [
+        "TARGET_UMUM_68", "Target_Umum_68", "target_umum_68",
+        "SAMPEL_UMUM_68", "Sampel_Umum_68", "sampel_umum_68",
+        "target68_umum", "Target68_Umum"
+    ])
+    umum_pop = pick_col(pop_df, [
+        "POP_UMUM", "Pop_Umum", "pop_umum",
+        "POPULASI_UMUM", "Populasi_Umum"
+    ])
+
+    return {
+        "sekolah": (sekolah_target, sekolah_pop),
+        "umum": (umum_target, umum_pop),
+    }
+
+
+def build_faktor_wilayah_jenis(
     df_filtered: pd.DataFrame,
     pop_kab: pd.DataFrame,
     pop_prov: pd.DataFrame,
     pop_khusus: pd.DataFrame,
     kew_value: str
 ):
+    """
+    Output: faktor per (wilayah x jenis)
+    Kolom minimal:
+      group_key, [Kab/Kota|Provinsi], Jenis,
+      n_jenis, target_total_68_jenis, pop_total_jenis,
+      coverage_jenis_%, faktor_penyesuaian_jenis, gap_target68_jenis
+    """
     if df_filtered is None or df_filtered.empty:
         return pd.DataFrame()
 
     kew_norm = str(kew_value or "").upper()
     df = df_filtered.copy()
+    df = df[df["_dataset"].isin(["sekolah", "umum", "khusus"])].copy()
+    if df.empty:
+        return pd.DataFrame()
 
-    if "KAB" in kew_norm or "KOTA" in kew_norm:
-        key_col = "kab_key"
-        label_col = "KAB_DISP"
-        label_name = "Kab/Kota"
-        pop = pop_kab.set_index("kab_key") if (pop_kab is not None and not pop_kab.empty) else pd.DataFrame().set_index(pd.Index([]))
-        target_field = "Target68_Total"
-        pop_field = "Pop_Total"
-        name_field = "Kab_Kota_Label"
-
-        # agregat KHUSUS per kab_key (sum)
-        if pop_khusus is not None and not pop_khusus.empty and "kab_key" in pop_khusus.columns:
-            pk_kab = pop_khusus.groupby("kab_key", as_index=False).agg({
-                "Target68_Total_Jenis": "sum",
-                "Pop_Total_Jenis": "sum"
-            }).set_index("kab_key")
-        else:
-            pk_kab = pd.DataFrame().set_index(pd.Index([]))
+    # tentukan level
+    if "PROV" in kew_norm:
+        key_col, label_col, label_name, mode = "prov_key", "PROV_DISP", "Provinsi", "PROV"
+        pop_base = pop_prov.set_index("prov_key") if (pop_prov is not None and not pop_prov.empty and "prov_key" in pop_prov.columns) else pd.DataFrame().set_index(pd.Index([]))
+    else:
+        key_col, label_col, label_name, mode = "kab_key", "KAB_DISP", "Kab/Kota", "KAB"
+        pop_base = pop_kab.set_index("kab_key") if (pop_kab is not None and not pop_kab.empty and "kab_key" in pop_kab.columns) else pd.DataFrame().set_index(pd.Index([]))
+
+    # hitung n per jenis
+    base_n = (
+        df.groupby([key_col, label_col, "_dataset"], dropna=False)
+          .size()
+          .reset_index(name="n_jenis")
+          .rename(columns={key_col: "group_key", label_col: label_name, "_dataset": "Jenis"})
+    )
+    base_n["Jenis"] = base_n["Jenis"].astype(str).str.lower().str.strip()
 
-        pk_prov = None  # tidak dipakai
+    # mapping target/pop sekolah & umum dari POP_KAB/POP_PROV (jika ada)
+    tp_map = _read_target_pop_per_jenis_from_pop(pop_base.reset_index(), mode=mode)
 
-    elif "PROV" in kew_norm:
-        key_col = "prov_key"
-        label_col = "PROV_DISP"
-        label_name = "Provinsi"
-        pop = pop_prov.set_index("prov_key") if (pop_prov is not None and not pop_prov.empty) else pd.DataFrame().set_index(pd.Index([]))
-        target_field = "Target68_Total_Prov"
-        pop_field = "Pop_Total_Prov"
-        name_field = "Provinsi_Label"
-
-        # agregat KHUSUS per prov_key (sum)
-        if pop_khusus is not None and not pop_khusus.empty and "prov_key" in pop_khusus.columns:
-            pk_prov = pop_khusus.groupby("prov_key", as_index=False).agg({
-                "Target68_Total_Jenis": "sum",
-                "Pop_Total_Jenis": "sum"
-            }).set_index("prov_key")
-        else:
-            pk_prov = pd.DataFrame().set_index(pd.Index([]))
+    # siapkan kolom target/pop default
+    base_n["target_total_68_jenis"] = 0.0
+    base_n["pop_total_jenis"] = 0.0
 
-        pk_kab = None  # tidak dipakai
+    # isi sekolah & umum dari POP_KAB/POP_PROV bila kolomnya tersedia
+    for j in ["sekolah", "umum"]:
+        tcol, pcol = tp_map.get(j, (None, None))
+        if tcol is None and pcol is None:
+            continue
 
-    else:
-        # fallback: perlakukan seperti kab/kota
-        key_col = "kab_key"
-        label_col = "KAB_DISP"
-        label_name = "Kab/Kota"
-        pop = pop_kab.set_index("kab_key") if (pop_kab is not None and not pop_kab.empty) else pd.DataFrame().set_index(pd.Index([]))
-        target_field = "Target68_Total"
-        pop_field = "Pop_Total"
-        name_field = "Kab_Kota_Label"
-
-        if pop_khusus is not None and not pop_khusus.empty and "kab_key" in pop_khusus.columns:
-            pk_kab = pop_khusus.groupby("kab_key", as_index=False).agg({
-                "Target68_Total_Jenis": "sum",
-                "Pop_Total_Jenis": "sum"
-            }).set_index("kab_key")
+        # ambil series target/pop per wilayah
+        # (pop_base masih set_index group_key)
+        if not pop_base.empty:
+            if tcol is not None and tcol in pop_base.columns:
+                tser = pd.to_numeric(pop_base[tcol], errors="coerce").fillna(0.0)
+            else:
+                tser = pd.Series(0.0, index=pop_base.index)
+
+            if pcol is not None and pcol in pop_base.columns:
+                pser = pd.to_numeric(pop_base[pcol], errors="coerce").fillna(0.0)
+            else:
+                pser = pd.Series(0.0, index=pop_base.index)
+
+            mask = base_n["Jenis"].eq(j)
+            # map by index
+            base_n.loc[mask, "target_total_68_jenis"] = base_n.loc[mask, "group_key"].map(tser).fillna(0.0).values
+            base_n.loc[mask, "pop_total_jenis"] = base_n.loc[mask, "group_key"].map(pser).fillna(0.0).values
+
+    # isi KHUSUS dari POP_KHUSUS (sum per wilayah)
+    if pop_khusus is not None and not pop_khusus.empty:
+        pk = pop_khusus.copy()
+        pk["Target68_Total_Jenis"] = pd.to_numeric(pk.get("Target68_Total_Jenis", np.nan), errors="coerce").fillna(0.0)
+        pk["Pop_Total_Jenis"] = pd.to_numeric(pk.get("Pop_Total_Jenis", np.nan), errors="coerce").fillna(0.0)
+
+        if mode == "PROV" and "prov_key" in pk.columns:
+            pk_map = pk.groupby("prov_key", as_index=False).agg(
+                target_total_68_jenis=("Target68_Total_Jenis", "sum"),
+                pop_total_jenis=("Pop_Total_Jenis", "sum"),
+            ).rename(columns={"prov_key": "group_key"})
+        elif mode == "KAB" and "kab_key" in pk.columns:
+            pk_map = pk.groupby("kab_key", as_index=False).agg(
+                target_total_68_jenis=("Target68_Total_Jenis", "sum"),
+                pop_total_jenis=("Pop_Total_Jenis", "sum"),
+            ).rename(columns={"kab_key": "group_key"})
         else:
-            pk_kab = pd.DataFrame().set_index(pd.Index([]))
+            pk_map = pd.DataFrame(columns=["group_key","target_total_68_jenis","pop_total_jenis"])
 
-        pk_prov = None
+        if not pk_map.empty:
+            mask_khusus = base_n["Jenis"].eq("khusus")
+            tmp = base_n.loc[mask_khusus, ["group_key"]].merge(pk_map, on="group_key", how="left")
+            base_n.loc[mask_khusus, "target_total_68_jenis"] = pd.to_numeric(tmp["target_total_68_jenis"], errors="coerce").fillna(0.0).values
+            base_n.loc[mask_khusus, "pop_total_jenis"] = pd.to_numeric(tmp["pop_total_jenis"], errors="coerce").fillna(0.0).values
 
-    base = df.groupby([key_col, label_col], dropna=False).agg(
-        n_total=("Indeks_Dasar_0_100", "size"),
-    ).reset_index().rename(columns={key_col: "group_key", label_col: label_name})
+    # fallback pop dari target
+    base_n["target_total_68_jenis"] = pd.to_numeric(base_n["target_total_68_jenis"], errors="coerce").fillna(0.0)
+    base_n["pop_total_jenis"] = pd.to_numeric(base_n["pop_total_jenis"], errors="coerce").fillna(0.0)
 
-    target_vals, pop_vals, label_fix = [], [], []
-    for _, r in base.iterrows():
-        gk = r["group_key"]
+    m_need_pop = (base_n["pop_total_jenis"] <= 0) & (base_n["target_total_68_jenis"] > 0)
+    base_n.loc[m_need_pop, "pop_total_jenis"] = base_n.loc[m_need_pop, "target_total_68_jenis"] / float(FALLBACK_TARGET_RATIO)
 
-        # --- ambil dari POP_KAB/POP_PROV (existing) ---
-        if gk in pop.index:
-            target_total = 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]
-
-        # --- TAMBAH KHUSUS (ini inti request kamu) ---
-        add_target, add_pop = 0.0, 0.0
-        if "PROV" in kew_norm:
-            if pk_prov is not None and (gk in pk_prov.index):
-                add_target = pk_prov.loc[gk, "Target68_Total_Jenis"] if "Target68_Total_Jenis" in pk_prov.columns else 0.0
-                add_pop = pk_prov.loc[gk, "Pop_Total_Jenis"] if "Pop_Total_Jenis" in pk_prov.columns else 0.0
-        else:
-            if pk_kab is not None and (gk in pk_kab.index):
-                add_target = pk_kab.loc[gk, "Target68_Total_Jenis"] if "Target68_Total_Jenis" in pk_kab.columns else 0.0
-                add_pop = pk_kab.loc[gk, "Pop_Total_Jenis"] if "Pop_Total_Jenis" in pk_kab.columns else 0.0
-
-        # amanin numeric
-        t0 = float(pd.to_numeric(target_total, errors="coerce")) if pd.notna(target_total) else 0.0
-        p0 = float(pd.to_numeric(pop_total, errors="coerce")) if pd.notna(pop_total) else 0.0
-        at = float(pd.to_numeric(add_target, errors="coerce")) if pd.notna(add_target) else 0.0
-        ap = float(pd.to_numeric(add_pop, errors="coerce")) if pd.notna(add_pop) else 0.0
-
-        target_vals.append(t0 + at)
-        pop_vals.append(p0 + ap)
-        label_fix.append(nm)
-
-    base[label_name] = label_fix
-    base["target_total_68"] = pd.to_numeric(pd.Series(target_vals), errors="coerce")
-    base["pop_total"] = pd.to_numeric(pd.Series(pop_vals), errors="coerce")
-
-    # fallback pop_total bila kosong tapi target ada
-    m = base["pop_total"].isna() & base["target_total_68"].notna() & (base["target_total_68"] > 0)
-    base.loc[m, "pop_total"] = base.loc[m, "target_total_68"] / float(FALLBACK_TARGET_RATIO)
-
-    # logika faktor TIDAK DIUBAH
-    base["faktor_penyesuaian"] = [
+    # faktor per jenis
+    base_n["faktor_penyesuaian_jenis"] = [
         faktor_penyesuaian_total(n, t)
         for n, t in zip(
-            pd.to_numeric(base["n_total"], errors="coerce").fillna(0).astype(float).tolist(),
-            pd.to_numeric(base["target_total_68"], errors="coerce").tolist()
+            pd.to_numeric(base_n["n_jenis"], errors="coerce").fillna(0).astype(float).tolist(),
+            pd.to_numeric(base_n["target_total_68_jenis"], errors="coerce").fillna(0).astype(float).tolist()
         )
     ]
 
-    base["coverage_total_%"] = [
-        (safe_div(n, p) * 100) if (p is not None and not pd.isna(p) and float(p) > 0) else np.nan
+    base_n["coverage_jenis_%"] = [
+        (safe_div(n, p) * 100) if (p is not None and not pd.isna(p) and float(p) > 0) else 0.0
         for n, p in zip(
-            pd.to_numeric(base["n_total"], errors="coerce").fillna(0).astype(float).tolist(),
-            base["pop_total"].tolist()
+            pd.to_numeric(base_n["n_jenis"], errors="coerce").fillna(0).astype(float).tolist(),
+            pd.to_numeric(base_n["pop_total_jenis"], errors="coerce").fillna(0).astype(float).tolist()
         )
     ]
 
-    # ====== DISPLAY (sesuai permintaan awal kamu) ======
-    base["target_total_68"] = pd.to_numeric(base["target_total_68"], errors="coerce").fillna(0).round(0).astype(int)
-    base["pop_total"] = pd.to_numeric(base["pop_total"], errors="coerce").fillna(0).round(0).astype(int)
-    base["coverage_total_%"] = pd.to_numeric(base["coverage_total_%"], errors="coerce").fillna(0.0).round(2)
-    base["faktor_penyesuaian"] = pd.to_numeric(base["faktor_penyesuaian"], errors="coerce").fillna(1.0).round(3)
+    base_n["gap_target68_jenis"] = [
+        max(t - n, 0)
+        for n, t in zip(
+            pd.to_numeric(base_n["n_jenis"], errors="coerce").fillna(0).astype(float).tolist(),
+            pd.to_numeric(base_n["target_total_68_jenis"], errors="coerce").fillna(0).astype(float).tolist()
+        )
+    ]
+
+    # DISPLAY sesuai request (target/pop int, coverage 2 desimal)
+    base_n["target_total_68_jenis"] = pd.to_numeric(base_n["target_total_68_jenis"], errors="coerce").fillna(0).round(0).astype(int)
+    base_n["pop_total_jenis"] = pd.to_numeric(base_n["pop_total_jenis"], errors="coerce").fillna(0).round(0).astype(int)
+    base_n["coverage_jenis_%"] = pd.to_numeric(base_n["coverage_jenis_%"], errors="coerce").fillna(0.0).round(2)
+    base_n["faktor_penyesuaian_jenis"] = pd.to_numeric(base_n["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0).round(3)
+    base_n["gap_target68_jenis"] = pd.to_numeric(base_n["gap_target68_jenis"], errors="coerce").fillna(0).round(0).astype(int)
 
-    return base
+    return base_n
 
 # ============================================================
-# 7) AGREGAT WILAYAH × JENIS (Final pakai faktor wilayah)
+# 7) AGREGAT WILAYAH × JENIS (PATCH: faktor 68% PER JENIS)
 # ============================================================
 
-def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, faktor_wilayah: pd.DataFrame, pop_khusus: pd.DataFrame, kew_value: str):
+def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, faktor_wilayah_jenis: pd.DataFrame, kew_value: str):
     if df_filtered is None or df_filtered.empty:
         return pd.DataFrame()
 
     kew_norm = str(kew_value or "").upper()
     df = df_filtered.copy()
 
-    if "KAB" in kew_norm or "KOTA" in kew_norm:
-        key_col = "kab_key"
-        label_col = "KAB_DISP"
-        label_name = "Kab/Kota"
-        mode = "KAB"
-    elif "PROV" in kew_norm:
-        key_col = "prov_key"
-        label_col = "PROV_DISP"
-        label_name = "Provinsi"
-        mode = "PROV"
+    if "PROV" in kew_norm:
+        key_col, label_col, label_name = "prov_key", "PROV_DISP", "Provinsi"
     else:
-        key_col = "kab_key"
-        label_col = "KAB_DISP"
-        label_name = "Kab/Kota"
-        mode = "KAB"
+        key_col, label_col, label_name = "kab_key", "KAB_DISP", "Kab/Kota"
 
     df = df[df["_dataset"].isin(["sekolah", "umum", "khusus"])].copy()
     if df.empty:
@@ -826,81 +853,41 @@ def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, faktor_wilayah: pd.DataFr
         Rata2_dim_kepatuhan=("dim_kepatuhan", "mean"),
         Rata2_dim_kinerja=("dim_kinerja", "mean"),
         Indeks_Dasar_Agregat_0_100=("Indeks_Dasar_0_100", "mean"),
-    ).reset_index()
+    ).reset_index().rename(columns={key_col: "group_key", label_col: label_name, "_dataset": "Jenis"})
 
-    agg = agg.rename(columns={key_col: "group_key", label_col: label_name, "_dataset": "Jenis"})
+    agg["Jenis"] = agg["Jenis"].astype(str).str.lower().str.strip()
 
-    # faktor wilayah (sama untuk semua jenis)
-    if faktor_wilayah is None or faktor_wilayah.empty:
-        agg["faktor_penyesuaian_wilayah"] = 1.0
-        agg["target_total_68"] = np.nan
-        agg["pop_total"] = np.nan
-        agg["coverage_total_%"] = np.nan
+    # merge faktor PER JENIS
+    if faktor_wilayah_jenis is None or faktor_wilayah_jenis.empty:
+        agg["faktor_penyesuaian_jenis"] = 1.0
+        agg["target_total_68_jenis"] = 0
+        agg["pop_total_jenis"] = 0
+        agg["coverage_jenis_%"] = 0.0
+        agg["gap_target68_jenis"] = 0
     else:
-        fw = faktor_wilayah.copy()
-        keep = ["group_key", label_name, "faktor_penyesuaian", "target_total_68", "pop_total", "coverage_total_%"]
+        fw = faktor_wilayah_jenis.copy()
+        keep = ["group_key", label_name, "Jenis",
+                "faktor_penyesuaian_jenis", "target_total_68_jenis", "pop_total_jenis",
+                "coverage_jenis_%", "gap_target68_jenis"]
         keep = [c for c in keep if c in fw.columns]
-        fw = fw[keep].rename(columns={"faktor_penyesuaian": "faktor_penyesuaian_wilayah"})
-        agg = agg.merge(fw, on=["group_key", label_name], how="left")
-        agg["faktor_penyesuaian_wilayah"] = pd.to_numeric(agg["faktor_penyesuaian_wilayah"], errors="coerce").fillna(1.0)
+        fw = fw[keep]
+        agg = agg.merge(fw, on=["group_key", label_name, "Jenis"], how="left")
 
-    agg["faktor_penyesuaian"] = agg["faktor_penyesuaian_wilayah"]
-    agg["Indeks_Final_Agregat_0_100"] = (
-        pd.to_numeric(agg["Indeks_Dasar_Agregat_0_100"], errors="coerce").fillna(0.0) * agg["faktor_penyesuaian"]
-    )
+        agg["faktor_penyesuaian_jenis"] = pd.to_numeric(agg["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0)
 
-    # =========================
-    # PATCH INTI: target/pop/coverage per jenis (khusus) via MERGE (anti miss)
-    # =========================
-    agg["target_total_68_jenis"] = 0.0
-    agg["pop_total_jenis"] = 0.0
-    agg["coverage_jenis"] = 0.0
+        for c in ["target_total_68_jenis","pop_total_jenis","gap_target68_jenis"]:
+            if c in agg.columns:
+                agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(0).round(0).astype(int)
+        if "coverage_jenis_%" in agg.columns:
+            agg["coverage_jenis_%"] = pd.to_numeric(agg["coverage_jenis_%"], errors="coerce").fillna(0.0).round(2)
 
-    if pop_khusus is not None and (not pop_khusus.empty):
-        pk = pop_khusus.copy()
-
-        # pastikan numeric
-        pk["Target68_Total_Jenis"] = pd.to_numeric(pk.get("Target68_Total_Jenis", np.nan), errors="coerce")
-        pk["Pop_Total_Jenis"] = pd.to_numeric(pk.get("Pop_Total_Jenis", np.nan), errors="coerce")
-
-        # ambil mapping sesuai mode
-        if mode == "PROV":
-            # agregat prov (sum) supaya provinsi khusus masuk
-            if "prov_key" in pk.columns:
-                pk_map = pk.groupby("prov_key", as_index=False).agg(
-                    target_total_68_jenis=("Target68_Total_Jenis", "sum"),
-                    pop_total_jenis=("Pop_Total_Jenis", "sum"),
-                ).rename(columns={"prov_key": "group_key"})
-            else:
-                pk_map = pd.DataFrame(columns=["group_key", "target_total_68_jenis", "pop_total_jenis"])
-        else:
-            # kab/kota (sum) supaya kab/kota khusus masuk
-            if "kab_key" in pk.columns:
-                pk_map = pk.groupby("kab_key", as_index=False).agg(
-                    target_total_68_jenis=("Target68_Total_Jenis", "sum"),
-                    pop_total_jenis=("Pop_Total_Jenis", "sum"),
-                ).rename(columns={"kab_key": "group_key"})
-            else:
-                pk_map = pd.DataFrame(columns=["group_key", "target_total_68_jenis", "pop_total_jenis"])
-
-        # merge hanya untuk baris Jenis=khusus (biar sekolah/umum tetap 0)
-        is_khusus = agg["Jenis"].astype(str).str.lower().str.strip().eq("khusus")
-        if is_khusus.any() and (pk_map is not None) and (not pk_map.empty):
-            tmp = agg.loc[is_khusus, ["group_key"]].merge(pk_map, on="group_key", how="left")
-            agg.loc[is_khusus, "target_total_68_jenis"] = pd.to_numeric(tmp["target_total_68_jenis"], errors="coerce").fillna(0.0).values
-            agg.loc[is_khusus, "pop_total_jenis"] = pd.to_numeric(tmp["pop_total_jenis"], errors="coerce").fillna(0.0).values
-
-    # fallback pop dari target
-    agg["target_total_68_jenis"] = pd.to_numeric(agg["target_total_68_jenis"], errors="coerce").fillna(0.0)
-    agg["pop_total_jenis"] = pd.to_numeric(agg["pop_total_jenis"], errors="coerce").fillna(0.0)
-
-    m_need_pop = (agg["pop_total_jenis"] <= 0) & (agg["target_total_68_jenis"] > 0)
-    agg.loc[m_need_pop, "pop_total_jenis"] = agg.loc[m_need_pop, "target_total_68_jenis"] / float(FALLBACK_TARGET_RATIO)
-
-    m2 = agg["pop_total_jenis"] > 0
-    agg.loc[m2, "coverage_jenis"] = (pd.to_numeric(agg.loc[m2, "Jumlah"], errors="coerce").fillna(0.0) / agg.loc[m2, "pop_total_jenis"]) * 100.0
+    # Indeks FINAL PER JENIS
+    agg["Indeks_Final_Agregat_0_100"] = (
+        pd.to_numeric(agg["Indeks_Dasar_Agregat_0_100"], errors="coerce").fillna(0.0)
+        * pd.to_numeric(agg["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0)
+    )
 
-    # rounding (tampilan konsisten)
+    # rounding tampilan
     for c in [
         "Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan",
         "Rata2_dim_kepatuhan","Rata2_dim_kinerja"
@@ -912,27 +899,19 @@ def build_agg_wilayah_jenis(df_filtered: pd.DataFrame, faktor_wilayah: pd.DataFr
         if c in agg.columns:
             agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(0.0).round(2)
 
-    for c in ["faktor_penyesuaian_wilayah","faktor_penyesuaian"]:
-        if c in agg.columns:
-            agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(1.0).round(3)
-
-    for c in ["target_total_68","pop_total","coverage_total_%","target_total_68_jenis","pop_total_jenis","coverage_jenis"]:
-        if c in agg.columns:
-            agg[c] = pd.to_numeric(agg[c], errors="coerce").fillna(0.0)
+    agg["faktor_penyesuaian_jenis"] = pd.to_numeric(agg["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0).round(3)
 
     return agg
-
-
 # ============================================================
-# 8) AGREGAT WILAYAH (KESELURUHAN) — RUMUS BARU: AVG3 dari 3 jenis
+# 8) AGREGAT WILAYAH (KESELURUHAN) — FIX: avg3 + tampilkan POP/TARGET/GAP per jenis
 # ============================================================
 
-def build_agg_wilayah_total_from_jenis(agg_jenis: pd.DataFrame, faktor_wilayah: pd.DataFrame, kew_value: str):
+def build_agg_wilayah_total_from_jenis(agg_jenis: pd.DataFrame, faktor_wilayah_jenis: pd.DataFrame, kew_value: str):
     if agg_jenis is None or agg_jenis.empty:
         return pd.DataFrame()
 
     kew_norm = str(kew_value or "").upper()
-    label_name = "Kab/Kota" if ("KAB" in kew_norm or "KOTA" in kew_norm) else ("Provinsi" if "PROV" in kew_norm else "Kab/Kota")
+    label_name = "Provinsi" if "PROV" in kew_norm else "Kab/Kota"
 
     jenis_list = ["sekolah", "umum", "khusus"]
 
@@ -961,11 +940,10 @@ def build_agg_wilayah_total_from_jenis(agg_jenis: pd.DataFrame, faktor_wilayah:
         how="left"
     )
 
-    # missing=0 (kunci avg3 tetap ÷3)
+    # missing=0 (avg3 tetap ÷3)
     for c in cols_present:
         full[c] = pd.to_numeric(full[c], errors="coerce").fillna(0.0)
 
-    # keseluruhan wilayah = avg3 dari 3 jenis
     out = full.groupby(["group_key", label_name], as_index=False).agg(
         n_total=("Jumlah", "sum"),
         Rata2_sub_koleksi=("Rata2_sub_koleksi", "mean"),
@@ -978,14 +956,34 @@ def build_agg_wilayah_total_from_jenis(agg_jenis: pd.DataFrame, faktor_wilayah:
         Indeks_Final_Wilayah_0_100=("Indeks_Final_Agregat_0_100", "mean"),
     )
 
-    # tempel faktor/target/pop/coverage (informasi verifikasi)
-    if faktor_wilayah is not None and not faktor_wilayah.empty:
-        fw = faktor_wilayah.copy()
-        keep_fw = ["group_key", label_name, "target_total_68", "pop_total", "faktor_penyesuaian", "coverage_total_%"]
-        keep_fw = [c for c in keep_fw if c in fw.columns]
-        out = out.merge(fw[keep_fw], on=["group_key", label_name], how="left")
+    # --- tempel POP/TARGET/SAMPEL/GAP per jenis ke agg_total ---
+    if faktor_wilayah_jenis is not None and not faktor_wilayah_jenis.empty:
+        fw = faktor_wilayah_jenis.copy()
+        fw["Jenis"] = fw["Jenis"].astype(str).str.lower().str.strip()
+
+        # pivot target/pop/n/gap per jenis
+        piv = fw.pivot_table(
+            index=["group_key", label_name],
+            columns="Jenis",
+            values=["pop_total_jenis", "target_total_68_jenis", "n_jenis", "gap_target68_jenis"],
+            aggfunc="first"
+        )
 
-    # rounding
+        # flatten columns
+        piv.columns = [f"{v}_{k}" for v, k in piv.columns]
+        piv = piv.reset_index()
+
+        out = out.merge(piv, on=["group_key", label_name], how="left")
+
+        # rapihin NaN -> 0
+        for j in ["sekolah","umum","khusus"]:
+            for basecol in ["pop_total_jenis", "target_total_68_jenis", "n_jenis", "gap_target68_jenis"]:
+                c = f"{basecol}_{j}"
+                if c in out.columns:
+                    if basecol == "pop_total_jenis" or basecol == "target_total_68_jenis" or basecol == "n_jenis" or basecol == "gap_target68_jenis":
+                        out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0).round(0).astype(int)
+
+    # rounding index
     for c in [
         "Rata2_sub_koleksi","Rata2_sub_sdm","Rata2_sub_pelayanan","Rata2_sub_pengelolaan",
         "Rata2_dim_kepatuhan","Rata2_dim_kinerja"
@@ -997,13 +995,6 @@ def build_agg_wilayah_total_from_jenis(agg_jenis: pd.DataFrame, faktor_wilayah:
         if c in out.columns:
             out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0).round(2)
 
-    if "faktor_penyesuaian" in out.columns:
-        out["faktor_penyesuaian"] = pd.to_numeric(out["faktor_penyesuaian"], errors="coerce").fillna(1.0).round(3)
-
-    for c in ["target_total_68","pop_total","coverage_total_%"]:
-        if c in out.columns:
-            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0.0)
-
     return out
 
 
@@ -1149,41 +1140,37 @@ def attach_final_to_detail(df_filtered: pd.DataFrame, agg_total: pd.DataFrame, m
 
 
 # ============================================================
-# 11) VERIFIKASI TOTAL (tanpa koma) — pakai faktor_wilayah
+# 11) VERIFIKASI PER JENIS (OPSIONAL, TANPA KOMA)
 # ============================================================
 
-def build_verif_total(faktor_wilayah: pd.DataFrame):
-    if faktor_wilayah is None or faktor_wilayah.empty:
+def build_verif_jenis(faktor_wilayah_jenis: pd.DataFrame, kew_value: str):
+    if faktor_wilayah_jenis is None or faktor_wilayah_jenis.empty:
         return pd.DataFrame()
 
-    df = faktor_wilayah.copy()
-    label_col = "Kab/Kota" if "Kab/Kota" in df.columns else ("Provinsi" if "Provinsi" in df.columns else "Wilayah")
-
-    out = pd.DataFrame({
-        label_col: df[label_col].astype(str),
-        "Pop_Total": df.get("pop_total", 0),
-        "Target_68_Total": df.get("target_total_68", 0),
-        "Sampel_Total_Terkumpul": df.get("n_total", 0),
-        "Coverage_Total_%": df.get("coverage_total_%", 0),
-        "Faktor_Penyesuaian_(Sampel/Target68)_persen": pd.to_numeric(df.get("faktor_penyesuaian", 1.0), errors="coerce").fillna(1.0) * 100,
-        "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.get("n_total", 0), errors="coerce").fillna(0).astype(float).tolist(),
-                pd.to_numeric(df.get("target_total_68", 0), errors="coerce").fillna(0).astype(float).tolist()
-            )
-        ],
-        "Catatan": [
-            ("Target68_Total_tidak_valid" if (t is None or pd.isna(t) or float(t) <= 0) else "")
-            for t in pd.to_numeric(df.get("target_total_68", 0), errors="coerce").tolist()
-        ]
-    })
+    kew_norm = str(kew_value or "").upper()
+    label_col = "Provinsi" if "PROV" in kew_norm else "Kab/Kota"
 
-    # TANPA KOMA: semua numerik jadi integer
-    for c in out.columns:
-        if c in [label_col, "Catatan"]:
-            continue
-        out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0).round(0).astype(int)
+    out = faktor_wilayah_jenis.copy()
+    keep = [c for c in [
+        label_col, "Jenis",
+        "pop_total_jenis", "target_total_68_jenis", "n_jenis",
+        "coverage_jenis_%", "faktor_penyesuaian_jenis", "gap_target68_jenis"
+    ] if c in out.columns]
+
+    out = out[keep].copy()
+
+    # tanpa koma untuk integer columns
+    for c in ["pop_total_jenis", "target_total_68_jenis", "n_jenis", "gap_target68_jenis"]:
+        if c in out.columns:
+            out[c] = pd.to_numeric(out[c], errors="coerce").fillna(0).round(0).astype(int)
+
+    # coverage 2 desimal tetap boleh (request awal kamu coverage decimal 2)
+    if "coverage_jenis_%" in out.columns:
+        out["coverage_jenis_%"] = pd.to_numeric(out["coverage_jenis_%"], errors="coerce").fillna(0.0).round(2)
+
+    # faktor 3 desimal
+    if "faktor_penyesuaian_jenis" in out.columns:
+        out["faktor_penyesuaian_jenis"] = pd.to_numeric(out["faktor_penyesuaian_jenis"], errors="coerce").fillna(1.0).round(3)
 
     return out
 
@@ -1300,10 +1287,10 @@ def _make_bell_curve(dfp: pd.DataFrame, xcol: str, title: str, label_col: str |
 
 
 # ============================================================
-# 13) KPI DASHBOARD (Final harus sumber Ringkasan)
+# 13) KPI DASHBOARD (PATCH: cakupan 68% PER JENIS -> avg3)
 # ============================================================
 
-def compute_dashboard_kpis(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, agg_jenis: pd.DataFrame):
+def compute_dashboard_kpis(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, agg_jenis: pd.DataFrame, faktor_wilayah_jenis: pd.DataFrame | None = None):
     def _get_final(j):
         sub = summary_jenis[summary_jenis["Jenis"].astype(str).str.lower() == j]
         if sub.empty:
@@ -1328,16 +1315,30 @@ def compute_dashboard_kpis(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame,
     dasar_khusus  = _get_dasar("khusus")
     dasar_all     = (dasar_sekolah + dasar_umum + dasar_khusus) / 3.0
 
-    if agg_total is not None and not agg_total.empty:
-        n_sum = float(pd.to_numeric(agg_total.get("n_total", 0), errors="coerce").fillna(0).sum())
-        t_ser = pd.to_numeric(agg_total.get("target_total_68", np.nan), errors="coerce")
-        t_sum = float(t_ser[t_ser > 0].fillna(0).sum()) if hasattr(t_ser, "__len__") else float(t_ser)
-        coverage_factor = min(n_sum / t_sum, 1.0) if (t_sum and t_sum > 0) else 1.0
-        cakupan_pct = coverage_factor * 100.0
-        faktor_mean = float(pd.to_numeric(agg_total.get("faktor_penyesuaian", 1.0), errors="coerce").fillna(1.0).mean())
-    else:
-        cakupan_pct = 0.0
-        faktor_mean = 1.0
+    # === PATCH: cakupan dihitung PER JENIS (total n_jenis / total target_jenis), lalu avg3 ===
+    cakupan_pct = 0.0
+    faktor_mean = 1.0
+    if faktor_wilayah_jenis is not None and (not faktor_wilayah_jenis.empty):
+        fw = faktor_wilayah_jenis.copy()
+        fw["Jenis"] = fw["Jenis"].astype(str).str.lower().str.strip()
+
+        factors = []
+        for j in ["sekolah","umum","khusus"]:
+            sub = fw[fw["Jenis"] == j]
+            if sub.empty:
+                factors.append(0.0)
+                continue
+
+            n_sum = float(pd.to_numeric(sub.get("n_jenis", 0), errors="coerce").fillna(0).sum())
+            t_sum = float(pd.to_numeric(sub.get("target_total_68_jenis", 0), errors="coerce").fillna(0).sum())
+            f = min(n_sum / t_sum, 1.0) if (t_sum and t_sum > 0) else 0.0
+            factors.append(f)
+
+        cakupan_pct = (sum(factors) / 3.0) * 100.0
+
+        # faktor_mean juga dibuat avg3 dari faktor total per jenis (opsional)
+        # kalau mau: mean faktor per-wilayah×jenis
+        faktor_mean = float(pd.to_numeric(fw.get("faktor_penyesuaian_jenis", 1.0), errors="coerce").fillna(1.0).mean())
 
     dampak = final_all - dasar_all
 
@@ -1349,11 +1350,12 @@ def compute_dashboard_kpis(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame,
         "dampak": dampak
     }
 
-def build_kpi_markdown(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, agg_jenis: pd.DataFrame) -> str:
+
+def build_kpi_markdown(summary_jenis: pd.DataFrame, agg_total: pd.DataFrame, agg_jenis: pd.DataFrame, faktor_wilayah_jenis: pd.DataFrame | None = None) -> str:
     if summary_jenis is None or summary_jenis.empty:
         return ""
 
-    k = compute_dashboard_kpis(summary_jenis, agg_total, agg_jenis)
+    k = compute_dashboard_kpis(summary_jenis, agg_total, agg_jenis, faktor_wilayah_jenis=faktor_wilayah_jenis)
 
     def fmt(x, nd=2):
         return "NA" if pd.isna(x) else f"{x:.{nd}f}"
@@ -1578,13 +1580,18 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
         if df.empty:
             return _empty_outputs("Tidak ada data untuk filter ini.")
 
-        # ==== PIPELINE BARU (KUNCI KONSISTENSI) ====
-        faktor_wilayah = build_faktor_wilayah(df, pop_kab, pop_prov, pop_khusus, kew_value or "(Semua)")
-        agg_jenis_full = build_agg_wilayah_jenis(df, faktor_wilayah, pop_khusus, kew_value or "(Semua)")
-        agg_total      = build_agg_wilayah_total_from_jenis(agg_jenis_full, faktor_wilayah, kew_value or "(Semua)")
+        # ==== PIPELINE BARU (PATCH: faktor 68% PER JENIS) ====
+        faktor_wilayah_jenis = build_faktor_wilayah_jenis(df, pop_kab, pop_prov, pop_khusus, kew_value or "(Semua)")
+        agg_jenis_full = build_agg_wilayah_jenis(df, faktor_wilayah_jenis, kew_value or "(Semua)")
+        agg_total      = build_agg_wilayah_total_from_jenis(agg_jenis_full, faktor_wilayah_jenis, kew_value or "(Semua)")
         summary_jenis  = build_summary_per_jenis(agg_jenis_full, agg_total)
-        verif_total    = build_verif_total(faktor_wilayah)  # tanpa koma
-        detail_view    = attach_final_to_detail(df, agg_total, meta, kew_value or "(Semua)")
+        
+        # verif_total: kalau kamu masih mau tabel verifikasi, sekarang logikanya sebaiknya per jenis
+        # tapi karena request kamu fokus ringkasan + agg_total, verif_total bisa tetap pakai "ringkas" dari faktor_wilayah_jenis
+        # (opsional) kita bikin verif_total sederhana dari faktor_wilayah_jenis:
+        verif_total = build_verif_jenis(faktor_wilayah_jenis, kew_value or "(Semua)")
+        detail_view  = attach_final_to_detail(df, agg_total, meta, kew_value or "(Semua)")
+
 
         # ====== UPDATE SESUAI PERMINTAAN (UI ONLY) ======
         # Tabel Agregat Wilayah × Jenis cukup sampai Indeks_Dasar_Agregat_0_100
@@ -1633,7 +1640,7 @@ def run_calc(prov_value, kab_value, kew_value, df_all, df_raw, pop_kab, pop_prov
             fig_khusus  = _fig_jenis_ent("khusus",  "Bell Curve — Jenis: Khusus (Indeks per Entitas)")
 
         # KPI markdown (FINAL sumber Ringkasan)
-        kpi_md = build_kpi_markdown(summary_jenis, agg_total, agg_jenis_full)
+        kpi_md = build_kpi_markdown(summary_jenis, agg_total, agg_jenis_full, faktor_wilayah_jenis=faktor_wilayah_jenis)
 
         tmpdir = tempfile.mkdtemp()
         prov_slug = (_canon(prov_value or "SEMUA").upper() or "SEMUA")