Make validation optional

app.py

@@ -1,4 +1,3 @@
-
 import gradio as gr
 import pandas as pd
 from io import BytesIO
@@ -9,10 +8,11 @@ APP_TITLE = "Cruce CLIENTE × MMP por EVENTO"
 APP_DESC = """
 **Pasos**  
 **1)** Subí **CLIENTE** (validación) y **MMP** (xlsx/csv), luego presioná **Cargar columnas**.  
-**2)** Elegí **ID CLIENTE**, **ID MMP**, **columna de validación (CLIENTE)** *(sugerimos Advertising ID/Status)* y **métrica del MMP** (opcional).  
+**2)** Elegí **ID CLIENTE**, **ID MMP**, **columna de validación (CLIENTE) [opcional]** y **métrica del MMP** (opcional).  
 **3)** Elegí la **columna de EVENTO (MMP)** y mapeá los **eventos por los que el cliente paga**.  
-**4)** Cargá los **valores de validación** (CLIENTE) y marcá cuáles significan **VALIDADO**.  
+**4)** (Opcional) Cargá los **valores de validación** (CLIENTE) y marcá cuáles significan **VALIDADO**.  
 **5)** Generá tablas. Por cada **EVENTO** se crea una tabla con **Cliente, MMP, %** y, si definiste **métrica**, se suma **sólo en filas validadas**.  
+   - Si **no** elegís columna/valores de validación, se considera **validado = cruce de IDs** (todas las filas de MMP del evento cuentan como Cliente).  
 **% = (Cliente / MMP) × 100** (1 decimal).  
 **Hoja 1:** tablas apiladas por EVENTO. **Hoja 2:** `raw_merge` con todas las filas de CLIENTE (left join).
 """
@@ -54,6 +54,7 @@ def _guess(cols, candidates):
             return lower_map[cand.lower()]
     return cols[0] if cols else None
 
+# --------------------- Load columns (Step 1) ---------------------
 def load_columns(cliente_file, mmp_file):
     try:
         df_c = _safe_read(cliente_file) if cliente_file else None
@@ -66,19 +67,21 @@ def load_columns(cliente_file, mmp_file):
 
     id_c_guess = _guess(cliente_cols, ["Advertising ID","advertising id","advertising_id","User Id","Transaction Id","ID","Id"])
     id_m_guess = _guess(mmp_cols, ["Advertising ID","advertising id","advertising_id","User Id","Transaction Id","ID","Id"])
-    validation_guess = _guess(cliente_cols, ["Advertising ID","advertising id","advertising_id","Validado","Validation","Status","Estado"])
+    # Validación OPCIONAL: no preseleccionamos valor por defecto
+    validation_guess = None
     metric_guess = _guess(mmp_cols, ["Event Revenue","Revenue","Amount","Value"])
     event_guess = _guess(mmp_cols, ["Event Name","event_name","Evento","EVENTO","Event"])
 
     return (
-        gr.update(choices=cliente_cols, value=id_c_guess),     # id_cliente_col
-        gr.update(choices=mmp_cols, value=id_m_guess),         # id_mmp_col
-        gr.update(choices=cliente_cols, value=validation_guess),# validation_col_client
-        gr.update(choices=mmp_cols, value=metric_guess),       # metric_col_mmp
-        gr.update(choices=mmp_cols, value=event_guess),        # mmp_event_col
-        "Columnas cargadas. Completá el Paso 2 y luego mapeá eventos."
+        gr.update(choices=cliente_cols, value=id_c_guess),      # id_cliente_col
+        gr.update(choices=mmp_cols, value=id_m_guess),          # id_mmp_col
+        gr.update(choices=cliente_cols, value=validation_guess),# validation_col_client (opcional)
+        gr.update(choices=mmp_cols, value=metric_guess),        # metric_col_mmp (opcional)
+        gr.update(choices=mmp_cols, value=event_guess),         # mmp_event_col
+        "Columnas cargadas. La validación es opcional (si la omitis, se usa cruce de IDs)."
     )
 
