# Praktik Mandiri 2 — Safe Multi-Source Pipeline Challenge
### SwiftBite
**Gunakan Starter yang sama untuk semua peserta; angka contoh bukan target universal.** PM2 menggunakan **lima clean output dari PM1 milikmu** + satu Delivery raw sesuai Variant ID. Tidak melakukan cleaning ulang PM1.
**Tujuan bisnis:** “Apakah enam sumber dapat menjadi dataset analitik aman, 1 row per order, valid, dan reproducible?”
### Cara mengikuti Notebook
1. Baca **CASE → TUJUAN → PAHAMI → CONTOH**.
2. Klik ▶ atau `Shift + Enter` pada **code cell**. Pastikan kernel (mesin eksekusi Python) aktif.
3. Baca output, tentukan alasan PASS/FAIL/PENDING, lalu isi **Working Paper** pada sheet/sel yang disebutkan.
4. Lanjut hanya jika checkpoint tahap terpenuhi. `PENDING` berarti belum lengkap, **bukan PASS**.
5. `SB-P01` digunakan **hanya untuk QA mentor**; semua jumlah baris/angka hasil didapat otomatis dari varianmu.
### Peta singkat 15 tahap
**A. Persiapan (0–3)** → **B. Safe Data & Blueprint (4–6)** → **C. Pipeline (7–10)** → **D. QA & Rerun (11–13)** → **E. Export & LMS (14)**.
**Bahasa teknis:** *source* = sumber data; *grain* = arti satu baris; *key* = pengenal record; *join* = penggabungan berdasarkan key; *validation* = pengujian terhadap kriteria; *reproducibility* = dapat dijalankan ulang dengan input/aturan yang sama. Istilah lainnya dijelaskan saat pertama dipakai.
**WORKING PAPER:** `00_Panduan` (baca), `01_Input_dan_Safe_Data`, `02_Integrasi_dan_Rerun`, dan `03_Validasi_dan_Keputusan` (diisi bertahap). Lihat peta cell di sheet 00.
### Wajib vs opsional — aturan kerja mandiri
- **EDIT 2 NILAI SAJA:** `PARTICIPANT_NAME` dan `VARIANT_ID` di Tahap 1. Jangan menulis fungsi Python/SQL dari nol.
- **JALANKAN:** Code cell bertanda `▶ WAJIB JALANKAN` dengan ▶ atau `Shift + Enter`, mulai dari atas ke bawah.
- **LATIHAN OPSIONAL:** Code cell bertanda `★ OPSIONAL` hanya untuk mencoba konsep, **bukan persyaratan kelulusan**. Jika memilih mencoba, jalankan contoh dalam urutan yang diberikan.
- **JANGAN UBAH:** fungsi Safe Data, Items, Payments, Delivery, Join, Validation, Rerun, serta Export.
- **ISI SENDIRI:** angka hasil, evidence, alasan, dan keputusan pada tiga sheet kerja Working Paper. Lihat file CONTOH PENGISIAN `DEMO-00` hanya sebagai contoh format, **jangan salin angkanya**.
- Jika tampil **FAIL**, baca `actual` / `missing_columns` / pesan error, perbaiki penyebab, lalu jalankan ulang dari tahap yang terkait. **Jangan mengganti tulisan FAIL menjadi PASS secara manual.**
**Setup perlindungan data berjalan otomatis.** Peserta cukup menekan ▶ Run pada Tahap 1. Notebook menyiapkan kunci pengaman lokal khusus untuk dataset latihan dan memakainya lagi pada rerun berikutnya. **Tidak perlu mengetik salt, mengubah environment variable, atau membuat kode Python.** Jika sudah memiliki pengaturan lama `SWIFTBITE_PM2_SALT`, Notebook memakainya seperti sebelumnya.
**PENTING:** Kunci pengaman tersimpan dalam file tersembunyi di `utils/` dalam workspace dan **tidak boleh diunggah, dikirim, disalin ke ZIP LMS, atau dibagikan**. Simpan workspace pada perangkat pribadi, bukan folder publik/bersama. Jangan menghapus atau memindahkan kunci ketika masih memerlukan hasil `customer_key` yang sama. Fitur ini dirancang untuk **dataset simulasi bootcamp**, bukan sebagai prosedur pengamanan produksi untuk data pelanggan nyata.
---
## TAHAP 0 — Kenali Kasus & Handoff PM1
**CASE — Situasi SwiftBite:** Lima sumber data sudah dibersihkan di PM1, tetapi informasi pelanggan masih perlu dilindungi dan Items/Payments memiliki lebih dari satu baris untuk setiap order.
**TUJUAN:** Memahami mengapa PM2 menambah Delivery dan menghasilkan satu baris per order.
**PAHAMI ISTILAH:** raw = data asli; clean = data setelah PM1; safe = data yang dilindungi; analytical dataset = tabel untuk analisis.
**WORKING PAPER:** Baca `00_Panduan` (mulai dari sini dan peta 15 tahap); belum ada tabel yang diisi.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**LIHAT CONTOH:** Orders O001 satu baris; Order Items O001 tiga baris. Jika langsung join, O001 menjadi tiga baris. Karena itu lakukan aggregation **sebelum** join.
**PERTANYAAN JUDGMENT:** Mengapa tidak cukup hanya menjalankan kode sampai selesai? Karena dataset bisa punya fan-out, kolom PII, atau perhitungan payment yang salah meskipun kode berjalan.
**CHECKPOINT:** Kamu bisa menjelaskan perbedaan PM1 (cleaning) dan PM2 (safe integration), lalu lanjut Tahap 1.
---
## TAHAP 1 — Setup Kernel, Identitas & Folder
**CASE — Situasi SwiftBite:** Pipeline gagal jika notebook mencari file di folder yang salah atau Python belum aktif.
**TUJUAN:** Menyiapkan identitas dan mengenali lokasi workspace.
**PAHAMI ISTILAH:** cell = kotak kode/penjelasan; kernel = proses Python yang menjalankan code cell; path = alamat file/folder; dependency = komponen yang dibutuhkan program.
**MULAI MANDIRI:** (1) Buka folder `Bootcamp_Data_Analyst` di VS Code/Jupyter; (2) buka Notebook dari `notebooks/`; (3) ganti **hanya** dua nilai identitas; (4) jalankan cell setup; (5) lihat pesan **PENGAMAN DATA: SIAP**. Tidak ada input salt manual.
**WORKING PAPER BARU:** Isi `01_Input_dan_Safe_Data!B4` = nama, `E4` = Variant ID, `G4` = tanggal. Identitas di sheet 02 dan 03 tampil otomatis.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**WAJIB EDIT 2 NILAI SAJA** di code cell berikut:
1. `PARTICIPANT_NAME` = nama lengkapmu (di antara tanda petik).
2. `VARIANT_ID` = ID dari Handoff Tracker, contoh `SB-P07` (di antara tanda petik).
**WAJIB LETAKKAN FILE:** lima CSV clean PM1 di `data/processed/pm1_swiftbite/`, Delivery di `data/raw/pm2_swiftbite/swiftbite_delivery.json`. Folder `data/` dan `notebooks/` sejajar di dalam `Bootcamp_Data_Analyst/`. Notebook disimpan di `notebooks/`.
**JALANKAN:** Code cell identitas → code cell setup (▶ atau `Shift + Enter`). Pastikan `WORKSPACE CHECK: PASS` dan `IDENTITY CHECK: PASS` muncul. `Workspace` harus menunjuk folder induk yang berisi `data/` dan `notebooks/`.
**Jika WORKSPACE_ROOT TIDAK DITEMUKAN:** buka folder utama di VS Code/Jupyter dan ulangi. Hanya bila kernel tetap berjalan dari folder luar, ubah `WORKSPACE_ROOT_OVERRIDE = None` pada cell setup menjadi alamat folder utama, misalnya Windows `r"D:\Bootcamp_Data_Analyst"`. Ini **pengecualian**, bukan perubahan yang wajib dilakukan semua peserta.
**PENGAMAN DATA OTOMATIS (TIDAK PERLU DIISI):**
1. Jalankan code cell Setup **satu kali** seperti biasa.
2. Notebook membuat/membaca kunci lokal tersembunyi, tanpa meminta kamu mengetik rahasia.
3. Pastikan output **`PENGAMAN DATA: SIAP`**, `WORKSPACE CHECK: PASS`, dan `IDENTITY CHECK: PASS`.
4. **Jangan** menghapus file tersembunyi di `utils/` dan **jangan** mengunggah folder `utils/` ke LMS. Jika kamu pernah menyiapkan `SWIFTBITE_PM2_SALT`, Notebook tetap memakainya agar hasil lamamu tidak berubah.
**Jika muncul error:** (a) `WORKSPACE_ROOT TIDAK DITEMUKAN` → buka folder `Bootcamp_Data_Analyst` yang berisi `data/` dan `notebooks/`; (b) `ModuleNotFoundError` → pilih Python kernel yang biasa dipakai saat bootcamp, lihat petunjuk output; (c) `PermissionError` → simpan workspace di folder milik sendiri yang dapat ditulis, bukan folder read-only/bersama; (d) `IDENTITY CHECK: PENDING` → perbaiki dua nilai identitas. **Jangan mengubah fungsi Python utama untuk mengatasi error.**
# <= WAJIB ISI IDENTITAS — ubah hanya dua nilai di bawah. PARTICIPANT_NAME = "Mita" # GANTI dengan nama lengkapmu VARIANT_ID = "SB-P18" # GANTI sesuai Handoff Tracker, contoh SB-P07
# ▶ WAJIB JALANKAN SETUP — override path opsional jika diperlukan.
from pathlib import Path
import os, json, hashlib, io, sys, secrets
try:
import numpy as np
import pandas as pd
from IPython.display import display
except ModuleNotFoundError as err:
raise RuntimeError(
'LIBRARY PYTHON BELUM TERSEDIA.\n'
'LANGKAH UNTUK PEMULA:\n'
'1. Pada VS Code/Jupyter pilih kernel Python yang sama dengan praktik bootcamp.\n'
'2. Jika belum terpasang, salin perintah ini ke Terminal VS Code (BUKAN ke Working Paper):\n'
' python -m pip install numpy pandas ipython\n'
'3. Setelah instalasi, restart kernel lalu jalankan Notebook dari Tahap 1.\n'
f'Detail library yang belum ada: {err.name}'
) from err
try:
import duckdb
DUCKDB_AVAILABLE = True
except ImportError:
DUCKDB_AVAILABLE = False
# OPSIONAL — hanya isi jika Jupyter/VS Code membuka kernel di luar folder workspace.
# Contoh Windows: WORKSPACE_ROOT_OVERRIDE = r"D:\Bootcamp_Data_Analyst"
# Contoh macOS/Linux: WORKSPACE_ROOT_OVERRIDE = "/home/user/Bootcamp_Data_Analyst"
# Biarkan None jika notebook dijalankan dari root workspace atau folder notebooks/.
WORKSPACE_ROOT_OVERRIDE = None
def find_workspace_root(start=None, override=None):
"""Cari root dengan dua folder sejajar: data/ dan notebooks/.
Gagal secara eksplisit jika tidak ditemukan; jangan fallback ke cwd yang salah.
"""
here = Path.cwd().resolve() if start is None else Path(start).expanduser().resolve()
def is_workspace_root(folder):
return folder.is_dir() and (folder / 'data').is_dir() and (folder / 'notebooks').is_dir()
if override is not None and str(override).strip():
chosen = Path(override).expanduser().resolve()
if not is_workspace_root(chosen):
raise FileNotFoundError(
'WORKSPACE_ROOT_OVERRIDE TIDAK VALID.\n'
f'Lokasi yang dimasukkan: {chosen}\n'
'Pastikan alamat tersebut adalah folder utama Bootcamp_Data_Analyst '
'yang berisi folder data/ dan notebooks/ secara sejajar.\n'
'Perbaiki WORKSPACE_ROOT_OVERRIDE pada Tahap 1 lalu jalankan ulang cell setup.'
)
return chosen
for candidate in (here, *here.parents):
if is_workspace_root(candidate):
return candidate
raise FileNotFoundError(
'WORKSPACE_ROOT TIDAK DITEMUKAN — Notebook dihentikan agar tidak membaca file dari lokasi yang salah.\n'
f'Lokasi kerja kernel saat ini: {here}\n'
'CARA MEMPERBAIKI:\n'
'1. Buka folder utama Bootcamp_Data_Analyst di VS Code/Jupyter.\n'
'2. Pastikan di dalamnya ada dua folder sejajar: data/ dan notebooks/.\n'
'3. Jalankan Notebook dari folder utama atau dari notebooks/ di dalamnya.\n'
'4. Jika kernel tetap berjalan dari folder lain, isi WORKSPACE_ROOT_OVERRIDE '
'dengan alamat folder utama yang benar pada cell setup Tahap 1.\n'
'5. Jalankan kembali cell setup, kemudian Tahap 2 untuk memeriksa enam file.'
)
WORKSPACE_ROOT = find_workspace_root(override=WORKSPACE_ROOT_OVERRIDE)
PM1_PROCESSED_DIR = WORKSPACE_ROOT / 'data' / 'processed' / 'pm1_swiftbite'
PM2_RAW_DIR = WORKSPACE_ROOT / 'data' / 'raw' / 'pm2_swiftbite'
PM2_OUTPUT_DIR = WORKSPACE_ROOT / 'outputs' / 'pm2_swiftbite'
PM2_PROCESSED_DIR = WORKSPACE_ROOT / 'data' / 'processed' / 'pm2_swiftbite'
# PENGAMAN DATA INTERNAL untuk DATA LATIHAN PM2. Tidak ada input peserta.
# Utamakan environment variable LAMA bila sudah disiapkan peserta sebelumnya
# agar customer_key dari pekerjaan terdahulu tidak berubah.
# Jika belum tersedia, simpan kunci acak di workspace pribadi dan gunakan lagi.
LOCAL_SECRET_PATH = WORKSPACE_ROOT / 'utils' / '.swiftbite_pm2_local_secret'
def load_or_create_training_secret():
existing_env = os.getenv('SWIFTBITE_PM2_SALT', '')
if existing_env:
if len(existing_env) < 16 or not existing_env.strip():
raise ValueError('PENGAMAN DATA LAMA tidak valid: hubungi admin jika tidak memahami pengaturan yang pernah dibuat.')
return existing_env, 'KONFIGURASI LAMA (tetap digunakan)'
secret_folder = LOCAL_SECRET_PATH.parent
try:
secret_folder.mkdir(parents=True, exist_ok=True)
if LOCAL_SECRET_PATH.is_symlink():
raise RuntimeError('File pengaman lokal berupa symlink; pindahkan workspace ke lokasi pribadi yang aman.')
if LOCAL_SECRET_PATH.exists():
value = LOCAL_SECRET_PATH.read_text(encoding='utf-8').strip()
if len(value) < 16:
raise RuntimeError('File pengaman lokal rusak/tidak lengkap. Jangan dihapus sebelum memeriksa dengan admin.')
return value, 'KUNCI LOKAL TERSEDIA (dipakai ulang)'
# Eksklusif agar kunci tidak diam-diam terganti ketika dua kernel aktif.
value = secrets.token_urlsafe(32)
try:
fd = os.open(str(LOCAL_SECRET_PATH), os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
except FileExistsError:
value = LOCAL_SECRET_PATH.read_text(encoding='utf-8').strip()
if len(value) < 16:
raise RuntimeError('Kunci lokal tidak valid. Periksa workspace dengan admin.')
return value, 'KUNCI LOKAL TERSEDIA (dipakai ulang)'
with os.fdopen(fd, 'w', encoding='utf-8') as handle:
handle.write(value)
try:
os.chmod(LOCAL_SECRET_PATH, 0o600)
except OSError:
pass # Mode permission dapat berbeda antar sistem operasi.
return value, 'KUNCI LOKAL BARU (disimpan otomatis)'
except OSError as err:
raise RuntimeError(
'SETUP PENGAMAN DATA GAGAL: workspace tidak dapat menulis file internal.\n'
'1. Simpan folder Bootcamp_Data_Analyst pada folder pribadi yang dapat ditulis.\n'
'2. Jangan menggunakan folder ZIP langsung, read-only, atau folder publik/bersama.\n'
'3. Buka Notebook dari workspace tersebut, lalu jalankan ulang Tahap 1.\n'
f'Informasi sistem: {type(err).__name__}'
) from err
CONTROLLED_SALT, SALT_SOURCE = load_or_create_training_secret()
print('PENGAMAN DATA: SIAP — konfigurasi otomatis, tidak perlu input peserta.')
print('Mode pengaman:', SALT_SOURCE)
print('CATATAN: Jangan unggah folder utils/ atau file pengaman lokal ke LMS.')
VALID_VARIANTS = {f'SB-P{i:02d}' for i in range(1, 29)}
IDENTITY_READY = PARTICIPANT_NAME.strip() != 'Isi Nama Kamu' and VARIANT_ID in VALID_VARIANTS
print('Participant name configured:', PARTICIPANT_NAME.strip() != 'Isi Nama Kamu')
print('Variant ID:', VARIANT_ID)
print('Workspace:', WORKSPACE_ROOT)
print('WORKSPACE CHECK: PASS — folder data/ dan notebooks/ ditemukan')
print('Workspace location mode:', 'MANUAL OVERRIDE' if WORKSPACE_ROOT_OVERRIDE else 'AUTO DETECTED')
print('pandas:', pd.__version__, '| DuckDB available:', DUCKDB_AVAILABLE)
print('Controlled salt:', 'AVAILABLE (nilai tidak ditampilkan)' if CONTROLLED_SALT else 'PENDING: belum tersedia')
print('IDENTITY CHECK:', 'PASS' if IDENTITY_READY else 'PENDING — ganti nama dan Variant ID pada cell sebelumnya')
PENGAMAN DATA: SIAP — konfigurasi otomatis, tidak perlu input peserta. Mode pengaman: KUNCI LOKAL TERSEDIA (dipakai ulang) CATATAN: Jangan unggah folder utils/ atau file pengaman lokal ke LMS. Participant name configured: True Variant ID: SB-P18 Workspace: C:\Users\DataAnalysProjects\Bootcamp_Data_Analyst_Workspace_Starter\Bootcamp_Data_Analyst WORKSPACE CHECK: PASS — folder data/ dan notebooks/ ditemukan Workspace location mode: AUTO DETECTED pandas: 3.0.6 | DuckDB available: True Controlled salt: AVAILABLE (nilai tidak ditampilkan) IDENTITY CHECK: PASS
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
**Output penting:** `Workspace` adalah folder induk; `IDENTITY CHECK: PASS` baru berarti dua identitas diisi benar, **bukan** bukti isi dataset sesuai varian. Jika kernel gagal, buka menu Select Kernel lalu pilih lingkungan Python kelas.
**ISI WORKING PAPER BARU:** Isi `01_Input_dan_Safe_Data!B4` = nama, `E4` = Variant ID, `G4` = tanggal. Identitas di sheet 02 dan 03 tampil otomatis.
**PENJELASAN OUTPUT:** Cek `IDENTITY CHECK`. Jika belum PASS, ulangi cell identitas. Periksa `WORKSPACE CHECK: PASS` dan pastikan `Workspace` mengarah ke folder utama yang memiliki `data/` dan `notebooks/` sejajar. Jika muncul `WORKSPACE_ROOT TIDAK DITEMUKAN` atau `WORKSPACE_ROOT_OVERRIDE TIDAK VALID`, baca lima langkah perbaikan pada error lalu ulangi cell setup. Periksa juga versi pandas dan ketersediaan salt tanpa menampilkan secret.
**CHECKPOINT:** Jika data atau evidence belum sesuai, jangan menandai PASS di Working Paper. Perbaiki tahap yang disebutkan output dan jalankan ulang pemeriksaan.
**LANJUT:** Tahap 2.
**JIKA BELAJAR MANDIRI:** `Controlled salt: AVAILABLE` = secret sudah ada dan langkah Safe Data dapat berjalan. Jika masih `PENDING`, jalankan kembali code cell setup dan isi prompt tertutup. **Jangan tulis secret pada cell identitas atau Working Paper.** Jika error `ModuleNotFoundError` untuk pandas/numpy, pastikan kernel menggunakan environment yang disiapkan saat Sesi 1; bila memang belum terpasang, buka Terminal VS Code dan jalankan `python -m pip install pandas numpy ipython`, kemudian **restart kernel** dan jalankan ulang dari Tahap 1. Jika terminal memakai interpreter berbeda, pilih kernel Python yang sama dengan yang terpasang paketnya.
**CONTOH PENGISIAN:** Bila kode menampilkan `IDENTITY CHECK: PASS`, tulis nama/varianmu pada sheet 01 B4/E4. Tulisan PASS tersebut bukan angka yang harus dicatat pada tabel enam input.
### Jika ada masalah di Tahap 1
- **`WORKSPACE_ROOT TIDAK DITEMUKAN`**: buka *folder utama* `Bootcamp_Data_Analyst`, bukan file Notebook secara terpisah. Pastikan folder `data/` dan `notebooks/` sejajar.
- **`ModuleNotFoundError`**: pilih kernel Python yang sudah digunakan selama bootcamp. Jika library belum ada, ikuti perintah instalasi yang tampil pada pesan error.
- **`PermissionError` / gagal menyimpan pengaman**: pindahkan workspace ke folder milik sendiri yang bisa ditulis, buka Notebook dari sana, lalu Run kembali.
- **`IDENTITY CHECK: PENDING`**: isi nama dan Variant ID pada cell sebelumnya.
- **Jika kamu sudah menjalankan PM2 dengan konfigurasi lama**: tidak perlu mengubah setup. Notebook akan tetap membaca pengaturan lama.
**Working Paper:** pada bagian parameter `SWIFTBITE_PM2_SALT` di sheet 02, tulis **nama parameter tersebut atau “Dikelola otomatis oleh Notebook” sesuai kolom yang tersedia**. Jangan menulis nilai rahasia apa pun.
---
## TAHAP 2 — Verify 6 Inputs & Source Structure
**CASE — Situasi SwiftBite:** Kamu telah menerima enam file. File yang ditemukan belum tentu mempunyai kolom yang sesuai; data yang tertukar antarpeserta juga belum tentu terlihat dari kecocokan `order_id`.
**TUJUAN:** Memeriksa keberadaan, keterbacaan, kolom wajib, dan grain/key enam input tanpa file kontrol tambahan.
**PAHAMI:** `file_ada=YA` berarti file ditemukan. `struktur=PASS` berarti kolom wajib tersedia. **Ini tidak membuktikan varian sudah cocok secara otomatis.** Admin mencocokkan PM1 dan Delivery peserta melalui Handoff Tracker.
**WORKING PAPER:** `01_Input_dan_Safe_Data!B6` = `input_check_result["status"]` dan `A7:H8` = penjelasan hasil; baris 13–18: C grain, D key, E rows, F file ada, G cek struktur, H catatan. Gunakan `wp_input_copy_df`.
> Jalankan code cell dengan **Shift + Enter** dan kerjakan dari atas ke bawah.
**LIHAT CONTOH:** `source_status_df.exists=True` berarti file tersedia. Setelah load, `source_structure_df.status=PASS` berarti semua kolom wajib ada. Status input PASS hanya berarti pemeriksaan teknis awal berhasil.
**COBA:** Jalankan pemeriksaan file di bawah. Jika ada `FILE NOT FOUND`, periksa folder. Admin, bukan peserta, memastikan apakah source PM1 dan Delivery benar-benar milik Variant ID yang sama.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
EXPECTED_PM1_FILES = {'Customers Clean':'customers_clean.csv','Orders Clean':'orders_clean.csv',
'Order Items Clean':'order_items_clean.csv','Payments Clean':'payments_clean.csv',
'Restaurants Clean':'restaurants_clean.csv'}
SOURCE_PATHS = {name: PM1_PROCESSED_DIR / fname for name,fname in EXPECTED_PM1_FILES.items()}
SOURCE_PATHS['Delivery'] = PM2_RAW_DIR / 'swiftbite_delivery.json'
source_status_df = pd.DataFrame([{'dataset':name,'filename':p.name,'file_path':str(p),'exists':p.is_file()}
for name,p in SOURCE_PATHS.items()])
INPUT_FILES_READY = bool(source_status_df['exists'].all())
print('FILE AVAILABILITY:', 'PASS' if INPUT_FILES_READY else 'PENDING — ada file belum ditemukan')
print('VARIAN YANG DIISI:', VARIANT_ID, '| pencocokan varian dilakukan admin melalui Handoff Tracker')
display(source_status_df)
FILE AVAILABILITY: PASS VARIAN YANG DIISI: SB-P18 | pencocokan varian dilakukan admin melalui Handoff Tracker
| dataset | filename | file_path | exists | |
|---|---|---|---|---|
| 0 | Customers Clean | customers_clean.csv | C:\Users\DataAnalysProjects\Bootcamp_Data_Anal... | True |
| 1 | Orders Clean | orders_clean.csv | C:\Users\DataAnalysProjects\Bootcamp_Data_Anal... | True |
| 2 | Order Items Clean | order_items_clean.csv | C:\Users\DataAnalysProjects\Bootcamp_Data_Anal... | True |
| 3 | Payments Clean | payments_clean.csv | C:\Users\DataAnalysProjects\Bootcamp_Data_Anal... | True |
| 4 | Restaurants Clean | restaurants_clean.csv | C:\Users\DataAnalysProjects\Bootcamp_Data_Anal... | True |
| 5 | Delivery | swiftbite_delivery.json | C:\Users\DataAnalysProjects\Bootcamp_Data_Anal... | True |
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
def load_pm2_inputs(paths):
missing = [str(p) for p in paths.values() if not p.is_file()]
if missing: raise FileNotFoundError('FILE BELUM DITEMUKAN:\n'+'\n'.join(missing))
data = {n:pd.read_csv(p) for n,p in paths.items() if n!='Delivery'}
with open(paths['Delivery'],encoding='utf-8') as f:
payload=json.load(f)
if isinstance(payload,dict):
payload=payload.get('records', payload.get('data',payload))
if not isinstance(payload,list): raise ValueError('Delivery JSON bukan daftar record: cek file sumber')
data['Delivery']=pd.DataFrame(payload)
return data
pm2_sources = load_pm2_inputs(SOURCE_PATHS) if INPUT_FILES_READY else {}
SOURCE_KEYS={'Customers Clean':'customer_id','Orders Clean':'order_id','Order Items Clean':'order_item_id',
'Payments Clean':'payment_id','Restaurants Clean':'restaurant_id','Delivery':'delivery_id'}
SOURCE_GRAINS={'Customers Clean':'1 row/customer','Orders Clean':'1 row/order',
'Order Items Clean':'1 row/order item','Payments Clean':'1 row/payment record',
'Restaurants Clean':'1 row/restaurant','Delivery':'1 row/delivery record'}
input_inventory_df = pd.DataFrame([{'dataset':n,'rows':len(df),'columns':len(df.columns),
'candidate_key':SOURCE_KEYS[n],'expected_grain':SOURCE_GRAINS[n]} for n,df in pm2_sources.items()])
# Pemeriksaan keberadaan kolom kunci pada setiap sumber (bukan bukti identitas varian).
REQUIRED_SOURCE_FIELDS = {
'Customers Clean': {'customer_id','customer_zone','customer_segment'},
'Orders Clean': {'order_id','customer_id','restaurant_id','order_timestamp','order_status'},
'Order Items Clean': {'order_item_id','order_id','quantity','line_amount'},
'Payments Clean': {'payment_id','order_id','payment_status','payment_amount','payment_timestamp','attempt_number','payment_method'},
'Restaurants Clean': {'restaurant_id','restaurant_name'},
'Delivery': {'delivery_id','order_id','assigned_at','picked_up_at','delivered_at','delivery_status','promised_delivery_minutes'}
}
source_structure_df = pd.DataFrame([
{'dataset': name, 'status': 'PASS' if not REQUIRED_SOURCE_FIELDS[name].difference(df.columns) else 'FAIL',
'missing_columns': ', '.join(sorted(REQUIRED_SOURCE_FIELDS[name].difference(df.columns))) or '-'}
for name,df in pm2_sources.items()
])
SOURCE_SCHEMA_READY = bool(len(source_structure_df)==6 and source_structure_df['status'].eq('PASS').all())
if not IDENTITY_READY:
input_check_result={'status':'PENDING','reason':'Isi nama dan Variant ID sesuai Handoff Tracker terlebih dahulu.'}
elif not INPUT_FILES_READY:
input_check_result={'status':'PENDING','reason':'Ada file input belum ditemukan di folder yang ditentukan.'}
elif not SOURCE_SCHEMA_READY:
failures=source_structure_df.loc[source_structure_df.status=='FAIL',['dataset','missing_columns']].to_dict('records')
input_check_result={'status':'FAIL','reason':f'Kolom wajib sumber tidak sesuai: {failures}'}
else:
input_check_result={'status':'PASS','reason':'Enam file berhasil dibaca; kolom wajib tersedia. Kesesuaian paket dengan varian peserta tetap dikontrol admin melalui Handoff Tracker.'}
print('SOURCE CHECK:',input_check_result['status'],'—',input_check_result['reason'])
if pm2_sources:
display(input_inventory_df)
display(source_structure_df)
print('INPUT READ:', 'PASS (enam source)' if len(pm2_sources)==6 else 'PENDING')
else: print('INPUT READ: PENDING — perbaiki lokasi file dahulu')
if input_check_result['status']=='FAIL':
raise ValueError('SOURCE CHECK FAIL — Kolom wajib tidak sesuai. Periksa file dan Variant ID pada paket yang diberikan admin.')
SOURCE CHECK: PASS — Enam file berhasil dibaca; kolom wajib tersedia. Kesesuaian paket dengan varian peserta tetap dikontrol admin melalui Handoff Tracker.
| dataset | rows | columns | candidate_key | expected_grain | |
|---|---|---|---|---|---|
| 0 | Customers Clean | 156 | 7 | customer_id | 1 row/customer |
| 1 | Orders Clean | 324 | 10 | order_id | 1 row/order |
| 2 | Order Items Clean | 822 | 9 | order_item_id | 1 row/order item |
| 3 | Payments Clean | 370 | 7 | payment_id | 1 row/payment record |
| 4 | Restaurants Clean | 22 | 7 | restaurant_id | 1 row/restaurant |
| 5 | Delivery | 311 | 9 | delivery_id | 1 row/delivery record |
| dataset | status | missing_columns | |
|---|---|---|---|
| 0 | Customers Clean | PASS | - |
| 1 | Orders Clean | PASS | - |
| 2 | Order Items Clean | PASS | - |
| 3 | Payments Clean | PASS | - |
| 4 | Restaurants Clean | PASS | - |
| 5 | Delivery | PASS | - |
INPUT READ: PASS (enam source)
**BANTUAN SALIN KE WORKING PAPER** — Jalankan code cell berikut agar nilai yang perlu dicatat dan nomor baris Excel tampil dalam satu tabel. Tabel ini tidak mengisi file Excel otomatis; peserta tetap membaca dan mencatat hasilnya.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
# BANTUAN SALIN KE WORKING PAPER — sheet 01, baris 13–18 (tidak menampilkan PII)
if len(input_inventory_df) == 6:
wp_input_copy_df = input_inventory_df[['dataset','expected_grain','candidate_key','rows']].copy()
wp_input_copy_df['file_ada'] = wp_input_copy_df['dataset'].map(source_status_df.set_index('dataset')['exists']).map({True:'YA',False:'TIDAK'})
wp_input_copy_df['cek_struktur'] = wp_input_copy_df['dataset'].map(source_structure_df.set_index('dataset')['status']).fillna('PENDING')
wp_input_copy_df.insert(0,'baris_excel',range(13,19))
display(wp_input_copy_df)
print('SALIN: C=expected_grain, D=candidate_key, E=rows, F=file_ada, G=cek_struktur pada sheet 01.')
else:
print('PANDUAN WORKING PAPER INPUT: PENDING — enam source belum terbaca.')
| baris_excel | dataset | expected_grain | candidate_key | rows | file_ada | cek_struktur | |
|---|---|---|---|---|---|---|---|
| 0 | 13 | Customers Clean | 1 row/customer | customer_id | 156 | YA | PASS |
| 1 | 14 | Orders Clean | 1 row/order | order_id | 324 | YA | PASS |
| 2 | 15 | Order Items Clean | 1 row/order item | order_item_id | 822 | YA | PASS |
| 3 | 16 | Payments Clean | 1 row/payment record | payment_id | 370 | YA | PASS |
| 4 | 17 | Restaurants Clean | 1 row/restaurant | restaurant_id | 22 | YA | PASS |
| 5 | 18 | Delivery | 1 row/delivery record | delivery_id | 311 | YA | PASS |
SALIN: C=expected_grain, D=candidate_key, E=rows, F=file_ada, G=cek_struktur pada sheet 01.
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
Pada `source_status_df` perhatikan `exists`; pada `source_structure_df` perhatikan `status` dan `missing_columns`. **Jangan menyalin angka contoh SB-P01.** `SOURCE CHECK=PASS` berarti file dapat dibaca dan kolom wajib ada, tetapi **tidak membuktikan identitas varian secara otomatis**.
**ISI WORKING PAPER BARU:** Isi `01_Input_dan_Safe_Data!B6` dari `input_check_result["status"]`, `A7:H8` dengan alasannya, dan baris 13–18 (C=grain, D=key, E=rows, F=file ada, G=cek struktur, H=catatan).
**PENJELASAN OUTPUT:** Admin memastikan file PM1 dan Delivery peserta sesuai Handoff Tracker; peserta cukup mencatat Variant ID miliknya pada sheet 01.
**CHECKPOINT:** Perbaiki source check FAIL/PENDING sebelum melanjutkan; jangan memberi status PASS jika input tidak memenuhi kolom wajib.
**LANJUT:** Tahap 3.
**CONTOH (hanya format, bukan angka varianmu):** apabila `input_inventory_df` menunjukkan `Orders Clean` mempunyai 30 baris, isi kolom E pada baris Orders dengan **30**. Kolom F: **YA** jika `exists=True`. Kolom G: **PASS** jika `source_structure_df.status=PASS`. Jika `Source Check` belum PASS, salin alasannya ke area catatan di sheet 01; **jangan memperbaiki dengan mengubah data raw**.
---
## TAHAP 3 — Grain, Candidate Key & Relationship
**CASE — Situasi SwiftBite:** Items dan Payments boleh mengulang `order_id`, tetapi `order_item_id` dan `payment_id` seharusnya unik.
**TUJUAN:** Menguji key sesuai unit observasi sebelum join.
**PAHAMI ISTILAH:** grain = arti satu row; candidate key = calon pengenal unik; foreign key = rujukan key antar-source; cardinality = jumlah pasangan antar-record.
**WORKING PAPER BARU:** Lengkapi `01_Input_dan_Safe_Data!C13:D18` dari `input_inventory_df` dan `grain_key_review`. `order_id` yang berulang pada Items/Payments sesuai grain dan bukan otomatis error.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**LIHAT CONTOH:** Dua pembayaran pada satu order adalah dua attempts, bukan duplikasi. Jangan menghapus record hanya karena `order_id` berulang di Payments.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
def key_check(df,key_cols,dataset_name):
cols=[key_cols] if isinstance(key_cols,str) else list(key_cols)
missing_cols=[c for c in cols if c not in df.columns]
if missing_cols: return {'dataset':dataset_name,'rows':len(df),'unique_key_count':0,'missing_key_rows':len(df),
'duplicate_key_rows':len(df),'candidate_key_unique':False,'error':'kolom hilang: '+str(missing_cols)}
miss=df[cols].isna().any(axis=1)
dup=df.duplicated(subset=cols,keep=False)
return {'dataset':dataset_name,'rows':len(df),'unique_key_count':df[cols].drop_duplicates().shape[0],
'missing_key_rows':int(miss.sum()),'duplicate_key_rows':int(dup.sum()),
'candidate_key_unique':bool(not miss.any() and not dup.any()),'error':''}
grain_key_review = pd.DataFrame([key_check(df,SOURCE_KEYS[name],name) for name,df in pm2_sources.items()])
if len(grain_key_review):
display(grain_key_review)
print('KEY CHECK:', 'PASS' if bool(grain_key_review.candidate_key_unique.all()) else 'FAIL — periksa dataset pada kolom dataset')
else: print('KEY CHECK: PENDING (input belum terbaca)')
| dataset | rows | unique_key_count | missing_key_rows | duplicate_key_rows | candidate_key_unique | error | |
|---|---|---|---|---|---|---|---|
| 0 | Customers Clean | 156 | 156 | 0 | 0 | True | |
| 1 | Orders Clean | 324 | 324 | 0 | 0 | True | |
| 2 | Order Items Clean | 822 | 822 | 0 | 0 | True | |
| 3 | Payments Clean | 370 | 370 | 0 | 0 | True | |
| 4 | Restaurants Clean | 22 | 22 | 0 | 0 | True | |
| 5 | Delivery | 311 | 311 | 0 | 0 | True |
KEY CHECK: PASS
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
`duplicate_key_rows=0` dan `missing_key_rows=0` berarti candidate key sesuai harapan. Kriteria sumber Items/Payments menggunakan `order_item_id`/`payment_id`, **bukan** `order_id`.
**ISI WORKING PAPER BARU:** Lengkapi `01_Input_dan_Safe_Data!C13:D18` dari `input_inventory_df` dan `grain_key_review`. `order_id` yang berulang pada Items/Payments sesuai grain dan bukan otomatis error.
**PENJELASAN OUTPUT:** Pada `grain_key_review`, nilai `candidate_key_unique=True` dengan `missing_key_rows=0` dan `duplicate_key_rows=0` berarti key sumber valid. Repeated `order_id` pada Payments/Items tidak diuji sebagai key tunggal.
**CHECKPOINT:** Jika data atau evidence belum sesuai, jangan menandai PASS di Working Paper. Perbaiki tahap yang disebutkan output dan jalankan ulang pemeriksaan.
**LANJUT:** Tahap 4.
---
## TAHAP 4 — Safe Data Policy
**CASE — Situasi SwiftBite:** Tim analitik perlu mengenali pelanggan yang sama tanpa mengetahui nama, email, atau nomor telepon.
**TUJUAN:** Menentukan field yang harus Remove/Pseudonymize/Keep/Investigate sebelum coding.
**PAHAMI ISTILAH:** PII = informasi identitas pribadi; direct PII = nama/email/telepon; raw identifier = customer_id asli; protection decision = tindakan atas field.
**WORKING PAPER BARU:** Isi `01_Input_dan_Safe_Data!C24:E30` (C jenis data, D keputusan, E alasan). Kolom A–B untuk empat field wajib sudah disiapkan; baris 28–30 opsional jika ada field tambahan.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**LIHAT CONTOH:** `email` → Direct PII → Remove dari analytical layer. `customer_id` → Raw Identifier → Pseudonymize menjadi `customer_key`. `customer_segment` → atribut analitik → Keep (sesuai brief).
**COBA:** jalankan daftar field, lalu beri *judgment* pada sheet 01. Jangan menghapus kolom pada PM1 Clean source.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
DIRECT_PII_FIELDS={'full_name','email','phone_number'}
RAW_IDENTIFIER_FIELDS={'customer_id'}
if 'Customers Clean' in pm2_sources:
field_policy_df=pd.DataFrame([{'field':c,
'proposed_class':'Direct PII' if c in DIRECT_PII_FIELDS else 'Raw Identifier' if c in RAW_IDENTIFIER_FIELDS else 'Analytical Field',
'proposed_decision':'Remove' if c in DIRECT_PII_FIELDS else 'Pseudonymize' if c in RAW_IDENTIFIER_FIELDS else 'Keep'}
for c in pm2_sources['Customers Clean'].columns])
display(field_policy_df)
else: print('POLICY: PENDING — Customers Clean tidak terbaca')
| field | proposed_class | proposed_decision | |
|---|---|---|---|
| 0 | customer_id | Raw Identifier | Pseudonymize |
| 1 | full_name | Direct PII | Remove |
| 2 | Direct PII | Remove | |
| 3 | phone_number | Direct PII | Remove |
| 4 | signup_date | Analytical Field | Keep |
| 5 | customer_zone | Analytical Field | Keep |
| 6 | customer_segment | Analytical Field | Keep |
**BANTUAN SALIN KE WORKING PAPER** — Jalankan code cell berikut agar nilai yang perlu dicatat dan nomor baris Excel tampil dalam satu tabel. Tabel ini tidak mengisi file Excel otomatis; peserta tetap membaca dan mencatat hasilnya.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
# BANTUAN PENGISIAN SAFE DATA — sheet 01, baris 24–30
if 'field_policy_df' in globals():
policy_preview = field_policy_df.loc[field_policy_df['field'].isin(['full_name','email','phone_number','customer_id'])].copy()
print('A24:A27 dan B24:B27 sudah terisi. C=proposed_class, D=proposed_decision; E=alasan judgment peserta.')
display(policy_preview)
A24:A27 dan B24:B27 sudah terisi. C=proposed_class, D=proposed_decision; E=alasan judgment peserta.
| field | proposed_class | proposed_decision | |
|---|---|---|---|
| 0 | customer_id | Raw Identifier | Pseudonymize |
| 1 | full_name | Direct PII | Remove |
| 2 | Direct PII | Remove | |
| 3 | phone_number | Direct PII | Remove |
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
Ini adalah **contoh usulan kebijakan berdasarkan scope PM2**, bukan perubahan data yang sudah terjadi. Di Working Paper isi alasan risiko dan expected final field untuk field yang dipilih.
**ISI WORKING PAPER BARU:** Isi `01_Input_dan_Safe_Data!C24:E30` (C jenis data, D keputusan, E alasan). Kolom A–B untuk empat field wajib sudah disiapkan; baris 28–30 opsional jika ada field tambahan.
**PENJELASAN OUTPUT:** `field_policy_df` merupakan rekomendasi klasifikasi. Tulis alasan keputusan berdasarkan fungsi field dalam analisis; jangan menyalin alamat email atau nomor telepon ke evidence.
**CHECKPOINT:** Jika data atau evidence belum sesuai, jangan menandai PASS di Working Paper. Perbaiki tahap yang disebutkan output dan jalankan ulang pemeriksaan.
**LANJUT:** Tahap 5.
---
## TAHAP 5 — Pseudonymization & Safe Relationship
**CASE — Situasi SwiftBite:** Menghapus `customer_id` tanpa pengganti merusak hubungan Orders–Customers.
**TUJUAN:** Membentuk customer_key deterministik, menjaga join dan menghilangkan PII dari safe copy.
**PAHAMI ISTILAH:** deterministic = sama hasilnya jika input dan parameter sama; salt = konfigurasi rahasia hashing; pseudonymization = mengganti ID asli dengan key pengganti.
**WORKING PAPER BARU:** Lengkapi `01_Input_dan_Safe_Data!F24:H30` (F bukti dari `safe_check_df`, G status implementasi, H catatan). Evidence V-01 sampai V-04 *hanya* dicatat pada sheet 03 setelah Tahap 11.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**LIHAT CONTOH:** `C0001` pada Customers dan `C0001` pada Orders harus menghasilkan **customer_key yang sama**. Hash aktual tidak perlu dibaca atau ditulis lengkap; cukup bukti konsistensinya.
**COBA:** jalankan definisi helper. Kamu tidak perlu menulis algoritma SHA-256 dari nol. `VARIANT_ID` menjadi namespace sehingga ID yang sama dari varian berbeda tidak otomatis menghasilkan key yang sama. Jika salt PENDING, kembali ke Tahap 1 dan isi **prompt tertutup**; jangan mengetik secret pada code cell atau mengirimkannya ke mentor.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
def deterministic_hash(value,salt,variant_id):
if pd.isna(value): return pd.NA
if not salt: raise ValueError('PENGAMAN DATA BELUM SIAP — jalankan ulang Tahap 1 terlebih dahulu')
payload=json.dumps([str(variant_id),str(value),str(salt)],ensure_ascii=False,separators=(',',':')).encode('utf-8')
return hashlib.sha256(payload).hexdigest()
def build_safe_customer_data(customers_input,orders_input,salt,variant_id):
customers=customers_input.copy(deep=True); orders=orders_input.copy(deep=True)
for name,df in [('Customers',customers),('Orders',orders)]:
if 'customer_id' not in df.columns: raise ValueError(name+': customer_id belum ada')
if df.customer_id.isna().any(): raise ValueError(name+': customer_id null; cek PM1 handoff')
customers['customer_key']=customers['customer_id'].map(lambda x:deterministic_hash(x,salt,variant_id))
orders['customer_key']=orders['customer_id'].map(lambda x:deterministic_hash(x,salt,variant_id))
customers=customers.drop(columns=[c for c in DIRECT_PII_FIELDS | RAW_IDENTIFIER_FIELDS if c in customers.columns])
orders=orders.drop(columns=['customer_id'])
return customers,orders
def safe_schema_check(df):
return sorted(set(df.columns)&(DIRECT_PII_FIELDS|RAW_IDENTIFIER_FIELDS))
def fk_unmatched_count(child,parent,child_key,parent_key):
if child_key not in child or parent_key not in parent: return len(child)
return int((~child[child_key].isin(set(parent[parent_key].dropna()))).sum())
RUN_READY=bool(INPUT_FILES_READY and IDENTITY_READY and CONTROLLED_SALT)
customers_safe,orders_safe=(build_safe_customer_data(pm2_sources['Customers Clean'],pm2_sources['Orders Clean'],CONTROLLED_SALT,VARIANT_ID)
if RUN_READY else (None,None))
if RUN_READY:
safe_check_df=pd.DataFrame([{'check':'forbidden customer fields','actual':len(safe_schema_check(customers_safe))},
{'check':'forbidden order fields','actual':len(safe_schema_check(orders_safe))},
{'check':'unmatched customer_key','actual':fk_unmatched_count(orders_safe,customers_safe,'customer_key','customer_key')},
{'check':'duplicate customer_key','actual':int(customers_safe.customer_key.duplicated().sum())}])
display(safe_check_df)
print('SAFE TRANSFORMATION:', 'PASS' if (safe_check_df.actual==0).all() else 'FAIL')
else: print('SAFE TRANSFORMATION: PENDING — perlu input lengkap, identitas dan SWIFTBITE_PM2_SALT')
| check | actual | |
|---|---|---|
| 0 | forbidden customer fields | 0 |
| 1 | forbidden order fields | 0 |
| 2 | unmatched customer_key | 0 |
| 3 | duplicate customer_key | 0 |
SAFE TRANSFORMATION: PASS
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
Semua metric dalam `safe_check_df` seharusnya 0. Output yang ditampilkan tidak memuat isi PII. PS-03 (pseudonymization rerun) dilengkapi nanti pada Tahap 12; SR-04 final schema setelah Tahap 10.
**ISI WORKING PAPER BARU:** Lengkapi `01_Input_dan_Safe_Data!F24:H30` (F bukti dari `safe_check_df`, G status implementasi, H catatan). Evidence V-01 sampai V-04 *hanya* dicatat pada sheet 03 setelah Tahap 11.
**PENJELASAN OUTPUT:** `safe_check_df` harus menunjukkan 0 forbidden fields, 0 unmatched customer key, dan 0 duplicate customer_key. Jika salt kosong, status PENDING dan jangan lanjut hashing.
**CHECKPOINT:** Jika data atau evidence belum sesuai, jangan menandai PASS di Working Paper. Perbaiki tahap yang disebutkan output dan jalankan ulang pemeriksaan.
**LANJUT:** Tahap 6.
**CONTOH membaca output:** `forbidden customer fields=0` dan `unmatched customer_key=0` berarti tidak ada field pelanggan terlarang dan hubungan pelanggan valid. Di sheet 01 (baris 24–30), tulis kebijakan field, misalnya `email → Direct PII → Remove`, lalu bukti penerapannya `safe_check_df`. **Jangan menuliskan hash pelanggan atau secret salt dalam Excel.**
---
## TAHAP 6 — Integration Blueprint sebelum Coding
**CASE — Situasi SwiftBite:** Join yang dilakukan tanpa rencana dapat melipatgandakan rows Orders.
**TUJUAN:** Menetapkan grain, pre-join action, dan urutan lima join sebelum coding integrasi.
**PAHAMI ISTILAH:** fan-out = baris bertambah akibat pasangan join; aggregation = merangkum banyak baris per key; LEFT JOIN = semua Orders tetap dipertahankan.
**WORKING PAPER BARU:** Isi rencana `02_Integrasi_dan_Rerun!B12:D14` untuk tiga proses (Items, Payments, Delivery) dan rencana `C20:C24` untuk lima join. Baris aktual belum diisi sebelum kode berjalan.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**LIHAT CONTOH:** 1 order punya 3 item, berarti `Orders JOIN Items` akan membuat 3 baris; setelah Items di-aggregate menjadi 1 baris/order, risiko tersebut hilang.
**COBA:** jalankan diagnosis jumlah source 1:M lalu tulis blueprint berdasarkan hasilnya. Kolom status dapat diisi `Planned`; jangan tulis “Validated” sebelum menjalankan join.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
if pm2_sources:
fanout_risk_df = pd.DataFrame([
{'source':'Order Items Clean','source_rows':len(pm2_sources['Order Items Clean']),
'distinct_order_id':pm2_sources['Order Items Clean'].order_id.nunique(),
'max_rows_per_order':int(pm2_sources['Order Items Clean'].groupby('order_id').size().max())},
{'source':'Payments Clean','source_rows':len(pm2_sources['Payments Clean']),
'distinct_order_id':pm2_sources['Payments Clean'].order_id.nunique(),
'max_rows_per_order':int(pm2_sources['Payments Clean'].groupby('order_id').size().max())}])
display(fanout_risk_df)
else: print('FAN-OUT CHECK: PENDING')
| source | source_rows | distinct_order_id | max_rows_per_order | |
|---|---|---|---|---|
| 0 | Order Items Clean | 822 | 324 | 4 |
| 1 | Payments Clean | 370 | 324 | 2 |
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
Jika `max_rows_per_order > 1`, source tersebut harus di-aggregate sebelum final join. Urutan lima joins: Customers Safe, Restaurants Clean, Item Aggregate, Payment Aggregate, Delivery Features.
**ISI WORKING PAPER BARU:** Isi rencana `02_Integrasi_dan_Rerun!B12:D14` untuk tiga proses (Items, Payments, Delivery) dan rencana `C20:C24` untuk lima join. Baris aktual belum diisi sebelum kode berjalan.
**PENJELASAN OUTPUT:** `fanout_risk_df` memperlihatkan berapa baris Items/Payments per order. Jika `max_rows_per_order > 1`, rencanakan aggregation sebelum join. Catat rencana di sheet 02 sebelum coding.
**CHECKPOINT:** Jika data atau evidence belum sesuai, jangan menandai PASS di Working Paper. Perbaiki tahap yang disebutkan output dan jalankan ulang pemeriksaan.
**LANJUT:** Tahap 7.
---
## TAHAP 7 — Order Items Aggregation
**CASE — Situasi SwiftBite:** Satu order dapat terdiri dari banyak item, tetapi final dataset harus satu baris per order.
**TUJUAN:** Membuat item_count, total_quantity, distinct_item_category_count dan items_subtotal.
**PAHAMI ISTILAH:** groupby = mengelompokkan baris; count = hitung item; sum = jumlah unit; nunique = jumlah kategori unik.
**WORKING PAPER BARU:** Isi `02_Integrasi_dan_Rerun!E12:H12` (E = `len(item_agg)`, F = status checkpoint, G = `item_agg`, H = catatan). Isi V-07 nanti pada sheet 03 baris 18.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**LIHAT CONTOH (data latihan, bukan data peserta):** O001 punya quantity [2,1,1] → item_count=3; total_quantity=4.
**LATIHAN OPSIONAL (boleh dilewati tanpa mengurangi penyelesaian PM2):** baris `kolom_jumlah = "quantity"` sudah diisi. Baca mengapa yang dijumlahkan quantity, bukan `order_item_id`. Kamu boleh mencoba mengganti pada data latihan, lalu kembalikan ke `quantity` sebelum lanjut.
# ★ LATIHAN OPSIONAL — boleh dilewati; bukan syarat penilaian.
example_items = pd.DataFrame({'order_id':['O001','O001','O001'], 'quantity':[2,1,1]})
kolom_jumlah = 'quantity' # COBA: ini kolom yang dijumlahkan, bukan ID item
example_result = example_items.groupby('order_id').agg(item_count=('quantity','size'),total_quantity=(kolom_jumlah,'sum')).reset_index()
display(example_result)
print('CHECK CONTOH:', 'PASS' if example_result.iloc[0].total_quantity==4 else 'FAIL — kembalikan kolom_jumlah ke quantity')
| order_id | item_count | total_quantity | |
|---|---|---|---|
| 0 | O001 | 3 | 4 |
CHECK CONTOH: PASS
# ★ LATIHAN OPSIONAL — boleh dilewati; bukan syarat penilaian.
# ★ LATIHAN OPSIONAL — jalankan contoh ini hanya jika sudah menjalankan contoh sebelumnya; tidak wajib mengubah nama kolom.
# Contoh: quantity adalah jumlah unit yang dijual, bukan jumlah baris item.
kolom_total_unit = "quantity" # COBA: jangan ubah untuk hasil akhir resmi
if INPUT_FILES_READY:
unit_per_order = (pm2_sources['Order Items Clean']
.groupby('order_id')[kolom_total_unit].sum())
print('Jumlah order yang mempunyai item:', len(unit_per_order))
print('Total quantity dari semua order:', int(unit_per_order.sum()))
print('BANDINGKAN dengan total_quantity pada item_agg setelah cell berikutnya dijalankan.')
else:
print('PENDING — data Items belum terbaca')
Jumlah order yang mempunyai item: 324 Total quantity dari semua order: 1640 BANDINGKAN dengan total_quantity pada item_agg setelah cell berikutnya dijalankan.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
def build_item_aggregate(order_items_df):
df=order_items_df.copy(deep=True)
required={'order_id','order_item_id','quantity','item_category','line_amount'}
if required-set(df.columns): raise ValueError('Item source kehilangan kolom: '+str(required-set(df.columns)))
for c in ['quantity','line_amount']:
df[c]=pd.to_numeric(df[c],errors='raise')
if df['order_item_id'].duplicated().any() or df.order_id.isna().any():
raise ValueError('ITEM AGG FAIL: item key/order_id tidak valid, periksa PM1 output')
agg=df.groupby('order_id',as_index=False,dropna=False).agg(
item_count=('order_item_id','size'),
total_quantity=('quantity','sum'),
distinct_item_category_count=('item_category','nunique'),
items_subtotal=('line_amount','sum'))
return agg
def aggregate_grain_check(df,key='order_id'):
if df is None or key not in df.columns: return {'rows':0,'unique_key_count':0,'duplicate_key_rows':0,'missing_key_rows':0,'valid':False}
return {'rows':len(df),'unique_key_count':df[key].nunique(dropna=True),
'duplicate_key_rows':int(df[key].duplicated().sum()),'missing_key_rows':int(df[key].isna().sum()),
'valid':bool(df[key].is_unique and df[key].notna().all())}
item_agg = build_item_aggregate(pm2_sources['Order Items Clean']) if INPUT_FILES_READY else None
if item_agg is not None:
print('ITEM AGG GRAIN:',aggregate_grain_check(item_agg))
display(item_agg.head(5))
else: print('ITEM AGG: PENDING — file PM1 belum siap')
ITEM AGG GRAIN: {'rows': 324, 'unique_key_count': 324, 'duplicate_key_rows': 0, 'missing_key_rows': 0, 'valid': True}
| order_id | item_count | total_quantity | distinct_item_category_count | items_subtotal | |
|---|---|---|---|---|---|
| 0 | O00001 | 2 | 3 | 2 | 60000 |
| 1 | O00002 | 2 | 3 | 1 | 52000 |
| 2 | O00003 | 1 | 2 | 1 | 47000 |
| 3 | O00004 | 2 | 3 | 2 | 90000 |
| 4 | O00005 | 2 | 3 | 1 | 104000 |
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
`item_agg` harus memiliki `order_id` unik, tanpa missing. Bandingkan jumlah rows aggregate dengan unique order_id pada Order Items sumber. Jangan menjadikan angka SB-P01 sebagai syarat.
**ISI WORKING PAPER BARU:** Isi `02_Integrasi_dan_Rerun!E12:H12` (E = `len(item_agg)`, F = status checkpoint, G = `item_agg`, H = catatan). Isi V-07 nanti pada sheet 03 baris 18.
**PENJELASAN OUTPUT:** `item_agg` harus satu baris per order_id, `aggregate_grain_check(item_agg)['valid']` harus True. `item_count` adalah banyak baris item dan `total_quantity` banyak unit, bisa berbeda.
**CHECKPOINT:** Jika data atau evidence belum sesuai, jangan menandai PASS di Working Paper. Perbaiki tahap yang disebutkan output dan jalankan ulang pemeriksaan.
**LANJUT:** Tahap 8.
**CONTOH ISI EXCEL (ilustrasi):** jika `item_agg` memuat 30 order unik, pada sheet 02 baris 12 tulis E=`30`, F=`PASS`, G=`item_agg`, H=`1 baris per order, tanpa duplikasi`. Jumlah aktualmu dapat berbeda. **Kode aggregation utama sudah lengkap; tidak perlu mengetik rumus Python.**
---
## TAHAP 8 — Payment Attempts dan Monetary Aggregation
**CASE — Situasi SwiftBite:** Pembayaran dapat gagal lalu berhasil, atau berhasil kemudian di-refund. Mengambil satu payment record secara sembarangan dapat mengubah net payment.
**TUJUAN:** Menghitung semua attempts dan menentukan status/method secara deterministic.
**PAHAMI ISTILAH:** attempt = satu catatan percobaan/event pembayaran; refund = pengembalian uang; tie-breaker = aturan urutan jika nilai sebelumnya sama.
**WORKING PAPER BARU:** Isi `02_Integrasi_dan_Rerun!E13:H13` (E = `len(payment_agg)`, F = status, G = `payment_agg`, H = catatan). V-08 dan V-09 nanti di sheet 03 baris 19–20.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**LIHAT CONTOH:** O001 failed Rp50.000 lalu successful Rp50.000 → payment_attempt_count 2, successful 50.000, refunded 0, net 50.000. Untuk successful → refunded penuh Rp50.000, net 0.
**Aturan resmi:** urutkan `attempt_number`, kemudian `payment_timestamp`, kemudian `payment_id`. Status final = record terakhir. Metode final = metode successful terakhir jika ada, jika tidak metode record terakhir.
**LATIHAN OPSIONAL (boleh dilewati):** kode berikut menguji rumus; pastikan `net = sukses - refund`. Failed tidak ditambah ke successful.
# ★ LATIHAN OPSIONAL — boleh dilewati; bukan syarat penilaian.
contoh_successful=50000
contoh_refunded=50000
contoh_net=contoh_successful-contoh_refunded
auto_check_contoh = contoh_net==0
print('Net payment setelah refund penuh:',contoh_net)
print('CHECK CONTOH:', 'PASS' if auto_check_contoh else 'FAIL — net harus successful dikurangi refunded')
Net payment setelah refund penuh: 0 CHECK CONTOH: PASS
# ★ LATIHAN OPSIONAL — boleh dilewati; bukan syarat penilaian.
# ★ LATIHAN OPSIONAL — cukup baca hasil; jangan ubah status bila belum memahami Python.
# Fokus: failed tetap ada sebagai attempt, tetapi tidak ditambah ke uang diterima.
STATUS_BERHASIL = 'successful' # Ubah hanya saat latihan; kembalikan ke successful
if INPUT_FILES_READY:
payments_latihan = pm2_sources['Payments Clean']
uang_sukses = payments_latihan.loc[payments_latihan.payment_status.eq(STATUS_BERHASIL),'payment_amount'].sum()
uang_refund = payments_latihan.loc[payments_latihan.payment_status.eq('refunded'),'payment_amount'].sum()
print('Successful amount:',int(uang_sukses),'| Refunded amount:',int(uang_refund))
print('Net amount:',int(uang_sukses-uang_refund))
else: print('PENDING — Payments Clean belum terbaca')
Successful amount: 40958000 | Refunded amount: 1109000 Net amount: 39849000
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
PAYMENT_STATUSES={'failed','successful','refunded'}
def build_payment_aggregate(payments_df):
df=payments_df.copy(deep=True)
required={'order_id','payment_id','payment_status','payment_method','payment_amount','payment_timestamp','attempt_number'}
if required-set(df): raise ValueError('PAYMENT COLUMNS MISSING: '+str(required-set(df)))
if df['payment_id'].isna().any() or df['payment_id'].duplicated().any() or df['order_id'].isna().any():
raise ValueError('PAYMENT KEY FAIL — payment_id duplikat/null atau order_id null')
if not set(df.payment_status.dropna().unique()).issubset(PAYMENT_STATUSES) or df.payment_status.isna().any():
raise ValueError('PAYMENT STATUS FAIL — kategori di luar failed/successful/refunded')
df['attempt_number']=pd.to_numeric(df.attempt_number,errors='coerce')
df['payment_timestamp']=pd.to_datetime(df.payment_timestamp,errors='coerce')
df['payment_amount']=pd.to_numeric(df.payment_amount,errors='coerce')
if df[['attempt_number','payment_timestamp','payment_amount','payment_method']].isna().any().any():
raise ValueError('PAYMENT INPUT FAIL — attempt/timestamp/amount/method kosong atau tidak valid')
if (df.payment_amount<0).any(): raise ValueError('PAYMENT AMOUNT FAIL — nilai negatif perlu investigasi')
if df.duplicated(['order_id','attempt_number']).any():
raise ValueError('PAYMENT ATTEMPT FAIL — attempt_number duplikat dalam satu order')
df=df.sort_values(['order_id','attempt_number','payment_timestamp','payment_id'],kind='stable')
if (df.groupby('order_id')['payment_timestamp'].diff().dt.total_seconds().dropna()<0).any():
raise ValueError('PAYMENT CHRONOLOGY FAIL — timestamp bertentangan dengan attempt_number')
# Refund harus mempunyai successful attempt lebih dahulu pada order yang sama.
# Hitung berdasarkan urutan attempt yang sudah divalidasi.
success_seen=df.payment_status.eq('successful').groupby(df.order_id).cumsum()
refund_without_success=df.payment_status.eq('refunded') & success_seen.eq(0)
if refund_without_success.any():
raise ValueError('PAYMENT REFUND FAIL — terdapat refund sebelum successful payment pada order yang sama')
df['_success_amt']=np.where(df.payment_status.eq('successful'),df.payment_amount,0)
df['_refund_amt']=np.where(df.payment_status.eq('refunded'),df.payment_amount,0)
grp=df.groupby('order_id',as_index=False).agg(
payment_attempt_count=('payment_id','size'),
successful_payment_amount=('_success_amt','sum'),refunded_payment_amount=('_refund_amt','sum'))
grp['net_payment_amount']=grp.successful_payment_amount-grp.refunded_payment_amount
if (grp.net_payment_amount<0).any():
raise ValueError('PAYMENT REFUND FAIL — refund melebihi successful amount')
final=df.groupby('order_id',as_index=False).tail(1)[['order_id','payment_status']].rename(columns={'payment_status':'final_payment_status'})
success=df.loc[df.payment_status.eq('successful')].groupby('order_id',as_index=False).tail(1)[['order_id','payment_method']]
fallback=df.groupby('order_id',as_index=False).tail(1)[['order_id','payment_method']].rename(columns={'payment_method':'_last_method'})
grp=grp.merge(final,on='order_id',how='left',validate='one_to_one')
grp=grp.merge(success.rename(columns={'payment_method':'_success_method'}),on='order_id',how='left',validate='one_to_one')
grp=grp.merge(fallback,on='order_id',how='left',validate='one_to_one')
grp['payment_method_final']=grp['_success_method'].fillna(grp['_last_method'])
return grp.drop(columns=['_success_method','_last_method'])
payment_agg=build_payment_aggregate(pm2_sources['Payments Clean']) if INPUT_FILES_READY else None
if payment_agg is not None:
print('PAYMENT GRAIN:',aggregate_grain_check(payment_agg))
print('Payments source rows:',len(pm2_sources['Payments Clean']), '| attempts preserved:',int(payment_agg.payment_attempt_count.sum()))
display(payment_agg.head(5))
display(payment_agg.final_payment_status.value_counts().rename('orders').to_frame())
else: print('PAYMENT AGG: PENDING')
PAYMENT GRAIN: {'rows': 324, 'unique_key_count': 324, 'duplicate_key_rows': 0, 'missing_key_rows': 0, 'valid': True}
Payments source rows: 370 | attempts preserved: 370
| order_id | payment_attempt_count | successful_payment_amount | refunded_payment_amount | net_payment_amount | final_payment_status | payment_method_final | |
|---|---|---|---|---|---|---|---|
| 0 | O00001 | 1 | 73000 | 0 | 73000 | successful | e_wallet |
| 1 | O00002 | 1 | 60000 | 0 | 60000 | successful | bank_transfer |
| 2 | O00003 | 2 | 50000 | 0 | 50000 | successful | credit_card |
| 3 | O00004 | 1 | 105000 | 0 | 105000 | successful | cash |
| 4 | O00005 | 1 | 107000 | 0 | 107000 | successful | e_wallet |
| orders | |
|---|---|
| final_payment_status | |
| successful | 298 |
| failed | 17 |
| refunded | 9 |
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
Lihat `payment_attempt_count`, `successful_payment_amount`, `refunded_payment_amount`, `net_payment_amount`, `final_payment_status`, dan `payment_method_final`. Kriteria: total attempts aggregate = jumlah baris Payments source, key unik, net = successful − refunded. Jika fungsi menghentikan proses, jangan paksa PASS.
**ISI WORKING PAPER BARU:** Isi `02_Integrasi_dan_Rerun!E13:H13` (E = `len(payment_agg)`, F = status, G = `payment_agg`, H = catatan). V-08 dan V-09 nanti di sheet 03 baris 19–20.
**PENJELASAN OUTPUT:** Lihat `payment_attempt_count`, successful/refunded/net amounts, `final_payment_status`, dan `payment_method_final`. Failed attempt tetap dihitung sebagai record namun tidak sebagai uang diterima. Jangan hapus repeated order_id.
**CHECKPOINT:** Jika data atau evidence belum sesuai, jangan menandai PASS di Working Paper. Perbaiki tahap yang disebutkan output dan jalankan ulang pemeriksaan.
**LANJUT:** Tahap 9.
**CONTOH PEMAHAMAN:** dua payment attempts (`failed`, lalu `successful`) berarti jumlah attempts=2 tetapi uang diterima hanya transaksi `successful`, bukan penjumlahan keduanya. Di Working Paper sheet 02 baris 13, catat jumlah baris agregasi, status, dan `payment_agg`, bukan angka dari contoh ini.
---
## TAHAP 9 — Delivery Features & Lifecycle
**CASE — Situasi SwiftBite:** Cancelled order tidak boleh dihitung on-time hanya karena waktu delivered kosong.
**TUJUAN:** Menghitung actual_delivery_minutes, delay_minutes, is_late khusus delivered.
**PAHAMI ISTILAH:** timestamp = tanggal dan jam; timedelta = selisih waktu; null = belum ada nilai; boolean = True/False.
**WORKING PAPER BARU:** Isi `02_Integrasi_dan_Rerun!E14:H14` (E = `len(delivery_features)`, F = status, G = `delivery_features`, H = catatan). V-14–V-17 di sheet 03 baris 25–28 setelah Tahap 11.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**LIHAT CONTOH (code cell latihan setelah ini OPSIONAL):** assigned 10:00, delivered 10:45, promised 30 menit → actual 45, delay 15, is_late=True. Jika status cancelled, ketiganya null. Delay negatif untuk delivery lebih cepat **bukan otomatis error**.
# ★ LATIHAN OPSIONAL — boleh dilewati; bukan syarat penilaian.
# COBA — latihan perhitungan durasi dengan data delivered milik varianmu
# Tidak ada data asli yang diubah pada latihan ini.
if INPUT_FILES_READY:
contoh_delivery = pm2_sources['Delivery'].loc[pm2_sources['Delivery'].delivery_status.eq('delivered')].head(1).copy()
if not contoh_delivery.empty:
awal = pd.to_datetime(contoh_delivery.iloc[0]['assigned_at'])
akhir = pd.to_datetime(contoh_delivery.iloc[0]['delivered_at'])
janji = float(contoh_delivery.iloc[0]['promised_delivery_minutes'])
actual_minutes = (akhir-awal).total_seconds()/60
print('Durasi aktual (menit):',actual_minutes,'| Durasi janji:',janji)
print('Delay:',actual_minutes-janji,'| Terlambat?',actual_minutes>janji)
else: print('Tidak ada record delivered; lanjutkan dan periksa source')
else: print('PENDING — Delivery belum terbaca')
Durasi aktual (menit): 21.0 | Durasi janji: 33.0 Delay: -12.0 | Terlambat? False
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
def derive_delivery_features(delivery_df):
out=delivery_df.copy(deep=True)
required={'delivery_id','order_id','assigned_at','picked_up_at','delivered_at','delivery_status','promised_delivery_minutes'}
if required-set(out): raise ValueError('DELIVERY COLUMNS MISSING: '+str(required-set(out)))
for c in ['assigned_at','picked_up_at','delivered_at']:
out[c]=pd.to_datetime(out[c],errors='coerce')
out['promised_delivery_minutes']=pd.to_numeric(out['promised_delivery_minutes'],errors='coerce')
delivered=out.delivery_status.eq('delivered')
out['actual_delivery_minutes']=(out.delivered_at-out.assigned_at).dt.total_seconds().div(60).where(delivered)
out['delay_minutes']=(out.actual_delivery_minutes-out.promised_delivery_minutes).where(delivered)
out['is_late']=pd.Series(pd.NA,index=out.index,dtype='boolean')
out.loc[delivered,'is_late']=(out.loc[delivered,'delay_minutes']>0).astype('boolean')
return out
def delivery_lifecycle_check(df,orders_df=None):
d=df.copy(deep=True)
for c in ['assigned_at','picked_up_at','delivered_at']:
d[c]=pd.to_datetime(d[c],errors='coerce')
delivered=d.delivery_status.eq('delivered')
invalid_status=~d.delivery_status.isin(['delivered','cancelled','incomplete'])
missing_for_delivered=delivered & d[['assigned_at','picked_up_at','delivered_at']].isna().any(axis=1)
order_violation=delivered & ((d.picked_up_at<d.assigned_at)|(d.delivered_at<d.picked_up_at))
negative_promised=delivered & (pd.to_numeric(d.promised_delivery_minutes,errors='coerce').isna() | (pd.to_numeric(d.promised_delivery_minutes,errors='coerce')<0))
cancelled_has_delivered=(~delivered)&d.delivered_at.notna()
chronology_count=0
if orders_df is not None:
ref=orders_df[['order_id','order_timestamp']].copy()
ref['order_timestamp']=pd.to_datetime(ref.order_timestamp,errors='coerce')
tmp=d[['order_id','assigned_at']].merge(ref,on='order_id',how='left',validate='many_to_one')
chronology_count=int((tmp.assigned_at<tmp.order_timestamp).sum())
return {'invalid_status':int(invalid_status.sum()),'missing_delivered_timestamps':int(missing_for_delivered.sum()),
'invalid_sequence':int(order_violation.sum()),'invalid_promised_minutes':int(negative_promised.sum()),
'non_delivered_with_delivered_at':int(cancelled_has_delivered.sum()),'assigned_before_order':chronology_count}
delivery_features=derive_delivery_features(pm2_sources['Delivery']) if INPUT_FILES_READY else None
if delivery_features is not None:
delivery_lifecycle_result=delivery_lifecycle_check(delivery_features,pm2_sources['Orders Clean'])
print('DELIVERY LIFECYCLE:',delivery_lifecycle_result)
display(delivery_features[['order_id','delivery_status','promised_delivery_minutes','actual_delivery_minutes','delay_minutes','is_late']].head(6))
else: print('DELIVERY FEATURES: PENDING')
DELIVERY LIFECYCLE: {'invalid_status': 0, 'missing_delivered_timestamps': 0, 'invalid_sequence': 0, 'invalid_promised_minutes': 0, 'non_delivered_with_delivered_at': 0, 'assigned_before_order': 0}
| order_id | delivery_status | promised_delivery_minutes | actual_delivery_minutes | delay_minutes | is_late | |
|---|---|---|---|---|---|---|
| 0 | O00001 | delivered | 33 | 21.0 | -12.0 | False |
| 1 | O00002 | delivered | 51 | 57.0 | 6.0 | True |
| 2 | O00003 | delivered | 56 | 61.0 | 5.0 | True |
| 3 | O00004 | delivered | 41 | 56.0 | 15.0 | True |
| 4 | O00005 | delivered | 38 | 33.0 | -5.0 | False |
| 5 | O00006 | delivered | 55 | 55.0 | 0.0 | False |
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
Lihat semua metric `delivery_lifecycle_result` dan pastikan 0. Untuk delivered, periksa tiga derived fields. Untuk cancelled/incomplete, ketiganya harus null, bukan False.
**ISI WORKING PAPER BARU:** Isi `02_Integrasi_dan_Rerun!E14:H14` (E = `len(delivery_features)`, F = status, G = `delivery_features`, H = catatan). V-14–V-17 di sheet 03 baris 25–28 setelah Tahap 11.
**PENJELASAN OUTPUT:** Bandingkan hasil `delivery_lifecycle_result` dengan nol; `delivery_features` berstatus cancelled/incomplete harus null untuk actual, delay, dan is_late. Delay negatif dapat berarti lebih cepat dari janji.
**CHECKPOINT:** Jika data atau evidence belum sesuai, jangan menandai PASS di Working Paper. Perbaiki tahap yang disebutkan output dan jalankan ulang pemeriksaan.
**LANJUT:** Tahap 10.
**CONTOH PEMAHAMAN:** order delivered dalam 45 menit dari janji 30 menit menghasilkan delay **15** dan `is_late=True`. Jika cancelled/incomplete, hasil durasi/delay/is_late adalah **null**, bukan nol. Di sheet 02 baris 14 tuliskan jumlah row `delivery_features` dan bukti output; tidak perlu menulis kode perhitungan sendiri.
---
## TAHAP 10 — Staged Joins ke Final Analytical Dataset
**CASE — Situasi SwiftBite:** Data yang sudah diringkas harus digabung tanpa menggandakan order.
**TUJUAN:** Menjalankan lima LEFT JOIN, memvalidasi key tabel kanan dan final grain.
**PAHAMI ISTILAH:** LEFT JOIN = pertahankan semua baris Orders; validate=one_to_one/many_to_one = pembatas hubungan saat join; fan-out = baris tergandakan.
**WORKING PAPER BARU:** Isi `02_Integrasi_dan_Rerun!C20:H24`: C join_key, D before_rows, E after_rows, F duplicate_order_rows_after, G status, H catatan unmatched. Ambil dari `integration_audit_df` / `wp_join_copy_df`. V-05/06, V-10–V-14 baru dicatat setelah Tahap 11.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**LIHAT CONTOH:** Jika sebelum join Orders=100 dan sesudah join=110, ada potensi fan-out; jangan hapus 10 baris secara diam-diam. Cek uniqueness pada tabel kanan.
**COBA:** gunakan helper yang sudah siap pakai. Join bertahap sesuai blueprint. Jika fungsi menampilkan FAIL, periksa source yang disebutkan.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
def join_with_audit(left,right,on,step_name,how='left'):
if left is None or right is None: raise ValueError(step_name+': source belum tersedia')
if on not in left or on not in right: raise ValueError(step_name+': join key '+on+' tidak ditemukan')
if right[on].isna().any() or right[on].duplicated().any():
raise ValueError(step_name+': right-side key tidak unik/null. Periksa grain sebelum join')
before=len(left)
unmatched=int((~left[on].isin(set(right[on]))).sum())
out=left.merge(right,on=on,how=how,validate='many_to_one',suffixes=('','_right'))
duplicate=int(out['order_id'].duplicated().sum())
audit={'step':step_name,'join_key':on,'before_rows':before,'after_rows':len(out),
'row_change':len(out)-before,'unmatched_left_rows':unmatched,
'duplicate_order_rows_after':duplicate,'status':'PASS' if len(out)==before and duplicate==0 else 'FAIL'}
if audit['status']!='PASS': raise ValueError('JOIN FAIL: '+str(audit))
return out,audit
def build_integrated(orders_safe,customers_safe,restaurants_clean,item_agg,payment_agg,delivery_features):
current=orders_safe.copy(deep=True)
steps=[('Safe Customers',customers_safe,'customer_key'),
('Restaurants',restaurants_clean,'restaurant_id'),
('Item Aggregate',item_agg,'order_id'),
('Payment Aggregate',payment_agg,'order_id'),
('Delivery Features',delivery_features,'order_id')]
audits=[]
for label,right,key in steps:
current,one_audit=join_with_audit(current,right,key,label)
audits.append(one_audit)
return current,pd.DataFrame(audits)
final_integrated,integration_audit_df=(build_integrated(orders_safe,customers_safe,pm2_sources['Restaurants Clean'],item_agg,payment_agg,delivery_features)
if RUN_READY else (None,pd.DataFrame()))
if final_integrated is not None:
display(integration_audit_df)
print('FINAL GRAIN:',aggregate_grain_check(final_integrated))
# Preview ONLY safe, non-PII sample; no raw customer_id
display(final_integrated[['order_id','customer_key','item_count','payment_attempt_count','delivery_status']].head(5))
else: print('INTEGRATION: PENDING — input/salt/identitas belum lengkap')
| step | join_key | before_rows | after_rows | row_change | unmatched_left_rows | duplicate_order_rows_after | status | |
|---|---|---|---|---|---|---|---|---|
| 0 | Safe Customers | customer_key | 324 | 324 | 0 | 0 | 0 | PASS |
| 1 | Restaurants | restaurant_id | 324 | 324 | 0 | 0 | 0 | PASS |
| 2 | Item Aggregate | order_id | 324 | 324 | 0 | 0 | 0 | PASS |
| 3 | Payment Aggregate | order_id | 324 | 324 | 0 | 0 | 0 | PASS |
| 4 | Delivery Features | order_id | 324 | 324 | 0 | 13 | 0 | PASS |
FINAL GRAIN: {'rows': 324, 'unique_key_count': 324, 'duplicate_key_rows': 0, 'missing_key_rows': 0, 'valid': True}
| order_id | customer_key | item_count | payment_attempt_count | delivery_status | |
|---|---|---|---|---|---|
| 0 | O00001 | 7126605f1efcbfab4ff812c508a97e53619d3d79b5529d... | 2 | 1 | delivered |
| 1 | O00002 | b5d022dca0aee7662cc15dd663010935edcda968a98179... | 2 | 1 | delivered |
| 2 | O00003 | 923f36c17cb10522afd7c434a4a8adccae029fb47e8372... | 1 | 2 | delivered |
| 3 | O00004 | 6830fc3b7013ce442c1e363c5bc486c9ca5bf7baf31a21... | 2 | 1 | delivered |
| 4 | O00005 | 5c6bc4ca22d7716d6cac543fd628a4a40e21aa41442d7d... | 2 | 1 | delivered |
**BANTUAN SALIN KE WORKING PAPER** — Jalankan code cell berikut agar nilai yang perlu dicatat dan nomor baris Excel tampil dalam satu tabel. Tabel ini tidak mengisi file Excel otomatis; peserta tetap membaca dan mencatat hasilnya.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
# BANTUAN SALIN HASIL JOIN — sheet 02, baris 20–24
if not integration_audit_df.empty:
wp_join_copy_df = integration_audit_df[['step','join_key','before_rows','after_rows','duplicate_order_rows_after','status','unmatched_left_rows']].copy()
wp_join_copy_df.insert(0,'baris_excel',range(20,20+len(wp_join_copy_df)))
display(wp_join_copy_df)
print('SALIN ke sheet 02: C=join_key, D=before_rows, E=after_rows, F=duplicate_order_rows_after, G=status, H=unmatched_left_rows bila penting.')
else: print('BANTUAN JOIN: PENDING — integrasi belum dibuat.')
| baris_excel | step | join_key | before_rows | after_rows | duplicate_order_rows_after | status | unmatched_left_rows | |
|---|---|---|---|---|---|---|---|---|
| 0 | 20 | Safe Customers | customer_key | 324 | 324 | 0 | PASS | 0 |
| 1 | 21 | Restaurants | restaurant_id | 324 | 324 | 0 | PASS | 0 |
| 2 | 22 | Item Aggregate | order_id | 324 | 324 | 0 | PASS | 0 |
| 3 | 23 | Payment Aggregate | order_id | 324 | 324 | 0 | PASS | 0 |
| 4 | 24 | Delivery Features | order_id | 324 | 324 | 0 | PASS | 13 |
SALIN ke sheet 02: C=join_key, D=before_rows, E=after_rows, F=duplicate_order_rows_after, G=status, H=unmatched_left_rows bila penting.
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
Setiap baris `integration_audit_df` harus status PASS, before_rows=after_rows, duplicate_order_rows_after=0. Pada `final_integrated`, final row count = **jumlah Orders varian sendiri**, bukan 321 untuk semua peserta.
**ISI WORKING PAPER BARU:** Isi `02_Integrasi_dan_Rerun!C20:H24`: C join_key, D before_rows, E after_rows, F duplicate_order_rows_after, G status, H catatan unmatched. Ambil dari `integration_audit_df` / `wp_join_copy_df`. V-05/06, V-10–V-14 baru dicatat setelah Tahap 11.
**PENJELASAN OUTPUT:** Untuk setiap baris `integration_audit_df`: `before_rows = after_rows`, `duplicate_order_rows_after = 0`, status PASS. Jangan menghapus row setelah fan-out; kembali cek key tabel kanan atau aggregation.
**CHECKPOINT:** Jika data atau evidence belum sesuai, jangan menandai PASS di Working Paper. Perbaiki tahap yang disebutkan output dan jalankan ulang pemeriksaan.
**LANJUT:** Tahap 11.
**CONTOH PENGISIAN (angka ilustrasi):** jika baris sebelum join=30, sesudah=30, duplicate order=0, catat pada baris join yang sesuai di sheet 02: D=`30`, E=`30`, F=`0`, G=`PASS`, H=`Tidak ada fan-out`. Ambil hasil sebenarnya dari `wp_join_copy_df`. Jika sesudah menjadi 31, **jangan hapus satu baris secara manual**; cari sumber yang berulang.
---
## TAHAP 11 — Core Validation V-01 s.d. V-17
**CASE — Situasi SwiftBite:** Output dapat terlihat lengkap meskipun salah; SwiftBite membutuhkan bukti per check.
**TUJUAN:** Menghasilkan 17 hasil verifikasi dari data aktual beserta metric, evidence, dan status.
**PAHAMI ISTILAH:** expected criteria = syarat; actual result = nilai nyata; evidence = output yang membuktikan keputusan; FAIL = syarat tidak terpenuhi.
**WORKING PAPER BARU:** Isi `03_Validasi_dan_Keputusan!D12:G28` untuk V-01–V-17. D = actual_result_metric, E = evidence_output, F = status, G = catatan perbaikan jika perlu. Gunakan `wp_core_validation_copy_df` (memuat nomor baris Excel).
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**LIHAT CONTOH:** V-05 PASS jika final rows=Orders rows. V-06 FAIL jika ada order_id duplikat. Catat hasil **aktual** dan nama evidence, jangan tulis PASS tanpa hasil.
**COBA:** definisikan fungsi validation. Kode siap pakai karena tujuan latihan adalah membaca output dan judgment, bukan menulis 17 assertions dari nol.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
REQUIRED_IDS=[f'V-{i:02d}' for i in range(1,20)]
VALIDATION_COLUMNS=['check_id','validation_level','dataset_relationship','validation_question','expected_criteria',
'actual_result_metric','evidence_output','status','related_stage','notes']
def validation_record(cid,level,source,question,expected,actual,evidence,ok,stage,notes=''):
return dict(zip(VALIDATION_COLUMNS,[cid,level,source,question,expected,str(actual),str(evidence),
'PASS' if bool(ok) else 'FAIL',stage,notes]))
def run_core_validations(src,cs,osafe,iagg,pagg,dfeat,final,audit,variant_id,salt):
if any(x is None for x in [cs,osafe,iagg,pagg,dfeat,final,audit]):
return pd.DataFrame(columns=VALIDATION_COLUMNS)
customers=src['Customers Clean']; orders=src['Orders Clean'];items=src['Order Items Clean'];payments=src['Payments Clean'];rest=src['Restaurants Clean'];delivery=src['Delivery']
rr=[]
add=lambda cid,lev,s,q,exp,actual,evid,ok,stage:rr.append(validation_record(cid,lev,s,q,exp,actual,evid,ok,stage))
forbidden=safe_schema_check(final)
add('V-01','Safe Data','final_integrated','Direct PII absent?','No direct PII',forbidden,'safe_schema_check(final_integrated)',len(set(forbidden)&DIRECT_PII_FIELDS)==0,'PL-02')
add('V-02','Safe Data','final_integrated','Raw customer_id absent?','customer_id absent','customer_id' in final.columns,'final.columns','customer_id' not in final.columns,'PL-02')
rehash=customers.customer_id.map(lambda x:deterministic_hash(x,salt,variant_id))
stable=rehash.equals(cs.customer_key.reset_index(drop=True))
add('V-03','Safe Data','customer_key','Same input/salt same key?','identical on recompute',stable,'deterministic_hash + source IDs',stable,'PL-02')
unmatched=fk_unmatched_count(osafe,cs,'customer_key','customer_key')
add('V-04','Safe Data','Customers/Orders','Safe customer relation valid?','unmatched=0',unmatched,'fk_unmatched_count',unmatched==0 and cs.customer_key.is_unique,'PL-02')
add('V-05','Grain','final_integrated','Final rows match Orders?','equal rows',f'{len(final)}/{len(orders)}','final_integrated + orders_pm1',len(final)==len(orders),'PL-06')
grain=aggregate_grain_check(final)
add('V-06','Grain','final_integrated','order_id unique and non-null?','duplicate=0 / missing=0',grain,'aggregate_grain_check',grain['valid'],'PL-06')
ig=aggregate_grain_check(iagg)
expected_item_ids=items.order_id.nunique()
item_ok=ig['valid'] and len(iagg)==expected_item_ids and int(iagg.item_count.sum())==len(items) and np.isclose(iagg.items_subtotal.sum(),pd.to_numeric(items.line_amount).sum())
add('V-07','Aggregation','Item Aggregate','1 row/order and conserved?','unique & item totals preserved',f'agg={len(iagg)}, unique source={expected_item_ids}, items={int(iagg.item_count.sum())}','item_agg + aggregate_grain_check',item_ok,'PL-03')
pg=aggregate_grain_check(pagg)
pay_ok=pg['valid'] and int(pagg.payment_attempt_count.sum())==len(payments) and len(pagg)==payments.order_id.nunique()
add('V-08','Aggregation','Payment Aggregate','One row/order; attempts preserved?','unique & attempt count preserved',f'attempts={int(pagg.payment_attempt_count.sum())}/{len(payments)}','payment_agg + aggregate_grain_check',pay_ok,'PL-04')
recomputed_success=payments.loc[payments.payment_status.eq('successful')].payment_amount.sum()
recomputed_refund=payments.loc[payments.payment_status.eq('refunded')].payment_amount.sum()
sums_ok=(np.isclose(pagg.successful_payment_amount.sum(),recomputed_success) and np.isclose(pagg.refunded_payment_amount.sum(),recomputed_refund)
and np.allclose(pagg.net_payment_amount,pagg.successful_payment_amount-pagg.refunded_payment_amount)
and (pagg.net_payment_amount>=0).all())
# V-09 juga memeriksa setiap order. Total global yang sama tidak cukup:
# kesalahan yang saling mengimbangi antar-order tetap harus terdeteksi.
raw_money=payments.copy(deep=True)
raw_money['_successful']=np.where(raw_money.payment_status.eq('successful'),raw_money.payment_amount,0)
raw_money['_refunded']=np.where(raw_money.payment_status.eq('refunded'),raw_money.payment_amount,0)
expected_money=raw_money.groupby('order_id',as_index=False).agg(
expected_successful=('_successful','sum'), expected_refunded=('_refunded','sum'))
money_check=expected_money.merge(
pagg[['order_id','successful_payment_amount','refunded_payment_amount','net_payment_amount']],
on='order_id', how='outer', indicator=True, validate='one_to_one')
per_order_ok=bool(
money_check['_merge'].eq('both').all() and
np.isclose(money_check.expected_successful,money_check.successful_payment_amount).all() and
np.isclose(money_check.expected_refunded,money_check.refunded_payment_amount).all() and
np.isclose(money_check.net_payment_amount,
money_check.expected_successful-money_check.expected_refunded).all())
sums_ok=bool(sums_ok and per_order_ok)
add('V-09','Payment Logic','Payment Aggregate','Failed excluded/refund correct?','successful-refunded per order; failed excluded',
f'success={recomputed_success}, refund={recomputed_refund}, per_order_match={per_order_ok}',
'payment_agg vs payments_clean (per-order reconciliation)',sums_ok,'PL-04')
add('V-10','Relationship','Safe Customers','Orders customer unmatched?','unmatched=0',unmatched,'safe relationship check',unmatched==0,'PL-06')
unrest=fk_unmatched_count(orders,rest,'restaurant_id','restaurant_id')
add('V-11','Relationship','Restaurants','Orders restaurant unmatched?','unmatched=0',unrest,'fk_unmatched_count',unrest==0,'PL-06')
item_left=int((~orders.order_id.isin(set(iagg.order_id))).sum());item_audit=audit.loc[audit.step.eq('Item Aggregate')].iloc[0]
add('V-12','Relationship','Item Aggregate','No fan-out and item coverage?','same rows; item coverage=100%',f'left_unmatched={item_left}, row_change={item_audit.row_change}','integration_audit_df',item_left==0 and item_audit.row_change==0,'PL-06')
pay_left=int((~orders.order_id.isin(set(pagg.order_id))).sum());pay_audit=audit.loc[audit.step.eq('Payment Aggregate')].iloc[0]
add('V-13','Relationship','Payment Aggregate','No fan-out and payment coverage?','same rows; payments covered',f'left_unmatched={pay_left}, row_change={pay_audit.row_change}','integration_audit_df',pay_left==0 and pay_audit.row_change==0,'PL-06')
delivery_unmatched=int((~delivery.order_id.isin(set(orders.order_id))).sum());dg=aggregate_grain_check(dfeat)
del_audit=audit.loc[audit.step.eq('Delivery Features')].iloc[0]
add('V-14','Relationship','Delivery','Delivery valid 0..1/order?','key unique; no orphan; no fanout',f'delivery_orphan={delivery_unmatched}, delivery_rows={len(dfeat)}, row_change={del_audit.row_change}','delivery key + integration_audit_df',dg['valid'] and delivery_unmatched==0 and del_audit.row_change==0,'PL-06')
lc=delivery_lifecycle_check(dfeat,orders)
add('V-15','Delivery','Delivery lifecycle','Timestamp lifecycle valid?','all issue counts=0',lc,'delivery_lifecycle_check',all(int(v)==0 for v in lc.values()),'PL-05')
delivered=dfeat.delivery_status.eq('delivered')
expected_actual=(dfeat.delivered_at-dfeat.assigned_at).dt.total_seconds().div(60)
actual_ok=np.allclose(dfeat.loc[delivered,'actual_delivery_minutes'].astype(float),expected_actual.loc[delivered].astype(float),equal_nan=False)
delay_ok=np.allclose(dfeat.loc[delivered,'delay_minutes'].astype(float),
(expected_actual-dfeat.promised_delivery_minutes).loc[delivered].astype(float),equal_nan=False)
late_ok=bool((dfeat.loc[delivered,'is_late'].astype(bool).to_numpy()==(dfeat.loc[delivered,'delay_minutes']>0).to_numpy()).all())
add('V-16','Delivery','Delivery features','Actual/delay/is_late correct?','formulas match',f'checked_delivered={int(delivered.sum())}, formula_matches={actual_ok and delay_ok and late_ok}','delivery_features + formula reconciliation',actual_ok and delay_ok and late_ok,'PL-05')
non_delivered=~delivered
null_ok=bool(dfeat.loc[non_delivered,['actual_delivery_minutes','delay_minutes','is_late']].isna().all().all())
add('V-17','Delivery','Cancelled/incomplete','Three outcome fields null?','all null',f'non_delivered={int(non_delivered.sum())}, all_null={null_ok}','delivery_features null check',null_ok,'PL-05')
return pd.DataFrame(rr,columns=VALIDATION_COLUMNS)
core_validation_df=(run_core_validations(pm2_sources,customers_safe,orders_safe,item_agg,payment_agg,delivery_features,final_integrated,integration_audit_df,VARIANT_ID,CONTROLLED_SALT)
if RUN_READY else pd.DataFrame(columns=VALIDATION_COLUMNS))
if not core_validation_df.empty:
display(core_validation_df[['check_id','validation_question','actual_result_metric','evidence_output','status']])
print('CORE VALIDATION:',core_validation_df.status.value_counts().to_dict())
else: print('CORE VALIDATION: PENDING — tunggu input/salt lengkap')
| check_id | validation_question | actual_result_metric | evidence_output | status | |
|---|---|---|---|---|---|
| 0 | V-01 | Direct PII absent? | [] | safe_schema_check(final_integrated) | PASS |
| 1 | V-02 | Raw customer_id absent? | False | final.columns | PASS |
| 2 | V-03 | Same input/salt same key? | True | deterministic_hash + source IDs | PASS |
| 3 | V-04 | Safe customer relation valid? | 0 | fk_unmatched_count | PASS |
| 4 | V-05 | Final rows match Orders? | 324/324 | final_integrated + orders_pm1 | PASS |
| 5 | V-06 | order_id unique and non-null? | {'rows': 324, 'unique_key_count': 324, 'duplic... | aggregate_grain_check | PASS |
| 6 | V-07 | 1 row/order and conserved? | agg=324, unique source=324, items=822 | item_agg + aggregate_grain_check | PASS |
| 7 | V-08 | One row/order; attempts preserved? | attempts=370/370 | payment_agg + aggregate_grain_check | PASS |
| 8 | V-09 | Failed excluded/refund correct? | success=40958000, refund=1109000, per_order_ma... | payment_agg vs payments_clean (per-order recon... | PASS |
| 9 | V-10 | Orders customer unmatched? | 0 | safe relationship check | PASS |
| 10 | V-11 | Orders restaurant unmatched? | 0 | fk_unmatched_count | PASS |
| 11 | V-12 | No fan-out and item coverage? | left_unmatched=0, row_change=0 | integration_audit_df | PASS |
| 12 | V-13 | No fan-out and payment coverage? | left_unmatched=0, row_change=0 | integration_audit_df | PASS |
| 13 | V-14 | Delivery valid 0..1/order? | delivery_orphan=0, delivery_rows=311, row_chan... | delivery key + integration_audit_df | PASS |
| 14 | V-15 | Timestamp lifecycle valid? | {'invalid_status': 0, 'missing_delivered_times... | delivery_lifecycle_check | PASS |
| 15 | V-16 | Actual/delay/is_late correct? | checked_delivered=298, formula_matches=True | delivery_features + formula reconciliation | PASS |
| 16 | V-17 | Three outcome fields null? | non_delivered=13, all_null=True | delivery_features null check | PASS |
CORE VALIDATION: {'PASS': 17}
**BANTUAN SALIN KE WORKING PAPER** — Jalankan code cell berikut agar nilai yang perlu dicatat dan nomor baris Excel tampil dalam satu tabel. Tabel ini tidak mengisi file Excel otomatis; peserta tetap membaca dan mencatat hasilnya.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
# BANTUAN SALIN V-01–V-17 — sheet 03, baris 12–28
if not core_validation_df.empty:
wp_core_validation_copy_df = core_validation_df[['check_id','actual_result_metric','evidence_output','status']].copy()
wp_core_validation_copy_df.insert(0,'baris_excel',wp_core_validation_copy_df['check_id'].str[-2:].astype(int)+11)
display(wp_core_validation_copy_df)
print('SALIN: sheet 03 D=actual_result_metric, E=evidence_output, F=status, G=catatan bila gagal.')
else: print('BANTUAN VALIDASI: PENDING — jalankan pipeline lebih dulu.')
| baris_excel | check_id | actual_result_metric | evidence_output | status | |
|---|---|---|---|---|---|
| 0 | 12 | V-01 | [] | safe_schema_check(final_integrated) | PASS |
| 1 | 13 | V-02 | False | final.columns | PASS |
| 2 | 14 | V-03 | True | deterministic_hash + source IDs | PASS |
| 3 | 15 | V-04 | 0 | fk_unmatched_count | PASS |
| 4 | 16 | V-05 | 324/324 | final_integrated + orders_pm1 | PASS |
| 5 | 17 | V-06 | {'rows': 324, 'unique_key_count': 324, 'duplic... | aggregate_grain_check | PASS |
| 6 | 18 | V-07 | agg=324, unique source=324, items=822 | item_agg + aggregate_grain_check | PASS |
| 7 | 19 | V-08 | attempts=370/370 | payment_agg + aggregate_grain_check | PASS |
| 8 | 20 | V-09 | success=40958000, refund=1109000, per_order_ma... | payment_agg vs payments_clean (per-order recon... | PASS |
| 9 | 21 | V-10 | 0 | safe relationship check | PASS |
| 10 | 22 | V-11 | 0 | fk_unmatched_count | PASS |
| 11 | 23 | V-12 | left_unmatched=0, row_change=0 | integration_audit_df | PASS |
| 12 | 24 | V-13 | left_unmatched=0, row_change=0 | integration_audit_df | PASS |
| 13 | 25 | V-14 | delivery_orphan=0, delivery_rows=311, row_chan... | delivery key + integration_audit_df | PASS |
| 14 | 26 | V-15 | {'invalid_status': 0, 'missing_delivered_times... | delivery_lifecycle_check | PASS |
| 15 | 27 | V-16 | checked_delivered=298, formula_matches=True | delivery_features + formula reconciliation | PASS |
| 16 | 28 | V-17 | non_delivered=13, all_null=True | delivery_features null check | PASS |
SALIN: sheet 03 D=actual_result_metric, E=evidence_output, F=status, G=catatan bila gagal.
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
Tabel `core_validation_df` merupakan sumber resmi V-01–V-17. Jika FAIL, lihat `check_id`, `actual_result_metric`, dan `evidence_output`, lalu kembali ke tahap terkait. Jangan ganti status secara manual di kode.
**ISI WORKING PAPER BARU:** Isi `03_Validasi_dan_Keputusan!D12:G28` untuk V-01–V-17. D = actual_result_metric, E = evidence_output, F = status, G = catatan perbaikan jika perlu. Gunakan `wp_core_validation_copy_df` (memuat nomor baris Excel).
**PENJELASAN OUTPUT:** V-01–V-17 dipaparkan pada `core_validation_df`; salin *actual result*, *evidence*, dan *status* masing-masing, bukan hanya angka PASS keseluruhan. Baris Excel = nomor Check ID + 11.
**CHECKPOINT:** Jika data atau evidence belum sesuai, jangan menandai PASS di Working Paper. Perbaiki tahap yang disebutkan output dan jalankan ulang pemeriksaan.
**LANJUT:** Tahap 12.
**CONTOH PENGISIAN V-05 (ilustrasi, bukan SB-P01):** jika output menunjukkan `orders=30; final=30`, tuliskan `03_Validasi_dan_Keputusan!D16 = orders=30; final=30`, `E16 =` nama evidence yang muncul pada `validation_df.evidence_output`, dan `F16 = PASS` **hanya bila Notebook menampilkan PASS**. Jika FAIL, isi F=`FAIL` dan jelaskan langkah perbaikan pada G; jangan menebak angkanya.
---
## TAHAP 12 — Reproducibility — Tiga Controlled Runs
**CASE — Situasi SwiftBite:** Proses yang bergantung pada manual edit belum dapat dipakai ulang oleh tim Analytics.
**TUJUAN:** Menjalankan pipeline tiga kali dari input asal yang sama dan membandingkan signature.
**PAHAMI ISTILAH:** controlled run = input/parameter sama; signature = fingerprint hasil; reproducible = hasil konsisten tanpa edit di tengah.
**WORKING PAPER BARU:** Isi `02_Integrasi_dan_Rerun!B29:H33` (parameter, jangan tulis nilai salt), `B38:H40` (3 controlled runs), kesimpulan `A43:H45`. V-18 dan V-19 di `03_Validasi_dan_Keputusan!D29:G30`, berdasarkan `wp_rerun_validation_copy_df`.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**LIHAT CONTOH:** RUN-01, RUN-02, RUN-03 masing-masing final_rows=N (N adalah Orders pada varianmu), 17/17 core PASS, signature sama.
**COBA:** jalankan fungsi pipeline di bawah. Fungsi harus memakai input asli (salinan data untuk tiap run) dan tidak menyunting DataFrame di tengah. Tiga run dijalankan dari file yang sama; jangan ubah salt atau identitas.
**Catatan:** signature dibandingkan sesudah mengurutkan baris dengan `order_id` dan kolom secara stabil. Ini menghindari perbedaan akibat urutan tampilan saja.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
def dataframe_signature(df):
if df is None: return None
if 'order_id' not in df: raise ValueError('SIGNATURE: final data harus punya order_id')
normalized=df.reindex(sorted(df.columns),axis=1).sort_values('order_id',kind='stable').reset_index(drop=True)
for c in normalized.columns:
if pd.api.types.is_datetime64_any_dtype(normalized[c]):
normalized[c]=normalized[c].dt.strftime('%Y-%m-%dT%H:%M:%S.%f')
payload=normalized.to_csv(index=False,na_rep='<NULL>',float_format='%.12g',lineterminator='\n').encode('utf-8')
return hashlib.sha256(payload).hexdigest()
def source_input_signature(dataframes):
# Fingerprint deterministik isi 6 input, diperiksa sebelum dan sesudah pipeline.
h=hashlib.sha256()
for name,df in sorted(dataframes.items()):
h.update(name.encode('utf-8'))
h.update(str(tuple(df.columns)).encode('utf-8'))
h.update(str(tuple(str(d) for d in df.dtypes)).encode('utf-8'))
h.update(df.to_csv(index=False,na_rep='<NULL>',float_format='%.12g',lineterminator='\n').encode('utf-8'))
return h.hexdigest()
def run_pm2_pipeline(customers_input,orders_input,order_items_input,payments_input,restaurants_input,delivery_input,controlled_salt,variant_id):
originals={'Customers Clean':customers_input,'Orders Clean':orders_input,
'Order Items Clean':order_items_input,'Payments Clean':payments_input,
'Restaurants Clean':restaurants_input,'Delivery':delivery_input}
original_sig_before=source_input_signature(originals)
src={'Customers Clean':customers_input.copy(deep=True),'Orders Clean':orders_input.copy(deep=True),
'Order Items Clean':order_items_input.copy(deep=True),'Payments Clean':payments_input.copy(deep=True),
'Restaurants Clean':restaurants_input.copy(deep=True),'Delivery':delivery_input.copy(deep=True)}
cs,osafe=build_safe_customer_data(src['Customers Clean'],src['Orders Clean'],controlled_salt,variant_id)
ia=build_item_aggregate(src['Order Items Clean'])
pa=build_payment_aggregate(src['Payments Clean'])
df=derive_delivery_features(src['Delivery'])
final,audit=build_integrated(osafe,cs,src['Restaurants Clean'],ia,pa,df)
val=run_core_validations(src,cs,osafe,ia,pa,df,final,audit,variant_id,controlled_salt)
original_sig_after=source_input_signature(originals)
input_unchanged=(original_sig_before==original_sig_after)
if not input_unchanged:
raise ValueError('RERUN INPUT FAIL — input sources berubah selama pipeline berjalan')
return {'final_integrated':final,'integration_audit':audit,'core_validation':val,
'run_summary':{'final_rows':len(final),'unique_order_id':int(final.order_id.nunique()),
'core_pass_count':int(val.status.eq('PASS').sum()),'manual_intervention':not input_unchanged,'input_signature':original_sig_before,
'output_signature':dataframe_signature(final)}}
pipeline_runs=[]; rerun_summary_df=pd.DataFrame(); rerun_validation_df=pd.DataFrame(columns=VALIDATION_COLUMNS)
if RUN_READY:
args=[pm2_sources[k] for k in ['Customers Clean','Orders Clean','Order Items Clean','Payments Clean','Restaurants Clean','Delivery']]
for j in range(1,4):
result=run_pm2_pipeline(*args,CONTROLLED_SALT,VARIANT_ID)
pipeline_runs.append(result)
rerun_summary_df=pd.DataFrame([{'run_id':f'RUN-{i:02d}',**res['run_summary']} for i,res in enumerate(pipeline_runs,1)])
signatures_same=rerun_summary_df.output_signature.nunique()==1
inputs_same=rerun_summary_df.input_signature.nunique()==1
rowcounts_same=rerun_summary_df.final_rows.nunique()==1 and rerun_summary_df.unique_order_id.nunique()==1
core_all_pass=bool((rerun_summary_df.core_pass_count==17).all() and all(x['core_validation'].status.eq('PASS').all() for x in pipeline_runs))
no_manual=bool((~rerun_summary_df.manual_intervention).all() and inputs_same)
r18=validation_record('V-18','Reproducibility','Pipeline rerun','No manual intervention?','3 fresh reruns no manual intervention',
f'runs={len(pipeline_runs)}, source_hashes_identical={inputs_same}, input_unchanged={no_manual}','rerun_summary_df',len(pipeline_runs)==3 and no_manual and core_all_pass,'PL-07')
r19=validation_record('V-19','Reproducibility','Output signature','Signatures and counts identical?','same counts and SHA256 across runs',
f'rows_consistent={rowcounts_same}, signature_consistent={signatures_same}','rerun_summary_df',signatures_same and rowcounts_same and core_all_pass,'PL-07')
rerun_validation_df=pd.DataFrame([r18,r19],columns=VALIDATION_COLUMNS)
display(rerun_summary_df.assign(output_signature=rerun_summary_df.output_signature.str.slice(0,16)+'…'))
display(rerun_validation_df[['check_id','actual_result_metric','status']])
# PS-03: rerun customer key check is also covered by same-salt signed output
else: print('RERUN: PENDING — lengkapi input/identitas/salt')
| run_id | final_rows | unique_order_id | core_pass_count | manual_intervention | input_signature | output_signature | |
|---|---|---|---|---|---|---|---|
| 0 | RUN-01 | 324 | 324 | 17 | False | e1894be892226cfd4a4d2309e022258ff6f6ac6963091b... | b0fa3ab3de1fec96… |
| 1 | RUN-02 | 324 | 324 | 17 | False | e1894be892226cfd4a4d2309e022258ff6f6ac6963091b... | b0fa3ab3de1fec96… |
| 2 | RUN-03 | 324 | 324 | 17 | False | e1894be892226cfd4a4d2309e022258ff6f6ac6963091b... | b0fa3ab3de1fec96… |
| check_id | actual_result_metric | status | |
|---|---|---|---|
| 0 | V-18 | runs=3, source_hashes_identical=True, input_un... | PASS |
| 1 | V-19 | rows_consistent=True, signature_consistent=True | PASS |
**BANTUAN SALIN KE WORKING PAPER** — Jalankan code cell berikut agar nilai yang perlu dicatat dan nomor baris Excel tampil dalam satu tabel. Tabel ini tidak mengisi file Excel otomatis; peserta tetap membaca dan mencatat hasilnya.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
# BANTUAN SALIN RUN DAN V-18/V-19 — sheet 02 dan sheet 03
if not rerun_summary_df.empty:
wp_rerun_copy_df = rerun_summary_df[['run_id','final_rows','unique_order_id','core_pass_count','manual_intervention','output_signature']].copy()
wp_rerun_copy_df.insert(0,'baris_excel',range(38,41))
display(wp_rerun_copy_df)
print('SALIN ke sheet 02 baris 38–40. Kolom E: manual_intervention=False berarti TIDAK.')
if not rerun_validation_df.empty:
wp_rerun_validation_copy_df = rerun_validation_df[['check_id','actual_result_metric','evidence_output','status']].copy()
wp_rerun_validation_copy_df.insert(0,'baris_excel',[29,30])
display(wp_rerun_validation_copy_df)
print('SALIN V-18/V-19 ke sheet 03 baris 29–30, D=actual, E=evidence, F=status.')
| baris_excel | run_id | final_rows | unique_order_id | core_pass_count | manual_intervention | output_signature | |
|---|---|---|---|---|---|---|---|
| 0 | 38 | RUN-01 | 324 | 324 | 17 | False | b0fa3ab3de1fec96548018aa69415cc194ec9eea097140... |
| 1 | 39 | RUN-02 | 324 | 324 | 17 | False | b0fa3ab3de1fec96548018aa69415cc194ec9eea097140... |
| 2 | 40 | RUN-03 | 324 | 324 | 17 | False | b0fa3ab3de1fec96548018aa69415cc194ec9eea097140... |
SALIN ke sheet 02 baris 38–40. Kolom E: manual_intervention=False berarti TIDAK.
| baris_excel | check_id | actual_result_metric | evidence_output | status | |
|---|---|---|---|---|---|
| 0 | 29 | V-18 | runs=3, source_hashes_identical=True, input_un... | rerun_summary_df | PASS |
| 1 | 30 | V-19 | rows_consistent=True, signature_consistent=True | rerun_summary_df | PASS |
SALIN V-18/V-19 ke sheet 03 baris 29–30, D=actual, E=evidence, F=status.
# Cetak isi lengkap V-18 & V-19 untuk Sheet 03 (Baris 29–30)
print("\n=== DETAIL LENGKAP V-18 & V-19 SHEET 03 (Baris 29-30) ===")
for r in rerun_validation_df.itertuples():
print(f"{r.check_id} | D: {r.actual_result_metric} | E: {r.evidence_output}")
=== DETAIL LENGKAP V-18 & V-19 SHEET 03 (Baris 29-30) === V-18 | D: runs=3, source_hashes_identical=True, input_unchanged=True | E: rerun_summary_df V-19 | D: rows_consistent=True, signature_consistent=True | E: rerun_summary_df
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
Setiap run harus mencatat final rows, unique order_id, 17 core checks, manual intervention, signature. Jangan menghitung 19 checks dalam setiap run: V-18 dan V-19 baru dibuat **setelah** membandingkan ketiganya.
**ISI WORKING PAPER BARU:** Isi `02_Integrasi_dan_Rerun!B29:H33` (parameter, jangan tulis nilai salt), `B38:H40` (3 controlled runs), kesimpulan `A43:H45`. V-18 dan V-19 di `03_Validasi_dan_Keputusan!D29:G30`, berdasarkan `wp_rerun_validation_copy_df`.
**PENJELASAN OUTPUT:** Setiap `rerun_summary_df` memuat final_rows, unique_order_id, `core_pass_count` (target 17), `manual_intervention` dan signature. V-18/V-19 dihitung setelah membandingkan tiga run, bukan di setiap run.
**CHECKPOINT:** Jika data atau evidence belum sesuai, jangan menandai PASS di Working Paper. Perbaiki tahap yang disebutkan output dan jalankan ulang pemeriksaan.
**LANJUT:** Tahap 13.
**Bukti tambahan V-18:** tiga rerun juga membandingkan fingerprint isi enam input sebelum dan sesudah pemrosesan serta antar-run. Ini menguji bahwa fungsi tidak mengubah input dan bahwa input antar-rerun konsisten. Pemeriksaan otomatis tidak dapat membuktikan seluruh aktivitas manual di luar Notebook; peserta tetap wajib menyatakan perubahan yang dilakukan secara jujur.
**CONTOH RERUN:** ketiga run sama-sama 30 baris/30 order unik, 17 core checks PASS, signature sama, edit manual=TIDAK. Catat tiap run pada baris 38–40 sheet 02. **Jangan ubah salt** dan jangan mengubah input saat tiga run berjalan. Jika Notebook dibuka ulang di hari lain, pakai secret yang sama untuk menjaga `customer_key` stabil.
---
## TAHAP 13 — Final Pipeline Readiness Gate
**CASE — Situasi SwiftBite:** Tim Analytics hanya menerima final analytical dataset jika semua pemeriksaan wajib memiliki bukti dan input benar-benar dari varian yang terverifikasi.
**TUJUAN:** Memutuskan PASS/NOT READY/PENDING tanpa false PASS.
**PAHAMI ISTILAH:** gate = aturan keputusan; PENDING = belum lengkap; NOT READY = FAIL kritis; PASS = semua syarat terpenuhi.
**WORKING PAPER BARU:** Isi `03_Validasi_dan_Keputusan!D33` persis sama dengan `PM2_FINAL_GATE`. B33 mengambil Variant Check secara otomatis; F33:G33 memberi peringatan administrasi. Tulis alasan pada `A36:G39` dan masalah pada `A42:G44`.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**PAHAMI:** Final Gate memeriksa 19 validation checks yang lengkap dan didukung evidence, serta input check teknis. Jika seluruhnya PASS, `PM2_FINAL_GATE=PASS`. Jika ada critical validation FAIL, status `NOT READY`. Jika evidence belum lengkap, status `PENDING`.
**PENTING:** Final Gate bersifat **kesiapan teknis pipeline**, bukan bukti independen bahwa peserta telah menerima paket varian yang benar. Kecocokan varian diverifikasi admin dari Handoff Tracker, tanpa file tambahan bagi peserta.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
def derive_pm2_final_gate(df,source_status='PENDING',verified_validation=None):
if source_status=='FAIL': return 'NOT READY'
if df is None or len(df)==0: return 'PENDING'
must={'check_id','status','actual_result_metric','evidence_output'}
if must-set(df.columns): return 'PENDING'
# Gate menerima bukti yang sama dengan pemeriksaan ulang dari data aktual.
if verified_validation is None or not df.equals(verified_validation): return 'PENDING'
ids=df.check_id.astype(str)
if len(df)!=19 or ids.nunique()!=19 or set(ids)!=set(REQUIRED_IDS): return 'PENDING'
status=df.status.astype(str).str.upper()
if not status.isin(['PASS','FAIL','PENDING']).all(): return 'PENDING'
if status.eq('FAIL').any(): return 'NOT READY'
evidence_complete=bool(df[['actual_result_metric','evidence_output']].apply(
lambda col: col.notna() & col.astype(str).str.strip().ne('')).all().all())
if not evidence_complete or not status.eq('PASS').all() or source_status!='PASS': return 'PENDING'
return 'PASS'
validation_df=pd.concat([core_validation_df,rerun_validation_df],ignore_index=True)
verified_core_validation=(run_core_validations(pm2_sources,customers_safe,orders_safe,item_agg,
payment_agg,delivery_features,final_integrated,integration_audit_df,VARIANT_ID,CONTROLLED_SALT)
if RUN_READY else pd.DataFrame(columns=VALIDATION_COLUMNS))
verified_validation_df=pd.concat([verified_core_validation,rerun_validation_df],ignore_index=True)
PM2_FINAL_GATE=derive_pm2_final_gate(validation_df,input_check_result.get('status'),
verified_validation=verified_validation_df)
print('VALIDATION STATUS:',validation_df.status.value_counts().to_dict() if not validation_df.empty else {})
print('SOURCE CHECK:',input_check_result.get('status'),'|',input_check_result.get('reason'))
print('PM2 PIPELINE READINESS GATE:',PM2_FINAL_GATE)
print('CATATAN: kecocokan paket dengan Variant ID diverifikasi admin melalui Handoff Tracker.')
if PM2_FINAL_GATE=='PENDING': print('ACTION: lengkapi seluruh input/evidence serta check IDs yang masih PENDING.')
elif PM2_FINAL_GATE=='NOT READY': print('ACTION: kembali ke tahap yang FAIL, perbaiki dan rerun.')
else: print('ACTION: siap final export, lalu verifikasi hasil.')
FINAL_JUDGMENT_RATIONALE=(f'{len(validation_df)} checks recorded, '+
f"{int(validation_df.status.eq('PASS').sum()) if not validation_df.empty else 0} PASS; "+
f'Input technical check={input_check_result.get("status")}; final gate={PM2_FINAL_GATE}. '+
('Semua syarat teknis final tervalidasi; identitas varian diperiksa admin.' if PM2_FINAL_GATE=='PASS' else 'Catat issue dan follow-up sesuai output.'))
print('Rationale draft:',FINAL_JUDGMENT_RATIONALE)
VALIDATION STATUS: {'PASS': 19}
SOURCE CHECK: PASS | Enam file berhasil dibaca; kolom wajib tersedia. Kesesuaian paket dengan varian peserta tetap dikontrol admin melalui Handoff Tracker.
PM2 PIPELINE READINESS GATE: PASS
CATATAN: kecocokan paket dengan Variant ID diverifikasi admin melalui Handoff Tracker.
ACTION: siap final export, lalu verifikasi hasil.
Rationale draft: 19 checks recorded, 19 PASS; Input technical check=PASS; final gate=PASS. Semua syarat teknis final tervalidasi; identitas varian diperiksa admin.
**BANTUAN SALIN KE WORKING PAPER** — Jalankan code cell berikut agar nilai yang perlu dicatat dan nomor baris Excel tampil dalam satu tabel. Tabel ini tidak mengisi file Excel otomatis; peserta tetap membaca dan mencatat hasilnya.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
# RINGKASAN UNTUK SHEET 03 — FINAL JUDGMENT
print('Sheet 03 B33 (otomatis dari sheet 01) =',input_check_result.get('status'))
print('Sheet 03 D33 (isi peserta) =',PM2_FINAL_GATE)
print('Tulis alasan 2–4 kalimat di A36:G39, keterbatasan di A42:G44.')
print('Pencocokan Variant ID dan paket data ditangani admin melalui Handoff Tracker.')
Sheet 03 B33 (otomatis dari sheet 01) = PASS Sheet 03 D33 (isi peserta) = PASS Tulis alasan 2–4 kalimat di A36:G39, keterbatasan di A42:G44. Pencocokan Variant ID dan paket data ditangani admin melalui Handoff Tracker.
**BACA OUTPUT → INTERPRETASI → JUDGMENT → ISI WORKING PAPER**
Baca `PM2_FINAL_GATE`. PASS hanya jika 19 checks lengkap/unik, evidence lengkap, seluruh status PASS, dan enam input lulus source check. PENDING berarti pemeriksaan atau bukti belum lengkap; NOT READY berarti critical FAIL.
**ISI WORKING PAPER:** Isi `03_Validasi_dan_Keputusan!D33` persis seperti `PM2_FINAL_GATE`. B33 otomatis mengambil Source Check dari sheet 01. Tulis alasan di `A36:G39` dan masalah di `A42:G44`.
**BATASAN:** `SOURCE CHECK=PASS` membuktikan kesiapan input teknis, bukan bahwa input secara administratif cocok dengan Variant ID. Admin memeriksa Handoff Tracker sebelum menerima pengumpulan peserta.
**CHECKPOINT:** Periksa evidence dan keputusan sebelum lanjut ke export.
**LANJUT:** Tahap 14.
**CONTOH MENULIS JUDGMENT (ilustrasi):** "Final Gate PASS karena 19 validation checks lengkap dan PASS. Lima join tidak menambah baris order; tiga rerun memiliki signature sama. Saya tidak mengubah input di tengah proses." Ubah alasan sesuai bukti aktualmu. Jika gate PENDING/NOT READY, jelaskan penyebab yang nyata, **jangan menyalin contoh PASS**.
---
## TAHAP 14 — Export Evidence & LMS Submission
**CASE — Situasi SwiftBite:** Mentor perlu memeriksa hasil yang dapat ditelusuri. File evidence boleh tersedia ketika pipeline PENDING, tetapi tidak boleh diklaim sebagai final approved dataset.
**TUJUAN:** Mengekspor dokumen teknis ke folder yang jelas serta memeriksa kelengkapan sebelum upload.
**PAHAMI ISTILAH:** export = menyimpan hasil; traceability = jejak bukti; approved output = data final yang memenuhi seluruh gate.
**WORKING PAPER BARU:** Cek seluruh sheet 01–03 lalu ikuti ketentuan LMS. Bukti hanya dikirim sesuai Participant Brief; jangan mengunggah raw source, PII, atau controlled salt.
> Ikuti cell dari atas ke bawah. Jalankan code cell dengan **Shift + Enter** atau tombol ▶ Run. *Markdown cell* adalah penjelasan yang tidak perlu dijalankan.
**PERHATIAN:** Output yang dibuat otomatis berbeda dari Working Paper yang harus kamu isi sendiri. Jangan upload raw dataset PM1, Delivery raw, atau salt kecuali admin LMS secara eksplisit meminta.
**COBA:** jalankan export. File evidence dapat diekspor walau gate belum PASS. `swiftbite_pm2_integrated_order_level.csv` **hanya** dibuat sebagai approved final output jika gate PASS. Jika run terbaru bukan PASS, Notebook akan **memindahkan CSV final dari run sebelumnya** ke folder arsip lokal (`outputs/pm2_swiftbite/_arsip_bukan_hasil_final/`), bukan menghapusnya. **Jangan masukkan file arsip ke LMS.**
**ISI WORKING PAPER BARU:** Setelah export, periksa `03_Validasi_dan_Keputusan!D33`, `A36:G39`, `A42:G44` dan kesimpulan rerun di `02_Integrasi_dan_Rerun!A43:H45`. Tidak ada lagi baris PL-08 khusus pada format Working Paper ringkas.
**LANGKAH SIMPAN TANPA:** setelah cell export selesai, buka Explorer/File Manager pada folder utama → `outputs/pm2_swiftbite/` untuk tiga evidence. Jika `PM2_FINAL_GATE=PASS`, cek juga `data/processed/pm2_swiftbite/swiftbite_pm2_integrated_order_level.csv`. Simpan Notebook dengan **Ctrl+S**, kemudian simpan Working Paper Excel. Ikuti petunjuk ZIP/upload pada LMS. **Jika gate belum PASS, jangan masukkan CSV final lama** meskipun pernah ada di folder dari percobaan sebelumnya.
# ▶ WAJIB JALANKAN — kode utama siap pakai; jangan ubah fungsi.
def export_pm2_evidence(audit,validation,summary,output_dir):
output_dir.mkdir(parents=True,exist_ok=True)
audit.to_csv(output_dir/'pm2_integration_audit.csv',index=False)
validation.to_csv(output_dir/'pm2_validation_results.csv',index=False)
(output_dir/'pm2_pipeline_readiness_summary.json').write_text(json.dumps(summary,ensure_ascii=False,indent=2,default=str),encoding='utf-8')
return [output_dir/'pm2_integration_audit.csv',output_dir/'pm2_validation_results.csv',output_dir/'pm2_pipeline_readiness_summary.json']
def archive_previous_unapproved_final(processed_dir, archive_root):
"""Amankan file final lama saat run TERBARU tidak PASS (tanpa menghapus evidence)."""
target = processed_dir / 'swiftbite_pm2_integrated_order_level.csv'
if not target.is_file():
return None
from datetime import datetime, timezone
archive_root.mkdir(parents=True, exist_ok=True)
stamp = datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S%fZ')
archived = archive_root / f'swiftbite_pm2_integrated_order_level_ARSIP_{stamp}.csv'
target.replace(archived)
print('FILE FINAL RUN LAMA DIPINDAHKAN KE ARSIP (BUKAN UNTUK LMS).')
print('Lokasi arsip:', archived)
return archived
def export_final_dataset(final_df,final_gate,processed_dir,archive_root):
if final_gate!='PASS':
archive_previous_unapproved_final(processed_dir, archive_root)
print('FINAL CSV NOT EXPORTED: gate bukan PASS. Tidak ada CSV approved di folder final.')
return None
if final_df is None or final_df.empty:
raise ValueError('FINAL EXPORT: final dataset kosong')
if safe_schema_check(final_df):
raise ValueError('FINAL EXPORT: ada PII atau raw customer ID')
processed_dir.mkdir(parents=True,exist_ok=True)
target=processed_dir/'swiftbite_pm2_integrated_order_level.csv'
# Simpan ke temp file dulu agar export yang gagal tidak merusak CSV sebelumnya.
import tempfile
tmp_path = None
try:
with tempfile.NamedTemporaryFile(mode='w', encoding='utf-8', newline='',
suffix='.csv', prefix='.pm2_export_',
dir=processed_dir, delete=False) as handle:
tmp_path = Path(handle.name)
final_df.to_csv(handle, index=False)
os.replace(tmp_path, target)
finally:
if tmp_path is not None and tmp_path.exists():
tmp_path.unlink()
return target
if not validation_df.empty:
summary={'participant_name':PARTICIPANT_NAME,'variant_id':VARIANT_ID,'input_check_status':input_check_result.get('status'),
'variant_handoff_control':'ADMIN_HANDOFF_TRACKER','pm2_final_gate':PM2_FINAL_GATE,
'validation_pass_count':int(validation_df.status.eq('PASS').sum()),
'validation_fail_count':int(validation_df.status.eq('FAIL').sum()),
'rationale':FINAL_JUDGMENT_RATIONALE,
'output_signature':dataframe_signature(final_integrated) if final_integrated is not None else None}
final_path=export_final_dataset(final_integrated,PM2_FINAL_GATE,PM2_PROCESSED_DIR,PM2_OUTPUT_DIR/'_arsip_bukan_hasil_final')
summary['final_dataset_export_status'] = 'APPROVED' if final_path else 'NOT_EXPORTED'
evidence_paths=export_pm2_evidence(integration_audit_df,validation_df,summary,PM2_OUTPUT_DIR)
print('EVIDENCE EXPORTED:')
for path in evidence_paths: print(' -',path)
print('FINAL DATASET:', final_path or 'Not exported (PENDING/NOT READY)')
else:
archive_previous_unapproved_final(PM2_PROCESSED_DIR,PM2_OUTPUT_DIR/'_arsip_bukan_hasil_final')
print('EXPORT: PENDING — validation belum tersedia. CSV final lama (jika ada) dipindahkan ke arsip.')
EVIDENCE EXPORTED: - C:\Users\DataAnalysProjects\Bootcamp_Data_Analyst_Workspace_Starter\Bootcamp_Data_Analyst\outputs\pm2_swiftbite\pm2_integration_audit.csv - C:\Users\DataAnalysProjects\Bootcamp_Data_Analyst_Workspace_Starter\Bootcamp_Data_Analyst\outputs\pm2_swiftbite\pm2_validation_results.csv - C:\Users\DataAnalysProjects\Bootcamp_Data_Analyst_Workspace_Starter\Bootcamp_Data_Analyst\outputs\pm2_swiftbite\pm2_pipeline_readiness_summary.json FINAL DATASET: C:\Users\DataAnalysProjects\Bootcamp_Data_Analyst_Workspace_Starter\Bootcamp_Data_Analyst\data\processed\pm2_swiftbite\swiftbite_pm2_integrated_order_level.csv
- [ ] Kelima clean file adalah **hasil PM1 varian saya**, bukan raw data dan bukan contoh SB-P01 milik mentor.
- [ ] Delivery sesuai Variant ID yang diterima dari admin; kecocokan paket dikontrol melalui Handoff Tracker (tanpa file kontrol tambahan).
- [ ] Safe data tidak mempunyai direct PII atau raw customer_id.
- [ ] Item dan Payment aggregation memenuhi grain; payment attempts sah tetap diperhitungkan.
- [ ] Delivery cancelled/incomplete mempunyai tiga derived outcomes **null**.
- [ ] Lima staged joins tidak menyebabkan fan-out; final rows = Orders milik saya.
- [ ] V-01–V-19 lengkap dan mempunyai angka aktual, evidence, serta status pada Working Paper.
- [ ] RUN-01–RUN-03 konsisten dan tercatat pada Working Paper.
- [ ] Gate final adalah PASS sebelum menyerahkan final approved dataset; jika PENDING/NOT READY, tulis alasan dan konsultasikan sesuai instruksi LMS.
- [ ] Saya sudah memeriksa folder `outputs/pm2_swiftbite/` dan `data/processed/pm2_swiftbite/`.
- [ ] Saya hanya mengunggah output yang **diminta Participant Brief/LMS**, tanpa file rahasia atau PII, **tanpa folder `utils/`, dan tanpa file dari `_arsip_bukan_hasil_final/`**.
**Selesai.** Jika ada perbedaan jumlah baris terhadap contoh, itu **normal** selama kriteria setiap varian terpenuhi. Jangan memaksa angka seperti SB-P01.
**ISI WORKING PAPER BARU:** Cek seluruh sheet 01–03 lalu ikuti ketentuan LMS. Bukti hanya dikirim sesuai Participant Brief; jangan mengunggah raw source, PII, atau controlled salt.
**PENJELASAN OUTPUT:** Periksa bahwa lima clean PM1 dan Delivery tidak diubah, evidence tersedia, Working Paper lengkap, dan hanya file yang diminta LMS disubmit. Jika PENDING/NOT READY, dokumentasikan blocker dan konsultasikan ke mentor.
**CHECKPOINT:** Jika data atau evidence belum sesuai, jangan menandai PASS di Working Paper. Perbaiki tahap yang disebutkan output dan jalankan ulang pemeriksaan.
**LANJUT:** Selesai, cek daftar upload LMS.
**Ingat:** Code cell berlabel ★ LATIHAN OPSIONAL tidak wajib dijalankan. Jika Tahap 14 menampilkan PENDING/NOT READY, jangan mengumpulkan CSV final dari arsip.