Upload 2 files

app.py

@@ -0,0 +1,270 @@
+
+import gradio as gr
+import pandas as pd
+from io import BytesIO
+import os
+import tempfile
+
+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).  
+**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**.  
+**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**.  
+**% = (Cliente / MMP) × 100** (1 decimal).  
+**Hoja 1:** tablas apiladas por EVENTO. **Hoja 2:** `raw_merge` con todas las filas de CLIENTE (left join).
+"""
+
+def _read_excel(pathlike):
+    return pd.read_excel(pathlike, engine="openpyxl")
+
+def _read_csv_with_fallbacks(pathlike):
+    try:
+        return pd.read_csv(pathlike, sep=None, engine="python", on_bad_lines="skip", encoding="utf-8")
+    except Exception:
+        return pd.read_csv(pathlike, sep=None, engine="python", on_bad_lines="skip", encoding="latin-1")
+
+def _safe_read(fileobj):
+    if fileobj is None:
+        return None
+    path = fileobj.name if hasattr(fileobj, "name") else fileobj
+    ext = os.path.splitext(str(path))[-1].lower()
+    try:
+        if ext in [".xlsx", ".xlsm", ".xltx", ".xltm"]:
+            return _read_excel(path)
+        elif ext == ".csv" or ext == "":
+            try:
+                return _read_excel(path)
+            except Exception:
+                return _read_csv_with_fallbacks(path)
+        else:
+            try:
+                return _read_excel(path)
+            except Exception:
+                return _read_csv_with_fallbacks(path)
+    except Exception as e:
+        raise RuntimeError(f"No se pudo leer '{os.path.basename(str(path))}': {e}")
+
+def _guess(cols, candidates):
+    lower_map = {c.lower(): c for c in cols}
+    for cand in candidates:
+        if cand.lower() in lower_map:
+            return lower_map[cand.lower()]
+    return cols[0] if cols else None
+
+def load_columns(cliente_file, mmp_file):
+    try:
+        df_c = _safe_read(cliente_file) if cliente_file else None
+        df_m = _safe_read(mmp_file) if mmp_file else None
+    except Exception as e:
+        return (gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), "Error al leer archivos: " + str(e))
+
+    cliente_cols = list(df_c.columns) if df_c is not None else []
+    mmp_cols = list(df_m.columns) if df_m is not None else []
+
+    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"])
+    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."
+    )
+
+def load_event_values(mmp_file, event_col):
+    try:
+        df_m = _safe_read(mmp_file) if mmp_file else None
+    except Exception as e:
+        return gr.update(choices=[], value=[]), f"Error al leer MMP: {e}"
+
+    if df_m is None or not event_col or event_col not in df_m.columns:
+        return gr.update(choices=[], value=[]), "Subí MMP y elegí la columna de EVENTO."
+    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)."
+
+def load_validation_values(cliente_file, validation_col):
+    try:
+        df_c = _safe_read(cliente_file) if cliente_file else None
+    except Exception as e:
+        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)."
+    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."
+
+def compute(cliente_file, mmp_file,
+            id_cliente_col, id_mmp_col,
+            validation_col_client, metric_col_mmp,
+            event_col, selected_events, validation_values):
+    if not cliente_file or not mmp_file:
+        return None, None, "Faltan archivos."
+
+    try:
+        df_c = _safe_read(cliente_file)
+        df_m = _safe_read(mmp_file)
+    except Exception as e:
+        return None, None, f"Error al leer archivos: {e}"
+
+    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}"
+
+    try:
+        merged = df_c.merge(
+            df_m, left_on=id_cliente_col, right_on=id_mmp_col, how="left",
+            suffixes=("_CLIENTE", "_MMP")
+        )
+    except Exception as e:
+        return None, None, f"Error durante el merge por IDs: {e}"
+
+    if merged.empty:
+        return None, None, "El cruce no arrojó filas."
+
+    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."
+
+    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 not selected_events:
+        selected_events = sorted(pd.Series(merged[event_in_merged].dropna().unique(), dtype="object").astype(str))
+
+    tables_by_event = {}
+    for ev in selected_events:
+        sub = merged[merged[event_in_merged].astype(str) == str(ev)]
+        if sub.empty:
+            row = {"Cliente": 0, "MMP": 0, "%": 0.0}
+            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 [])])
+        cliente_count = int(valid_mask.sum())
+        pct = round((cliente_count / mmp_count * 100), 1) if mmp_count else 0.0
+
+        row = {"Cliente": cliente_count, "MMP": mmp_count, "%": pct}
+        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])
+
+    xls_bytes = BytesIO()
+    with pd.ExcelWriter(xls_bytes, engine="xlsxwriter") as writer:
+        sheet_name = "tablas_por_EVENTO"
+        start_row = 0
+        for ev, table_df in tables_by_event.items():
+            pd.DataFrame([[ev]]).to_excel(writer, sheet_name=sheet_name, startrow=start_row, index=False, header=False)
+            start_row += 1
+            table_df.to_excel(writer, sheet_name=sheet_name, startrow=start_row, index=False)
+            start_row += len(table_df) + 2
+
+        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]:
+            if col in merged.columns and col not in cols_keep:
+                cols_keep.append(col)
+        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]
+        merged[cols_keep + cols_rest].to_excel(writer, sheet_name="raw_merge", index=False)
+    xls_bytes.seek(0)
+
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx")
+    tmp.write(xls_bytes.getvalue())
+    tmp.flush(); tmp.close()
+    download_path = tmp.name
+
+    preview = None
+    if tables_by_event:
+        first_ev = list(tables_by_event.keys())[0]
+        preview = tables_by_event[first_ev]
+
+    return preview, download_path, "Listo ✅"
+
+with gr.Blocks(title=APP_TITLE) as demo:
+    gr.Markdown(f"# {APP_TITLE}\n\n{APP_DESC}")
+
+    # Paso 1
+    gr.Markdown("## Paso 1: Subir archivos")
+    with gr.Row():
+        cliente_file = gr.File(label="CLIENTE.xlsx (o .csv)", file_types=[".xlsx", ".csv"])
+        mmp_file = gr.File(label="MMP.xlsx (o .csv)", file_types=[".xlsx", ".csv"])
+    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)")
+    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)")
+    mmp_event_col = gr.Dropdown(choices=[], label="(Se usará en el Paso 3) Columna de EVENTO en MMP")
+    step1_btn.click(
+        load_columns,
+        inputs=[cliente_file, mmp_file],
+        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)
+    map_events_btn = gr.Button("Mapear eventos desde columna de eventos de MMP")
+
+    # Paso 3
+    gr.Markdown("## Paso 3: Seleccionar EVENTOS")
+    event_vals = gr.CheckboxGroup(choices=[], label="Eventos por los que el cliente paga")
+    map_events_btn.click(
+        load_event_values,
+        inputs=[mmp_file, mmp_event_col],
+        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")
+    valid_vals = gr.CheckboxGroup(choices=[], label="Valores que significan VALIDADO (CLIENTE)")
+    load_valid_btn.click(
+        load_validation_values,
+        inputs=[cliente_file, validation_col_client],
+        outputs=[valid_vals, gr.Markdown()]
+    )
+
+    # Paso 5
+    gr.Markdown("## Paso 5: Generar tablas y Excel")
+    run_btn = gr.Button("Generar tablas")
+    preview_out = gr.Dataframe(label="Preview: primera tabla por EVENTO", interactive=False)
+    xls_file = gr.File(label="Descargar Excel (tablas_por_EVENTO + raw_merge)", interactive=False)
+    run_btn.click(
+        compute,
+        inputs=[cliente_file, mmp_file,
+                id_cliente_col, id_mmp_col,
+                validation_col_client, metric_col_mmp,
+                mmp_event_col, event_vals, valid_vals],
+        outputs=[preview_out, xls_file, gr.Markdown()]
+    )
+
+if __name__ == "__main__":
+    gr.close_all()
+    demo.launch()

requirements.txt

@@ -0,0 +1,4 @@
+pandas==2.2.2
+gradio==4.44.0
+openpyxl==3.1.5
+xlsxwriter==3.2.0