+# --------------------- Load event values (Step 3) ---------------------
 def load_event_values(mmp_file, event_col):
     try:
         df_m = _safe_read(mmp_file) if mmp_file else None
@@ -90,6 +93,7 @@ def load_event_values(mmp_file, event_col):
     vals = sorted(pd.Series(df_m[event_col].unique(), dtype="object").astype(str).fillna(""))
     return gr.update(choices=vals, value=vals), f"{len(vals)} eventos encontrados (pre-seleccionados)."
 
+# --------------------- Load validation values (Step 4, opcional) ---------------------
 def load_validation_values(cliente_file, validation_col):
     try:
         df_c = _safe_read(cliente_file) if cliente_file else None
@@ -97,10 +101,11 @@ def load_validation_values(cliente_file, validation_col):
         return gr.update(choices=[], value=[]), f"Error al leer CLIENTE: {e}"
 
     if df_c is None or not validation_col or validation_col not in df_c.columns:
-        return gr.update(choices=[], value=[]), "Subí CLIENTE y elegí la columna de validación (CLIENTE)."
+        return gr.update(choices=[], value=[]), "Omitido: sin columna de validación (se usará cruce de IDs)."
     vals = sorted(pd.Series(df_c[validation_col].unique(), dtype="object").astype(str).fillna(""))
     return gr.update(choices=vals, value=[]), f"{len(vals)} valores posibles de validación."
 
