Update app.py

app.py

@@ -1,37 +1,45 @@
-import gradio as gr
-from google import genai
-from google.genai import types
-import os
-import time
 from datetime import datetime, timedelta
-import tempfile
-import shutil
-from pathlib import Path
-
-G_API_KEY = os.environ.get("G_API_KEY")
-
-fecha_actual = datetime.now().strftime("%d/%m/%Y")
-dos_semanas_atras = (datetime.now() - timedelta(weeks=2)).strftime("%d/%m/%Y")
-
-# Variables globales para almacenar datos del trabajador y cédula
-datos_trabajador = {
-    'nombre': None,
-    'apellido': None,
-    'rut': None,
-    'fecha_vencimiento': None,
-    'cedula_path': None  # Guardar el path temporal de la cédula
-}
 
+INSTRUCCIONES_USUARIO ="""
+        # 📋 Sistema de Revisión de Documentos
+        
+        **📦 Instrucciones para preparar el archivo ZIP:**
+        
+        1. **Crea una Carpeta para cada trabajador** (por ejemplo: "Juan Pérez", "María López", etc.)
+        2. **Dentro de cada Carpeta**, coloca:
+           - La cédula del trabajador (el nombre debe contener "cedula" o "cédula")
+           - Todos los demás documentos del trabajador (contratos, afiliafonasa, etc.)
+        3. **Comprime todas las carpetas en un solo archivo ZIP**
+        4. **Sube el archivo ZIP** usando el botón de abajo
+        
+        **Ejemplo de estructura:**
+        ```
+        Documentos.zip
+        ├── Juan Perez/
+        │   ├── cedula.pdf
+        │   ├── contrato.pdf
+        │   └── afiliafonasa.pdf
+        ├── Maria Lopez/
+        │   ├── cedula.pdf
+        │   ├── contrato.pdf
+        │   └── certificado.pdf
+        └── Pedro Garcia/
+            ├── cedula.pdf
+            └── contrato.pdf
+        ```
+        
+        ⚠️ **Importante:** Cada Carpeta debe tener un archivo que contenga "cedula" o "cédula" en su nombre.
+        """
 prompt_cedula = """
 Eres un revisor de acreditación de personal para una minera chilena.
-Se te entrega un documento de identificación Nacional de un trabajador en formato PDF, enviado por el contratista para acreditación.
+Se te entrega un Documento de identificación Nacional de un trabajador en formato PDF, enviado por el contratista para acreditación.
 
 Tu tarea:
-- Verifica la vigencia del documento.
-- Verifica que se vea el frente y el reverso del documento.
-- Verifica que exista una firma en el documento.
-- Verifica que exista una foto de la cara del trabajador en el documento.
-- Extrae la fecha de vencimiento del documento.
+- Verifica la vigencia del Documento.
+- Verifica que se vea el frente y el reverso del Documento en la misma hoja.
+- Verifica que exista una firma en el Documento.
+- Verifica que exista una foto de la cara del trabajador en el Documento.
+- Extrae la fecha de vencimiento del Documento.
 - Identifica el RUT o RUN del trabajador, bajo la imagen de su foto.
 
 - Si todo está correcto, responde EXACTAMENTE en este formato (sin agregar texto adicional):
@@ -45,11 +53,14 @@ Tu tarea:
 No agregues texto adicional, saludos, ni explicaciones fuera del formato solicitado.
 """
 
