Fix de features y slider de App Id

app.py

@@ -1,17 +1,18 @@
-import gradio as gr
-import pandas as pd
-from io import BytesIO
+# app.py
 import os
+import json
+from io import BytesIO
 import tempfile
+import pandas as pd
+import gradio as gr
 
-# BigQuery (opcional)
+# ================== BigQuery deps (opcionales) ==================
 try:
     from google.cloud import bigquery
     _HAS_BQ = True
 except Exception:
     _HAS_BQ = False
 
-# Para dtypes de BQ -> pandas (opcional)
 try:
     import db_dtypes  # noqa: F401
     _HAS_DB_DTYPES = True
@@ -24,10 +25,11 @@ APP_DESC = """
 **BigQuery (tabla única)**: `leadgenios-tech.afiliacion_datalake.daily_afiliate_datalake`
 
 Pasos BQ:
-1) Ingresá **App ID** y **rango de fechas** (YYYY-MM-DD).  
-2) **Obtener columnas (schema)** → sugiere **columna temporal (event_time)**, **evento (event_name)**, **ID en MMP (appsflyer_id)** y **App ID columna** (app_id).  
-3) **Listar eventos por rango** (usa App ID + fechas + columna de evento).  
-4) **Consultar y cargar MMP** → genera CSV temporal, preview y descarga.
+1) **Listar App IDs (BigQuery)** y seleccionar uno.  
+2) Ingresá **rango de fechas** (YYYY-MM-DD).  
+3) **Obtener columnas (schema)** → sugiere **columna temporal (event_time)**, **evento (event_name)**, **ID en MMP (appsflyer_id/customer_user_id/advertising_id)** y **App ID** (app_id).  
+4) **Listar eventos por rango** (usa App ID + fechas + columna de evento).  
+5) **Consultar y cargar MMP** → genera CSV temporal, preview y descarga.
 
 **Archivo**: subir archivo, detectar columnas y (opcional) **listar eventos** para filtrar. No hace falta App ID ni fechas.
 
@@ -43,7 +45,7 @@ Pasos BQ:
 - Excel: **Hoja 1** tablas por evento; **Hoja 2** `raw_merge`.
 """
 
-# -------------------------- Helpers --------------------------
+# ================== Helpers de lectura ==================
 def _read_excel(pathlike):
     return pd.read_excel(pathlike, engine="openpyxl")
 
@@ -82,7 +84,6 @@ def _guess(cols, candidates):
     return cols[0] if cols else None
 
 def _guess_optional(cols, candidates):
-    """Como _guess, pero devuelve None si no encuentra coincidencia."""
     lower_map = {c.lower(): c for c in cols}
     for cand in candidates:
         if cand.lower() in lower_map:
@@ -94,7 +95,35 @@ def _safe_file_output(path):
         return path
     return None
 
-# -------------------------- BQ helpers (tabla fija) --------------------------
+# ================== Normalización de IDs ==================
+def normalize_id_series(s: pd.Series) -> pd.Series:
+    """
+    Normaliza IDs para merges:
+    - Convierte a string, quita espacios.
+    - Si es float 'entero' (123.0) lo transforma a '123'.
+    - Deja NaN como NaN.
+    """
+    def _norm(v):
+        if pd.isna(v):
+            return pd.NA
+        # floats que representan enteros → sin .0
+        if isinstance(v, float):
+            if v.is_integer():
+                return str(int(v))
+            else:
+                # si es float no entero, lo pasamos a string tal cual
+                return str(v)
+        # todo lo demás a str
+        vs = str(v).strip()
+        # si quedó como "nan" literal, considerar NA
+        if vs.lower() in ("nan", "none", ""):
+            return pd.NA
+        return vs
+    out = s.map(_norm)
+    # asegura dtype string que permite NA
+    return out.astype("string")
+
+# ================== BigQuery helpers ==================
 BQ_PROJECT = "leadgenios-tech"
 BQ_TABLE_FQN = "leadgenios-tech.afiliacion_datalake.daily_afiliate_datalake"
 
@@ -108,7 +137,6 @@ def _need_bq_client():
 
     sa_json = os.getenv("GCP_SA_JSON")
     if sa_json:
-        import json
         try:
             from google.oauth2 import service_account
         except Exception as e:
@@ -121,7 +149,6 @@ def _need_bq_client():
         except Exception as e:
             raise RuntimeError(f"GCP_SA_JSON inválido o no utilizable: {e}")
 
