Lab: Produce an Evidence-Backed Decision Memo

option,completed_deliveries,attempted_deliveries,total_cost_pkr,median_support_hours,terms_verified
Option A,88,100,30800,5,true
Option B,81,90,27000,2,false

from pathlib import Path
import json
import math
import pandas as pd

df = pd.read_csv("options.csv", dtype=str, keep_default_na=False)
required = {
    "option", "completed_deliveries", "attempted_deliveries",
    "total_cost_pkr", "median_support_hours", "terms_verified"
}
missing = required - set(df.columns)
if missing:
    raise ValueError(f"Missing columns: {sorted(missing)}")

if len(df) != 2 or df["option"].duplicated().any() or df["option"].str.strip().eq("").any():
    raise ValueError("Expected two distinct named options")
numeric = ["completed_deliveries", "attempted_deliveries", "total_cost_pkr", "median_support_hours"]
for column in numeric:
    if not df[column].str.fullmatch(r"[0-9]+(?:\.[0-9]+)?").all():
        raise ValueError(f"Invalid numeric value in {column}")
    df[column] = pd.to_numeric(df[column], errors="raise")
    if not df[column].map(lambda x: math.isfinite(x)).all():
        raise ValueError(f"Nonfinite value in {column}")
for column in ["completed_deliveries", "attempted_deliveries"]:
    if (df[column] % 1 != 0).any():
        raise ValueError("Delivery counts must be whole numbers")
if not df["terms_verified"].isin(["true", "false"]).all():
    raise ValueError("Terms must explicitly be true or false")
df["terms_verified"] = df["terms_verified"].map({"true": True, "false": False})

if (df["attempted_deliveries"] <= 0).any():
    raise ValueError("attempted_deliveries must be positive")
if (df["completed_deliveries"] <= 0).any():
    raise ValueError("completed_deliveries must be positive before calculating cost per completion")
if (df["completed_deliveries"] > df["attempted_deliveries"]).any():
    raise ValueError("completed cannot exceed attempted")
if (df["total_cost_pkr"] < 0).any():
    raise ValueError("cost cannot be negative in this fixture")

df["completion_rate"] = df["completed_deliveries"] / df["attempted_deliveries"]
df["cost_per_completed_pkr"] = df["total_cost_pkr"] / df["completed_deliveries"]

# Normalize only within this comparison. Lower cost/support is better.
def benefit(series):
    span = series.max() - series.min()
    return pd.Series([1.0] * len(series), index=series.index) if span == 0 else (series - series.min()) / span

def inverse_benefit(series):
    span = series.max() - series.min()
    return pd.Series([1.0] * len(series), index=series.index) if span == 0 else (series.max() - series) / span

weights = {"reliability": 0.50, "cost": 0.30, "support": 0.20}
df["score"] = (
    weights["reliability"] * benefit(df["completion_rate"])
    + weights["cost"] * inverse_benefit(df["cost_per_completed_pkr"])
    + weights["support"] * inverse_benefit(df["median_support_hours"])
)

# A missing verified term is a gate, not a hidden scoring penalty.
df["decision_status"] = df["terms_verified"].map(
    {True: "eligible_for_pilot", False: "blocked_pending_terms"}
)

columns = [
    "option", "completion_rate", "cost_per_completed_pkr",
    "median_support_hours", "score", "decision_status"
]
result = df[columns].round(4)
Path("calculated_options.csv").write_text(result.to_csv(index=False), encoding="utf-8")
Path("calculation_record.json").write_text(
    json.dumps({"weights": weights, "rows": result.to_dict(orient="records")}, indent=2),
    encoding="utf-8",
)
print(result.to_string(index=False))