+# --------------------- Compute (Step 5) ---------------------
 def compute(cliente_file, mmp_file,
             id_cliente_col, id_mmp_col,
             validation_col_client, metric_col_mmp,
@@ -114,14 +119,15 @@ def compute(cliente_file, mmp_file,
     except Exception as e:
         return None, None, f"Error al leer archivos: {e}"
 
+    # Validaciones base (validación puede omitirse)
     for name, col, df in [
         ("ID CLIENTE", id_cliente_col, df_c),
         ("ID MMP", id_mmp_col, df_m),
-        ("Validación (CLIENTE)", validation_col_client, df_c),
     ]:
         if not col or col not in df.columns:
             return None, None, f"Columna inválida: {name} = {col}"
 
+    # Left join para mantener todas las filas de CLIENTE
     try:
         merged = df_c.merge(
             df_m, left_on=id_cliente_col, right_on=id_mmp_col, how="left",
@@ -133,45 +139,73 @@ def compute(cliente_file, mmp_file,
     if merged.empty:
         return None, None, "El cruce no arrojó filas."
 
+    # Resolver nombres en merged (para filtrar por EVENTO en merged) y en df_m (para contar MMP)
     event_in_merged = event_col if (event_col and event_col in merged.columns) else (f"{event_col}_MMP" if event_col else None)
     if not event_in_merged or event_in_merged not in merged.columns:
         return None, None, "Elegí la columna de EVENTO en el Paso 3."
 
-    validation_in_merged = validation_col_client if validation_col_client in merged.columns else f"{validation_col_client}_CLIENTE"
-    if validation_in_merged not in merged.columns:
-        return None, None, f"No se encuentra '{validation_col_client}' en merged."
+    if event_col not in df_m.columns:
+        return None, None, f"No se encuentra '{event_col}' en el reporte MMP."
+
+    # Validación opcional
+    validation_in_merged = None
+    if validation_col_client:
+        if validation_col_client in merged.columns:
+            validation_in_merged = validation_col_client
+        elif f"{validation_col_client}_CLIENTE" in merged.columns:
+            validation_in_merged = f"{validation_col_client}_CLIENTE"
 
+    # Métrica opcional
     metric_in_merged = None
     if metric_col_mmp and len(str(metric_col_mmp)) > 0:
-        metric_in_merged = metric_col_mmp if metric_col_mmp in merged.columns else f"{metric_col_mmp}_MMP"
-        if metric_in_merged not in merged.columns:
-            metric_in_merged = None
+        if metric_col_mmp in merged.columns:
+            metric_in_merged = metric_col_mmp
+        elif f"{metric_col_mmp}_MMP" in merged.columns:
+            metric_in_merged = f"{metric_col_mmp}_MMP"
 
+    # Eventos por defecto: tomar SIEMPRE de MMP (no del merged)
     if not selected_events:
-        selected_events = sorted(pd.Series(merged[event_in_merged].dropna().unique(), dtype="object").astype(str))
+        selected_events = sorted(pd.Series(df_m[event_col].dropna().unique(), dtype="object").astype(str))
 
+    # Precontar filas de MMP por evento (base del denominador y de la columna "MMP")
+    mmp_counts_map = df_m[event_col].astype(str).value_counts(dropna=False).to_dict()
+
+    # Construcción de tablas
     tables_by_event = {}
     for ev in selected_events:
-        sub = merged[merged[event_in_merged].astype(str) == str(ev)]
+        ev_str = str(ev)
+        # Subconjunto del merged SOLO para el EVENTO (para contar "Cliente" y sumar métricas)
+        sub = merged[merged[event_in_merged].astype(str) == ev_str]
+
+        # Denominador y columna "MMP": contar directamente en el archivo MMP
+        mmp_total = int(mmp_counts_map.get(ev_str, 0))
+
         if sub.empty:
-            row = {"Cliente": 0, "MMP": 0, "%": 0.0}
+            row = {"Cliente": 0, "MMP": mmp_total, "%": (0.0 if mmp_total == 0 else round(0 / mmp_total * 100, 1))}
             if metric_in_merged:
                 row[f"MMP_{metric_in_merged}_suma_validado"] = 0.0
             tables_by_event[ev] = pd.DataFrame([row])
             continue
 
-        mmp_count = len(sub)
-        valid_mask = sub[validation_in_merged].astype(str).isin([str(v) for v in (validation_values or [])])
+        # valid_mask: si hay validación y valores → usar; si no → todo True (cruce de IDs)
+        if validation_in_merged and validation_values:
+            valid_mask = sub[validation_in_merged].astype(str).isin([str(v) for v in validation_values])
+        else:
+            valid_mask = pd.Series(True, index=sub.index)
+
         cliente_count = int(valid_mask.sum())
-        pct = round((cliente_count / mmp_count * 100), 1) if mmp_count else 0.0
+        pct = round((cliente_count / mmp_total * 100), 1) if mmp_total else 0.0
+
+        row = {"Cliente": cliente_count, "MMP": mmp_total, "%": pct}
 
-        row = {"Cliente": cliente_count, "MMP": mmp_count, "%": pct}
+        # Métrica: suma sólo en las filas "válidas" del merged (si validación omitida → todas)
         if metric_in_merged:
             vals = pd.to_numeric(sub.loc[valid_mask, metric_in_merged], errors="coerce")
             row[f"MMP_{metric_in_merged}_suma_validado"] = float(vals.sum()) if cliente_count else 0.0
 
         tables_by_event[ev] = pd.DataFrame([row])
 
+    # Excel
     xls_bytes = BytesIO()
     with pd.ExcelWriter(xls_bytes, engine="xlsxwriter") as writer:
         sheet_name = "tablas_por_EVENTO"
@@ -182,10 +216,13 @@ def compute(cliente_file, mmp_file,
             table_df.to_excel(writer, sheet_name=sheet_name, startrow=start_row, index=False)
             start_row += len(table_df) + 2
 
+        # raw_merge (cols clave primero)
         cols_keep = []
-        for col in [id_cliente_col, id_mmp_col if id_mmp_col in merged.columns else f"{id_mmp_col}_MMP", event_in_merged, validation_in_merged]:
+        for col in [id_cliente_col, id_mmp_col if id_mmp_col in merged.columns else f"{id_mmp_col}_MMP", event_in_merged]:
             if col in merged.columns and col not in cols_keep:
                 cols_keep.append(col)
+        if validation_in_merged and validation_in_merged in merged.columns and validation_in_merged not in cols_keep:
+            cols_keep.append(validation_in_merged)
         if metric_in_merged and metric_in_merged in merged.columns and metric_in_merged not in cols_keep:
             cols_keep.append(metric_in_merged)
         cols_rest = [c for c in merged.columns if c not in cols_keep]
@@ -202,8 +239,9 @@ def compute(cliente_file, mmp_file,
         first_ev = list(tables_by_event.keys())[0]
         preview = tables_by_event[first_ev]
 
-    return preview, download_path, "Listo ✅"
+    return preview, download_path, "Listo ✅ (MMP como denominador real)"
 
+# --------------------- App (Pasos) ---------------------
 with gr.Blocks(title=APP_TITLE) as demo:
     gr.Markdown(f"# {APP_TITLE}\n\n{APP_DESC}")
 
@@ -215,13 +253,13 @@ with gr.Blocks(title=APP_TITLE) as demo:
     step1_btn = gr.Button("Paso 1: Cargar columnas")
 
     # Paso 2
-    gr.Markdown("## Paso 2: Elegir columnas de ID, validación (CLIENTE) y métrica MMP (opcional)")
+    gr.Markdown("## Paso 2: Elegir columnas de ID, validación (CLIENTE) [opcional] y métrica MMP (opcional)")
     with gr.Row():
         id_cliente_col = gr.Dropdown(choices=[], label="ID en CLIENTE (para cruce)")
         id_mmp_col = gr.Dropdown(choices=[], label="ID en MMP (para cruce)")
     with gr.Row():
-        validation_col_client = gr.Dropdown(choices=[], label="Columna de validación (CLIENTE) — sugerimos 'Advertising ID' o 'Status'")
-        metric_col_mmp = gr.Dropdown(choices=[], label="Columna de métrica en MMP (opcional)")
+        validation_col_client = gr.Dropdown(choices=[], value=None, label="Columna de validación (CLIENTE) — opcional")
+        metric_col_mmp = gr.Dropdown(choices=[], value=None, label="Columna de métrica en MMP — opcional")
     mmp_event_col = gr.Dropdown(choices=[], label="(Se usará en el Paso 3) Columna de EVENTO en MMP")
     step1_btn.click(
         load_columns,
@@ -229,7 +267,7 @@ with gr.Blocks(title=APP_TITLE) as demo:
         outputs=[id_cliente_col, id_mmp_col, validation_col_client, metric_col_mmp, mmp_event_col, gr.Markdown()]
     )
 
-    # Botón de mapeo (reubicado arriba del Paso 3)
+    # Mapeo de eventos (antes del Paso 3)
     map_events_btn = gr.Button("Mapear eventos desde columna de eventos de MMP")
 
     # Paso 3
@@ -241,9 +279,9 @@ with gr.Blocks(title=APP_TITLE) as demo:
         outputs=[event_vals, gr.Markdown()]
     )
 
-    # Paso 4: mover el BOTÓN arriba del título
-    load_valid_btn = gr.Button("Paso 4: Cargar valores de validación (CLIENTE)")
-    gr.Markdown("## Paso 4: Cargar valores de validación (CLIENTE) y elegirlos")
+    # Paso 4 (opcional)
+    load_valid_btn = gr.Button("Paso 4 (opcional): Cargar valores de validación (CLIENTE)")
+    gr.Markdown("## Paso 4 (opcional): Cargar valores de validación (CLIENTE) y elegirlos")
     valid_vals = gr.CheckboxGroup(choices=[], label="Valores que significan VALIDADO (CLIENTE)")
     load_valid_btn.click(
         load_validation_values,