-    # Fallback local
     if os.getenv("GOOGLE_APPLICATION_CREDENTIALS"):
         try:
             return bigquery.Client(project=BQ_PROJECT)
@@ -134,12 +161,28 @@ def bq_get_columns_fixed():
     client = _need_bq_client()
     table = client.get_table(BQ_TABLE_FQN)
     cols = [sch.name for sch in table.schema]
-    time_guess  = _guess(cols, ["event_time","event_date","event_datetime","timestamp","date"])
-    event_guess = _guess(cols, ["event_name","Event Name","evento","event"])
-    id_guess    = _guess(cols, ["appsflyer_id","advertising_id","adid","idfa","ID","Id"])
-    appid_guess = _guess(cols, ["app_id","bundle_id","app","appId"])
+
+    time_guess  = _guess(cols, ["event_time", "install_time", "attributed_touch_time"])
+    event_guess = _guess(cols, ["event_name"])
+    # IDs típicos
+    id_guess    = _guess(cols, ["appsflyer_id", "customer_user_id", "advertising_id"])
+    appid_guess = _guess(cols, ["app_id"])
     return cols, time_guess, event_guess, id_guess, appid_guess
 
+def bq_list_app_ids(limit=500):
+    """Lista App IDs de la tabla BQ para el dropdown."""
+    client = _need_bq_client()
+    sql = f"""
+    SELECT DISTINCT CAST(app_id AS STRING) AS app_id
+    FROM `{BQ_TABLE_FQN}`
+    WHERE app_id IS NOT NULL AND app_id <> ''
+    ORDER BY app_id
+    LIMIT {int(limit)}
+    """
+    df = client.query(sql).result().to_dataframe(create_bqstorage_client=False)
+    vals = sorted(df["app_id"].dropna().astype(str).tolist())
+    return vals, f"{len(vals)} App IDs encontrados."
+
 def bq_list_events_fixed(event_col, time_col, app_id_col, app_id_value, start_date, end_date, limit=500):
     client = _need_bq_client()
     cols, t_guess, e_guess, _, a_guess = bq_get_columns_fixed()
