Update app.py

app.py

@@ -31,30 +31,64 @@ def _ensure_columns(df: pd.DataFrame):
     if missing:
         raise ValueError(f"CSV missing required columns: {missing}")
 
+# Helper untuk normalisasi nilai_huruf sel yang mungkin berisi list/Series/None
+def _to_simple_string(val):
+    try:
+        # pandas NA
+        if pd.isna(val):
+            return ""
+    except Exception:
+        # if val is unhashable, continue
+        pass
+
+    # If the cell contains a pandas Series or ndarray-like
+    if isinstance(val, pd.Series):
+        # take first non-null element if possible
+        non_null = val.dropna()
+        if not non_null.empty:
+            return str(non_null.iloc[0])
+        if not val.empty:
+            return str(val.iloc[0])
+        return ""
+    if isinstance(val, (list, tuple)):
+        if len(val) == 0:
+            return ""
+        return str(val[0])
+    # dict or other object: convert to string
+    try:
+        return str(val)
+    except Exception:
+        return ""
+
 # Loader CSV dengan cache
 @lru_cache(maxsize=1)
 def load_data_cached() -> pd.DataFrame:
     if not os.path.exists(CSV_PATH):
         raise FileNotFoundError(f"CSV not found at: {CSV_PATH}")
 
+    # Read CSV (let pandas infer types). If encoding issues happen, set encoding='utf-8'
     df = pd.read_csv(CSV_PATH)
-    df.columns = [c.strip() for c in df.columns]  # Hilangkan spasi
+    # Normalize column names: strip whitespace
+    df.columns = [c.strip() for c in df.columns]
 
     _ensure_columns(df)
 
+    # Normalize numeric columns
     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)
 
-    df["nilai_huruf"] = df["nilai_huruf"].astype(str).strip()
+    # SAFELY normalize nilai_huruf (handle lists, Series, NaN, ints, etc.)
+    df["nilai_huruf"] = df["nilai_huruf"].apply(_to_simple_string).astype(str).str.strip()
+    # Map A, AB, B, ... -> numeric
     df["nilai_numerik"] = df["nilai_huruf"].map(MAP_NILAI)
 
-    # Jika huruf invalid → fallback ke nilai_akhir 0–100
+    # Jika huruf invalid → fallback ke nilai_akhir (0–100 -> skala 0-4)
     def fallback_numeric(row):
+        # jika sudah mapped, kembalikan
         if pd.notna(row["nilai_numerik"]):
             return row["nilai_numerik"]
-
         try:
-            v = float(row["nilai_akhir"])
+            v = float(row.get("nilai_akhir", 0))
             if v >= 86: return 4.0
             if v >= 76: return 3.5
             if v >= 66: return 3.0
@@ -62,10 +96,11 @@ def load_data_cached() -> pd.DataFrame:
             if v >= 56: return 2.0
             if v >= 41: return 1.0
             return 0.0
-        except:
+        except Exception:
             return 0.0
 
     df["nilai_numerik"] = df.apply(fallback_numeric, axis=1)
+
     return df
 
 # Pakai nilai terakhir per (mhs, matkul)
@@ -77,14 +112,13 @@ def get_final_records(df: pd.DataFrame) -> pd.DataFrame:
 # ENDPOINT 1 — TOTAL MAHASISWA
 # ----------------------------------------------------
 @app.get("/jumlah_mahasiswa")
-def jumlah_mahasiswa(reload: bool = False):
+def jumlah_mahasiswa(reload: bool = Query(False, description="reload CSV cache")):
     if reload:
         load_data_cached.cache_clear()
-
     try:
         df = load_data_cached()
     except Exception as e:
-        raise HTTPException(500, str(e))
+        raise HTTPException(status_code=500, detail=str(e))
 
     total = int(df["kode_mhs"].nunique())
     return {"total_mahasiswa": total}
@@ -93,57 +127,49 @@ def jumlah_mahasiswa(reload: bool = False):
 # ENDPOINT 2 — JUMLAH PER ANGKATAN
 # ----------------------------------------------------
 @app.get("/jumlah_per_angkatan")
-def jumlah_per_angkatan(reload: bool = False):
+def jumlah_per_angkatan(reload: bool = Query(False, description="reload CSV cache")):
     if reload:
         load_data_cached.cache_clear()
-
     try:
         df = load_data_cached()
     except Exception as e:
-        raise HTTPException(500, str(e))
+        raise HTTPException(status_code=500, detail=str(e))
 
     per_ang = df.groupby("Tahun angkatan")["kode_mhs"].nunique().sort_index().to_dict()
     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 = False, min_sks: int = 110):
+def eligible_ta(reload: bool = Query(False, description="reload CSV cache"),
+                min_sks: int = Query(110, description="threshold SKS untuk eligible (default:110)")):
     if reload:
         load_data_cached.cache_clear()
-
     try:
         df = load_data_cached()
     except Exception as e:
-        raise HTTPException(500, str(e))
+        raise HTTPException(status_code=500, detail=str(e))
 
     final = get_final_records(df)
     sks_per_mhs = final.groupby("kode_mhs")["sks"].sum()
-
     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
-    ]
-
+    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 = False):
+def ipk_rata_rata(reload: bool = Query(False, description="reload CSV cache")):
     if reload:
         load_data_cached.cache_clear()
-
     try:
         df = load_data_cached()
     except Exception as e:
-        raise HTTPException(500, str(e))
+        raise HTTPException(status_code=500, detail=str(e))
 
     final = get_final_records(df)
     final["total_bobot"] = final["sks"] * final["nilai_numerik"]
@@ -153,34 +179,29 @@ def ipk_rata_rata(reload: bool = False):
         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.0, axis=1)
     ipk_series = grp.groupby("kode_mhs")["ips"].mean()
-    mean_ipk = float(round(ipk_series.mean(), 3))
 
+    if ipk_series.empty:
+        return {"ipk_rata_rata": 0.0, "ipk_quartiles": {}}
+
+    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 = False):
+def dashboard_summary(reload: bool = Query(False, description="reload CSV cache")):
     if reload:
         load_data_cached.cache_clear()
-
     try:
         df = load_data_cached()
     except Exception as e:
-        raise HTTPException(500, str(e))
+        raise HTTPException(status_code=500, detail=str(e))
 
     final = get_final_records(df)
     total_mhs = int(df["kode_mhs"].nunique())
@@ -190,11 +211,7 @@ def dashboard_summary(reload: bool = False):
 
     sks_per_mhs = final.groupby("kode_mhs")["sks"].sum()
     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
-    ]
+    eligible_list = [{"kode_mhs": m, "total_sks": int(sks_per_mhs[m])} for m in eligible.index]
 
     # Hitung IPK
     final["total_bobot"] = final["sks"] * final["nilai_numerik"]
@@ -202,10 +219,9 @@ def dashboard_summary(reload: bool = False):
         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, axis=1)
+    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))
+    mean_ipk = float(round(ipk_series.mean(), 3)) if not ipk_series.empty else 0.0
 
     return {
         "total_mahasiswa": total_mhs,
@@ -220,7 +236,73 @@ def dashboard_summary(reload: bool = False):
     }
 
 # ----------------------------------------------------
-# ENDPOINT 6 — RELOAD CSV
+# ADDITIONAL ENDPOINT — RATA-RATA SKS
+# ----------------------------------------------------
+@app.get("/rata_sks")
+def rata_sks(reload: bool = Query(False, description="reload CSV cache")):
+    if reload:
+        load_data_cached.cache_clear()
+    try:
+        df = load_data_cached()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+    final = get_final_records(df)
+    sks_per_mhs = final.groupby("kode_mhs")["sks"].sum()
+    if sks_per_mhs.empty:
+        return {"rata_rata_sks": 0.0}
+    rata2 = float(round(sks_per_mhs.mean(), 2))
+    return {"rata_rata_sks": rata2}
+
+# ----------------------------------------------------
+# ADDITIONAL ENDPOINT — IPS TREND (per angkatan per semester)
+# ----------------------------------------------------
+@app.get("/ips_trend")
+def ips_trend(reload: bool = Query(False, description="reload CSV cache")):
+    if reload:
+        load_data_cached.cache_clear()
+    try:
+        df = load_data_cached()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+    final = get_final_records(df)
+    final["total_bobot"] = final["sks"] * final["nilai_numerik"]
+
+    grp = final.groupby(["kode_mhs", "id_smt", "Tahun angkatan"]).agg(
+        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)
+
+    result = grp.groupby(["Tahun angkatan", "id_smt"])["ips"].mean().round(3).reset_index()
+
+    output = {}
+    for _, row in result.iterrows():
+        angkatan = str(int(row["Tahun angkatan"]))
+        semester = str(int(row["id_smt"]))
+        output.setdefault(angkatan, {})[semester] = float(row["ips"])
+    return output
+
+# ----------------------------------------------------
+# ADDITIONAL ENDPOINT — POPULASI (jumlah mahasiswa per angkatan)
+# ----------------------------------------------------
+@app.get("/populasi")
+def populasi(reload: bool = Query(False, description="reload CSV cache")):
+    if reload:
+        load_data_cached.cache_clear()
+    try:
+        df = load_data_cached()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+    per_ang = df.groupby("Tahun angkatan")["kode_mhs"].nunique().sort_index().to_dict()
+    per_ang = {str(k): int(v) for k, v in per_ang.items()}
+    return {"populasi": per_ang}
+
+# ----------------------------------------------------
+# ENDPOINT — RELOAD CSV
 # ----------------------------------------------------
 @app.post("/reload_data")
 def reload_data():
@@ -228,5 +310,5 @@ def reload_data():
     try:
         _ = load_data_cached()
     except Exception as e:
-        raise HTTPException(500, f"Reload failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Reload failed: {e}")
     return {"status": "reloaded"}