+fecha_actual = datetime.now().strftime("%d/%m/%Y")
+dos_semanas_atras = (datetime.now() - timedelta(weeks=10)).strftime("%d/%m/%Y")
+
 prompt_documento_general = """
 Eres un revisor de documentos de acreditación de personal para una minera chilena.
 Se te entregan dos documentos PDF:
 1. La cédula de identidad del trabajador (como referencia para revisar firma).
-2. Un documento enviado por el contratista para ser acreditado.
+2. Un Documento enviado por el contratista para ser acreditado.
 
 Datos del trabajador a verificar:
 - Nombre: {nombre}
@@ -58,17 +69,17 @@ Datos del trabajador a verificar:
 - Fecha actual: {fecha_actual}
 
 Tu tarea:
-- Verifica que el documento contenga el nombre completo ({nombre} {apellido}) del trabajador.
-- Verifica que el documento contenga el RUT ({rut}) del trabajador.
-- Rechazar la aprobación en el caso de que las firmas que estén presentes en el documento y que sean del trabajador, no sean lo suficientemente similares a la firma en la cédula de identidad como para asumir que es él quien firma.
-- Verifica que el documento tenga una fecha reciente (mayor a """+f"{dos_semanas_atras}"+""").
-- Verifica que el documento esté completo y legible.
-- Extrae la fecha del documento.
+- Verifica que el Documento contenga el nombre completo ({nombre} {apellido}) del trabajador.
+- Verifica que el Documento contenga el RUT ({rut}) del trabajador.
+- Rechazar la aprobación en el caso de que las firmas que estén presentes en el Documento y que sean del trabajador, no sean lo suficientemente similares a la firma en la cédula de identidad como para asumir que es él quien firma.
+- Verifica que el Documento tenga una fecha reciente (mayor a """+f"{dos_semanas_atras}"+""").
+- Verifica que el Documento esté completo y legible.
+- Extrae la fecha del Documento.
 
 - Si todo está correcto, responde EXACTAMENTE en este formato (sin agregar texto adicional):
   "Acreditado: [Nombre], [Apellido], [RUT], [Fecha_Documento], [Estado_Firma]"
 
-- Si el documento son examenes médicos, solo verifica [Nombre], [Apellido] y [Fecha_Documento]
+- Si el Documento son examenes médicos, solo verifica [Nombre], [Apellido] y [Fecha_Documento]
   
   Donde [Estado_Firma] puede ser: "Firma Coincide" o "Firma Similar" o "Firma No Verificable"
   
@@ -79,14 +90,41 @@ Tu tarea:
   
 No agregues texto adicional, saludos, ni explicaciones fuera del formato solicitado.
 """
-client = genai.Client(api_key=G_API_KEY)
+
+# pip install google-genai gradio
+
+import gradio as gr
+from google import genai
+from google.genai import types
+import os
+import time
+from datetime import datetime, timedelta
+import tempfile
+import shutil
+from pathlib import Path
+from collections import defaultdict
+import zipfile
+import analytics
+
+fecha_actual = datetime.now().strftime("%d/%m/%Y")
+dos_semanas_atras = (datetime.now() - timedelta(weeks=2)).strftime("%d/%m/%Y")
+
+# Variables globales para almacenar datos del trabajador y cédula
+datos_trabajador = {
+    'nombre': None,
+    'apellido': None,
+    'rut': None,
+    'fecha_vencimiento': None,
+    'cedula_path': None
+}
+
+G_API_KEY = os.environ.get("G_API_KEY")
+client = genai.Client(breakpoint_key=G_API_KEY)
 
 def revisar_cedula(cedula_file):
     """Procesa la cédula y extrae datos del trabajador"""
     global datos_trabajador
     
-    # Inicializar cliente Gemini
-    
     try:
         # Leer bytes de la cédula
         with open(cedula_file, "rb") as f:
@@ -107,14 +145,12 @@ def revisar_cedula(cedula_file):
         )
         
         result = response.text.strip()
-        
+        analytics.enviar_evento(email_us,'Revisión cédula')
         if result.lower().startswith("acreditado"):
             try:
-                # Extraer la parte después de "Acreditado:"
                 txt_str = result.split(":", 1)[1].strip()
                 partes = [p.strip() for p in txt_str.split(",")]
                 
-                # Verificar que tengamos 4 partes
                 if len(partes) >= 4:
                     datos_trabajador['nombre'] = partes[0]
                     datos_trabajador['apellido'] = partes[1]