@@ -196,21 +239,19 @@ def bq_query_to_temp_fixed(event_col, time_col, app_id_col, app_id_value, start_
     df.to_csv(tmp.name, index=False)
     return tmp.name, df.head(20).to_dict(orient="records")
 
-# -------------------------- MMP por archivo --------------------------
+# ================== MMP por archivo ==================
 def file_mmp_schema(file):
     try:
         df = _safe_read(file)
     except Exception as e:
         return (gr.update(), gr.update(), gr.update(), gr.update(), f"Error al leer MMP: {e}")
     cols = list(df.columns)
-
-    # Requeridas (para el flujo de archivo)
-    event_guess = _guess(cols, ["event_name","Event Name","evento","EVENTO","Event"])
-    id_guess    = _guess(cols, ["appsflyer_id","Advertising ID","advertising_id","adid","idfa","ID","Id"])
-
-    # Opcionales (NO preseleccionar si no existen)
-    time_guess  = _guess_optional(cols, ["event_time","event_date","event_time_millis","timestamp","date","Date","Event Time"])
-    appid_guess = _guess_optional(cols, ["app_id","bundle_id","app","appId","App ID"])
+    event_guess = _guess(cols, ["event_name", "Event Name", "evento", "EVENTO", "Event"])
+    id_guess    = _guess(cols, ["appsflyer_id", "customer_user_id", "advertising_id",
+                                "Advertising ID", "adid", "idfa", "ID", "Id"])
+    time_guess  = _guess_optional(cols, ["event_time", "install_time", "attributed_touch_time",
+                                         "event_date", "timestamp", "date", "Date", "Event Time"])
+    appid_guess = _guess_optional(cols, ["app_id", "bundle_id", "app", "appId", "App ID"])
 
     return (gr.update(choices=cols, value=time_guess),
             gr.update(choices=cols, value=event_guess),
@@ -239,29 +280,26 @@ def file_prepare(src_file, ev_col, selected_events):
     except Exception as e:
         raise RuntimeError(f"Error al preparar MMP (archivo): {e}")
 
-# -------------------------- CLIENTE helpers --------------------------
+# ================== CLIENTE helpers ==================
 def cliente_map_columns(cliente_file):
     try:
         df = _safe_read(cliente_file)
     except Exception as e:
         return (gr.update(), gr.update(), gr.update(), gr.update(), "Error al leer CLIENTE: "+str(e))
     cols = list(df.columns)
-
-    # Requerida
     id_guess = _guess(cols, [
-        "appsflyer_id","Advertising ID","advertising_id","user_id","User Id",
+        "appsflyer_id","customer_user_id","advertising_id",
+        "Advertising ID","user_id","User Id",
         "transaction_id","Transaction Id","ID","Id","rut"
     ])
-
-    # Opcionales: NO preseleccionar si no existen
     valid_guess  = None
     metric_guess = _guess_optional(cols, ["revenue","amount","value","ticket","Event Revenue","importe","monto"])
     event_guess  = _guess_optional(cols, ["event_name","Event Name","evento","EVENTO","Event"])
 
     return (gr.update(choices=cols, value=id_guess),
-            gr.update(choices=cols, value=valid_guess),   # opcional
-            gr.update(choices=cols, value=metric_guess),  # opcional
-            gr.update(choices=cols, value=event_guess),   # opcional
+            gr.update(choices=cols, value=valid_guess),
+            gr.update(choices=cols, value=metric_guess),
+            gr.update(choices=cols, value=event_guess),
             "Columnas de CLIENTE listas.")
 
 def load_validation_values(cliente_file, validation_col):
@@ -274,13 +312,55 @@ def load_validation_values(cliente_file, validation_col):
     vals = sorted(pd.Series(df_c[validation_col].astype(str).unique()).dropna().tolist())
     return gr.update(choices=vals, value=[]), f"{len(vals)} valores posibles de validación."
 
-# -------------------------- Compute --------------------------
+
+# ================== Compute ==================
+from io import BytesIO
+import tempfile
+import re
+import pandas as pd
+
+# --- helpers ---------------------------------------------------------
+
+def normalize_id_series(s: pd.Series) -> pd.Series:
+    """
+    Normalize IDs for robust equality:
+    - cast to string
+    - strip whitespace
+    - lowercase
+    - convert 'nan'/'none' to ''
+    """
+    x = s.astype(str).str.strip().str.lower()
+    x = x.replace({"nan": "", "none": ""})
+    return x.fillna("")
+
+def _autodetect_validation_col(cols):
+    """Try to find a likely validation column if user didn't pick one."""
+    candidates = [
+        "valid", "valido", "válido", "is_valid", "usable", "status",
+        "approved", "aprobado", "ok", "flag", "validated", "validation"
+    ]
+    lower = {c.lower(): c for c in cols}
+    for cand in candidates:
+        if cand in lower:
+            return lower[cand]
+    return None
+
+def _default_truthy_set():
+    # NOTE: all lowercased string checks
+    return {
+        "true", "1", "yes", "y", "ok", "si", "sí",
+        "valid", "valido", "válido", "usable", "approved", "aprobado",
+        "x", "t"
+    }
+
+# --- main ------------------------------------------------------------
+
 def compute(cliente_file, mmp_final_path,
             id_cliente_col, id_mmp_col,
-            validation_col_client, validation_values,
-            metric_col_client,
-            client_event_col,          # opcional
-            mmp_event_col,             # requerido
+            validation_col_client, validation_values,   # optional
+            metric_col_client,                          # ignored in this logic
+            client_event_col,                           # ignored (denominator is MMP)
+            mmp_event_col,                              # required
             selected_events_mmp):
 
     if not mmp_final_path:
@@ -288,124 +368,121 @@ def compute(cliente_file, mmp_final_path,
     if not cliente_file:
         return None, None, "Subí CLIENTE y mapeá las columnas."
 
+    # Read sources
     try:
         df_c = _safe_read(cliente_file)
         df_m = _safe_read(mmp_final_path)
     except Exception as e:
         return None, None, f"Error al leer fuentes: {e}"
 
-    # Requeridos
+    # Required columns present?
     for name, col, df in [
-        ("ID CLIENTE", id_cliente_col, df_c),
-        ("ID MMP",     id_mmp_col,     df_m),
-        ("EVENTO (MMP)", mmp_event_col, df_m),
+        ("ID en CLIENTE", id_cliente_col, df_c),
+        ("ID en MMP",     id_mmp_col,     df_m),
+        ("EVENTO en MMP", mmp_event_col,  df_m),
     ]:
         if not col or col not in df.columns:
             return None, None, f"Columna inválida: {name} = {col}"
 
-    # Merge 1: raw (CLIENTE ← MMP)
+    # Normalize IDs
+    try:
+        ids_cli_norm = normalize_id_series(df_c[id_cliente_col])
+        ids_mmp_norm = normalize_id_series(df_m[id_mmp_col])
+    except Exception as e:
+        return None, None, f"Error normalizando IDs: {e}"
+
+    # If user didn't select a validation col, try to autodetect one
+    if not validation_col_client or validation_col_client not in df_c.columns:
+        auto_val_col = _autodetect_validation_col(df_c.columns)
+        validation_col_client = auto_val_col if auto_val_col else None
+
+    # If a validation column exists but user didn't pick values, use default “truthy” set
+    truthy = _default_truthy_set()
+    use_validation = validation_col_client is not None
+    if use_validation:
+        cand_vals = validation_values or []
+        if cand_vals:
+            truthy = {str(v).strip().lower() for v in cand_vals}
+
+    # Build set of CLIENTE IDs that are considered valid
     try:
-        merged_left = df_c.merge(df_m, left_on=id_cliente_col, right_on=id_mmp_col, how="left",
-                                 suffixes=("_CLIENTE", "_MMP"))
+        if use_validation:
+            val_series = df_c[validation_col_client].astype(str).str.strip().str.lower()
+            mask_valid = val_series.isin(truthy)
+            valid_client_ids = set(ids_cli_norm[mask_valid][ids_cli_norm[mask_valid] != ""])
+        else:
+            # No validation column → any presence in CLIENTE counts as valid
+            valid_client_ids = set(ids_cli_norm[ids_cli_norm != ""])
     except Exception as e:
-        return None, None, f"Error durante el merge por IDs: {e}"
-
-    # Merge 2: contar sobre MMP (MMP ← CLIENTE)
-    merged_by_mmp = df_m.merge(df_c, left_on=id_mmp_col, right_on=id_cliente_col, how="left",
-                               suffixes=("_MMP", "_CLIENTE"))
-
-    # Resolver nombres tras el merge (manejo de sufijos)
-    def _resolve(df, col, prefer_suffix):
-        if not col:
-            return None
-        if col in df.columns:
-            return col
-        for c in (f"{col}{prefer_suffix}", f"{col}_x", f"{col}_y"):
-            if c in df.columns:
-                return c
-        lower_map = {c.lower(): c for c in df.columns}
-        return lower_map.get(col.lower(), col)
-
-    client_event_in_left = _resolve(merged_left, client_event_col, "_CLIENTE") if client_event_col else None
-    mmp_event_in_left    = _resolve(merged_left, mmp_event_col,    "_MMP")
-    validation_in_left   = _resolve(merged_left, validation_col_client, "_CLIENTE") if validation_col_client else None
-    metric_in_left       = _resolve(merged_left, metric_col_client,     "_CLIENTE") if metric_col_client else None
-
-    client_event_in_mmp  = _resolve(merged_by_mmp, client_event_col, "_CLIENTE") if client_event_col else None
-    validation_in_mmp    = _resolve(merged_by_mmp, validation_col_client, "_CLIENTE") if validation_col_client else None
-    metric_in_mmp        = _resolve(merged_by_mmp, metric_col_client,     "_CLIENTE") if metric_col_client else None
-    mmp_event_in_mmp     = _resolve(merged_by_mmp, mmp_event_col,         "_MMP")
-
-    # Eventos objetivo
+        return None, None, f"Error aplicando validación en CLIENTE: {e}"
+
+    # Create VALIDO flag in MMP: True if MMP id ∈ valid_client_ids
+    df_m = df_m.copy()
+    df_m["VALIDO"] = ids_mmp_norm.isin(valid_client_ids)
+
+    # Events to process (if none selected, use all present in MMP)
     if not selected_events_mmp:
-        selected_events_mmp = sorted(df_m[mmp_event_col].astype(str).dropna().unique().tolist())
+        try:
+            selected_events_mmp = (
+                df_m[mmp_event_col].astype(str).dropna().unique().tolist()
+            )
+            selected_events_mmp = sorted(map(str, selected_events_mmp))
+        except Exception as e:
+            return None, None, f"Error obteniendo lista de eventos MMP: {e}"
 
-    # Denominador: conteo MMP por evento
-    mmp_counts_map = df_m[mmp_event_col].astype(str).value_counts(dropna=False).to_dict()
+    # B: total rows in MMP per event
+    mmp_counts = df_m.groupby(df_m[mmp_event_col].astype(str), dropna=False).size()
 
-    tables_by_event = {}
+    # A: total rows in MMP per event with VALIDO=True
+    cliente_counts = (
+        df_m[df_m["VALIDO"]]
+        .groupby(df_m.loc[df_m["VALIDO"], mmp_event_col].astype(str), dropna=False)
+        .size()
+    )
 
+    # Build event tables
+    tables_by_event = {}
     for ev in selected_events_mmp:
         ev_str = str(ev)
-        mmp_total = int(mmp_counts_map.get(ev_str, 0))
-
-        # Numerador: filas MMP con match por ID en CLIENTE (y validación si aplica).
-        sub_mmp = merged_by_mmp[merged_by_mmp[mmp_event_in_mmp].astype(str) == ev_str]
-
-        if client_event_in_mmp and client_event_in_mmp in merged_by_mmp.columns:
-            # Si hay evento en CLIENTE, además debe coincidir con el ev del MMP
-            sub_mmp = sub_mmp[sub_mmp[client_event_in_mmp].astype(str) == ev_str]
-
-        has_client = sub_mmp[id_cliente_col].notna()
-        valid_mask = has_client
-        if validation_in_mmp and validation_values:
-            valid_mask = valid_mask & sub_mmp[validation_in_mmp].astype(str).isin([str(v) for v in validation_values])
-
-        cliente_count = int(valid_mask.sum())
-
-        metric_sum = 0.0
-        if metric_in_mmp and metric_in_mmp in sub_mmp.columns:
-            vals = pd.to_numeric(sub_mmp.loc[valid_mask, metric_in_mmp], errors="coerce")
-            metric_sum = float(vals.sum()) if cliente_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}
-        if metric_col_client and metric_in_mmp and metric_in_mmp in merged_by_mmp.columns:
-            row[f"CLIENTE_{metric_col_client}_suma_validado"] = metric_sum
+        B = int(mmp_counts.get(ev_str, 0))
+        A = int(cliente_counts.get(ev_str, 0))
+        pct = round((A / B * 100), 1) if B else 0.0
+        tables_by_event[ev] = pd.DataFrame([{"Cliente": A, "MMP": B, "%": pct}])
 
-        tables_by_event[ev] = pd.DataFrame([row])
-
-    # ===== Excel =====
+    # ===== Excel output =====
     xls_bytes = BytesIO()
     with pd.ExcelWriter(xls_bytes, engine="xlsxwriter") as writer:
+        # Sheet 1: tables by EVENT
         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)
+            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)
+            table_df.to_excel(
+                writer, sheet_name=sheet_name, startrow=start_row, index=False
+            )
             start_row += len(table_df) + 2
 
