# 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 = "Nurnia"   # GANTI dengan nama lengkapmu
VARIANT_ID = "SB-P06"             # 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-P06
Workspace: C:\Users\User\Downloads\Bootcamp_Data_Analyst_Workspace_Starter\Bootcamp_Data_Analyst
WORKSPACE CHECK: PASS — folder data/ dan notebooks/ ditemukan
Workspace location mode: AUTO DETECTED
pandas: 2.2.3 | 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-P06 | pencocokan varian dilakukan admin melalui Handoff Tracker
dataset filename file_path exists
0 Customers Clean customers_clean.csv C:\Users\User\Downloads\Bootcamp_Data_Analyst_... True
1 Orders Clean orders_clean.csv C:\Users\User\Downloads\Bootcamp_Data_Analyst_... True
2 Order Items Clean order_items_clean.csv C:\Users\User\Downloads\Bootcamp_Data_Analyst_... True
3 Payments Clean payments_clean.csv C:\Users\User\Downloads\Bootcamp_Data_Analyst_... True
4 Restaurants Clean restaurants_clean.csv C:\Users\User\Downloads\Bootcamp_Data_Analyst_... True
5 Delivery swiftbite_delivery.json C:\Users\User\Downloads\Bootcamp_Data_Analyst_... 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 158 7 customer_id 1 row/customer
1 Orders Clean 330 10 order_id 1 row/order
2 Order Items Clean 872 9 order_item_id 1 row/order item
3 Payments Clean 374 7 payment_id 1 row/payment record
4 Restaurants Clean 28 7 restaurant_id 1 row/restaurant
5 Delivery 313 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 158 YA PASS
1 14 Orders Clean 1 row/order order_id 330 YA PASS
2 15 Order Items Clean 1 row/order item order_item_id 872 YA PASS
3 16 Payments Clean 1 row/payment record payment_id 374 YA PASS
4 17 Restaurants Clean 1 row/restaurant restaurant_id 28 YA PASS
5 18 Delivery 1 row/delivery record delivery_id 313 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 158 158 0 0 True
1 Orders Clean 330 330 0 0 True
2 Order Items Clean 872 872 0 0 True
3 Payments Clean 374 374 0 0 True
4 Restaurants Clean 28 28 0 0 True
5 Delivery 313 313 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 email 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 email 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 872 330 5
1 Payments Clean 374 330 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: 330
Total quantity dari semua order: 1807
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': 330, 'unique_key_count': 330, '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 4 1 111000
1 O00002 2 2 1 29000
2 O00003 3 6 1 184000
3 O00004 4 8 3 183000
4 O00005 2 5 1 134000

**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: 43214000 | Refunded amount: 1677000
Net amount: 41537000
# ▶ 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': 330, 'unique_key_count': 330, 'duplicate_key_rows': 0, 'missing_key_rows': 0, 'valid': True}
Payments source rows: 374 | attempts preserved: 374
order_id payment_attempt_count successful_payment_amount refunded_payment_amount net_payment_amount final_payment_status payment_method_final
0 O00001 2 108000 0 108000 successful e_wallet
1 O00002 1 27000 0 27000 successful bank_transfer
2 O00003 1 184000 0 184000 successful credit_card
3 O00004 1 198000 0 198000 successful cash
4 O00005 1 142000 0 142000 successful e_wallet
orders
final_payment_status
successful 297
failed 22
refunded 11