@@ -140,21 +176,14 @@ def revisar_cedula(cedula_file):
 
 
 def revisar_documento_general(documento_file):
-    """Revisa cualquier documento comparándolo con la cédula"""
+    """Revisa cualquier Documento comparándolo con la cédula"""
     global datos_trabajador
     
-    # Verificar que tengamos los datos del trabajador y la cédula
     if not all([datos_trabajador['nombre'], datos_trabajador['apellido'], 
                 datos_trabajador['rut'], datos_trabajador['cedula_path']]):
         return os.path.basename(documento_file), "⚠️ Pendiente", "Debe procesarse primero la cédula"
     
-    # Inicializar cliente Gemini
-
-    
     try:
-        # Obtener fecha actual
-
-        # Crear prompt con los datos del trabajador
         prompt = prompt_documento_general.format(
             nombre=datos_trabajador['nombre'],
             apellido=datos_trabajador['apellido'],
@@ -162,11 +191,9 @@ def revisar_documento_general(documento_file):
             fecha_actual=fecha_actual
         )
         
-        # Leer cédula
         with open(datos_trabajador['cedula_path'], "rb") as f:
             cedula_bytes = f.read()
         
-        # Leer documento a validar
         with open(documento_file, "rb") as f:
             documento_bytes = f.read()
         
@@ -183,14 +210,12 @@ def revisar_documento_general(documento_file):
         )
         
         result = response.text.strip()
-        
+        analytics.enviar_evento(email_us,'Revisión')
         if result.lower().startswith("acreditado"):
             try:
-                # Extraer la parte después de "Acreditado:"
                 txt_str = result.split(":", 1)[1].strip()
                 partes = [p.strip() for p in txt_str.split(",")]
                 
-                # Verificar que tengamos 5 partes
                 if len(partes) >= 5:
                     nombre = partes[0]
                     apellido = partes[1]
@@ -206,11 +231,9 @@ def revisar_documento_general(documento_file):
                     
                     return os.path.basename(documento_file), "✅ Pre-Acreditado", detalle
                 else:
-                    # Si no hay 5 partes, mostrar lo que se recibió
                     return os.path.basename(documento_file), "✅ Pre-Acreditado", result
                     
             except Exception as e:
-                # Si hay error al parsear, mostrar la respuesta completa
                 return os.path.basename(documento_file), "✅ Pre-Acreditado", result
         else:
             return os.path.basename(documento_file), "❌ Posible rechazo", result.replace(f'no es mayor a {dos_semanas_atras}', 'es posible que sea muy antigua')\
@@ -220,148 +243,313 @@ def revisar_documento_general(documento_file):
                                                                                         .replace('Rechazado: ','')
             
     except Exception as e:
-        return os.path.basename(documento_file), "❌ Error", f"Error al procesar documento: {str(e)}"
+        return os.path.basename(documento_file), "❌ Error", f"Error al procesar Documento: {str(e)}"
 
 
+def validar_acceso(email):
+    import re
+    global email_us 
 
 
-def revisar_carpeta_stream(archivos):
-    global datos_trabajador
+    patron_email = r'^\+569[0-9]+$'
+    if not email or not email.strip():
+        return {
+            pantalla_acceso: gr.update(visible=True),
+            pantalla_principal: gr.update(visible=False),
+            mensaje_error: gr.update(value="⚠️ Por favor ingresa un número de WhatsApp para recibir los resultados", visible=True),
+            acceso_granted: False,
+            email_usuario: ""
+        }
     
