dqlab-grader 0.1.0__py3-none-any.whl

dqcheck/__init__.py

@@ -0,0 +1,296 @@
+"""dqcheck — pengecek jawaban latihan Data Analyst with Python.
+
+Pemakaian singkat (di Colab / Jupyter)::
+
+    import dqcheck as dq
+    dq.mulai(nama="Budi Santoso", id_peserta="DQ-001", sesi=6)
+    ...                       # kerjakan soal
+    dq.cek("2.1")             # cek jawaban soal 2.1
+    dq.daftar_soal()          # soal mana yang belum selesai
+    dq.status()               # rekap jawabanmu
+
+Ketik ``dq.bantuan()`` untuk panduan lengkap.
+"""
+
+__version__ = "0.1.0"
+
+import datetime as _dt
+import inspect as _inspect
+import re as _re
+import uuid as _uuid
+
+from . import analisis as _analisis
+from . import soal as _soal
+from . import storage as _storage
+from .tampilan import kartu as _kartu, tabel as _tabel
+
+__all__ = ["mulai", "ganti_sesi", "cek", "status", "daftar_soal", "bantuan", "kirim_ulang"]
+
+_POLA_ID = _re.compile(r"^[A-Za-z0-9_.\-]{2,40}$")
+_peserta = {}
+_sesi_aktif = None
+
+
+# ------------------------------------------------------------------ identitas
+
+def mulai(nama=None, id_peserta=None, sesi=None):
+    """Isi identitas peserta (wajib sebelum ``cek``). Sesi opsional."""
+    global _sesi_aktif
+    nama = (nama or input("Nama lengkap : ")).strip()
+    id_peserta = (id_peserta or input("ID peserta   : ")).strip()
+    nama = " ".join(nama.split())
+
+    salah = []
+    if not 2 <= len(nama) <= 80:
+        salah.append("Nama wajib diisi (2–80 karakter).")
+    if not _POLA_ID.match(id_peserta):
+        salah.append("ID peserta 2–40 karakter, hanya huruf, angka, titik, `-` atau `_` (tanpa spasi).")
+    if sesi is not None and int(sesi) not in _soal.daftar_sesi():
+        salah.append(f"Sesi {sesi} belum tersedia. Pilihan: {_soal.daftar_sesi()}.")
+    if salah:
+        _kartu("salah", "Identitas belum valid", bagian=[("Perbaiki:", salah)],
+               catatan='Contoh: `dq.mulai(nama="Budi Santoso", id_peserta="DQ-001", sesi=6)`')
+        return
+
+    _peserta.update(nama=nama, id_peserta=id_peserta)
+    if sesi is not None:
+        _sesi_aktif = int(sesi)
+
+    mode = _storage.mode()
+    info = [f"Nama: {nama}", f"ID peserta: `{id_peserta}`"]
+    if _sesi_aktif:
+        info.append(f"Sesi aktif: {_sesi_aktif} — {_soal.judul_sesi(_sesi_aktif)} "
+                    f"({len(_soal.semua_soal(_sesi_aktif))} soal)")
+    info.append("Penyimpanan: server (jawaban tercatat ke instruktur)" if mode == "server"
+                else "Penyimpanan: LOKAL saja (belum terhubung ke server instruktur)")
+    langkah = [
+        "Kerjakan soal di sel jawabanmu, lalu jalankan sel tersebut.",
+        "Cek jawaban: `dq.cek(\"2.1\")`" + ("" if _sesi_aktif else "  (atau `dq.cek(\"2.1\", sesi=6)`)"),
+        "Lihat soal yang belum selesai: `dq.daftar_soal()`",
+        "Lihat rekap jawabanmu: `dq.status()`",
+    ]
+    _kartu("info" if mode == "server" else "peringatan", f"Halo, {nama}! Siap mengecek jawaban.",
+           bagian=[("Identitas", info), ("Langkah berikutnya", langkah)],
+           catatan="Salah itu wajar — setiap percobaan tercatat dan kamu boleh mencoba lagi sampai benar.")
+
+
+def ganti_sesi(sesi):
+    """Ganti sesi aktif, misal ``dq.ganti_sesi(7)``."""
+    global _sesi_aktif
+    if int(sesi) not in _soal.daftar_sesi():
+        _kartu("salah", f"Sesi {sesi} belum tersedia", sub=f"Pilihan: {_soal.daftar_sesi()}")
+        return
+    _sesi_aktif = int(sesi)
+    _kartu("info", f"Sesi aktif: {sesi} — {_soal.judul_sesi(sesi)}",
+           sub=f"{len(_soal.semua_soal(sesi))} soal. Lihat daftarnya: dq.daftar_soal()")
+
+
+def _butuh_login():
+    if _peserta:
+        return False
+    _kartu("peringatan", "Isi identitas dulu sebelum mengecek jawaban",
+           bagian=[("Jalankan:", ['`dq.mulai(nama="Nama Lengkapmu", id_peserta="ID-dari-instruktur", sesi=6)`'])])
+    return True
+
+
+def _tentukan_sesi(sesi):
+    s = sesi if sesi is not None else _sesi_aktif
+    if s is None:
+        _kartu("peringatan", "Sesi belum ditentukan",
+               bagian=[("Pilih salah satu:", ["`dq.cek(\"2.1\", sesi=6)`", "`dq.ganti_sesi(6)` lalu `dq.cek(\"2.1\")`"])])
+        return None
+    if int(s) not in _soal.daftar_sesi():
+        _kartu("salah", f"Sesi {s} belum tersedia", sub=f"Pilihan: {_soal.daftar_sesi()}")
+        return None
+    return int(s)
+
+
+# ---------------------------------------------------------------------- cek
+
+def cek(soal, sesi=None):
+    """Cek jawaban satu soal, misal ``dq.cek("2.1")`` atau ``dq.cek("Capstone", sesi=8)``."""
+    if _butuh_login():
+        return
+    s = _tentukan_sesi(sesi)
+    if s is None:
+        return
+    try:
+        sid, kode = _soal.cari_soal(s, soal)
+    except KeyError:
+        _kartu("salah", f"Soal \"{soal}\" tidak ada di Sesi {s}",
+               bagian=[("Soal yang tersedia:", ", ".join(_soal.semua_soal(s)))],
+               catatan="Perhatikan penulisan, contoh: `dq.cek(\"2.1\")`, `dq.cek(\"Capstone A\")`.")
+        return
+
+    ns = _inspect.currentframe().f_back.f_globals
+    hasil = _analisis.jalankan(kode, ns, f"sesi{s} {sid}")
+
+    rec = {
+        "waktu": _dt.datetime.now(_dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "id_peserta": _peserta["id_peserta"],
+        "nama": _peserta["nama"],
+        "sesi": s,
+        "soal": sid,
+        "status": "BENAR" if hasil.benar else "SALAH",
+        "pesan": hasil.ringkas,
+        "uid": _uuid.uuid4().hex,
+        "versi": __version__,
+    }
+    simpan = _storage.simpan(rec)
+    ke = simpan["percobaan_ke"]
+    sub = f"Sesi {s} · Soal {sid} · {_peserta['nama']} ({_peserta['id_peserta']})" + (f" · percobaan ke-{ke}" if ke else "")
+
+    if simpan["tempat"] == "server":
+        catatan = "Tersimpan di server instruktur ✓"
+    elif simpan["tempat"] == "lokal":
+        catatan = f"Tersimpan lokal di `{_storage.config.LOCAL_CSV}` (mode lokal)."
+    elif simpan["tempat"] == "antrean":
+        catatan = ("⚠️ Server tidak terjangkau — hasil disimpan di antrean dan akan dikirim otomatis "
+                   "saat kamu mengecek lagi (atau jalankan `dq.kirim_ulang()`).")
+    else:
+        catatan = f"⚠️ Hasil TIDAK tersimpan: {simpan['error']}"
+
+    if hasil.benar:
+        _kartu("benar", "BENAR! Jawabanmu lolos semua pengecekan", sub=sub,
+               bagian=[("Output", hasil.output)] if hasil.output.strip() else [], catatan=catatan)
+    else:
+        bagian = [
+            ("Pengecekan yang gagal", f"{hasil.masalah}" if hasil.masalah else ""),
+            ("Apa yang belum tepat", hasil.detail),
+            ("Nilai variabelmu saat ini", hasil.konteks),
+            ("Cara memperbaiki", hasil.saran + [f"Setelah diperbaiki, jalankan ulang sel jawabanmu lalu `dq.cek(\"{sid}\")` lagi."]),
+        ]
+        _kartu("salah", "Belum tepat — ayo coba lagi!", sub=sub, bagian=bagian, catatan=catatan)
+
+
+def kirim_ulang():
+    """Kirim ulang hasil yang tertunda karena koneksi putus."""
+    sisa = _storage.kirim_antrean()
+    if sisa:
+        _kartu("peringatan", f"Masih ada {sisa} hasil tertunda", sub="Cek koneksi internet lalu coba lagi.")
+    else:
+        _kartu("benar", "Tidak ada hasil tertunda — semua sudah terkirim.")
+
+
+# ------------------------------------------------------------------- status
+
+def _rekap(rows):
+    """Kelompokkan riwayat per (sesi, soal)."""
+    rows = sorted(rows, key=lambda r: r["waktu"])  # stabil: urutan asli dipertahankan bila waktu sama
+    rek = {}
+    for r in rows:
+        k = (int(r["sesi"]), r["soal"])
+        d = rek.setdefault(k, {"percobaan": 0, "benar_di": None, "terakhir": None, "waktu": None})
+        d["percobaan"] += 1
+        d["terakhir"] = r["status"]
+        d["waktu"] = r["waktu"]
+        if r["status"] == "BENAR" and d["benar_di"] is None:
+            d["benar_di"] = d["percobaan"]
+    return rek
+
+
+def _ambil(id_peserta, sesi=None):
+    try:
+        return _storage.ambil_riwayat(id_peserta, sesi)
+    except _storage.ServerError as e:
+        _kartu("salah", "Gagal mengambil status dari server", sub=str(e))
+        return None
+
+
+def status(id_peserta=None, sesi=None, kembalikan=False):
+    """Rekap jawaban (benar/salah + jumlah percobaan) milik peserta.
+
+    ``dq.status()`` untuk peserta yang sedang login, atau ``dq.status("DQ-001")``
+    untuk mengecek ID tertentu tanpa login. Tambahkan ``sesi=6`` untuk satu sesi.
+    """
+    id_peserta = id_peserta or _peserta.get("id_peserta")
+    if not id_peserta:
+        _kartu("peringatan", "Masukkan ID peserta", sub='Contoh: dq.status("DQ-001") atau login dulu dengan dq.mulai(...)')
+        return None
+    rows = _ambil(id_peserta, sesi)
+    if rows is None:
+        return None
+    if not rows:
+        _kartu("info", f"Belum ada jawaban tercatat untuk ID `{id_peserta}`" + (f" di Sesi {sesi}" if sesi else ""),
+               sub="Pastikan ID-nya benar. Mulai mengecek dengan dq.cek(\"nomor_soal\").")
+        return None
+
+    rek = _rekap(rows)
+    nama = sorted(rows, key=lambda r: r["waktu"])[-1]["nama"]
+    ringkas = []
+    for s in sorted({k[0] for k in rek}):
+        total = len(_soal.semua_soal(s)) if s in _soal.daftar_sesi() else "?"
+        benar = sum(1 for (ss, _), d in rek.items() if ss == s and d["benar_di"])
+        ringkas.append(f"Sesi {s}: {benar}/{total} soal benar")
+    _kartu("info", f"Status jawaban {nama} ({id_peserta})", bagian=[("Ringkasan", ringkas)],
+           catatan="✅ = sudah pernah benar · ❌ = belum benar. Soal yang belum dikerjakan: dq.daftar_soal()")
+
+    data = []
+    for (s, sid), d in sorted(rek.items(), key=lambda kv: (kv[0][0], _soal.urutan(kv[0][0], kv[0][1]))):
+        data.append({
+            "Sesi": s, "Soal": sid,
+            "Status": "✅ Benar" if d["benar_di"] else "❌ Salah",
+            "Jumlah percobaan": d["percobaan"],
+            "Benar di percobaan ke-": d["benar_di"] or "-",
+            "Hasil terakhir": d["terakhir"],
+            "Terakhir dicek (UTC)": d["waktu"].replace("T", " ").replace("Z", ""),
+        })
+    df = _tabel(data, list(data[0].keys()))
+    return df if kembalikan else None
+
+
+def daftar_soal(sesi=None, hanya_belum=False, kembalikan=False):
+    """Daftar soal satu sesi beserta statusmu: ✅ benar, ❌ belum benar, ⬜ belum dikerjakan."""
+    s = _tentukan_sesi(sesi)
+    if s is None:
+        return None
+    rek = {}
+    if _peserta:
+        rows = _ambil(_peserta["id_peserta"], s)
+        rek = _rekap(rows or [])
+
+    data = []
+    for sid in _soal.semua_soal(s):
+        d = rek.get((s, sid))
+        if d and d["benar_di"]:
+            st = "✅ Benar"
+        elif d:
+            st = f"❌ Belum benar ({d['percobaan']}x)"
+        else:
+            st = "⬜ Belum dikerjakan"
+        if hanya_belum and st.startswith("✅"):
+            continue
+        data.append({"Soal": sid, "Status": st, "Perintah cek": f'dq.cek("{sid}", sesi={s})'})
+
+    total = len(_soal.semua_soal(s))
+    benar = sum(1 for sid in _soal.semua_soal(s) if rek.get((s, sid), {}).get("benar_di"))
+    sub = (f"Progres: {benar}/{total} benar · sisa {total - benar} soal" if _peserta
+           else "Login dengan dq.mulai(...) untuk melihat statusmu per soal.")
+    _kartu("info", f"Sesi {s} — {_soal.judul_sesi(s)}", sub=sub)
+    if not data:
+        _kartu("benar", "Semua soal sesi ini sudah benar. Mantap! 🏆")
+        return None
+    df = _tabel(data, ["Soal", "Status", "Perintah cek"])
+    return df if kembalikan else None
+
+
+# ------------------------------------------------------------------ bantuan
+
+def bantuan():
+    """Tampilkan panduan singkat."""
+    _kartu("info", f"Panduan dqcheck v{__version__}", bagian=[
+        ("1. Isi identitas (wajib, sekali per notebook)",
+         ['`dq.mulai(nama="Budi Santoso", id_peserta="DQ-001", sesi=6)`']),
+        ("2. Kerjakan soal, jalankan selnya, lalu cek",
+         ['`dq.cek("2.1")`  — cek soal 2.1 di sesi aktif',
+          '`dq.cek("Capstone A", sesi=7)`  — cek soal di sesi lain',
+          '`dq.ganti_sesi(8)`  — pindah sesi aktif']),
+        ("3. Pantau progres",
+         ['`dq.daftar_soal()`  — semua soal sesi aktif + statusnya',
+          '`dq.daftar_soal(hanya_belum=True)`  — hanya yang belum benar',
+          '`dq.status()`  — rekap benar/salah & jumlah percobaan',
+          '`dq.status("DQ-001")`  — cek status ID tertentu']),
+        ("Tips", ["Variabel/function harus bernama persis seperti di soal.",
+                  "Jalankan ulang sel jawaban setiap kali kamu mengubah kode, baru cek lagi.",
+                  "Setiap percobaan tercatat; yang dihitung adalah apakah kamu pernah benar."]),
+    ], catatan=f"Sesi tersedia: {_soal.daftar_sesi()} · Mode penyimpanan: {_storage.mode()}")

dqcheck/admin.py

@@ -0,0 +1,176 @@
+import argparse
+import glob
+import io
+import os
+import urllib.request
+
+from . import soal as _soal
+
+KOLOM_WAJIB = {"waktu", "id_peserta", "nama", "sesi", "soal", "status"}
+
+
+def _pd():
+    try:
+        import pandas as pd
+        return pd
+    except ImportError:
+        raise SystemExit("Modul admin butuh pandas: pip install pandas openpyxl") from None
+
+
+def muat(sumber=None, endpoint=None, admin_key=None, sesi=None):
+    """Baca semua percobaan menjadi satu DataFrame.
+
+    sumber   : folder (dicari rekursif file ``percobaan.csv`` / CSV dqcheck) atau satu file CSV
+    endpoint : URL Worker; butuh ``admin_key``
+    """
+    pd = _pd()
+    if endpoint:
+        url = endpoint.rstrip("/") + "/export" + (f"?sesi={int(sesi)}" if sesi else "")
+        req = urllib.request.Request(url, headers={"Authorization": f"Bearer {admin_key}",
+                                                   "User-Agent": "dqcheck-admin"})
+        with urllib.request.urlopen(req, timeout=60) as r:
+            df = pd.read_csv(io.StringIO(r.read().decode("utf-8")), dtype={"id_peserta": str, "soal": str})
+    elif sumber and os.path.isdir(sumber):
+        files = sorted(set(glob.glob(os.path.join(sumber, "**", "percobaan.csv"), recursive=True)
+                           + glob.glob(os.path.join(sumber, "**", "jawaban_dqcheck*.csv"), recursive=True)))
+        if not files:
+            raise SystemExit(f"Tidak ada file percobaan.csv di {sumber}")
+        df = pd.concat([pd.read_csv(f, dtype={"id_peserta": str, "soal": str}) for f in files], ignore_index=True)
+    elif sumber:
+        df = pd.read_csv(sumber, dtype={"id_peserta": str, "soal": str})
+    else:
+        raise SystemExit("Isi salah satu: sumber=... atau endpoint=... + admin_key=...")
+
+    kurang = KOLOM_WAJIB - set(df.columns)
+    if kurang:
+        raise SystemExit(f"Kolom wajib tidak ada: {sorted(kurang)}")
+    if "uid" in df.columns:
+        df = df.drop_duplicates("uid")
+    df["sesi"] = df["sesi"].astype(int)
+    if sesi:
+        df = df[df["sesi"] == int(sesi)]
+    df = df.sort_values("waktu", kind="stable").reset_index(drop=True)
+    df["percobaan_ke"] = df.groupby(["id_peserta", "sesi", "soal"]).cumcount() + 1
+    return df
+
+
+def _urut(sesi, soal):
+    try:
+        return _soal.urutan(sesi, soal)
+    except KeyError:
+        return 999
+
+
+def rekap(df):
+    """Hasilkan dict DataFrame: ringkasan, detail, per_soal, matriks per sesi, dan log mentah."""
+    pd = _pd()
+    nama_terakhir = df.groupby("id_peserta")["nama"].last()
+
+    g = df.groupby(["id_peserta", "sesi", "soal"], sort=False)
+    detail = g.agg(
+        jumlah_percobaan=("status", "size"),
+        jumlah_benar=("status", lambda s: int((s == "BENAR").sum())),
+        hasil_terakhir=("status", "last"),
+        pertama=("waktu", "min"),
+        terakhir=("waktu", "max"),
+    ).reset_index()
+    benar_di = (df[df["status"] == "BENAR"].groupby(["id_peserta", "sesi", "soal"])["percobaan_ke"].min()
+                .rename("benar_di_percobaan"))
+    detail = detail.merge(benar_di, on=["id_peserta", "sesi", "soal"], how="left")
+    detail["status"] = detail["benar_di_percobaan"].notna().map({True: "BENAR", False: "SALAH"})
+    detail.insert(1, "nama", detail["id_peserta"].map(nama_terakhir))
+    detail["_u"] = [_urut(s, q) for s, q in zip(detail["sesi"], detail["soal"])]
+    detail = detail.sort_values(["sesi", "id_peserta", "_u"]).drop(columns="_u")
+    detail = detail[["id_peserta", "nama", "sesi", "soal", "status", "jumlah_percobaan",
+                     "benar_di_percobaan", "jumlah_benar", "hasil_terakhir", "pertama", "terakhir"]]
+    detail["benar_di_percobaan"] = detail["benar_di_percobaan"].astype("Int64")
+
+    def _total(s):
+        return len(_soal.semua_soal(s)) if s in _soal.daftar_sesi() else None
+
+    ring = detail.groupby(["id_peserta", "sesi"]).agg(
+        dikerjakan=("soal", "size"),
+        benar=("status", lambda s: int((s == "BENAR").sum())),
+        total_percobaan=("jumlah_percobaan", "sum"),
+        rata2_percobaan_sampai_benar=("benar_di_percobaan", "mean"),
+        terakhir=("terakhir", "max"),
+    ).reset_index()
+    ring.insert(1, "nama", ring["id_peserta"].map(nama_terakhir))
+    ring["total_soal"] = ring["sesi"].map(_total)
+    ring["belum_benar"] = ring["dikerjakan"] - ring["benar"]
+    ring["belum_dikerjakan"] = ring["total_soal"] - ring["dikerjakan"]
+    ring["persen_benar"] = (100 * ring["benar"] / ring["total_soal"]).round(1)
+    ring["rata2_percobaan_sampai_benar"] = ring["rata2_percobaan_sampai_benar"].astype(float).round(2)
+    ring = ring[["id_peserta", "nama", "sesi", "total_soal", "benar", "belum_benar", "belum_dikerjakan",
+                 "persen_benar", "total_percobaan", "rata2_percobaan_sampai_benar", "terakhir"]]
+    ring = ring.sort_values(["sesi", "persen_benar", "id_peserta"], ascending=[True, False, True])
+
+    per_soal = detail.groupby(["sesi", "soal"]).agg(
+        peserta_mencoba=("id_peserta", "nunique"),
+        peserta_benar=("status", lambda s: int((s == "BENAR").sum())),
+        total_percobaan=("jumlah_percobaan", "sum"),
+        rata2_percobaan_sampai_benar=("benar_di_percobaan", "mean"),
+    ).reset_index()
+    per_soal["persen_benar"] = (100 * per_soal["peserta_benar"] / per_soal["peserta_mencoba"]).round(1)
+    per_soal["rata2_percobaan_sampai_benar"] = per_soal["rata2_percobaan_sampai_benar"].astype(float).round(2)
+    per_soal["_u"] = [_urut(s, q) for s, q in zip(per_soal["sesi"], per_soal["soal"])]
+    per_soal = per_soal.sort_values(["sesi", "_u"]).drop(columns="_u")
+
+    hasil = {"ringkasan": ring, "detail": detail, "per_soal": per_soal}
+
+    # matriks per sesi: baris = peserta, kolom = soal, isi = ✔/✘ (jumlah percobaan)
+    for s in sorted(detail["sesi"].unique()):
+        d = detail[detail["sesi"] == s].copy()
+        d["sel"] = [("✔" if st == "BENAR" else "✘") + f" ({n})"
+                    for st, n in zip(d["status"], d["jumlah_percobaan"])]
+        m = d.pivot_table(index=["id_peserta", "nama"], columns="soal", values="sel", aggfunc="first")
+        urutan_kolom = list(_soal.semua_soal(s)) if s in _soal.daftar_sesi() else sorted(m.columns)
+        m = m.reindex(columns=[c for c in urutan_kolom] + [c for c in m.columns if c not in urutan_kolom])
+        m = m.fillna("").reset_index()
+        m.columns.name = None
+        hasil[f"sesi-{int(s):02d}"] = m
+
+    hasil["log_percobaan"] = df
+    return hasil
+
+
+def ekspor(hasil, keluar="rekap_dqcheck.xlsx"):
+    """Simpan hasil ``rekap`` ke Excel (satu sheet per tabel) atau folder CSV."""
+    if keluar.lower().endswith(".xlsx"):
+        pd = _pd()
+        try:
+            with pd.ExcelWriter(keluar) as w:
+                for nama, tabel in hasil.items():
+                    tabel.to_excel(w, sheet_name=nama[:31], index=False)
+            return keluar
+        except ImportError:
+            print("openpyxl tidak ada, beralih ke CSV. (pip install openpyxl untuk Excel)")
+            keluar = keluar[:-5]
+    os.makedirs(keluar, exist_ok=True)
+    for nama, tabel in hasil.items():
+        tabel.to_csv(os.path.join(keluar, f"{nama}.csv"), index=False)
+    return keluar
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog="python -m dqcheck.admin",
+                                description="Rekap & export jawaban peserta dqcheck.")
+    p.add_argument("--sumber", help="folder data hasil sinkron GitHub, atau satu file CSV")
+    p.add_argument("--endpoint", help="URL Worker (ambil langsung dari server)")
+    p.add_argument("--admin-key", default=os.environ.get("DQCHECK_ADMIN_KEY"),
+                   help="ADMIN_KEY Worker (atau env DQCHECK_ADMIN_KEY)")
+    p.add_argument("--sesi", type=int, help="hanya sesi tertentu")
+    p.add_argument("--keluar", default="rekap_dqcheck.xlsx", help="file .xlsx atau nama folder CSV")
+    a = p.parse_args(argv)
+
+    df = muat(a.sumber, a.endpoint, a.admin_key, a.sesi)
+    hasil = rekap(df)
+    lokasi = ekspor(hasil, a.keluar)
+    r = hasil["ringkasan"]
+    print(f"{len(df)} percobaan dari {df['id_peserta'].nunique()} peserta, sesi {sorted(int(s) for s in df['sesi'].unique())}")
+    print(r.to_string(index=False, max_rows=30))
+    print(f"\nTersimpan: {lokasi}")
+
+
+if __name__ == "__main__":
+    main()