**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): 47.0 | Durasi janji: 54.0
Delay: -7.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 54 47.0 -7.0 False
1 O00002 delivered 55 44.0 -11.0 False
2 O00003 delivered 44 56.0 12.0 True
3 O00004 delivered 30 28.0 -2.0 False
4 O00005 delivered 48 34.0 -14.0 False
5 O00006 delivered 54 51.0 -3.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 330 330 0 0 0 PASS
1 Restaurants restaurant_id 330 330 0 0 0 PASS
2 Item Aggregate order_id 330 330 0 0 0 PASS
3 Payment Aggregate order_id 330 330 0 0 0 PASS
4 Delivery Features order_id 330 330 0 17 0 PASS
FINAL GRAIN: {'rows': 330, 'unique_key_count': 330, 'duplicate_key_rows': 0, 'missing_key_rows': 0, 'valid': True}
order_id customer_key item_count payment_attempt_count delivery_status
0 O00001 39c115ccba99033f47acecd541d1def1c327f56cd46e32... 2 2 delivered
1 O00002 c0230e90c22cbcd1da038be7fb64f3ea8211a6f2a87409... 2 1 delivered
2 O00003 c7c23fabb75e03cd2cd3472a6b3e650243c9d9329928a2... 3 1 delivered
3 O00004 9cba8569339a42f8ba0deaaf4506c4e07b4f71e776ec3d... 4 1 delivered
4 O00005 15719368d881b7c62aa1744c3438a9f0e9967b86102ac7... 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 330 330 0 PASS 0
1 21 Restaurants restaurant_id 330 330 0 PASS 0
2 22 Item Aggregate order_id 330 330 0 PASS 0
3 23 Payment Aggregate order_id 330 330 0 PASS 0
4 24 Delivery Features order_id 330 330 0 PASS 17
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? 330/330 final_integrated + orders_pm1 PASS
5 V-06 order_id unique and non-null? {'rows': 330, 'unique_key_count': 330, 'duplic... aggregate_grain_check PASS
6 V-07 1 row/order and conserved? agg=330, unique source=330, items=872 item_agg + aggregate_grain_check PASS
7 V-08 One row/order; attempts preserved? attempts=374/374 payment_agg + aggregate_grain_check PASS
8 V-09 Failed excluded/refund correct? success=43214000, refund=1677000, 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=313, 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=297, formula_matches=True delivery_features + formula reconciliation PASS
16 V-17 Three outcome fields null? non_delivered=16, 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 330/330 final_integrated + orders_pm1 PASS
5 17 V-06 {'rows': 330, 'unique_key_count': 330, 'duplic... aggregate_grain_check PASS
6 18 V-07 agg=330, unique source=330, items=872 item_agg + aggregate_grain_check PASS
7 19 V-08 attempts=374/374 payment_agg + aggregate_grain_check PASS
8 20 V-09 success=43214000, refund=1677000, 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=313, 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=297, formula_matches=True delivery_features + formula reconciliation PASS
16 28 V-17 non_delivered=16, 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 330 330 17 False 7c136a7e114f3e7455ae37bdcc326ddc69b30cb283fb60... d005ee2dcb139179…
1 RUN-02 330 330 17 False 7c136a7e114f3e7455ae37bdcc326ddc69b30cb283fb60... d005ee2dcb139179…
2 RUN-03 330 330 17 False 7c136a7e114f3e7455ae37bdcc326ddc69b30cb283fb60... d005ee2dcb139179…
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 330 330 17 False d005ee2dcb139179084a82d9d6c4457501b36aca792426...
1 39 RUN-02 330 330 17 False d005ee2dcb139179084a82d9d6c4457501b36aca792426...
2 40 RUN-03 330 330 17 False d005ee2dcb139179084a82d9d6c4457501b36aca792426...
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.

**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\User\Downloads\Bootcamp_Data_Analyst_Workspace_Starter\Bootcamp_Data_Analyst\outputs\pm2_swiftbite\pm2_integration_audit.csv
 - C:\Users\User\Downloads\Bootcamp_Data_Analyst_Workspace_Starter\Bootcamp_Data_Analyst\outputs\pm2_swiftbite\pm2_validation_results.csv
 - C:\Users\User\Downloads\Bootcamp_Data_Analyst_Workspace_Starter\Bootcamp_Data_Analyst\outputs\pm2_swiftbite\pm2_pipeline_readiness_summary.json
FINAL DATASET: C:\Users\User\Downloads\Bootcamp_Data_Analyst_Workspace_Starter\Bootcamp_Data_Analyst\data\processed\pm2_swiftbite\swiftbite_pm2_integrated_order_level.csv

Final Checklist Sebelum Pengumpulan

- [ ] 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.