Update app.py

app.py

@@ -6,9 +6,10 @@ from typing import Dict, Any
 
 app = FastAPI(title="Dashboard Akademik API")
 
-# Path ke CSV: bisa override lewat env var CSV_PATH
+# Lokasi CSV dapat dioverride di HuggingFace: Settings → Variables → CSV_PATH
 CSV_PATH = os.getenv("CSV_PATH", "generated_dummy_data.csv")
 
+# Konversi nilai huruf ke skala 4.0
 MAP_NILAI = {
     "A": 4.0,
     "AB": 3.5,
@@ -19,6 +20,7 @@ MAP_NILAI = {
     "E": 0.0
 }
 
+# Pastikan CSV memiliki kolom wajib
 def _ensure_columns(df: pd.DataFrame):
     required = {
         "kode_mhs", "nama_prodi", "id_smt", "kode_mk", "nama_mk",
@@ -29,190 +31,202 @@ def _ensure_columns(df: pd.DataFrame):
     if missing:
         raise ValueError(f"CSV missing required columns: {missing}")
 
+# Loader CSV dengan cache
 @lru_cache(maxsize=1)
 def load_data_cached() -> pd.DataFrame:
-    """
-    Load CSV into DataFrame and cache it for reuse.
-    Jika ingin reload, panggil /reload_data endpoint (opsional).
-    """
     if not os.path.exists(CSV_PATH):
-        raise FileNotFoundError(f"CSV not found at path: {CSV_PATH}")
+        raise FileNotFoundError(f"CSV not found at: {CSV_PATH}")
+
     df = pd.read_csv(CSV_PATH)
-    # Normalisasi kolom whitespace
-    df.columns = [c.strip() for c in df.columns]
+    df.columns = [c.strip() for c in df.columns]  # Hilangkan spasi
+
     _ensure_columns(df)
-    # Pastikan tipe
+
     df["sks"] = pd.to_numeric(df["sks"], errors="coerce").fillna(0).astype(int)
     df["id_smt"] = pd.to_numeric(df["id_smt"], errors="coerce").fillna(0).astype(int)
-    # map nilai huruf -> numerik, jika kosong set NaN -> 0.0
-    df["nilai_huruf"] = df["nilai_huruf"].astype(str).str.strip()
+
+    df["nilai_huruf"] = df["nilai_huruf"].astype(str).strip()
     df["nilai_numerik"] = df["nilai_huruf"].map(MAP_NILAI)
-    # bila nilai_huruf tidak ada / invalid -> gunakan nilai_akhir jika ada (0-100 scale)
+
+    # Jika huruf invalid → fallback ke nilai_akhir 0–100
     def fallback_numeric(row):
         if pd.notna(row["nilai_numerik"]):
             return row["nilai_numerik"]
+
         try:
-            v = float(row.get("nilai_akhir", None))
-            # convert angka 0-100 ke skala 0-4 berdasarkan mapping ranges
-            if v >= 86:
-                return 4.0
-            if v >= 76:
-                return 3.5
-            if v >= 66:
-                return 3.0
-            if v >= 61:
-                return 2.5
-            if v >= 56:
-                return 2.0
-            if v >= 41:
-                return 1.0
+            v = float(row["nilai_akhir"])
+            if v >= 86: return 4.0
+            if v >= 76: return 3.5
+            if v >= 66: return 3.0
+            if v >= 61: return 2.5
+            if v >= 56: return 2.0
+            if v >= 41: return 1.0
             return 0.0
-        except Exception:
+        except:
             return 0.0
+
     df["nilai_numerik"] = df.apply(fallback_numeric, axis=1)
     return df
 
+# Pakai nilai terakhir per (mhs, matkul)
 def get_final_records(df: pd.DataFrame) -> pd.DataFrame:
-    """
-    Ambil record terakhir tiap (kode_mhs, kode_mk) berdasarkan id_smt.
-    Ini memenuhi aturan: nilai terakhir berlaku, SKS dihitung sekali.
-    """
-    # sort by id_smt lalu ambil tail(1) per group
     df_sorted = df.sort_values(["kode_mhs", "kode_mk", "id_smt"])
-    final = df_sorted.groupby(["kode_mhs", "kode_mk"], as_index=False).last()
-    return final
+    return df_sorted.groupby(["kode_mhs", "kode_mk"], as_index=False).last()
 
+# ----------------------------------------------------
+# ENDPOINT 1 — TOTAL MAHASISWA
+# ----------------------------------------------------
 @app.get("/jumlah_mahasiswa")
-def jumlah_mahasiswa(reload: bool = Query(False, description="set true to reload CSV from disk")):
-    """
-    Mengembalikan total mahasiswa unik (kode_mhs).
-    Tambah ?reload=true untuk load ulang CSV.
-    """
+def jumlah_mahasiswa(reload: bool = False):
     if reload:
         load_data_cached.cache_clear()
+
     try:
         df = load_data_cached()
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(500, str(e))
+
     total = int(df["kode_mhs"].nunique())
     return {"total_mahasiswa": total}
 
+# ----------------------------------------------------
+# ENDPOINT 2 — JUMLAH PER ANGKATAN
+# ----------------------------------------------------
 @app.get("/jumlah_per_angkatan")
-def jumlah_per_angkatan(reload: bool = Query(False, description="set true to reload CSV from disk")):
+def jumlah_per_angkatan(reload: bool = False):
     if reload:
         load_data_cached.cache_clear()
+
     try:
         df = load_data_cached()
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(500, str(e))
+
     per_ang = df.groupby("Tahun angkatan")["kode_mhs"].nunique().sort_index().to_dict()
-    # convert keys to str (JSON-friendly)
     per_ang = {str(k): int(v) for k, v in per_ang.items()}
+
     return {"mahasiswa_per_angkatan": per_ang}
 
+# ----------------------------------------------------
+# ENDPOINT 3 — MAHASISWA ELIGIBLE TA
+# ----------------------------------------------------
 @app.get("/eligible_ta")
-def eligible_ta(reload: bool = Query(False, description="set true to reload CSV from disk"),
-                min_sks: int = Query(110, description="threshold SKS untuk eligible (default:110)")):
-    """
-    Mengembalikan daftar mahasiswa yang total SKS (menggunakan nilai terakhir tiap matkul) > min_sks.
-    """
+def eligible_ta(reload: bool = False, min_sks: int = 110):
     if reload:
         load_data_cached.cache_clear()
+
     try:
         df = load_data_cached()
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(500, str(e))
+
     final = get_final_records(df)
     sks_per_mhs = final.groupby("kode_mhs")["sks"].sum()
-    eligible_series = sks_per_mhs[sks_per_mhs > min_sks]
-    eligible_list = eligible_series.sort_values(ascending=False).index.to_list()
-    # optional: juga sertakan total SKS per mahasiswa pada hasil
-    eligible_info = [{"kode_mhs": m, "total_sks": int(sks_per_mhs.loc[m])} for m in eligible_list]
-    return {"jumlah_eligible": len(eligible_list), "daftar": eligible_info}
 
+    eligible = sks_per_mhs[sks_per_mhs > min_sks]
+
+    data = [
+        {"kode_mhs": m, "total_sks": int(sks_per_mhs[m])}
+        for m in eligible.index
+    ]
+
+    return {"jumlah_eligible": len(data), "daftar": data}
+
+# ----------------------------------------------------
+# ENDPOINT 4 — IPK RATA-RATA
+# ----------------------------------------------------
 @app.get("/ipk_rata_rata")
-def ipk_rata_rata(reload: bool = Query(False, description="set true to reload CSV from disk")):
-    """
-    Menghitung IPK rata-rata seluruh mahasiswa:
-    - IPS per semester = (Σ sks * nilai_numerik) / Σ sks  (menggunakan nilai terakhir utk matkul yang diulang)
-    - IPK mahasiswa = rata-rata IPS mahasiswa
-    - IPK rata-rata = rata-rata IPK semua mahasiswa
-    """
+def ipk_rata_rata(reload: bool = False):
     if reload:
         load_data_cached.cache_clear()
+
     try:
         df = load_data_cached()
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(500, str(e))
+
     final = get_final_records(df)
-    # bobot per record
     final["total_bobot"] = final["sks"] * final["nilai_numerik"]
-    # IPS per mahasiswa per semester
+
     grp = final.groupby(["kode_mhs", "id_smt"]).agg(
-        total_bobot=pd.NamedAgg(column="total_bobot", aggfunc="sum"),
-        total_sks=pd.NamedAgg(column="sks", aggfunc="sum")
+        total_bobot=("total_bobot", "sum"),
+        total_sks=("sks", "sum")
     ).reset_index()
-    # Hindari pembagian 0
-    grp["ips"] = grp.apply(lambda r: (r["total_bobot"] / r["total_sks"]) if r["total_sks"] > 0 else 0.0, axis=1)
-    # IPK = rata-rata ips tiap mahasiswa
+
+    grp["ips"] = grp.apply(
+        lambda r: (r["total_bobot"] / r["total_sks"]) if r["total_sks"] > 0 else 0.0,
+        axis=1
+    )
+
     ipk_series = grp.groupby("kode_mhs")["ips"].mean()
-    mean_ipk = float(round(ipk_series.mean(), 3)) if not ipk_series.empty else 0.0
-    # optional: distribusi ipk (quartiles)
-    q = ipk_series.quantile([0.25, 0.5, 0.75]).to_dict() if not ipk_series.empty else {}
+    mean_ipk = float(round(ipk_series.mean(), 3))
+
+    q = ipk_series.quantile([0.25, 0.5, 0.75]).to_dict()
     q = {str(k): float(v) for k, v in q.items()}
-    return {"ipk_rata_rata": mean_ipk, "ipk_quartiles": q}
 
+    return {
+        "ipk_rata_rata": mean_ipk,
+        "ipk_quartiles": q
+    }
+
+# ----------------------------------------------------
+# ENDPOINT 5 — DASHBOARD SUMMARY (SEMUA RINGKASAN)
+# ----------------------------------------------------
 @app.get("/dashboard_summary")
-def dashboard_summary(reload: bool = Query(False, description="set true to reload CSV from disk")):
+def dashboard_summary(reload: bool = False):
     if reload:
         load_data_cached.cache_clear()
+
     try:
         df = load_data_cached()
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(500, str(e))
 
     final = get_final_records(df)
     total_mhs = int(df["kode_mhs"].nunique())
-    per_ang = df.groupby("Tahun angkatan")["kode_mhs"].nunique().sort_index().to_dict()
+
+    per_ang = df.groupby("Tahun angkatan")["kode_mhs"].nunique().to_dict()
     per_ang = {str(k): int(v) for k, v in per_ang.items()}
 
     sks_per_mhs = final.groupby("kode_mhs")["sks"].sum()
-    eligible_series = sks_per_mhs[sks_per_mhs > 110]
-    eligible_list = [{"kode_mhs": m, "total_sks": int(sks_per_mhs.loc[m])} for m in eligible_series.sort_values(ascending=False).index]
+    eligible = sks_per_mhs[sks_per_mhs > 110]
+
+    eligible_list = [
+        {"kode_mhs": m, "total_sks": int(sks_per_mhs[m])}
+        for m in eligible.index
+    ]
 
-    # IPK
+    # Hitung IPK
     final["total_bobot"] = final["sks"] * final["nilai_numerik"]
     grp = final.groupby(["kode_mhs", "id_smt"]).agg(
-        total_bobot=pd.NamedAgg(column="total_bobot", aggfunc="sum"),
-        total_sks=pd.NamedAgg(column="sks", aggfunc="sum")
+        total_bobot=("total_bobot", "sum"),
+        total_sks=("sks", "sum")
     ).reset_index()
-    grp["ips"] = grp.apply(lambda r: (r["total_bobot"] / r["total_sks"]) if r["total_sks"] > 0 else 0.0, axis=1)
+
+    grp["ips"] = grp.apply(lambda r: r["total_bobot"] / r["total_sks"] if r["total_sks"] > 0 else 0, axis=1)
     ipk_series = grp.groupby("kode_mhs")["ips"].mean()
-    mean_ipk = float(round(ipk_series.mean(), 3)) if not ipk_series.empty else 0.0
+    mean_ipk = float(round(ipk_series.mean(), 3))
 
-    summary: Dict[str, Any] = {
+    return {
         "total_mahasiswa": total_mhs,
         "mahasiswa_per_angkatan": per_ang,
         "eligible_ta": {
-            "jumlah": int(eligible_series.shape[0]),
+            "jumlah": len(eligible_list),
             "daftar": eligible_list
         },
         "ipk": {
             "rata_rata_ipk": mean_ipk
         }
     }
-    return summary
 
+# ----------------------------------------------------
+# ENDPOINT 6 — RELOAD CSV
+# ----------------------------------------------------
 @app.post("/reload_data")
 def reload_data():
-    """
-    Endpoint untuk menghapus cache dan reload CSV.
-    (tidak perlu query param, panggil endpoint ini setelah CSV diganti)
-    """
     load_data_cached.cache_clear()
     try:
-        # force load to check file validity
         _ = load_data_cached()
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Reload failed: {e}")
+        raise HTTPException(500, f"Reload failed: {e}")
     return {"status": "reloaded"}