-    if not archivos:
-        yield [["⚠️ No se subieron archivos.", "", ""]]
-        return
-    
-    datos_trabajador = {
-        'nombre': None,
-        'apellido': None,
-        'rut': None,
-        'fecha_vencimiento': None,
-        'cedula_path': None
+    if not re.match(patron_email, email.strip()):
+        return {
+            pantalla_acceso: gr.update(visible=True),
+            pantalla_principal: gr.update(visible=False),
+            mensaje_error: gr.update(value="⚠️ Por favor ingresa un número de WhatsApp válido", visible=True),
+            acceso_granted: False,
+            email_usuario: ""
+        }
+
+    email_us = email
+
+    analytics.enviar_evento(email,'Sign up')
+
+    return {
+        pantalla_acceso: gr.update(visible=False),
+        pantalla_principal: gr.update(visible=True),
+        mensaje_error: gr.update(visible=False),
+        acceso_granted: True,
+        email_usuario: email
     }
+
+
+def extraer_archivos_de_zip(zip_path):
+    """
+    Extrae archivos del ZIP y los organiza por Carpeta.
+    Retorna un diccionario: {nombre_carpeta: [lista_de_rutas_pdf]}
+    """
+    carpetas = defaultdict(list)
+    temp_dir = tempfile.mkdtemp()
     
-    resultados = []
-    
-    # Obtener lista de PDFs desde los archivos subidos
-    lista_pdfs = []
-    for archivo in archivos:
-        archivo_path = archivo if isinstance(archivo, str) else archivo.name
-        if archivo_path.lower().endswith(".pdf"):
-            lista_pdfs.append(archivo_path)
-    
-    if not lista_pdfs:
-        yield [["⚠️ No se encontraron archivos PDF.", "", ""]]
-        return
-    
-    # Separar cédula del resto de documentos
-    cedula = None
-    otros_docs = []
-    
-    for pdf_path in lista_pdfs:
-        nombre_archivo = os.path.basename(pdf_path)
-        
-        if 'cedula' in nombre_archivo.lower() or 'cédula' in nombre_archivo.lower():
-            cedula = pdf_path
-        else:
-            otros_docs.append(pdf_path)
-    
-    if not cedula:
-        yield [["❌ Error", "", "No se encontró ninguna cédula. Debe incluir un archivo con 'cedula' o 'cédula' en el nombre."]]
-        return
-    
-    # 1. Procesar primero la cédula
     try:
-        nombre, estado, detalle = revisar_cedula(cedula)
-        resultados.append([nombre, estado, detalle])
-        yield resultados
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            # Extraer todos los archivos
+            zip_ref.extractall(temp_dir)
         
-        if estado == "❌ Rechazado" or estado == "❌ Error":
-            yield resultados
-            return
+        # Recorrer el directorio extraído
+        for root, dirs, files in os.walk(temp_dir):
+            for file in files:
+                if file.lower().endswith('.pdf'):
+                    archivo_path = os.path.join(root, file)
+                    
+                    # Obtener la Carpeta relativa
+                    carpeta_relativa = os.path.relpath(root, temp_dir)
+                    
+                    # Si está en la raíz, usar "Raíz"
+                    if carpeta_relativa == '.':
+                        carpeta_nombre = "Raíz"
+                    else:
+                        # Usar solo el primer nivel de Carpeta
+                        carpeta_nombre = carpeta_relativa.split(os.sep)[0]
+                    
+                    carpetas[carpeta_nombre].append(archivo_path)
+        
+        return carpetas, temp_dir
         
-        time.sleep(1)
     except Exception as e:
-        resultados.append([os.path.basename(cedula), "❌ Error", str(e)])
-        yield resultados
-        return
-    
-    # 2. Procesar el resto de documentos
-    for doc_path in otros_docs:
-        try:
-            nombre, estado, detalle = revisar_documento_general(doc_path)
-            resultados.append([nombre, estado, detalle])
-            yield resultados
-            time.sleep(15)
-        except Exception as e:
-            resultados.append([os.path.basename(doc_path), "❌ Error", str(e)])
-            yield resultados
-    
-    if len(resultados) == 1:
-        resultados.append(["⚠️ Información", "", "Solo se procesó la cédula. No se encontraron otros documentos."])
-        yield resultados
+        # Limpiar en caso de error
+        if os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+        raise e
 
 
-# Interfaz Gradio
-with gr.Blocks(title="Revisión de Documentos SERCOL") as demo:
-    gr.Markdown("""
-    ## 🧾 Revisor de Documentos de Acreditación de Personal para SERCOL  
-                
-    El sistema revisará primero la **cédula** para extraer los datos del trabajador y su firma, 
-    y usará esa información para validar **todos los demás documentos**, verificando:
-    
-    **Para la Cédula:**
-    - ✅ Nombre, Apellido y RUT
-    - ✅ Fecha de vencimiento
-    
-    **Para otros documentos:**
-    - ✅ Nombre y apellido coincidan
-    - ✅ RUT coincida
-    - ✅ Firma sea similar a la de la cédula
-    - ✅ Fecha del documento reciente (últimas 2 semanas)
-    - ✅ Formato de fechas
-    
-    ⚠️ **Importante**: 
-    - El archivo de la cédula debe tener "cedula" o "cédula" en el nombre
-    - Puedes subir archivos PDF individuales o seleccionar una carpeta completa
-    - Todos los documentos deben estar en formato PDF
-    """)
-
-    archivos_input = gr.File(
-        label="📁 Sube PDFs o selecciona una carpeta con documentos",
-        file_count="directory",
-        file_types=[".pdf"]
-    )
 
-    tabla_resultados = gr.Dataframe(
-        headers=["Archivo", "Estado", "Detalle"],
-        datatype=["str", "str", "str"],
-        interactive=False,
-        wrap=True,
-        label="📋 Resultados de revisión"
-    )
 
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import threading
+
+def revisar_zip_stream(archivo_zip, email_usuario, progress=gr.Progress()):
+    global datos_trabajador, resultados_acreditacion
+
+    # ✅ Reiniciar resultados de forma segura
+    resultados_acreditacion = {}
+    resultados_acreditacion['Carpeta'] = []
+    resultados_acreditacion['Documento'] = []
+    resultados_acreditacion['Estado'] = []
+    resultados_acreditacion['Observaciones'] = []
+
+    if not archivo_zip:
+        return []
+
+    zip_path = archivo_zip if isinstance(archivo_zip, str) else archivo_zip.name
+    if not zip_path.lower().endswith('.zip'):
+        return []
+
+    resumen_carpetas = []
+    temp_dir = None
+    resultados_lock = threading.Lock()
+
+    try:
+        progress(0, desc="📦 Extrayendo archivo ZIP...")
+        carpetas_dict, temp_dir = extraer_archivos_de_zip(zip_path)
+
+        if not carpetas_dict:
+            return []
+
+        carpetas_ordenadas = sorted(carpetas_dict.items())
+        total_carpetas = len(carpetas_ordenadas)
+
+        for idx_carpeta, (nombre_carpeta, archivos_carpeta) in enumerate(carpetas_ordenadas, 1):
+            progress(idx_carpeta / total_carpetas, desc=f"📂 Revisando carpeta: \"{nombre_carpeta}\"")
+
+            # Reiniciar datos del trabajador
+            datos_trabajador = {
+                'nombre': None, 'apellido': None, 'rut': None,
+                'fecha_vencimiento': None, 'cedula_path': None
+            }
+
+            # Buscar cédula
+            cedula = next((p for p in archivos_carpeta if 'cedula' in p.lower() or 'cédula' in p.lower() or ' ci.pdf' in p.lower()), None)
+            if not cedula:
+                resultados_acreditacion['Carpeta'].append(nombre_carpeta)
+                resultados_acreditacion['Documento'].append("-")
+                resultados_acreditacion['Estado'].append("❌ Error")
+                resultados_acreditacion['Observaciones'].append("No se encontró ninguna cédula en esta Carpeta.")
+                resumen_carpetas.append([nombre_carpeta, "❌ Error", "No se encontró cédula"])
+                continue
 
+            # Procesar cédula
+            nombre, Estado, detalle = revisar_cedula(cedula)
+            resultados_acreditacion['Carpeta'].append(nombre_carpeta)
+            resultados_acreditacion['Documento'].append(os.path.basename(cedula))
+            resultados_acreditacion['Estado'].append(Estado)
+            resultados_acreditacion['Observaciones'].append(detalle)
 
-    # Por esto:
-    revisar_btn = gr.Button("🔍 Iniciar revisión", variant="primary")
+            if Estado.startswith("❌"):
+                resumen_carpetas.append([nombre_carpeta, "❌ Posible rechazo", "Error en cédula"])
+                continue
 
-    def activar_carga():
-        return gr.Button("⏳ Procesando...", interactive=False)
+            # Procesar documentos generales
+            documentos_a_procesar = [
+                p for p in archivos_carpeta
+                if 'cedula' not in os.path.basename(p).lower()
+                and 'cédula' not in os.path.basename(p).lower()
+                and ' ci.pdf' not in os.path.basename(p).lower()
+            ]
 
-    def desactivar_carga():
+            tiene_rechazo = False
+            documentos_procesados = 0
+            total_docs = len(documentos_a_procesar)
+
+            def procesar_doc(pdf_path, idx_doc):
+                """Revisa un documento y actualiza el progreso."""
+                doc_name = os.path.basename(pdf_path)
+                progress(
+                    (idx_carpeta - 1 + (idx_doc / max(1, total_docs))) / total_carpetas,
+                    desc=f"📂 Carpeta: '{nombre_carpeta}' → 📄 Documento {idx_doc}/{total_docs}: {doc_name}"
+                )
+
+                nombre, Estado, detalle = revisar_documento_general(pdf_path)
+                with resultados_lock:
+                    resultados_acreditacion['Carpeta'].append(nombre_carpeta)
+                    resultados_acreditacion['Documento'].append(nombre)
+                    resultados_acreditacion['Estado'].append(Estado)
+                    resultados_acreditacion['Observaciones'].append(detalle)
+                return Estado
+
+            # ✅ Paralelización por carpeta si hay más de 1 documento
+            if total_docs >= 2:
+                print(f"🧩 Procesando {total_docs} documentos en paralelo dentro de '{nombre_carpeta}'")
+                with ThreadPoolExecutor(max_workers=min(4, total_docs)) as executor:
+                    futures = {executor.submit(procesar_doc, pdf, i+1): pdf for i, pdf in enumerate(documentos_a_procesar)}
+                    for future in as_completed(futures):
+                        try:
+                            estado = future.result()
+                            if "rechazo" in estado.lower() or "error" in estado.lower():
+                                tiene_rechazo = True
+                            documentos_procesados += 1
+                        except Exception as e:
+                            print(f"⚠️ Error en revisión paralela de {futures[future]}: {e}")
+            else:
+                # Procesamiento secuencial (solo 1 documento)
+                for idx_doc, pdf_path in enumerate(documentos_a_procesar, 1):
+                    estado = procesar_doc(pdf_path, idx_doc)
+                    if "rechazo" in estado.lower() or "error" in estado.lower():
+                        tiene_rechazo = True
+                    documentos_procesados += 1
+
+            resumen_carpetas.append([
+                nombre_carpeta,
+                "⚠️ Posible rechazo" if tiene_rechazo else "✅ Pre-acreditada",
+                f"{documentos_procesados + 1} documentos revisados"
+            ])
+
+
+        progress(1.0, desc=f"🎉 Completado - {total_carpetas} Carpeta(s) revisada(s)")
+
+        # ✅ Reemplazar global al final
+        resultados_acreditacion = resultados_acreditacion.copy()
+
+        # Envío de correo
+        import brevo
+        email = brevo.BrevoEmail(API_BREVO)
+        email.enviar(
+            destinatario_email='emiliano@prosync.cl',
+            asunto=f"Resultados pre-acreditación: {email_usuario}",
+            data=resultados_acreditacion,
+            numero_documentos=len(resultados_acreditacion['Documento']),
+            numero_carpetas=len(set(resultados_acreditacion['Carpeta']))
+        )
+
+        return resumen_carpetas
+
+    finally:
+        if temp_dir and os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+
+
+def habilitar_boton(archivo):
+    """Habilita el botón solo si hay un archivo cargado"""
+    if archivo is None:
+        return gr.Button("🔍 Iniciar revisión", variant="primary", interactive=False)
+    else:
         return gr.Button("🔍 Iniciar revisión", variant="primary", interactive=True)
 
-    revisar_btn.click(
-        fn=activar_carga,
-        outputs=revisar_btn
-    ).then(
-        fn=revisar_carpeta_stream,
-        inputs=archivos_input,
-        outputs=tabla_resultados
-    ).then(
-        fn=desactivar_carga,
-        outputs=revisar_btn
+with gr.Blocks(title="Revisión de Documentos de Acreditación de Personal") as demo:
+    acceso_granted = gr.State(False)
+    email_usuario = gr.State("")
+    
+    # PANTALLA DE ACCESO
+    with gr.Column(visible=True) as pantalla_acceso:
+        gr.Markdown("""
+        # 🔐 Sistema de revisión documentos de Acreditación de Personal
+        
+        Por favor, ingresa tu tu WhatsApp para recibir los resultados.
+        """)
+        
+        email_input = gr.Textbox(
+            label="WhatsApp",
+            placeholder="Deja tu WhatsApp para recibir los resultados",
+            type="email",
+            value="+569"
+        )
+        
+        acceder_btn = gr.Button("Acceder al Sistema", variant="primary", size="lg")
+        mensaje_error = gr.Markdown(visible=False)
+    
+    with gr.Column(visible=False) as pantalla_principal:
+        gr.Markdown("""
+        # 📋 Sistema de Revisión de Documentos
+        
+        Sube un archivo ZIP con las carpetas de documentos para revisar.
+        """)
+
+        archivo_zip_input = gr.File(
+            label="📦 Sube el archivo ZIP con las carpetas de documentos",
+            file_types=[".zip"],
+            file_count="single"
+        )
+
+        revisar_btn = gr.Button("🔍 Iniciar revisión", variant="primary", size="lg")
+        
+        # Tabla de resumen por carpetas
+        tabla_resumen = gr.Dataframe(
+            headers=["Carpeta", "Estado", "Detalle"],
+            datatype=["str", "str", "str"],
+            interactive=False,
+            wrap=True,
+            label=f"📊 Resumen por Carpeta (Información completa en tu WhatsApp)"
+        )
+        # Habilitar botón cuando se cargue el archivo
+        archivo_zip_input.change(
+            fn=habilitar_boton,
+            inputs=[archivo_zip_input],
+            outputs=revisar_btn
+        )
+        def activar_carga():
+            return gr.Button("⏳ Procesando...", interactive=False)
+
+        def desactivar_carga():
+            return gr.Button("🔍 Iniciar revisión", variant="primary", interactive=True)
+
+        revisar_btn.click(
+            fn=activar_carga,
+            outputs=revisar_btn
+        ).then(
+            fn=revisar_zip_stream,
+            inputs=[archivo_zip_input, email_usuario],
+            outputs=tabla_resumen
+        ).then(
+            fn=desactivar_carga,
+            outputs=revisar_btn
+        )
+
+    acceder_btn.click(
+        fn=validar_acceso,
+        inputs=[email_input],
+        outputs=[pantalla_acceso, pantalla_principal, mensaje_error, acceso_granted, email_usuario]
     )
 
+
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(share=True)