-        # Hoja 2: raw_merge (cliente ← mmp)
-        cols_keep = []
-        for col in [id_cliente_col, id_mmp_col, client_event_in_left, mmp_event_in_left]:
-            if col and col in merged_left.columns and col not in cols_keep:
-                cols_keep.append(col)
-        if validation_in_left and validation_in_left in merged_left.columns and validation_in_left not in cols_keep:
-            cols_keep.append(validation_in_left)
-        if metric_in_left and metric_in_left in merged_left.columns and metric_in_left not in cols_keep:
-            cols_keep.append(metric_in_left)
-        cols_rest = [c for c in merged_left.columns if c not in cols_keep]
-        merged_left[cols_keep + cols_rest].to_excel(writer, sheet_name="raw_merge", index=False)
+        # Sheet 2: raw MMP + only VALIDO (explicitly drop the ID columns)
+        cols_front = ["VALIDO"]  # first column
+        # Keep event column visible & useful
+        if mmp_event_col in df_m.columns:
+            cols_front.insert(0, mmp_event_col)
+
+        # Exclude ID & any helper columns from raw output
+        drop_cols = {id_mmp_col, "_id_norm_mmp"}  # (we never created _id_norm_mmp here)
+        cols_rest = [c for c in df_m.columns if c not in set(cols_front) | drop_cols]
+        df_m[cols_front + cols_rest].to_excel(writer, sheet_name="raw_mmp", 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
+    # Preview: first event table
     preview = None
     if tables_by_event:
         first_ev = list(tables_by_event.keys())[0]
@@ -413,7 +490,7 @@ def compute(cliente_file, mmp_final_path,
 
     return preview, download_path, "Listo ✅"
 
-# -------------------------- UI --------------------------
+# ================== UI ==================
 with gr.Blocks(title=APP_TITLE) as demo:
     gr.Markdown(f"# {APP_TITLE}\n\n{APP_DESC}")
 
@@ -421,11 +498,15 @@ with gr.Blocks(title=APP_TITLE) as demo:
     gr.Markdown("## Fuente 1: MMP")
     mmp_source = gr.Radio(choices=["Subir archivo", "BigQuery"], value="Subir archivo", label="Fuente de MMP")
 
-    # --- BigQuery Panel (tabla fija) ---
+    # --- BigQuery Panel ---
     with gr.Column(visible=False) as bq_panel:
         gr.Markdown("**Paso MMP-BQ 1**: App ID y Fechas")
         with gr.Row():
-            bq_app_id_value = gr.Textbox(label="App ID (valor exacto)", placeholder="com.tu.app")
+            bq_app_id_value = gr.Dropdown(choices=[], value=None, label="App ID (BigQuery)")
+            list_app_ids_btn = gr.Button("Listar App IDs (BigQuery)")
+        list_app_ids_msg = gr.Markdown()
+
+        with gr.Row():
             bq_start = gr.Textbox(label="Fecha desde (YYYY-MM-DD)", placeholder="YYYY-MM-DD")
             bq_end = gr.Textbox(label="Fecha hasta (YYYY-MM-DD)", placeholder="YYYY-MM-DD")
 
@@ -433,7 +514,7 @@ with gr.Blocks(title=APP_TITLE) as demo:
         with gr.Row():
             bq_time_col = gr.Dropdown(choices=[], value=None, label="Columna temporal (ej: event_time)")
             mmp_event_col_bq = gr.Dropdown(choices=[], value=None, label="Columna de EVENTO en MMP (ej: event_name)")
-            id_mmp_col_bq = gr.Dropdown(choices=[], value=None, label="ID en MMP (para cruce) (ej: appsflyer_id)")
+            id_mmp_col_bq = gr.Dropdown(choices=[], value=None, label="ID en MMP (para cruce)")
             bq_app_id_col = gr.Dropdown(choices=[], value=None, label="Columna App ID (ej: app_id)")
         bq_schema_btn = gr.Button("Obtener columnas (schema)")
         bq_schema_msg = gr.Markdown()
@@ -450,7 +531,7 @@ with gr.Blocks(title=APP_TITLE) as demo:
         bq_query_btn = gr.Button("Consultar y cargar MMP (BigQuery)")
         bq_query_msg = gr.Markdown()
 
-    # --- File Panel (simplificado) ---
+    # --- File Panel ---
     with gr.Column(visible=True) as file_panel:
         gr.Markdown("**Paso MMP-Archivo 1**: Subir y detectar columnas")
         mmp_file = gr.File(label="Subí MMP.xlsx/csv", file_types=[".xlsx", ".csv"])
@@ -479,6 +560,15 @@ with gr.Blocks(title=APP_TITLE) as demo:
         return (gr.update(visible=(src=="Subir archivo")), gr.update(visible=(src=="BigQuery")))
     mmp_source.change(_toggle_source, inputs=[mmp_source], outputs=[file_panel, bq_panel])
 
+    # BQ: listar App IDs
+    def _bq_list_app_ids():
+        try:
+            vals, msg = bq_list_app_ids()
+            return gr.update(choices=vals, value=(vals[0] if vals else None)), msg
+        except Exception as e:
+            return gr.update(choices=[], value=None), f"Error listando App IDs: {e}"
+    list_app_ids_btn.click(_bq_list_app_ids, inputs=[], outputs=[bq_app_id_value, list_app_ids_msg])
+
     # BQ: schema
     def _bq_schema_fixed():
         try:
@@ -582,13 +672,13 @@ with gr.Blocks(title=APP_TITLE) as demo:
 
         if source == "Subir archivo":
             mmp_path = mmp_final_file_panel
-            id_mmp = id_mmp_file          # valor seleccionado
-            mmp_evt_col = mmp_evt_file    # valor seleccionado
+            id_mmp = id_mmp_file
+            mmp_evt_col = mmp_evt_file
             selected_events = events_file
         else:
             mmp_path = mmp_final_bq_panel
-            id_mmp = id_mmp_bq            # valor seleccionado
-            mmp_evt_col = mmp_evt_bq      # valor seleccionado
+            id_mmp = id_mmp_bq
+            mmp_evt_col = mmp_evt_bq
             selected_events = events_bq
 
         if not id_cli: