Delete app.py

app.py

@@ -1,1597 +0,0 @@
-import os
-import re
-import tempfile
-from pathlib import Path
-
-import gradio as gr
-import numpy as np
-import pandas as pd
-import plotly.graph_objects as go
-from huggingface_hub import InferenceClient
-from sklearn.preprocessing import PowerTransformer
-
-# ============================================================
-# 1. KONFIGURASI FILE & PARAMETER
-# ============================================================
-
-DATA_FILE       = "DM.xlsx"                       # data utama perpustakaan
-META_KAB_FILE   = "jumlahdesa_fixed.xlsx"         # kecamatan & desa/kel per kab/kota
-META_SDSMP_FILE = "jumlah_SD_SMP.xlsx"            # jumlah SD & SMP per kab/kota
-META_SMA_FILE   = "Data_SMA_propinsi_update.xlsx" # jumlah SMA per provinsi
-
-# Kelompok indikator IPLM
-koleksi_cols = [
-    "JudulTercetak","EksemplarTercetak","JudulElektronik","EksemplarElektronik",
-    "TambahJudulTercetak","TambahEksemplarTercetak",
-    "TambahJudulElektronik","TambahEksemplarElektronik",
-    "KomitmenAnggaranKoleksi"
-]
-sdm_cols = [
-    "TenagaKualifikasiIlmuPerpustakaan",
-    "TenagaFungsionalProfesional",
-    "TenagaPKB",
-    "AnggaranTenaga"
-]
-pelayanan_cols = [
-    "PesertaBudayaBaca","PemustakaLuringDaring","PemustakaFasilitasTIK",
-    "PemanfaatanJudulTercetak","PemanfaatanEksemplarTercetak",
-    "PemanfaatanJudulElektronik","PemanfaatanEksemplarElektronik"
-]
-pengelolaan_cols = [
-    "KegiatanBudayaBaca","KegiatanKerjasama","VariasiLayanan","Kebijakan","AnggaranLayanan"
-]
-all_indicators = koleksi_cols + sdm_cols + pelayanan_cols + pengelolaan_cols
-
-# Bobot indeks IPLM
-w_kepatuhan = 0.30
-w_kinerja   = 0.70
-
-# Bobot untuk Confidence
-W_DATA   = 0.7
-W_SAMPLE = 0.3
-SAMPLE_THRESHOLD = 10   # ambang jumlah perpus per kab/kota
-
-# Target normatif per jenis perpustakaan
-TARGETS = {
-    "sekolah": {
-        "JudulTercetak": 1000,
-        "EksemplarTercetak": 5000,
-        "KegiatanBudayaBaca": 12,
-        "PemustakaLuringDaring": 1000,
-    },
-    "umum": {
-        "JudulTercetak": 500,
-        "EksemplarTercetak": 1000,
-        "KegiatanBudayaBaca": 24,
-        "PemustakaLuringDaring": 1000,
-        "VariasiLayanan": 7,
-        "TenagaKualifikasiIlmuPerpustakaan": 1,
-    },
-    "khusus": {
-        "JudulTercetak": 5000,
-        "EksemplarTercetak": 10000,
-        "KegiatanBudayaBaca": 6,
-        "PemustakaLuringDaring": 1000,
-    }
-}
-
-# ============================================================
-# 1b. KONFIGURASI LLM (Hugging Face Inference)
-# ============================================================
-
-# Pilih model yang stabil untuk text_generation:
-# 1b. KONFIGURASI LLM (Hugging Face Inference)
-USE_LLM = True
-
-# Pilih salah satu model yang kompatibel
-LLM_MODEL_NAME = "meta-llama/Meta-Llama-3-8B-Instruct"
-# LLM_MODEL_NAME = "mistralai/Mistral-7B-Instruct-v0.2"
-# Alternatif lain (juga kompatibel):
-# LLM_MODEL_NAME = "mistralai/Mistral-7B-Instruct-v0.2"
-
-HF_TOKEN = (
-    os.getenv("HF_TOKEN")
-    or os.getenv("HUGGINGFACEHUB_API_TOKEN")
-    or os.getenv("HF_API_TOKEN")
-)
-
-_HF_CLIENT = None
-
-
-def get_llm_client():
-    """
-    Inisialisasi InferenceClient sekali, lalu dipakai ulang.
-    Kalau gagal (misal token salah / model tidak support), kembalikan None.
-    """
-    global _HF_CLIENT
-    if _HF_CLIENT is not None:
-        return _HF_CLIENT
-
-    try:
-        if HF_TOKEN:
-            _HF_CLIENT = InferenceClient(model=LLM_MODEL_NAME, token=HF_TOKEN)
-        else:
-            # Bisa saja tetap jalan tanpa token jika model public, tapi rate-limit keras.
-            _HF_CLIENT = InferenceClient(model=LLM_MODEL_NAME)
-        return _HF_CLIENT
-    except Exception:
-        _HF_CLIENT = None
-        return None
-
-
-# ============================================================
-# 2. FUNGSI UTIL
-# ============================================================
-
-def _canon(s: str) -> str:
-    return re.sub(r"[^a-z0-9]+", "", str(s).lower())
-
-
-def coerce_num(val):
-    if pd.isna(val):
-        return np.nan
-    t = str(val).strip()
-    if t == "" or t in {"-", "–", "—"}:
-        return np.nan
-    t = t.replace("\u00a0", " ").replace("Rp", "").replace("%", "")
-    t = re.sub(r"[^0-9,.\-]", "", t)
-    if t.count(".") > 1 and t.count(",") == 1:
-        t = t.replace(".", "").replace(",", ".")
-    elif t.count(",") > 1 and t.count(".") == 1:
-        t = t.replace(",", "")
-    elif t.count(",") == 1 and t.count(".") == 0:
-        t = t.replace(",", ".")
-    else:
-        t = t.replace(",", "")
-    try:
-        return float(t)
-    except Exception:
-        return np.nan
-
-
-def minmax_norm(s: pd.Series) -> pd.Series:
-    x = s.astype(float)
-    mn, mx = x.min(skipna=True), x.max(skipna=True)
-    if pd.isna(mn) or pd.isna(mx) or mx == mn:
-        return pd.Series(0.0, index=s.index)
-    return (x - mn) / (mx - mn)
-
-
-def pick_col(df, candidates):
-    for c in candidates:
-        if c in df.columns:
-            return c
-    can_map = {_canon(c): c for c in df.columns}
-    for c in candidates:
-        k = _canon(c)
-        if k in can_map:
-            return can_map[k]
-    return None
-
-
-def norm_kew(v):
-    if pd.isna(v):
-        return None
-    t = str(v).strip().upper()
-    if "KAB" in t or "KOTA" in t:
-        return "KAB/KOTA"
-    if "PROV" in t:
-        return "PROVINSI"
-    if "PUSAT" in t or "NASIONAL" in t:
-        return "PUSAT"
-    return t
-
-
-def _norm_text(x):
-    if pd.isna(x):
-        return None
-    t = str(x).strip().upper()
-    return " ".join(t.split())
-
-
-def penalized_mean(row, cols):
-    vals = []
-    for c in cols:
-        colname = f"norm_{c}"
-        if colname in row.index:
-            v = row[colname]
-            if pd.isna(v):
-                v = 0.0
-            vals.append(v)
-    if not vals:
-        return np.nan
-    return float(np.sum(vals) / len(vals))
-
-
-def skor_normatif(value, target):
-    if pd.isna(value):
-        return 0.0
-    return min(float(value) / target, 1.0)
-
-
-def slugify(s: str) -> str:
-    if s is None:
-        return "NA"
-    t = str(s).strip()
-    if t == "":
-        return "NA"
-    return _canon(t).upper()
-
-
-def norm_prov_label(s):
-    if pd.isna(s):
-        return None
-    t = str(s).upper()
-    for bad in ["PROVINSI", "PROPINSI"]:
-        t = t.replace(bad, "")
-    t = " ".join(t.split())
-    return re.sub(r"[^A-Z0-9]+", "", t)
-
-
-def norm_kab_label(s):
-    """
-    Normalisasi nama Kab/Kota tapi tetap membedakan:
-    - 'Kabupaten Bandung' -> 'KABBANDUNG'
-    - 'Kota Bandung'      -> 'KOTABANDUNG'
-    """
-    if pd.isna(s):
-        return None
-
-    t = str(s).upper()
-    t = t.replace("KABUPATEN", "KAB")
-    t = t.replace("KAB.", "KAB")
-    t = t.replace("KAB  ", "KAB ")
-
-    t = t.replace("KOTA ADMINISTRASI", "KOTA")
-    t = t.replace("KOTA ADM.", "KOTA")
-    t = t.replace("KOTA.", "KOTA")
-
-    t = " ".join(t.split())
-    return re.sub(r"[^A-Z0-9]+", "", t)
-
-
-# ============================================================
-# 3. LOAD DATA DM.xlsx + META
-# ============================================================
-
-DATA_INFO = ""
-df_all_raw = None
-meta_kab_df = None
-meta_sma_df = None
-
-prov_col_glob = kab_col_glob = kew_col_glob = jenis_col_glob = nama_col_glob = None
-
-try:
-    fp = Path(DATA_FILE)
-    if not fp.exists():
-        raise FileNotFoundError(f"File tidak ditemukan: {DATA_FILE}")
-
-    xls = pd.ExcelFile(fp)
-    frames = [pd.read_excel(fp, sheet_name=s) for s in xls.sheet_names]
-    df_all_raw = pd.concat(frames, ignore_index=True, sort=False)
-
-    prov_col_glob  = pick_col(df_all_raw, ["provinsi", "Provinsi", "PROVINSI"])
-    kab_col_glob   = pick_col(df_all_raw, ["kab_kota", "Kab_Kota", "Kab/Kota", "KAB/KOTA", "kabupaten_kota", "kota"])
-    kew_col_glob   = pick_col(df_all_raw, ["kewenangan", "jenis_kewenangan", "Kewenangan", "KEWENANGAN"])
-    jenis_col_glob = pick_col(df_all_raw, ["jenis_perpustakaan", "JENIS_PERPUSTAKAAN", "Jenis Perpustakaan", "jenis perpustakaan"])
-    nama_col_glob  = pick_col(df_all_raw, ["nama_perpustakaan", "nm_perpustakaan", "nm_instansi_lembaga", "Nama Perpustakaan"])
-
-    if kew_col_glob:
-        df_all_raw["KEW_NORM"] = df_all_raw[kew_col_glob].apply(norm_kew)
-    else:
-        df_all_raw["KEW_NORM"] = None
-
-    val_map_jenis = {
-        "PERPUSTAKAAN SEKOLAH": "sekolah",
-        "SEKOLAH": "sekolah",
-        "PERPUSTAKAAN UMUM": "umum",
-        "UMUM": "umum",
-        "PERPUSTAKAAN DAERAH": "umum",
-        "PERPUSTAKAAN KHUSUS": "khusus",
-        "KHUSUS": "khusus",
-    }
-    if jenis_col_glob:
-        df_all_raw["_dataset"] = df_all_raw[jenis_col_glob].apply(_norm_text).map(val_map_jenis)
-    else:
-        df_all_raw["_dataset"] = None
-
-    def all_prov_choices():
-        if prov_col_glob is None:
-            return ["(Semua)"]
-        s = df_all_raw[prov_col_glob].dropna().astype(str).str.strip()
-        vals = sorted([o for o in s.unique() if o != ""])
-        return ["(Semua)"] + vals
-
-    def get_kab_choices_for_prov(prov_value):
-        if kab_col_glob is None:
-            return ["(Semua)"]
-        if prov_value is None or prov_value == "(Semua)" or prov_col_glob is None:
-            s = df_all_raw[kab_col_glob].dropna().astype(str).str.strip()
-        else:
-            m = df_all_raw[prov_col_glob].astype(str).str.strip() == prov_value
-            s = df_all_raw.loc[m, kab_col_glob].dropna().astype(str).str.strip()
-        vals = sorted([x for x in s.unique() if x != ""])
-        return ["(Semua)"] + vals
-
-    def all_kew_choices():
-        s = df_all_raw["KEW_NORM"].dropna().astype(str).str.strip()
-        vals = sorted([o for o in s.unique() if o != ""])
-        if not vals:
-            return ["(Semua)"]
-        return ["(Semua)"] + vals
-
-    prov_choices = all_prov_choices()
-    kab_choices  = get_kab_choices_for_prov(prov_choices[0] if prov_choices else "(Semua)")
-    kew_choices  = all_kew_choices()
-    default_kew  = "KAB/KOTA" if "KAB/KOTA" in kew_choices else kew_choices[0]
-
-    DATA_INFO = f"Data terbaca dari: **{DATA_FILE}** | Jumlah baris: **{len(df_all_raw)}**"
-except Exception as e:
-    df_all_raw = None
-    prov_choices = kab_choices = kew_choices = ["(Semua)"]
-    default_kew = "(Semua)"
-    DATA_INFO = f"⚠️ Gagal memuat data dari file: `{DATA_FILE}`\n\nError: `{e}`"
-
-# 3b. META KECAMATAN/DESA + SD/SMP + SMA
-extra_info = []
-
-# --- jumlah kecamatan & desa/kel per kab/kota ---
-try:
-    meta_kab_raw = pd.read_excel(META_KAB_FILE)
-    col_kab = pick_col(meta_kab_raw, ["Kab/Kota", "Kab_Kota", "kab/kota", "kabupaten_kota"])
-    col_kec = pick_col(meta_kab_raw, ["Kecamatan", "jml_kecamatan", "jumlah_kecamatan"])
-    col_des = pick_col(meta_kab_raw, ["Desa/Kel", "Desa Kelurahan", "Desa", "Desa_kel"])
-
-    if col_kab and col_kec and col_des:
-        meta_kab_df = pd.DataFrame({
-            "Kab_Kota_Label": meta_kab_raw[col_kab].astype(str).str.strip(),
-            "Jml_Kecamatan":  meta_kab_raw[col_kec].apply(coerce_num),
-            "Jml_DesaKel":    meta_kab_raw[col_des].apply(coerce_num),
-        })
-        meta_kab_df["kab_key"] = meta_kab_df["Kab_Kota_Label"].apply(norm_kab_label)
-        extra_info.append(f"Verifikasi Kab/Kota (Kec/Desa) dari **{META_KAB_FILE}** (n={len(meta_kab_df)})")
-    else:
-        meta_kab_df = None
-        extra_info.append(f"Verifikasi Kab/Kota: kolom kunci tidak lengkap di `{META_KAB_FILE}`")
-except Exception as e:
-    meta_kab_df = None
-    extra_info.append(f"⚠️ Gagal memuat `{META_KAB_FILE}` ({e})")
-
-# --- jumlah SD & SMP per kab/kota ---
-try:
-    sd_smp_raw = pd.read_excel(META_SDSMP_FILE)
-    col_kab2 = pick_col(sd_smp_raw, [
-        "Kabupaten/Kota_Kabupaten/Kota", "Kabupaten/Kota",
-        "Kab/Kota", "Kab_Kota", "kab/kota", "kabupaten_kota"
-    ])
-    col_sd   = pick_col(sd_smp_raw, ["SD", "Jumlah SD", "Total SD", "SD_Total", "jml_sd", "Jml_SD"])
-    col_smp  = pick_col(sd_smp_raw, ["SMP", "Jumlah SMP", "Total SMP", "SMP_Total", "jml_smp", "Jml_SMP"])
-
-    if col_kab2 and (col_sd or col_smp):
-        df_sd_smp = pd.DataFrame({
-            "Kab_Kota_Label_SD": sd_smp_raw[col_kab2].astype(str).str.strip(),
-        })
-        df_sd_smp["Jml_SD"]  = sd_smp_raw[col_sd].apply(coerce_num) if col_sd else 0.0
-        df_sd_smp["Jml_SMP"] = sd_smp_raw[col_smp].apply(coerce_num) if col_smp else 0.0
-
-        df_sd_smp["kab_key"] = df_sd_smp["Kab_Kota_Label_SD"].apply(norm_kab_label)
-
-        df_sd_smp_grp = df_sd_smp.groupby("kab_key", as_index=False).agg({
-            "Jml_SD": "sum",
-            "Jml_SMP": "sum",
-        })
-
-        if meta_kab_df is not None:
-            meta_kab_df = meta_kab_df.merge(
-                df_sd_smp_grp,
-                on="kab_key",
-                how="left"
-            )
-        else:
-            meta_kab_df = df_sd_smp_grp.copy()
-            meta_kab_df["Kab_Kota_Label"] = df_sd_smp.groupby("kab_key")["Kab_Kota_Label_SD"].first().values
-
-        extra_info.append(
-            f"Data SD/SMP per Kab/Kota dari **{META_SDSMP_FILE}** ditambahkan (n={len(df_sd_smp_grp)})"
-        )
-    else:
-        extra_info.append(f"Data SD/SMP: kolom kunci tidak lengkap di `{META_SDSMP_FILE}`")
-except Exception as e:
-    extra_info.append(f"⚠️ Gagal memuat `{META_SDSMP_FILE}` ({e})")
-
-# --- jumlah SMA per provinsi ---
-try:
-    meta_sma_raw = pd.read_excel(META_SMA_FILE)
-
-    col_prov_sma = pick_col(meta_sma_raw, [
-        "Provinsi", "provinsi", "PROVINSI", "NAMA_PROVINSI", "Nama Provinsi",
-        "nm_prov", "nm_provinsi", "prov"
-    ])
-    col_sma = pick_col(meta_sma_raw, [
-        "Jml_SMA", "Jumlah SMA", "SMA", "Total SMA", "SMA_Total",
-        "jumlah_sma", "total_sma", "jml_sma", "total"
-    ])
-
-    if col_prov_sma is None:
-        raise ValueError("Kolom provinsi tidak ditemukan dalam file SMA.")
-    if col_sma is None:
-        raise ValueError("Kolom jumlah SMA tidak ditemukan.")
-
-    meta_sma_df = pd.DataFrame({
-        "Provinsi_Label": meta_sma_raw[col_prov_sma].astype(str).str.strip(),
-        "Jml_SMA":        meta_sma_raw[col_sma].apply(coerce_num),
-    })
-    meta_sma_df["prov_key"] = meta_sma_df["Provinsi_Label"].apply(norm_prov_label)
-    meta_sma_df = meta_sma_df.groupby(["prov_key", "Provinsi_Label"], as_index=False).agg(
-        {"Jml_SMA": "sum"}
-    )
-
-    extra_info.append(f"Verifikasi SMA per Provinsi berhasil dimuat ({len(meta_sma_df)} provinsi).")
-except Exception as e:
-    meta_sma_df = None
-    extra_info.append(f"⚠️ Gagal memuat file SMA: {e}")
-
-if extra_info:
-    DATA_INFO = DATA_INFO + "<br>" + "<br>".join(extra_info)
-
-
-# ============================================================
-# 4. BELL CURVE
-# ============================================================
-
-def make_bell_figure(df_all: pd.DataFrame,
-                     title: str,
-                     index_col: str = "Indeks_Real_0_100",
-                     name_col: str = None,
-                     min_points: int = 5) -> go.Figure:
-
-    fig = go.Figure()
-
-    if index_col not in df_all.columns:
-        fig.update_layout(
-            title=title,
-            xaxis_title="Indeks (0–100)",
-            yaxis_title="Kepadatan (relatif)",
-        )
-        return fig
-
-    df_plot = df_all.copy()
-    df_plot = df_plot[pd.notna(df_plot[index_col])]
-
-    if df_plot.empty or len(df_plot) < min_points:
-        fig.update_layout(
-            title=title,
-            xaxis_title="Indeks (0–100)",
-            yaxis_title="Kepadatan (relatif)",
-            annotations=[
-                dict(
-                    text="Grafik tidak ditampilkan (data terlalu sedikit).",
-                    x=0.5, y=0.5, xref="paper", yref="paper",
-                    showarrow=False, font=dict(size=14)
-                )
-            ]
-        )
-        return fig
-
-    x_vals = df_plot[index_col].values.astype(float)
-    mu = x_vals.mean()
-    sigma = x_vals.std(ddof=1) if len(x_vals) > 1 else 1.0
-
-    xs = np.linspace(max(0, x_vals.min() - 5), min(100, x_vals.max() + 5), 200)
-    pdf = (1.0 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((xs - mu) / sigma) ** 2)
-    pdf = pdf / pdf.max()
-    y_max = 1.0
-
-    if name_col and name_col in df_plot.columns:
-        hover_text = [
-            f"{str(n)}<br>Indeks: {v:.2f}"
-            for n, v in zip(df_plot[name_col], x_vals)
-        ]
-    else:
-        hover_text = [f"Indeks: {v:.2f}" for v in x_vals]
-
-    fig.add_trace(go.Scatter(
-        x=xs,
-        y=pdf,
-        mode="lines",
-        name="Bell curve",
-        hoverinfo="skip"
-    ))
-
-    fig.add_trace(go.Scatter(
-        x=x_vals,
-        y=np.zeros_like(x_vals),
-        mode="markers",
-        name="Perpustakaan",
-        hovertext=hover_text,
-        hovertemplate="%{hovertext}<extra></extra>"
-    ))
-
-    q1, q2, q3 = np.quantile(x_vals, [0.25, 0.5, 0.75])
-    for q, label in [(q1, "Q1"), (q2, "Q2 (Median)"), (q3, "Q3")]:
-        fig.add_trace(go.Scatter(
-            x=[q, q],
-            y=[0, y_max * 1.05],
-            mode="lines",
-            name=label,
-            hovertemplate=f"{label}: {q:.2f}<extra></extra>"
-        ))
-
-    fig.update_layout(
-        title=title,
-        xaxis_title="Indeks IPLM (0–100)",
-        yaxis_title="Kepadatan (relatif)",
-        yaxis=dict(showticklabels=False, zeroline=True, range=[0, y_max * 1.2]),
-        margin=dict(l=40, r=20, t=60, b=40),
-        hovermode="x"
-    )
-
-    return fig
-
-
-# ============================================================
-# 5. PIPELINE REALSCORE + NORMATIF
-# ============================================================
-
-def run_pipeline_core(df_subset: pd.DataFrame, kab_name=None, kew_name=None):
-    df = df_subset.copy()
-    df_raw = df_subset.copy()
-
-    canonical_targets = set(all_indicators)
-    alias_map_raw = {
-        "j_judul_koleksi_tercetak": "JudulTercetak",
-        "j_eksemplar_koleksi_tercetak": "EksemplarTercetak",
-        "j_judul_koleksi_digital": "JudulElektronik",
-        "j_eksemplar_koleksi_digital": "EksemplarElektronik",
-        "tambah_judul_koleksi_tercetak": "TambahJudulTercetak",
-        "tambah_eksemplar_koleksi_tercetak": "TambahEksemplarTercetak",
-        "tambah_judul_koleksi_digital": "TambahJudulElektronik",
-        "tambah_eksemplar_koleksi_digital": "TambahEksemplarElektronik",
-        "j_anggaran_koleksi": "KomitmenAnggaranKoleksi",
-        "j_tenaga_ilmu_perpus": "TenagaKualifikasiIlmuPerpustakaan",
-        "j_tenaga_nonilmu_perpus": "TenagaFungsionalProfesional",
-        "j_tenaga_pkb": "TenagaPKB",
-        "j_anggaran_diklat_perpus": "AnggaranTenaga",
-        "j_peserta_budaya_baca": "PesertaBudayaBaca",
-        "j_pemustaka_luring_daring": "PemustakaLuringDaring",
-        "j_pemustaka_fasilitas_tik": "PemustakaFasilitasTIK",
-        "j_judul_koleksi_tercetak_termanfaat": "PemanfaatanJudulTercetak",
-        "j_eksemplar_koleksi_tercetak_termanfaat": "PemanfaatanEksemplarTercetak",
-        "j_judul_koleksi_digital_termanfaat": "PemanfaatanJudulElektronik",
-        "j_eksemplar_koleksi_digital_termanfaat": "PemanfaatanEksemplarElektronik",
-        "j_kegiatan_budaya_baca_peningkatan_literasi": "KegiatanBudayaBaca",
-        "j_kerjasama_pengembangan_perpus": "KegiatanKerjasama",
-        "j_variasi_layanan": "VariasiLayanan",
-        "j_kebijakan_prosedur_pelayanan": "Kebijakan",
-        "j_anggaran_peningkatan_pelayanan": "AnggaranLayanan"
-    }
-    alias_map = {_canon(k): v for k, v in alias_map_raw.items()}
-
-    rename_map = {}
-    for col in list(df.columns):
-        ccol = _canon(col)
-        if ccol in alias_map:
-            rename_map[col] = alias_map[ccol]
-        else:
-            for tgt in canonical_targets:
-                if ccol == _canon(tgt):
-                    rename_map[col] = tgt
-                    break
-    if rename_map:
-        df = df.rename(columns=rename_map)
-
-    available_indicators = [c for c in all_indicators if c in df.columns]
-    for c in available_indicators:
-        df[c] = df[c].apply(coerce_num)
-
-    # Yeo–Johnson + MinMax
-    yj_cols = []
-    for c in available_indicators:
-        yj_col = f"yj_{c}"
-        x = df[c].astype(float).values
-        mask = ~np.isnan(x)
-        transformed = np.full_like(x, np.nan, dtype=float)
-        if mask.sum() > 1:
-            pt = PowerTransformer(method="yeo-johnson", standardize=False)
-            transformed[mask] = pt.fit_transform(x[mask].reshape(-1, 1)).ravel()
-        else:
-            transformed[mask] = x[mask]
-        df[yj_col] = transformed
-        yj_cols.append(yj_col)
-
-    for yj_col in yj_cols:
-        base = yj_col[3:]
-        df[f"norm_{base}"] = minmax_norm(df[yj_col])
-
-    # Sub-indeks real
-    df["sub_koleksi"]     = df.apply(lambda r: penalized_mean(r, [c for c in koleksi_cols    if c in available_indicators]), axis=1)
-    df["sub_sdm"]         = df.apply(lambda r: penalized_mean(r, [c for c in sdm_cols        if c in available_indicators]), axis=1)
-    df["sub_pelayanan"]   = df.apply(lambda r: penalized_mean(r, [c for c in pelayanan_cols  if c in available_indicators]), axis=1)
-    df["sub_pengelolaan"] = df.apply(lambda r: penalized_mean(r, [c for c in pengelolaan_cols if c in available_indicators]), axis=1)
-
-    df["dim_kepatuhan"] = df[["sub_koleksi", "sub_sdm"]].mean(axis=1)
-    df["dim_kinerja"]   = df[["sub_pelayanan", "sub_pengelolaan"]].mean(axis=1)
-
-    df["Indeks_Real_0_100"] = 100 * (w_kepatuhan * df["dim_kepatuhan"] + w_kinerja * df["dim_kinerja"])
-
-    # Confidence
-    df["n_ind_filled"] = df[available_indicators].notna().sum(axis=1)
-    df["n_ind_total"]  = len(available_indicators)
-
-    df["Confidence_Data"] = np.where(
-        df["n_ind_total"] > 0,
-        df["n_ind_filled"] / df["n_ind_total"],
-        np.nan
-    )
-
-    if kab_col_glob and kab_col_glob in df.columns:
-        df["_Kab_norm"] = df[kab_col_glob].astype(str).str.upper().str.strip()
-        freq_kab = df["_Kab_norm"].value_counts()
-        df["Jml_Perpus_Kab"] = df["_Kab_norm"].map(freq_kab)
-        df["Confidence_Sample"] = (df["Jml_Perpus_Kab"] / SAMPLE_THRESHOLD).clip(0, 1)
-    else:
-        df["Jml_Perpus_Kab"] = np.nan
-        df["Confidence_Sample"] = 1.0
-
-    df["Confidence_IPLM"] = (
-        W_DATA   * df["Confidence_Data"].fillna(0) +
-        W_SAMPLE * df["Confidence_Sample"].fillna(0)
-    )
-
-    df["Indeks_Real_AdjData"] = df["Indeks_Real_0_100"] * df["Confidence_Data"].fillna(0)
-    df["Indeks_Real_AdjConf"] = df["Indeks_Real_0_100"] * df["Confidence_IPLM"].fillna(0)
-
-    # Indeks normatif
-    df["Indeks_Normatif_0_100"] = np.nan
-    df["sub_koleksi_n"] = np.nan
-    df["sub_sdm_n"] = np.nan
-    df["sub_pelayanan_n"] = np.nan
-    df["sub_pengelolaan_n"] = np.nan
-    df["dim_kepatuhan_n"] = np.nan
-    df["dim_kinerja_n"] = np.nan
-
-    for i, row in df.iterrows():
-        jenis = row.get("_dataset", None)
-        if jenis not in TARGETS:
-            continue
-        t = TARGETS[jenis]
-
-        skor_ind = {}
-        for ind, target in t.items():
-            if ind in df.columns:
-                skor_ind[ind] = skor_normatif(row[ind], target)
-
-        sub_koleksi_n = np.mean([
-            skor_ind.get("JudulTercetak", 0),
-            skor_ind.get("EksemplarTercetak", 0)
-        ])
-        sub_sdm_n = skor_ind.get("TenagaKualifikasiIlmuPerpustakaan", 0)
-        sub_pelayanan_n = np.mean([
-            skor_ind.get("PemustakaLuringDaring", 0),
-            skor_ind.get("KegiatanBudayaBaca", 0)
-        ])
-        sub_pengelolaan_n = skor_ind.get("VariasiLayanan", 0)
-
-        dim_kepatuhan_n = np.mean([sub_koleksi_n, sub_sdm_n])
-        dim_kinerja_n   = np.mean([sub_pelayanan_n, sub_pengelolaan_n])
-
-        indeks_normatif = 100 * (w_kepatuhan * dim_kepatuhan_n + w_kinerja * dim_kinerja_n)
-
-        df.at[i, "sub_koleksi_n"]     = sub_koleksi_n
-        df.at[i, "sub_sdm_n"]         = sub_sdm_n
-        df.at[i, "sub_pelayanan_n"]   = sub_pelayanan_n
-        df.at[i, "sub_pengelolaan_n"] = sub_pengelolaan_n
-        df.at[i, "dim_kepatuhan_n"]   = dim_kepatuhan_n
-        df.at[i, "dim_kinerja_n"]     = dim_kinerja_n
-        df.at[i, "Indeks_Normatif_0_100"] = indeks_normatif
-
-    df["Indeks_Normatif_AdjConf"] = df["Indeks_Normatif_0_100"] * df["Confidence_IPLM"].fillna(0)
-
-    # DETAIL untuk tampilan
-    detail_cols = []
-    if prov_col_glob and prov_col_glob in df.columns:
-        detail_cols.append(prov_col_glob)
-    if kab_col_glob and kab_col_glob in df.columns:
-        detail_cols.append(kab_col_glob)
-    if nama_col_glob and nama_col_glob in df.columns:
-        detail_cols.append(nama_col_glob)
-
-    detail_cols += [
-        "_dataset",
-        "sub_koleksi", "sub_sdm", "sub_pelayanan", "sub_pengelolaan",
-        "dim_kepatuhan", "dim_kinerja",
-        "Indeks_Real_0_100",
-        "Indeks_Normatif_0_100",
-        "Confidence_IPLM",
-    ]
-    detail_cols = [c for c in detail_cols if c in df.columns]
-
-    detail_df = df[detail_cols].copy().round(3)
-
-    # AGREGAT per jenis
-    expected_ds = ["sekolah", "umum", "khusus"]
-    label_map = {
-        "sekolah": "Perpustakaan Sekolah",
-        "umum": "Perpustakaan Umum",
-        "khusus": "Perpustakaan Khusus"
-    }
-
-    rows = []
-    for ds in expected_ds:
-        dsub = df[df["_dataset"] == ds].copy()
-        if dsub.empty:
-            rows.append({
-                "Jenis Perpustakaan": label_map.get(ds, ds),
-                "Jumlah Perpustakaan": 0,
-                "Rata2_DimKepatuhan": 0.0,
-                "Rata2_DimKinerja": 0.0,
-                "Rata2_Indeks_IPLM_0_100": 0.0,
-            })
-        else:
-            rows.append({
-                "Jenis Perpustakaan": label_map.get(ds, ds),
-                "Jumlah Perpustakaan": len(dsub),
-                "Rata2_DimKepatuhan": dsub["dim_kepatuhan"].mean(skipna=True),
-                "Rata2_DimKinerja": dsub["dim_kinerja"].mean(skipna=True),
-                "Rata2_Indeks_IPLM_0_100": dsub["Indeks_Real_0_100"].mean(skipna=True),
-            })
-
-    if rows:
-        base_rows = rows[:len(expected_ds)]
-        total_jumlah = int(sum(r["Jumlah Perpustakaan"] for r in base_rows))
-        mean_dim_kep     = float(np.mean([r["Rata2_DimKepatuhan"] for r in base_rows]))
-        mean_dim_kinerja = float(np.mean([r["Rata2_DimKinerja"] for r in base_rows]))
-        mean_indeks      = float(np.mean([r["Rata2_Indeks_IPLM_0_100"] for r in base_rows]))
-
-        rows.append({
-            "Jenis Perpustakaan": "Rata-rata keseluruhan",
-            "Jumlah Perpustakaan": total_jumlah,
-            "Rata2_DimKepatuhan": mean_dim_kep,
-            "Rata2_DimKinerja": mean_dim_kinerja,
-            "Rata2_Indeks_IPLM_0_100": mean_indeks,
-        })
-
-    agg_view = pd.DataFrame(rows).round(3)
-
-    # Simpan Excel (AGG, DETAIL, RAW)
-    kab_slug = slugify(kab_name) if kab_name else "SEMUA_KAB"
-    kew_slug = slugify(kew_name) if kew_name else "SEMUA_KEW"
-    tmpdir = tempfile.mkdtemp()
-
-    agg_path    = os.path.join(tmpdir, f"IPLM_RealscoreNormatif_Agregat_{kab_slug}_{kew_slug}.xlsx")
-    detail_path = os.path.join(tmpdir, f"IPLM_RealscoreNormatif_Detail_{kab_slug}_{kew_slug}.xlsx")
-    raw_path    = os.path.join(tmpdir, f"IPLM_RealscoreNormatif_Raw_{kab_slug}_{kew_slug}.xlsx")
-
-    agg_view.to_excel(agg_path, index=False)
-    df.to_excel(detail_path, index=False)
-    df_raw.to_excel(raw_path, index=False)
-
-    # Bell curve
-    name_col = nama_col_glob if (nama_col_glob and nama_col_glob in detail_df.columns) else None
-
-    fig_all = make_bell_figure(detail_df, "Sebaran Indeks RealScore – Semua Perpustakaan",
-                               index_col="Indeks_Real_0_100", name_col=name_col)
-
-    fig_sekolah = make_bell_figure(
-        detail_df[detail_df["_dataset"] == "sekolah"],
-        "Sebaran Indeks RealScore – Perpustakaan Sekolah",
-        index_col="Indeks_Real_0_100", name_col=name_col, min_points=3
-    )
-
-    fig_umum = make_bell_figure(
-        detail_df[detail_df["_dataset"] == "umum"],
-        "Sebaran Indeks RealScore – Perpustakaan Umum",
-        index_col="Indeks_Real_0_100", name_col=name_col, min_points=3
-    )
-
-    fig_khusus = make_bell_figure(
-        detail_df[detail_df["_dataset"] == "khusus"],
-        "Sebaran Indeks RealScore – Perpustakaan Khusus",
-        index_col="Indeks_Real_0_100", name_col=name_col, min_points=3
-    )
-
-    return (
-        agg_view,
-        detail_df,
-        agg_path,
-        detail_path,
-        raw_path,
-        fig_all,
-        fig_sekolah,
-        fig_umum,
-        fig_khusus,
-    )
-
-
-# ============================================================
-# 6. VERIFIKASI SAMPEL
-# ============================================================
-
-def compute_verification(df_filtered: pd.DataFrame, kew_value):
-    if df_filtered is None or len(df_filtered) == 0:
-        return pd.DataFrame()
-
-    kew_norm = str(kew_value or "").upper()
-
-    # ---------- Kewenangan KAB/KOTA ----------
-    if ("KAB" in kew_norm or "KOTA" in kew_norm) and (kab_col_glob is not None) and (meta_kab_df is not None):
-        tmp = df_filtered.copy()
-        tmp = tmp[pd.notna(tmp[kab_col_glob])]
-        if tmp.empty:
-            return pd.DataFrame()
-
-        tmp["kab_key"] = tmp[kab_col_glob].apply(norm_kab_label)
-
-        # total perpus
-        g_total = tmp.groupby("kab_key").size().rename("jml_perpus_sampel_total").reset_index()
-
-        # klasifikasi jenjang sekolah (kalau ada)
-        if "sub_jenis_perpus" in tmp.columns:
-            def jenjang(x):
-                if pd.isna(x):
-                    return "OTHER"
-                t = str(x).upper()
-                if " SD " in f" {t} " or " SD/" in t or " MI " in f" {t} ":
-                    return "SD"
-                if " SMP " in f" {t} " or " SMP/" in t or " MTS " in f" {t} ":
-                    return "SMP"
-                return "OTHER"
-            tmp["jenjang_sekolah"] = tmp["sub_jenis_perpus"].apply(jenjang)
-        else:
-            tmp["jenjang_sekolah"] = "OTHER"
-
-        if "_dataset" in tmp.columns:
-            mask_sek = tmp["_dataset"] == "sekolah"
-        else:
-            mask_sek = True
-
-        tmp_sek = tmp[mask_sek].copy()
-        tmp_sd  = tmp_sek[tmp_sek["jenjang_sekolah"] == "SD"].copy()
-        tmp_smp = tmp_sek[tmp_sek["jenjang_sekolah"] == "SMP"].copy()
-
-        g_sd      = tmp_sd.groupby("kab_key").size().rename("jml_perpus_sd_sampel").reset_index()
-        g_smp     = tmp_smp.groupby("kab_key").size().rename("jml_perpus_smp_sampel").reset_index()
-        g_sekolah = tmp_sek.groupby("kab_key").size().rename("jml_perpus_sekolah_total").reset_index()
-
-        if "_dataset" in tmp.columns:
-            tmp_umum = tmp[tmp["_dataset"] == "umum"].copy()
-        else:
-            tmp_umum = tmp.copy()
-        g_umum = tmp_umum.groupby("kab_key").size().rename("jml_perpus_umum_sampel").reset_index()
-
-        use_cols = ["kab_key", "Kab_Kota_Label", "Jml_Kecamatan", "Jml_DesaKel", "Jml_SD", "Jml_SMP"]
-        use_cols = [c for c in use_cols if (meta_kab_df is not None and c in meta_kab_df.columns)]
-
-        merged = (
-            g_total
-            .merge(g_sd,      on="kab_key", how="left")
-            .merge(g_smp,     on="kab_key", how="left")
-            .merge(g_sekolah, on="kab_key", how="left")
-            .merge(g_umum,    on="kab_key", how="left")
-            .merge(meta_kab_df[use_cols], on="kab_key", how="left")
-        )
-
-        for c in ["jml_perpus_sampel_total", "jml_perpus_sd_sampel",
-                  "jml_perpus_smp_sampel", "jml_perpus_sekolah_total",
-                  "jml_perpus_umum_sampel"]:
-            if c in merged.columns:
-                merged[c] = merged[c].fillna(0).astype(int)
-
-        def safe_pct(num, den):
-            if pd.isna(den) or den <= 0:
-                return np.nan
-            return 100.0 * float(num) / float(den)
-
-        # sekolah SD+SMP
-        if "Jml_SD" in merged.columns or "Jml_SMP" in merged.columns:
-            merged["total_sd_smp"] = merged[["Jml_SD", "Jml_SMP"]].sum(axis=1, skipna=True)
-        else:
-            merged["total_sd_smp"] = np.nan
-
-        merged["cov_sekolah_total_%"] = merged.apply(
-            lambda r: safe_pct(r["jml_perpus_sekolah_total"], r.get("total_sd_smp", np.nan)),
-            axis=1
-        )
-
-        # umum vs kombinasi (Kecamatan + Desa/Kel)
-        merged["total_kec_desakel"] = merged.get("Jml_Kecamatan", np.nan) + merged.get("Jml_DesaKel", np.nan)
-        merged["cov_umum_vs_kec_desakel_%"] = merged.apply(
-            lambda r: safe_pct(r["jml_perpus_umum_sampel"], r.get("total_kec_desakel", np.nan)),
-            axis=1
-        )
-
-        out = pd.DataFrame({
-            "Kab/Kota": merged["Kab_Kota_Label"],
-            "Perpus Sampel (Total)": merged["jml_perpus_sampel_total"],
-            "Perpus Sampel – SD": merged["jml_perpus_sd_sampel"],
-            "Perpus Sampel – SMP": merged["jml_perpus_smp_sampel"],
-            "Perpus Sampel – Sekolah (Total SD+SMP)": merged["jml_perpus_sekolah_total"],
-            "Sekolah (SD+SMP)": merged.get("total_sd_smp", np.nan),
-            "Coverage Perpus Sekolah vs Sekolah (%)": merged["cov_sekolah_total_%"],
-            "Perpus Sampel – Umum": merged["jml_perpus_umum_sampel"],
-            "Jumlah Kecamatan": merged.get("Jml_Kecamatan", np.nan),
-            "Jumlah Desa/Kel": merged.get("Jml_DesaKel", np.nan),
-            "Coverage Perpus Umum vs Kec+Desa/Kel (%)": merged["cov_umum_vs_kec_desakel_%"],
-        })
-
-        return out.sort_values("Kab/Kota").reset_index(drop=True).round(3)
-
-    # ---------- Kewenangan PROVINSI ----------
-    if ("PROV" in kew_norm) and (meta_sma_df is not None):
-        tmp = df_filtered.copy()
-
-        if prov_col_glob is None:
-            possible = [c for c in tmp.columns if "prov" in c.lower()]
-            if possible:
-                prov_use = possible[0]
-            else:
-                return pd.DataFrame({"Info": ["Kolom provinsi tidak ditemukan di DM.xlsx"]})
-        else:
-            prov_use = prov_col_glob
-
-        tmp = tmp[pd.notna(tmp[prov_use])]
-        if tmp.empty:
-            return pd.DataFrame({"Info": ["Tidak ada data perpustakaan pada kewenangan provinsi."]})
-
-        tmp["prov_key"] = tmp[prov_use].apply(norm_prov_label)
-
-        g_total = tmp.groupby("prov_key").size().rename("Jumlah_Perpus_Sampel").reset_index()
-
-        if "_dataset" in tmp.columns:
-            tmp_sek = tmp[tmp["_dataset"] == "sekolah"].copy()
-        else:
-            tmp_sek = tmp.copy()
-        g_sek = tmp_sek.groupby("prov_key").size().rename("Jml_Perpus_SMA_Sampel").reset_index()
-
-        merged = g_total.merge(g_sek, on="prov_key", how="left") \
-                        .merge(meta_sma_df[["prov_key", "Provinsi_Label", "Jml_SMA"]],
-                               on="prov_key", how="left")
-
-        merged["Jml_Perpus_SMA_Sampel"] = merged["Jml_Perpus_SMA_Sampel"].fillna(0).astype(int)
-
-        def cov_sma(row):
-            tot = row.get("Jml_SMA", np.nan)
-            if pd.isna(tot) or tot <= 0:
-                return np.nan
-            return 100.0 * row["Jml_Perpus_SMA_Sampel"] / tot
-
-        merged["Coverage_Perpus_SMA_vs_SMA_%"] = merged.apply(cov_sma, axis=1)
-
-        cols_out = [
-            "Provinsi_Label",
-            "Jumlah_Perpus_Sampel",
-            "Jml_Perpus_SMA_Sampel",
-            "Jml_SMA",
-            "Coverage_Perpus_SMA_vs_SMA_%",
-        ]
-        exists = [c for c in cols_out if c in merged.columns]
-        if not exists:
-            return pd.DataFrame()
-
-        return merged[exists].sort_values("Provinsi_Label").reset_index(drop=True).round(3)
-
-    return pd.DataFrame()
-
-
-# ============================================================
-# 7. KONTEKS RINGKAS UNTUK LLM (RAG MINI)
-# ============================================================
-
-def build_context_for_llm(detail_df: pd.DataFrame,
-                          agg_df: pd.DataFrame,
-                          verif_df: pd.DataFrame,
-                          kab_name: str,
-                          kew_value: str) -> str:
-    wilayah = kab_name
-    if kew_value and kew_value != "(Semua)":
-        wilayah = f"{kab_name} (kewenangan {kew_value})"
-
-    lines = []
-    lines.append(f"Wilayah: {wilayah}")
-    lines.append(f"Jumlah perpustakaan sampel: {len(detail_df)}")
-
-    if "Indeks_Real_0_100" in detail_df.columns:
-        mean_ind = detail_df["Indeks_Real_0_100"].mean(skipna=True)
-        lines.append(f"Rata-rata Indeks IPLM 0-100: {mean_ind:.2f}")
-
-    if "dim_kepatuhan" in detail_df.columns:
-        mean_kep = detail_df["dim_kepatuhan"].mean(skipna=True)
-        lines.append(f"Rata-rata dimensi kepatuhan (0-1): {mean_kep:.3f}")
-    else:
-        mean_kep = np.nan
-
-    if "dim_kinerja" in detail_df.columns:
-        mean_kin = detail_df["dim_kinerja"].mean(skipna=True)
-        lines.append(f"Rata-rata dimensi kinerja (0-1): {mean_kin:.3f}")
-    else:
-        mean_kin = np.nan
-
-    if "Confidence_IPLM" in detail_df.columns:
-        mean_conf = detail_df["Confidence_IPLM"].mean(skipna=True)
-        lines.append(f"Rata-rata Confidence_IPLM (0-1): {mean_conf:.2f}")
-
-    # ringkasan per jenis perpustakaan
-    if agg_df is not None and not agg_df.empty and "Jenis Perpustakaan" in agg_df.columns:
-        lines.append("\nRingkasan per jenis perpustakaan:")
-        for _, r in agg_df.iterrows():
-            jp = str(r.get("Jenis Perpustakaan", "") or "")
-            if jp.lower().startswith("rata-rata"):
-                continue
-            n = r.get("Jumlah Perpustakaan", np.nan)
-            idx = r.get("Rata2_Indeks_IPLM_0_100", np.nan)
-            lines.append(f"- {jp}: n={int(n)}, rata-rata indeks={idx:.2f}")
-
-    # contoh ekstrem tinggi & rendah (top-3 dan bottom-3)
-    if "Indeks_Real_0_100" in detail_df.columns:
-        df_valid = detail_df.dropna(subset=["Indeks_Real_0_100"]).copy()
-        if "Confidence_IPLM" in df_valid.columns:
-            df_valid = df_valid.sort_values("Confidence_IPLM", ascending=False)
-        col_nama = nama_col_glob if (nama_col_glob and nama_col_glob in df_valid.columns) else None
-
-        if not df_valid.empty and col_nama:
-            top3 = df_valid.sort_values("Indeks_Real_0_100", ascending=False).head(3)
-            bottom3 = df_valid.sort_values("Indeks_Real_0_100", ascending=True).head(3)
-
-            lines.append("\nPerpustakaan dengan indeks (contoh singkat):")
-            for _, r in top3.iterrows():
-                lines.append(
-                    f"- {str(r[col_nama])}: indeks={r['Indeks_Real_0_100']:.2f}, "
-                    f"kepatuhan={r['dim_kepatuhan']:.3f}, kinerja={r['dim_kinerja']:.3f}"
-                )
-
-            lines.append("\nPerpustakaan dengan indeks (contoh singkat):")
-            for _, r in bottom3.iterrows():
-                lines.append(
-                    f"- {str(r[col_nama])}: indeks={r['Indeks_Real_0_100']:.2f}, "
-                    f"kepatuhan={r['dim_kepatuhan']:.3f}, kinerja={r['dim_kinerja']:.3f}"
-                )
-
-    # ringkasan coverage (kalau ada verif_df)
-    if verif_df is not None and not verif_df.empty:
-        try:
-            if "Coverage Perpus Sekolah vs Sekolah (%)" in verif_df.columns:
-                cov_sek = verif_df["Coverage Perpus Sekolah vs Sekolah (%)"]
-                if len(cov_sek.dropna()) > 0:
-                    avg_cov_sek = cov_sek.mean()
-                    lines.append(
-                        f"Rata-rata coverage perpustakaan sekolah terhadap SD+SMP: {avg_cov_sek:.2f}%"
-                    )
-            if "Coverage Perpus Umum vs Kec+Desa/Kel (%)" in verif_df.columns:
-                cov_umum = verif_df["Coverage Perpus Umum vs Kec+Desa/Kel (%)"]
-                if len(cov_umum.dropna()) > 0:
-                    avg_cov_umum = cov_umum.mean()
-                    lines.append(
-                        f"Rata-rata coverage perpustakaan umum terhadap kecamatan+desa/kelurahan: {avg_cov_umum:.2f}%"
-                    )
-        except Exception:
-            pass
-
-    return "\n".join(lines)
-
-
-# ============================================================
-# 7a. RULE-BASED ANALYSIS (FALLBACK)
-# ============================================================
-
-def classify_level(x):
-    if pd.isna(x):
-        return "tidak tersedia"
-    if x < 40:
-        return "-"
-    if x < 60:
-        return "-"
-    return "-"
-
-
-def generate_rule_based_analysis(detail_df: pd.DataFrame,
-                                 agg_df: pd.DataFrame,
-                                 kab_name: str,
-                                 kew_value: str) -> str:
-    if detail_df is None or detail_df.empty:
-        return "Tidak ada data yang dapat dianalisis."
-
-    wilayah = kab_name
-    if kew_value and kew_value != "(Semua)":
-        wilayah = f"{kab_name} (kewenangan {kew_value})"
-
-    # angka agregat
-    mean_ind = detail_df.get("Indeks_Real_0_100", pd.Series(dtype=float)).mean(skipna=True)
-    mean_kep = detail_df.get("dim_kepatuhan", pd.Series(dtype=float)).mean(skipna=True)
-    mean_kin = detail_df.get("dim_kinerja", pd.Series(dtype=float)).mean(skipna=True)
-    mean_conf = detail_df.get("Confidence_IPLM", pd.Series(dtype=float)).mean(skipna=True)
-
-    lines = []
-    lines.append("## Analisis Otomatis & Rekomendasi Kebijakan (Rule-based)\n")
-    lines.append("### Gambaran Umum Wilayah")
-    lines.append(f"- Wilayah: {wilayah}")
-    lines.append(f"- Jumlah perpustakaan dalam sampel: {len(detail_df)}")
-    lines.append(f"- Rata-rata Indeks IPLM 2025: {mean_ind:.2f}")
-    lines.append(f"- Rata-rata dimensi kepatuhan: {mean_kep:.3f}")
-    lines.append(f"- Rata-rata dimensi kinerja: {mean_kin:.3f}")
-    if not pd.isna(mean_conf):
-        lines.append(f"- Rata-rata Confidence_IPLM: {mean_conf:.2f}")
-
-    lines.append("\n### Capaian per Jenis Perpustakaan")
-    if agg_df is not None and not agg_df.empty:
-        for _, r in agg_df.iterrows():
-            jp = str(r.get("Jenis Perpustakaan", ""))
-            if not jp or jp.lower().startswith("rata-rata"):
-                continue
-            idx = r.get("Rata2_Indeks_IPLM_0_100", np.nan)
-            n  = int(r.get("Jumlah Perpustakaan", 0))
-            lines.append(f"- {jp}: rata-rata indeks {idx:.2f} dengan {n} perpustakaan.")
-    else:
-        lines.append("- Data agregat per jenis perpustakaan tidak tersedia.")
-
-    lines.append("\n### Arah Kebijakan dan Rekomendasi Program")
-    lines.append(
-        "Prioritas utama adalah penguatan layanan dasar perpustakaan serta peningkatan "
-        "ketersediaan SDM dan koleksi. Dimensi kepatuhan yang relatif rendah mengindikasikan "
-        "perlunya pembenahan pada aspek koleksi, kebijakan layanan, dan kualifikasi pustakawan. "
-        "Dimensi kinerja yang masih terbatas menunjukkan bahwa intensitas pemanfaatan dan "
-        "kegiatan literasi perlu diperkuat agar perpustakaan benar-benar berfungsi sebagai "
-        "pusat belajar masyarakat."
-    )
-    lines.append(
-        "Program-program yang dapat diprioritaskan antara lain: peningkatan alokasi anggaran "
-        "untuk pengembangan koleksi mutakhir, penguatan kapasitas pustakawan melalui pelatihan "
-        "berkelanjutan, perluasan kegiatan budaya baca yang menyasar komunitas rentan, serta "
-        "kolaborasi lintas sektor dengan satuan pendidikan, organisasi masyarakat, dan pelaku "
-        "usaha lokal. Seluruh intervensi perlu disertai mekanisme monitoring dan evaluasi "
-        "berbasis data IPLM agar perbaikan yang dilakukan dapat terukur dari waktu ke waktu."
-    )
-
-    lines.append(
-        "\n> Peringatan: analisis ini bersifat otomatis berbasis data IPLM. Untuk penetapan kebijakan, "
-        "perlu verifikasi dan kajian kualitatif lebih lanjut."
-    )
-
-    return "\n".join(lines)
-
-# ============================================================
-# 7b. ANALISIS BERBASIS LLM (DENGAN FALLBACK RULE-BASED)
-# ============================================================
-
-def generate_llm_analysis(detail_df: pd.DataFrame,
-                          agg_df: pd.DataFrame,
-                          verif_df: pd.DataFrame,
-                          kab_name: str,
-                          kew_value: str) -> str:
-    """
-    Analisis otomatis:
-    - Jika pemanggilan LLM gagal -> fallback ke rule-based dengan pesan error ringkas.
-    """
-
-    # MODE LLM AKTIF: selalu coba, token bisa dari HF_TOKEN / HUGGINGFACEHUB_API_TOKEN
-    context = build_context_for_llm(detail_df, agg_df, verif_df, kab_name, kew_value)
-
-    client = get_llm_client()
-    if client is None:
-        rb = generate_rule_based_analysis(detail_df, agg_df, kab_name, kew_value)
-        return (
-            "⚠️ Terjadi kendala saat menginisialisasi model LLM, sehingga analisis otomatis "
-            "saat ini menggunakan pendekatan **rule-based**.\n\n"
-            + rb
-        )
-
-    system_prompt = (
-        "Anda adalah analis kebijakan perpustakaan dan literasi yang berpengalaman di Indonesia. "
-        "Tugas Anda adalah membaca ringkasan data Indeks Pembangunan Literasi Masyarakat (IPLM) "
-        "dan menyusun analisis kebijakan yang tajam, tetapi tetap komunikatif dan mudah dipahami "
-        "oleh pemangku kepentingan pemerintah daerah."
-    )
-
-    user_prompt = f"""
-DATA RINGKAS IPLM UNTUK WILAYAH BERIKUT:
-
-{context}
-
-TULISKAN ANALISIS DALAM BAHASA INDONESIA FORMAL, DENGAN STRUKTUR:
-
-1. Gambaran umum kondisi perpustakaan di wilayah tersebut (1 paragraf).
-2. Analisis capaian indeks: soroti kekuatan dan kelemahan utama, terutama perbedaan antar jenis perpustakaan (2 paragraf).
-3. Analisis risiko dan kesenjangan layanan, termasuk jika coverage perpustakaan terhadap satuan pendidikan atau wilayah administratif masih rendah (1-2 paragraf).
-4. Rekomendasi program dan kebijakan prioritas yang konkret untuk 3-5 tahun ke depan. Susun dalam bentuk paragraf naratif, bukan bullet list (2 paragraf).
-
-PANDUAN GAYA:
-- Jangan hanya mengulang angka apa adanya, tetapi jelaskan maknanya.
-- Gunakan istilah kebijakan publik dan manajemen program perpustakaan ketika relevan.
-- Hindari kalimat terlalu panjang; gunakan kalimat efektif dan jelas.
-"""
-
-    try:
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_prompt},
-        ]
-
-        resp = client.chat_completion(
-            model=LLM_MODEL_NAME,
-            messages=messages,
-            max_tokens=900,
-            temperature=0.35,
-            top_p=0.9,
-        )
-
-        text = resp.choices[0].message.content.strip()
-        if not text:
-            raise ValueError("Respon LLM kosong.")
-
-        return text
-
-    except Exception as e:
-        rb = generate_rule_based_analysis(detail_df, agg_df, kab_name, kew_value)
-        return (
-            "⚠️ Terjadi error saat memanggil model LLM, sehingga analisis berikut "
-            "dibuat menggunakan pendekatan **rule-based**.\n\n"
-            f"(Detail teknis: {repr(e)})\n\n"
-            f"{rb}"
-        )
-
-
-# ============================================================
-# 8. WORD REPORT (Plotly Pie + Indeks + Agregat + LLM Narrative)
-# ============================================================
-
-from docx import Document
-from docx.shared import Inches
-import plotly.express as px
-
-# Cek apakah kaleido tersedia
-try:
-    import kaleido  # noqa: F401
-    HAS_KALEIDO = True
-except Exception:
-    HAS_KALEIDO = False
-
-
-def make_pie_plotly(num, den, title):
-    """
-    Generate pie chart PNG menggunakan Plotly.
-    Jika kaleido tidak tersedia / gagal, return None (tanpa error).
-    """
-    # kalau tidak ada kaleido, jangan pakai write_image
-    if not HAS_KALEIDO:
-        return None
-
-    if den is None or den <= 0:
-        values = [0, 1]
-        labels = ["Terjangkau", "Belum Terjangkau"]
-    else:
-        values = [num, max(den - num, 0)]
-        labels = ["Terjangkau", "Belum Terjangkau"]
-
-    fig = px.pie(
-        values=values,
-        names=labels,
-        title=title,
-        hole=0.3
-    )
-
-    tmp = tempfile.mktemp(suffix=".png")
-    try:
-        fig.write_image(tmp, scale=2)  # butuh kaleido
-        return tmp
-    except Exception:
-        # kalau masih gagal (misal ada error lain), jangan jatuhkan app
-        return None
-
-
-def generate_word_report_all(detail_df, agg_df, verif_df, prov, kab, kew, analysis_text):
-    """
-    Membuat laporan lengkap untuk wilayah yang dipilih:
-    - Ringkasan indeks
-    - Tabel agregat
-    - (opsional) Pie chart coverage
-    - Narasi otomatis (LLM/rule-based)
-    """
-    # Tidak berlaku untuk PUSAT
-    if kew == "PUSAT":
-        return None
-
-    wilayah = kab if kab != "(Semua)" else prov
-
-    doc = Document()
-    doc.add_heading(f"Laporan IPLM – {wilayah}", level=1)
-
-    # =====================
-    # 1. Ringkasan Indeks
-    # =====================
-    doc.add_heading("Ringkasan Indeks", level=2)
-
-    mean_ind = detail_df["Indeks_Real_0_100"].mean(skipna=True)
-    mean_kep = detail_df["dim_kepatuhan"].mean(skipna=True)
-    mean_kin = detail_df["dim_kinerja"].mean(skipna=True)
-    mean_conf = detail_df["Confidence_IPLM"].mean(skipna=True)
-
-    doc.add_paragraph(f"- Jumlah perpustakaan: {len(detail_df)}")
-    doc.add_paragraph(f"- Rata-rata Indeks IPLM: {mean_ind:.2f}")
-    doc.add_paragraph(f"- Rata-rata Dimensi Kepatuhan: {mean_kep:.3f}")
-    doc.add_paragraph(f"- Rata-rata Dimensi Kinerja: {mean_kin:.3f}")
-    doc.add_paragraph(f"- Rata-rata Confidence IPLM: {mean_conf:.2f}")
-
-    # =====================
-    # 2. Tabel Agregat
-    # =====================
-    doc.add_heading("Ringkasan Agregat per Jenis Perpustakaan", level=2)
-
-    table = doc.add_table(rows=1, cols=len(agg_df.columns))
-    hdr = table.rows[0].cells
-    for i, c in enumerate(agg_df.columns):
-        hdr[i].text = str(c)
-
-    for _, row in agg_df.iterrows():
-        r = table.add_row().cells
-        for i, c in enumerate(agg_df.columns):
-            r[i].text = str(row[c])
-
-    # =====================
-    # 3. PIE CHART COVERAGE (opsional, hanya kalau kaleido & data ada)
-    # =====================
-    doc.add_heading("Coverage / Cakupan Pembinaan", level=2)
-
-    if not HAS_KALEIDO:
-        doc.add_paragraph(
-            "Grafik pie coverage tidak dibuat karena modul 'kaleido' "
-            "tidak tersedia di server. Hanya ringkasan teks yang ditampilkan."
-        )
-    elif verif_df is not None and not verif_df.empty:
-
-        if kew == "KAB/KOTA":
-            for _, r in verif_df.iterrows():
-                nama = r["Kab/Kota"]
-
-                # Sekolah SD+SMP
-                if "Sekolah (SD+SMP)" in verif_df.columns:
-                    img_path = make_pie_plotly(
-                        r["Perpus Sampel – Sekolah (Total SD+SMP)"],
-                        r["Sekolah (SD+SMP)"],
-                        f"Coverage Perpustakaan Sekolah – {nama}"
-                    )
-                    if img_path:
-                        doc.add_paragraph(f"Coverage Perpustakaan Sekolah – {nama}")
-                        doc.add_picture(img_path, width=Inches(4))
-
-                # Umum
-                if "Jumlah Kecamatan" in verif_df.columns and "Jumlah Desa/Kel" in verif_df.columns:
-                    denom = r["Jumlah Kecamatan"] + r["Jumlah Desa/Kel"]
-                    img_path = make_pie_plotly(
-                        r["Perpus Sampel – Umum"],
-                        denom,
-                        f"Coverage Perpustakaan Umum – {nama}"
-                    )
-                    if img_path:
-                        doc.add_paragraph(f"Coverage Perpustakaan Umum – {nama}")
-                        doc.add_picture(img_path, width=Inches(4))
-
-        elif kew == "PROVINSI":
-            for _, r in verif_df.iterrows():
-                nama = r["Provinsi_Label"]
-                img_path = make_pie_plotly(
-                    r["Jml_Perpus_SMA_Sampel"],
-                    r["Jml_SMA"],
-                    f"Coverage Perpustakaan SMA – {nama}"
-                )
-                if img_path:
-                    doc.add_paragraph(f"Coverage Perpustakaan SMA – {nama}")
-                    doc.add_picture(img_path, width=Inches(4))
-
-    # =====================
-    # 4. Narasi LLM / Rule-based
-    # =====================
-    doc.add_heading("Analisis Naratif Otomatis", level=2)
-    for paragraph in analysis_text.split("\n"):
-        if paragraph.strip():
-            doc.add_paragraph(paragraph)
-
-    # =====================
-    # Simpan
-    # =====================
-    outpath = tempfile.mktemp(suffix=".docx")
-    doc.save(outpath)
-    return outpath
-
-# ============================================================
-# 8. FUNGSI GRADIO
-# ============================================================
-
-def run_app(prov_value, kab_value, kew_value):
-    if df_all_raw is None:
-        empty = pd.DataFrame()
-        return (
-            empty, empty, empty,   # agg_df, detail_df, verif_df
-            None, None, None,      # agg_path, detail_path, raw_path
-            None,                  # word_path
-            None, None, None, None,  # fig_all, fig_sekolah, fig_umum, fig_khusus
-            "Data belum berhasil dimuat. Periksa kembali nama file di DATA_FILE.",
-            "Belum ada analisis otomatis yang dapat ditampilkan."
-        )
-
-    df = df_all_raw.copy()
-
-    # Filter provinsi
-    if prov_col_glob and prov_value and prov_value != "(Semua)":
-        df = df[df[prov_col_glob].astype(str).str.strip() == prov_value]
-
-    # Filter kab/kota
-    if kab_col_glob and kab_value and kab_value != "(Semua)":
-        df = df[df[kab_col_glob].astype(str).str.strip() == kab_value]
-
-    # Filter kewenangan
-    if kew_value and kew_value != "(Semua)":
-        df = df[df["KEW_NORM"] == kew_value]
-
-    if len(df) == 0:
-        empty = pd.DataFrame()
-        return (
-            empty, empty, empty,   # agg_df, detail_df, verif_df
-            None, None, None,      # agg_path, detail_path, raw_path
-            None,                  # word_path
-            None, None, None, None,  # fig_all, fig_sekolah, fig_umum, fig_khusus
-            "Tidak ada data untuk kombinasi filter yang dipilih.",
-            "Belum ada analisis otomatis yang dapat ditampilkan."
-        )
-
-    kab_name = kab_value if kab_value and kab_value != "(Semua)" else "SEMUA KAB/KOTA"
-    kew_name = kew_value if kew_value and kew_value != "(Semua)" else "SEMUA KEWENANGAN"
-
-    (
-        agg_df,
-        detail_df,
-        agg_path,
-        detail_path,
-        raw_path,
-        fig_all,
-        fig_sekolah,
-        fig_umum,
-        fig_khusus,
-    ) = run_pipeline_core(df, kab_name=kab_name, kew_name=kew_name)
-
-    # Verifikasi sampel
-    verif_df = compute_verification(df, kew_value)
-
-    # Pesan ringkas di UI
-    mean_conf = None
-    if "Confidence_IPLM" in detail_df.columns:
-        mean_conf = detail_df["Confidence_IPLM"].mean(skipna=True)
-
-    msg = f"Berhasil dihitung untuk {len(detail_df)} baris perpustakaan."
-    if mean_conf is not None and not np.isnan(mean_conf):
-        msg += f" | Rata-rata Confidence_IPLM: {mean_conf:.2f}"
-    if not verif_df.empty:
-        msg += " | Verifikasi sampel tersedia."
-
-    # Analisis otomatis (LLM / rule-based)
-    analysis_text = generate_llm_analysis(
-        detail_df=detail_df,
-        agg_df=agg_df,
-        verif_df=verif_df,
-        kab_name=kab_name,
-        kew_value=kew_value,
-    )
-
-    # Laporan Word
-    word_path = generate_word_report_all(
-        detail_df, agg_df, verif_df,
-        prov_value, kab_value, kew_value,
-        analysis_text
-    )
-
-    return (
-        agg_df,
-        detail_df,
-        verif_df,
-        agg_path,
-        detail_path,
-        raw_path,
-        word_path,
-        fig_all,
-        fig_sekolah,
-        fig_umum,
-        fig_khusus,
-        msg,
-        analysis_text,
-    )
-
-
-def on_prov_change(prov_value):
-    if df_all_raw is None or kab_col_glob is None:
-        return gr.update(choices=["(Semua)"], value="(Semua)")
-    if prov_value is None or prov_value == "(Semua)" or prov_col_glob is None:
-        s = df_all_raw[kab_col_glob].dropna().astype(str).str.strip()
-    else:
-        m = df_all_raw[prov_col_glob].astype(str).str.strip() == prov_value
-        s = df_all_raw.loc[m, kab_col_glob].dropna().astype(str).str.strip()
-    vals = sorted([x for x in s.unique() if x != ""])
-    new_choices = ["(Semua)"] + vals
-    return gr.update(choices=new_choices, value="(Semua)")
-
-
-# ============================================================
-# 9. BUILD UI GRADIO
-# ============================================================
-
-with gr.Blocks() as demo:
-    gr.Markdown(
-        f"""
-        # IPLM 2025 – RealScore + Normatif + Verifikasi Sampel + Analisis Otomatis (LLM + Rule-based)
-
-        Dataset diambil langsung dari file di repository (tanpa upload):
-
-        - **`{DATA_FILE}`** – Data perpustakaan (semua jenis, multi-sheet).
-        - **`{META_KAB_FILE}`** – Jumlah kecamatan & desa/kel per kab/kota.
-        - **`{META_SDSMP_FILE}`** – Jumlah SD & SMP per kab/kota.
-        - **`{META_SMA_FILE}`** – Jumlah SMA per provinsi.
-
-        {DATA_INFO}
-        """
-    )
-
-    with gr.Row():
-        dd_prov = gr.Dropdown(label="Provinsi", choices=prov_choices, value=prov_choices[0])
-        dd_kab  = gr.Dropdown(label="Kab/Kota", choices=kab_choices, value=kab_choices[0])
-        dd_kew  = gr.Dropdown(label="Kewenangan", choices=kew_choices, value=default_kew)
-
-    dd_prov.change(
-        fn=on_prov_change,
-        inputs=dd_prov,
-        outputs=dd_kab,
-    )
-
-    run_btn = gr.Button("Jalankan Perhitungan")
-    msg_out = gr.Markdown()
-
-    gr.Markdown("### Hasil Agregat (RealScore) per Jenis Perpustakaan")
-    agg_df_out = gr.DataFrame(interactive=False)
-
-    gr.Markdown("### Detail Indeks (Real + Normatif) per Perpustakaan")
-    detail_df_out = gr.DataFrame(interactive=False)
-
-    gr.Markdown("### Verifikasi Kondisi Sampel di Lapangan")
-    verif_df_out = gr.DataFrame(
-        label="Perbandingan jumlah sampel dengan populasi unit (SD/SMP/SMA, Kecamatan, Desa/Kel)",
-        interactive=False
-    )
-
-    gr.Markdown("### Sebaran Indeks – Semua Perpustakaan (RealScore)")
-    bell_all_out = gr.Plot()
-
-    gr.Markdown("### Sebaran Indeks – Perpustakaan Sekolah")
-    bell_sekolah_out = gr.Plot()
-
-    gr.Markdown("### Sebaran Indeks – Perpustakaan Umum")
-    bell_umum_out = gr.Plot()
-
-    gr.Markdown("### Sebaran Indeks – Perpustakaan Khusus")
-    bell_khusus_out = gr.Plot()
-
-    gr.Markdown("### Analisis Otomatis & Rekomendasi Kebijakan")
-    analysis_out = gr.Markdown()
-
-    with gr.Row():
-        agg_file_out   = gr.File(label="Download File Agregat (.xlsx)")
-        detail_file_out = gr.File(label="Download File Detail (.xlsx)")
-        raw_file_out   = gr.File(label="Download Data Mentah (.xlsx)")
-        word_file_out  = gr.File(label="Download Laporan Word (.docx)")
-
-    run_btn.click(
-        fn=run_app,
-        inputs=[dd_prov, dd_kab, dd_kew],
-        outputs=[
-            agg_df_out,
-            detail_df_out,
-            verif_df_out,
-            agg_file_out,
-            detail_file_out,
-            raw_file_out,
-            word_file_out,
-            bell_all_out,
-            bell_sekolah_out,
-            bell_umum_out,
-            bell_khusus_out,
-            msg_out,
-            analysis_out,
-        ],
-    )
-
-demo.launch()