Interfaz guiada paso a paso en español

app.py

@@ -12,6 +12,7 @@ import docx2pdf
 
 class DocumentProcessor:
     def __init__(self):
+        self.input_files = []
         self.excel_data = None
         self.mapping = {}
         self.conditional_docs = {}
@@ -19,86 +20,57 @@ class DocumentProcessor:
         self.column_associations = {}
         self.first_df = None
         self.second_df = None
-        self.folder_column = None
-        self.current_step = 1
-        self.conditional_files = []
+        self.folder_column = None  # Agregar para recordar la columna de carpetas
         
     def load_excel_file(self, excel_file):
         """Cargar archivo Excel y retornar información de columnas"""
         if excel_file is None:
-            return "❌ No se ha seleccionado ningún archivo", gr.Dropdown(choices=[]), "", gr.update(visible=False), gr.update(visible=False)
+            return "No file selected", gr.Dropdown(choices=[]), "", gr.Dropdown(choices=[])
         
         try:
             self.excel_data = pd.read_excel(excel_file.name)
             columns = list(self.excel_data.columns)
-            preview = self.excel_data.head(3).to_string()
-            success_msg = f"✅ ¡Excelente! Se cargó correctamente el archivo Excel.\n📊 Se encontraron {len(self.excel_data)} filas de datos.\n📋 Columnas disponibles: {', '.join(columns)}"
-            
-            return (success_msg, 
-                   gr.Dropdown(choices=columns, visible=True), 
+            preview = self.excel_data.head().to_string()
+            return (f"Excel file loaded successfully. Columns: {', '.join(columns)}", 
+                   gr.Dropdown(choices=columns), 
                    preview,
-                   gr.update(visible=True),
-                   gr.update(visible=True))
+                   gr.Dropdown(choices=columns))
         except Exception as e:
-            return f"❌ Error al cargar el archivo Excel: {str(e)}", gr.Dropdown(choices=[]), "", gr.update(visible=False), gr.update(visible=False)
+            return f"Error loading Excel file: {str(e)}", gr.Dropdown(choices=[]), "", gr.Dropdown(choices=[])
     
     def set_folder_column(self, column_name):
         """Establecer la columna para nombrar carpetas"""
-        if not column_name:
-            return "⚠️ Por favor selecciona una columna"
-        
         self.folder_column = column_name
-        # Mostrar algunos ejemplos de nombres de carpetas que se crearán
-        examples = self.excel_data[column_name].head(3).tolist()
-        examples_text = ", ".join([str(ex).replace(" ", "_") for ex in examples])
-        return f"✅ Perfecto! Se usará la columna '{column_name}' para nombrar las carpetas.\n\n📁 Ejemplos de carpetas que se crearán: {examples_text}"
+        return f"Folder column set to: {column_name}"
     
     def add_keyword_mapping(self, column_name, keyword):
         """Agregar un mapeo individual de palabra clave"""
         if not column_name or not keyword:
-            return "⚠️ Por favor selecciona una columna y escribe una palabra clave", gr.update(visible=False)
-        
-        if not keyword.startswith('{{') or not keyword.endswith('}}'):
-            keyword = '{{' + keyword.strip('{}') + '}}'
+            return "Please select a column and enter a keyword"
         
         self.mapping[keyword] = column_name
         
         # Retornar lista actualizada de mapeos
-        mappings_text = ""
-        for i, (k, v) in enumerate(self.mapping.items(), 1):
-            mappings_text += f"{i}. {k} ➜ se reemplazará con datos de la columna '{v}'\n"
-        
-        return f"✅ ¡Mapeo agregado correctamente!\n\n📝 Palabras clave configuradas:\n{mappings_text}", gr.update(visible=len(self.mapping) > 0)
-    
-    def load_documents(self, files):
-        """Cargar documentos generales"""
-        if not files:
-            return "⚠️ No se han seleccionado archivos", gr.update(visible=False)
-        
-        self.general_docs = files
-        file_names = [os.path.basename(f.name) for f in files]
-        valid_files = [f for f in file_names if f.endswith(('.docx', '.pdf'))]
-        
-        if len(valid_files) == 0:
-            return "❌ No se encontraron archivos válidos (.docx o .pdf)", gr.update(visible=False)
-        
-        return f"✅ ¡Documentos cargados correctamente!\n\n📄 Archivos que se procesarán:\n" + "\n".join([f"• {name}" for name in valid_files]), gr.update(visible=True)
+        mappings_text = "\n".join([f"{k} -> {v}" for k, v in self.mapping.items()])
+        return f"Mapping added successfully!\n\nCurrent mappings:\n{mappings_text}"
     
     def load_conditional_files(self, files):
         """Cargar archivos para documentos condicionales"""
         if not files:
-            return "⚠️ No se han seleccionado archivos", [], gr.update(visible=False)
-        
-        self.conditional_files = files
-        file_names = [f.name for f in files if f.name.endswith(('.docx', '.pdf'))]
-        file_basenames = [os.path.basename(f) for f in file_names]
+            return "No files selected"
         
-        if len(file_names) == 0:
-            return "❌ No se encontraron archivos válidos (.docx o .pdf)", [], gr.update(visible=False)
+        file_list = []
+        for file in files:
+            if file.name.endswith(('.docx', '.pdf')):
+                file_list.append(file.name)
         
-        return (f"✅ Archivos condicionales cargados:\n" + "\n".join([f"• {name}" for name in file_basenames]), 
-                file_basenames, 
-                gr.update(visible=True))
+        return f"Loaded {len(file_list)} conditional files: {', '.join([os.path.basename(f) for f in file_list])}"
+    
+    def get_excel_columns(self):
+        """Obtener columnas del Excel cargado"""
+        if self.excel_data is not None:
+            return list(self.excel_data.columns)
+        return []
     
     def get_column_unique_values(self, column_name):
         """Obtener valores únicos de una columna específica"""
@@ -110,7 +82,7 @@ class DocumentProcessor:
     def set_document_condition(self, column_name, condition_value, selected_files):
         """Establecer condición para documentos específicos"""
         if not selected_files or not column_name or not condition_value:
-            return "⚠️ Por favor selecciona archivos, columna y valor de condición"
+            return "Please select files, column name, and condition value"
         
         # Inicializar estructura si no existe
         if column_name not in self.conditional_docs:
@@ -119,24 +91,19 @@ class DocumentProcessor:
         if condition_value not in self.conditional_docs[column_name]:
             self.conditional_docs[column_name][condition_value] = []
         
-        # Encontrar archivos correspondientes
-        matching_files = []
-        for file in self.conditional_files:
-            if os.path.basename(file.name) in selected_files:
-                matching_files.append(file)
-        
         # Agregar archivos a la condición
-        self.conditional_docs[column_name][condition_value] = matching_files
+        for file in selected_files:
+            if file not in self.conditional_docs[column_name][condition_value]:
+                self.conditional_docs[column_name][condition_value].append(file)
         
-        # Generar resumen
-        summary = "✅ Condiciones configuradas:\n\n"
+        # Generar resumen de todas las condiciones
+        summary = "Current Conditional Documents:\n\n"
         for col, conditions in self.conditional_docs.items():
-            summary += f"📋 Columna: {col}\n"
+            summary += f"Column: {col}\n"
             for value, files in conditions.items():
-                summary += f"  ▶️ Cuando {col} = '{value}':\n"
+                summary += f"  When {col} = '{value}':\n"
                 for file in files:
-                    file_name = os.path.basename(file.name) if hasattr(file, 'name') else str(file)
-                    summary += f"    • {file_name}\n"
+                    summary += f"    - {os.path.basename(file.name) if hasattr(file, 'name') else file}\n"
             summary += "\n"
         
         return summary
@@ -144,26 +111,26 @@ class DocumentProcessor:
     def load_first_excel(self, file):
         """Cargar primer archivo Excel para asociaciones"""
         if file is None:
-            return "⚠️ No se ha seleccionado archivo", []
+            return "No file selected", gr.Dropdown(choices=[])
         
         try:
             self.first_df = pd.read_excel(file.name)
             columns = list(self.first_df.columns)
-            return f"✅ Primer Excel cargado correctamente\n📋 Columnas: {', '.join(columns)}", columns
+            return f"First Excel loaded: {', '.join(columns)}", gr.Dropdown(choices=columns)
         except Exception as e:
-            return f"❌ Error: {str(e)}", []
+            return f"Error: {str(e)}", gr.Dropdown(choices=[])
     
     def load_second_excel(self, file):
         """Cargar segundo archivo Excel para asociaciones"""
         if file is None:
-            return "⚠️ No se ha seleccionado archivo", []
+            return "No file selected", gr.Dropdown(choices=[])
         
         try:
             self.second_df = pd.read_excel(file.name)
             columns = list(self.second_df.columns)
-            return f"✅ Segundo Excel cargado correctamente\n📋 Columnas: {', '.join(columns)}", columns
+            return f"Second Excel loaded: {', '.join(columns)}", gr.Dropdown(choices=columns)
         except Exception as e:
-            return f"❌ Error: {str(e)}", []
+            return f"Error: {str(e)}", gr.Dropdown(choices=[])
     
     def get_column_values(self, df, column_name):
         """Obtener valores únicos de una columna"""
@@ -174,82 +141,48 @@ class DocumentProcessor:
     def assign_values(self, first_column, first_value, second_column, second_value):
         """Asignar valores para asociaciones de columnas"""
         if not all([first_column, first_value, second_column, second_value]):
-            return "⚠️ Por favor completa todos los campos"
+            return "Please fill all fields"
         
         # Crear asociación
-        self.column_associations[first_value] = second_value
+        if first_value not in self.column_associations:
+            self.column_associations[first_value] = second_value
         
         # Retornar resumen actual de asociaciones
-        associations_text = "✅ Asociaciones configuradas:\n\n"
-        for k, v in self.column_associations.items():
-            associations_text += f"• {k} ➜ {v}\n"
-        
-        return associations_text
+        associations_text = "\n".join([f"{k} -> {v}" for k, v in self.column_associations.items()])
+        return f"Association added. Current associations:\n{associations_text}"
     
-    def check_ready_status(self):
-        """Verificar si todo está listo para procesar"""
-        status = []
-        ready = True
+    def load_general_documents(self, files):
+        """Cargar documentos generales"""
+        if not files:
+            return "No files selected"
         
-        if self.excel_data is not None:
-            status.append("✅ Archivo Excel principal cargado")
-        else:
-            status.append("❌ Falta cargar archivo Excel principal")
-            ready = False
-        
-        if self.folder_column:
-            status.append("✅ Columna para carpetas seleccionada")
-        else:
-            status.append("❌ Falta seleccionar columna para carpetas")
-            ready = False
-            
-        if len(self.mapping) > 0:
-            status.append(f"✅ {len(self.mapping)} palabra(s) clave configurada(s)")
-        else:
-            status.append("❌ Faltan palabras clave por configurar")
-            ready = False
-            
-        if len(self.general_docs) > 0:
-            status.append(f"✅ {len(self.general_docs)} documento(s) general(es) cargado(s)")
-        else:
-            status.append("❌ Faltan documentos generales por cargar")
-            ready = False
-        
-        # Verificar configuraciones opcionales
-        if len(self.conditional_docs) > 0:
-            total_conditions = sum(len(conditions) for conditions in self.conditional_docs.values())
-            status.append(f"✅ {total_conditions} condición(es) para documentos específicos")
-        else:
-            status.append("ℹ️ Sin documentos condicionales (opcional)")
-            
-        if len(self.column_associations) > 0:
-            status.append(f"✅ {len(self.column_associations)} asociación(es) de datos configurada(s)")
-        else:
-            status.append("ℹ️ Sin asociaciones de datos (opcional)")
-        
-        status_text = "\n".join(status)
-        
-        if ready:
-            status_text += "\n\n🎉 ¡Todo listo para procesar!"
-            return status_text, gr.update(visible=True)
-        else:
-            status_text += "\n\n⏳ Completa los pasos obligatorios para continuar"
-            return status_text, gr.update(visible=False)
+        self.general_docs = files
+        file_names = [os.path.basename(f.name) for f in files]
+        return f"Loaded {len(files)} general documents: {', '.join(file_names)}"
     
-    def process_documents(self, progress=gr.Progress()):
+    def process_documents(self, folder_column=None, progress=gr.Progress()):
         """Procesar todos los documentos"""
-        if not all([self.excel_data is not None, self.folder_column, self.mapping, self.general_docs]):
-            return "❌ Faltan datos por configurar. Revisa los pasos anteriores.", None
+        if self.excel_data is None:
+            return "Please load an Excel file first", None
+        
+        # Usar la columna guardada si no se proporciona una
+        if folder_column is None:
+            folder_column = self.folder_column
+            
+        if not folder_column:
+            return "Please select a column for folder naming in Main Setup tab", None
+        
+        if folder_column not in self.excel_data.columns:
+            return f"Column '{folder_column}' not found in Excel file", None
         
         try:
             # Crear directorio temporal para salida
             output_dir = tempfile.mkdtemp()
-            total_rows = len(self.excel_data)
             
-            progress(0, desc="Iniciando procesamiento...")
+            total_rows = len(self.excel_data)
             
-            for index, row in progress.tqdm(self.excel_data.iterrows(), total=total_rows, desc="Procesando documentos"):
-                folder_name = str(row[self.folder_column]).strip().replace(" ", "_")
+            for index, row in progress.tqdm(self.excel_data.iterrows(), total=total_rows, desc="Processing documents"):
+                folder_name = str(row[folder_column]).strip().replace(" ", "_")
                 client_folder = os.path.join(output_dir, folder_name)
                 os.makedirs(client_folder, exist_ok=True)
                 
@@ -265,8 +198,6 @@ class DocumentProcessor:
                             for doc_file in conditions[value]:
                                 self.process_file(doc_file, row, client_folder)
             
-            progress(0.8, desc="Creando archivo ZIP...")
-            
             # Crear archivo ZIP con todos los resultados
             zip_buffer = BytesIO()
             with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
@@ -279,19 +210,17 @@ class DocumentProcessor:
             zip_buffer.seek(0)
             
             # Guardar ZIP temporal
-            zip_path = os.path.join(tempfile.gettempdir(), "documentos_procesados.zip")
+            zip_path = os.path.join(tempfile.gettempdir(), "processed_documents.zip")
             with open(zip_path, 'wb') as f:
                 f.write(zip_buffer.getvalue())
             
             # Limpiar directorio temporal
             shutil.rmtree(output_dir)
             
-            progress(1.0, desc="¡Completado!")
-            
-            return f"🎉 ¡Procesamiento completado con éxito!\n\n📊 Se procesaron {total_rows} registros\n📁 Se crearon {total_rows} carpetas con documentos personalizados\n\n⬇️ Descarga tu archivo ZIP con todos los documentos", zip_path
+            return f"Processing complete! Generated documents for {total_rows} entries.", zip_path
             
         except Exception as e:
-            return f"❌ Error durante el procesamiento: {str(e)}", None
+            return f"Error during processing: {str(e)}", None
     
     def process_file(self, file, row, client_folder):
         """Procesar un archivo individual"""
@@ -323,7 +252,7 @@ class DocumentProcessor:
         """Reemplazar palabras clave en documento"""
         for keyword, column in self.mapping.items():
             if column in row:
-                replacement = str(row[column]) if pd.notna(row[column]) else ""
+                replacement = str(row[column])
                 
                 # Aplicar asociaciones de columnas si existen
                 if replacement in self.column_associations:
@@ -331,21 +260,17 @@ class DocumentProcessor:
                 
                 # Manejar texto multilínea
                 if '\\n' in replacement:
-                    replacement = replacement.replace('\\n', '\n')
+                    replacement = self.format_multiline_text(replacement)
                 
                 # Reemplazar en párrafos
                 for paragraph in doc.paragraphs:
                     self.replace_text_in_runs(paragraph.runs, keyword, replacement)
                 
-                # Reemplazar en encabezados y pies de página
+                # Reemplazar en encabezados
                 for section in doc.sections:
                     header = section.header
                     for paragraph in header.paragraphs:
                         self.replace_text_in_runs(paragraph.runs, keyword, replacement)
-                    
-                    footer = section.footer
-                    for paragraph in footer.paragraphs:
-                        self.replace_text_in_runs(paragraph.runs, keyword, replacement)
                 
                 # Reemplazar en tablas
                 for table in doc.tables:
@@ -363,6 +288,12 @@ class DocumentProcessor:
         for run in runs:
             if keyword in run.text:
                 run.text = run.text.replace(keyword, replacement)
+                run.font.highlight_color = None
+    
+    def format_multiline_text(self, text):
+        """Formatear texto multilínea"""
+        lines = text.split('\\n')
+        return '\n'.join(lines)
     
     def replace_text_in_textboxes(self, document, placeholder, replacement):
         """Reemplazar texto en cuadros de texto"""
@@ -392,237 +323,161 @@ class DocumentProcessor:
 # Inicializar procesador
 processor = DocumentProcessor()
 
+# Crear interfaz Gradio
 def create_interface():
-    with gr.Blocks(title="Procesador de Documentos", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("""
-        # 📄 Procesador Automático de Documentos
-        
-        **¡Bienvenido!** Esta herramienta te ayudará a personalizar documentos automáticamente usando datos de Excel.
-        
-        **¿Qué hace esta herramienta?**
-        - Toma tus documentos de Word (.docx) o PDF
-        - Reemplaza palabras especiales con información de una hoja de Excel
-        - Crea carpetas personalizadas con documentos únicos para cada fila de tu Excel
-        
-        **Por ejemplo:** Si tienes un contrato con {{nombre}} y {{fecha}}, y un Excel con nombres y fechas, 
-        creará un contrato personalizado para cada persona.
-        
-        ---
-        """)
-        
-        # PASO 1: Cargar Excel
-        with gr.Group():
-            gr.Markdown("## 📊 Paso 1: Carga tu archivo de Excel")
-            gr.Markdown("""
-            **Instrucciones:**
-            - Selecciona tu archivo Excel (.xlsx o .xls)
-            - Debe contener toda la información que quieres usar en los documentos
-            - Cada fila será una persona/caso diferente
-            """)
-            
-            excel_file = gr.File(
-                label="📁 Selecciona tu archivo de Excel",
-                file_types=[".xlsx", ".xls"],
-                file_count="single"
-            )
-            excel_status = gr.Textbox(label="Estado", interactive=False, lines=3)
-            excel_preview = gr.Textbox(label="Vista previa de tus datos", lines=8, interactive=False, visible=False)
-        
-        # PASO 2: Seleccionar columna para carpetas
-        with gr.Group():
-            gr.Markdown("## 📁 Paso 2: Elige cómo nombrar las carpetas")
-            gr.Markdown("""
-            **Instrucciones:**
-            - Selecciona la columna que quieres usar para nombrar las carpetas
-            - Por ejemplo: si eliges "Nombre", cada carpeta se llamará como el nombre de cada fila
-            - Se creará una carpeta para cada fila de tu Excel
-            """)
-            
-            folder_column = gr.Dropdown(
-                label="🏷️ Selecciona la columna para nombrar carpetas",
-                choices=[],
-                interactive=True,
-                visible=False
-            )
-            folder_status = gr.Textbox(label="Estado", interactive=False, lines=3, visible=False)
-        
-        # PASO 3: Configurar palabras clave
-        with gr.Group():
-            gr.Markdown("## 🔑 Paso 3: Configura las palabras clave")
-            gr.Markdown("""
-            **Instrucciones:**
-            - Las palabras clave son las partes de tu documento que quieres reemplazar
-            - Por ejemplo: si tu documento dice "{{nombre}}", se reemplazará con el nombre de cada fila
-            - Puedes escribir la palabra clave con o sin las llaves {{ }}
-            """)
+    with gr.Blocks(title="Document Processor", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# Document Processor")
+        gr.Markdown("Process documents by replacing keywords with Excel data")
+        
+        with gr.Tabs():
+            # Pestaña Principal
+            with gr.TabItem("Main Setup"):
+                with gr.Row():
+                    excel_file = gr.File(label="Upload Excel File", file_types=[".xlsx", ".xls"])
+                    folder_column = gr.Dropdown(label="Select Column for Folder Naming", choices=[], interactive=True)
+                
+                excel_status = gr.Textbox(label="Excel Status", interactive=False)
+                excel_preview = gr.Textbox(label="Excel Preview", lines=10, interactive=False)
+                
+                gr.Markdown("### Keyword Mapping")
+                gr.Markdown("Select a column and enter the keyword that will be replaced in documents")
+                
+                with gr.Row():
+                    mapping_column = gr.Dropdown(label="Select Column", choices=[], interactive=True)
+                    keyword_input = gr.Textbox(label="Enter Keyword (e.g., {{name}}, {{address}})", placeholder="{{keyword}}")
+                
+                add_mapping_btn = gr.Button("Add Mapping", variant="secondary")
+                mapping_status = gr.Textbox(label="Current Mappings", lines=8, interactive=False)
             
-            with gr.Row():
-                mapping_column = gr.Dropdown(
-                    label="📋 Selecciona la columna de Excel",
+            # Pestaña Documentos Condicionales
+            with gr.TabItem("Conditional Documents"):
+                gr.Markdown("### Set up conditional documents that will only be included based on Excel data")
+                
+                conditional_files = gr.File(
+                    label="Upload Conditional Documents",
+                    file_count="multiple",
+                    file_types=[".docx", ".pdf"]
+                )
+                conditional_status = gr.Textbox(label="Conditional Files Status", interactive=False)
+                
+                gr.Markdown("### Set Conditions")
+                gr.Markdown("Choose which documents to include based on Excel column values")
+                
+                with gr.Row():
+                    condition_column = gr.Dropdown(
+                        label="Select Excel Column for Condition", 
+                        choices=[], 
+                        interactive=True
+                    )
+                    condition_value = gr.Dropdown(
+                        label="Select Value from Column", 
+                        choices=[], 
+                        interactive=True
+                    )
+                
+                selected_docs = gr.CheckboxGroup(
+                    label="Select Documents to Include for this Condition",
                     choices=[],
                     interactive=True
                 )
-                keyword_input = gr.Textbox(
-                    label="🔤 Escribe la palabra clave",
-                    placeholder="Ejemplo: nombre, fecha, direccion...",
-                    info="Puedes escribir con o sin {{ }}"
-                )
-            
-            add_mapping_btn = gr.Button("➕ Agregar palabra clave", variant="secondary")
-            mapping_status = gr.Textbox(label="Palabras clave configuradas", lines=6, interactive=False)
-            continue_btn1 = gr.Button("✅ Continuar al siguiente paso", variant="primary", visible=False)
-        
-        # PASO 4: Cargar documentos
-        with gr.Group():
-            gr.Markdown("## 📄 Paso 4: Sube tus documentos")
-            gr.Markdown("""
-            **Instrucciones:**
-            - Sube los documentos que quieres personalizar (.docx o .pdf)
-            - Estos documentos deben contener las palabras clave que configuraste en el paso anterior
-            - Por ejemplo: un contrato con {{nombre}} y {{fecha}}
-            """)
-            
-            document_files = gr.File(
-                label="📎 Selecciona tus documentos generales",
-                file_count="multiple",
-                file_types=[".docx", ".pdf"]
-            )
-            documents_status = gr.Textbox(label="Estado de los documentos", interactive=False, lines=4)
-            continue_btn2 = gr.Button("✅ Continuar al paso final", variant="primary", visible=False)
-        
-        # PASO 4B: Documentos condicionales (opcional)
-        with gr.Group():
-            gr.Markdown("## 📋 Paso 4B: Documentos condicionales (OPCIONAL)")
-            gr.Markdown("""
-            **¿Qué son los documentos condicionales?**
-            - Documentos que solo se incluirán para ciertas personas/casos
-            - Por ejemplo: un anexo especial solo para clientes VIP
-            - O un documento adicional solo para mayores de edad
-            
-            **Si no necesitas esto, puedes saltarte esta sección.**
-            """)
+                
+                set_condition_btn = gr.Button("Set Condition for Selected Documents")
+                condition_result = gr.Textbox(label="Condition Status", lines=8, interactive=False)
             
-            conditional_files = gr.File(
-                label="📎 Documentos condicionales (opcional)",
-                file_count="multiple",
-                file_types=[".docx", ".pdf"]
-            )
-            conditional_status = gr.Textbox(label="Estado archivos condicionales", interactive=False, lines=3)
+            # Pestaña Asociaciones de Columnas  
+            with gr.TabItem("Column Associations"):
+                gr.Markdown("### Set up value mappings between different Excel files")
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("**First Excel File**")
+                        first_excel = gr.File(label="First Excel File", file_types=[".xlsx", ".xls"])
+                        first_status = gr.Textbox(label="First Excel Status", interactive=False)
+                        first_column = gr.Dropdown(label="First Column", choices=[])
+                        first_value = gr.Dropdown(label="First Value", choices=[])
+                    
+                    with gr.Column():
+                        gr.Markdown("**Second Excel File**")
+                        second_excel = gr.File(label="Second Excel File", file_types=[".xlsx", ".xls"])
+                        second_status = gr.Textbox(label="Second Excel Status", interactive=False)
+                        second_column = gr.Dropdown(label="Second Column", choices=[])
+                        second_value = gr.Dropdown(label="Second Value", choices=[])
+                
+                assign_btn = gr.Button("Create Association")
+                associations_display = gr.Textbox(label="Current Associations", lines=10, interactive=False)
             
-            with gr.Row():
-                condition_column = gr.Dropdown(
-                    label="📋 Selecciona la columna para la condición",
-                    choices=[],
-                    interactive=True,
-                    visible=False
-                )
-                condition_value = gr.Dropdown(
-                    label="📝 Selecciona el valor específico",
-                    choices=[],
-                    interactive=True,
-                    visible=False
+            # Pestaña Documentos Generales
+            with gr.TabItem("General Documents"):
+                gr.Markdown("### Upload documents that will be processed for all entries")
+                
+                general_files = gr.File(
+                    label="Upload General Documents",
+                    file_count="multiple",
+                    file_types=[".docx", ".pdf"]
                 )
+                general_status = gr.Textbox(label="General Documents Status", interactive=False)
             
-            selected_conditional_docs = gr.CheckboxGroup(
-                label="✅ Selecciona qué documentos incluir para esta condición",
-                choices=[],
-                interactive=True,
-                visible=False
-            )
-            
-            set_condition_btn = gr.Button("➕ Configurar condición", visible=False)
-            condition_result = gr.Textbox(label="Condiciones configuradas", lines=6, interactive=False, visible=False)
-        
-        # PASO 4C: Asociaciones de datos (opcional)
-        with gr.Group():
-            gr.Markdown("## 🔗 Paso 4C: Asociación con otro Excel (OPCIONAL)")
-            gr.Markdown("""
-            **¿Para qué sirve esto?**
-            - Si tienes datos en otro archivo Excel que necesitas combinar
-            - Por ejemplo: tu Excel principal tiene códigos, pero los nombres completos están en otro archivo
-            - La herramienta puede buscar automáticamente la información correspondiente
-            
-            **Si no necesitas esto, puedes saltarte esta sección.**
-            """)
-            
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("**Primer Excel (datos principales)**")
-                    first_excel = gr.File(label="📊 Archivo Excel principal", file_types=[".xlsx", ".xls"])
-                    first_status = gr.Textbox(label="Estado", interactive=False, lines=2)
-                    first_column = gr.Dropdown(label="📋 Columna", choices=[])
-                    first_value = gr.Dropdown(label="📝 Valor", choices=[])
+            # Pestaña de Procesamiento
+            with gr.TabItem("Process Documents"):
+                gr.Markdown("## Ready to Process?")
+                gr.Markdown("Make sure you have completed all the setup in the previous tabs:")
                 
-                with gr.Column():
-                    gr.Markdown("**Segundo Excel (datos adicionales)**")
-                    second_excel = gr.File(label="📊 Archivo Excel adicional", file_types=[".xlsx", ".xls"])
-                    second_status = gr.Textbox(label="Estado", interactive=False, lines=2)
-                    second_column = gr.Dropdown(label="📋 Columna", choices=[])
-                    second_value = gr.Dropdown(label="📝 Valor", choices=[])
-            
-            assign_btn = gr.Button("🔗 Crear asociación")
-            associations_display = gr.Textbox(label="Asociaciones configuradas", lines=6, interactive=False)
-        
-        # PASO 5: Revisar y procesar
-        with gr.Group():
-            gr.Markdown("## 🚀 Paso 5: Revisar y procesar")
-            gr.Markdown("""
-            **¡Ya casi terminamos!** Revisa que todo esté correcto y presiona el botón para procesar.
-            """)
-            
-            ready_status = gr.Textbox(
-                label="Estado de preparación",
-                interactive=False,
-                lines=8,
-                value="⏳ Completa los pasos anteriores para ver el estado aquí"
-            )
-            
-            process_btn = gr.Button(
-                "🎯 ¡PROCESAR DOCUMENTOS!",
-                variant="primary",
-                size="lg",
-                visible=False
-            )
-            
-            process_status = gr.Textbox(label="Estado del procesamiento", lines=4, interactive=False)
-            download_file = gr.File(label="📥 Descargar documentos procesados", visible=False)
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("""
+                        ### Checklist:
+                        ✅ **Main Setup**: Excel file loaded and folder column selected  
+                        ✅ **Keyword Mapping**: Keywords mapped to Excel columns  
+                        ✅ **Conditional Documents**: Documents with conditions set (optional)  
+                        ✅ **Column Associations**: Value mappings configured (optional)  
+                        ✅ **General Documents**: Documents for all entries uploaded (optional)  
+                        """)
+                    
+                    with gr.Column():
+                        process_btn = gr.Button(
+                            "🚀 Process All Documents", 
+                            variant="primary", 
+                            size="lg"
+                        )
+                
+                process_status = gr.Textbox(label="Processing Status", lines=3, interactive=False)
+                download_file = gr.File(label="📥 Download Processed Documents")
         
-        # Configurar eventos
+        # CONFIGURAR TODOS LOS EVENTOS DESPUÉS DE DEFINIR TODOS LOS COMPONENTES
+        
+        # Eventos de Main Setup
         excel_file.change(
-            fn=lambda file: processor.load_excel_file(file) + (processor.get_excel_columns(),),
+            fn=lambda file: (
+                processor.load_excel_file(file)[0],  # status
+                processor.load_excel_file(file)[1],  # folder_column choices
+                processor.load_excel_file(file)[2],  # preview
+                processor.load_excel_file(file)[3],  # mapping_column choices
+                gr.Dropdown(choices=processor.get_excel_columns())  # condition_column choices
+            ),
             inputs=[excel_file],
-            outputs=[excel_status, folder_column, excel_preview, mapping_column, folder_status, condition_column]
-        )
-        
-        folder_column.change(
-            fn=processor.set_folder_column,
-            inputs=[folder_column],
-            outputs=[folder_status]
+            outputs=[excel_status, folder_column, excel_preview, mapping_column, condition_column]
         )
         
         add_mapping_btn.click(
             fn=processor.add_keyword_mapping,
             inputs=[mapping_column, keyword_input],
-            outputs=[mapping_status, continue_btn1]
+            outputs=[mapping_status]
         )
         
-        document_files.change(
-            fn=processor.load_documents,
-            inputs=[document_files],
-            outputs=[documents_status, continue_btn2]
+        folder_column.change(
+            fn=processor.set_folder_column,
+            inputs=[folder_column],
+            outputs=[]
         )
         
-        # Eventos para documentos condicionales
+        # Eventos de Conditional Documents
         conditional_files.change(
-            fn=lambda files: processor.load_conditional_files(files) + (
-                gr.update(visible=len(files) > 0 if files else False),
-                gr.update(visible=len(files) > 0 if files else False),
-                gr.update(visible=len(files) > 0 if files else False),
-                gr.update(visible=len(files) > 0 if files else False),
-                gr.update(visible=len(files) > 0 if files else False)
+            fn=lambda files: (
+                processor.load_conditional_files(files),
+                gr.CheckboxGroup(choices=[os.path.basename(f.name) for f in files] if files else [])
             ),
             inputs=[conditional_files],
-            outputs=[conditional_status, selected_conditional_docs, condition_column, condition_value, selected_conditional_docs, set_condition_btn, condition_result]
+            outputs=[conditional_status, selected_docs]
         )
         
         condition_column.change(
@@ -632,15 +487,14 @@ def create_interface():
         )
         
         set_condition_btn.click(
-            fn=lambda col, val, selected_docs: (
-                processor.set_document_condition(col, val, selected_docs),
-                gr.update(visible=True)
+            fn=lambda col, val, selected_doc_names, files: processor.set_document_condition(
+                col, val, [f for f in files if os.path.basename(f.name) in selected_doc_names] if files else []
             ),
-            inputs=[condition_column, condition_value, selected_conditional_docs],
-            outputs=[condition_result, condition_result]
+            inputs=[condition_column, condition_value, selected_docs, conditional_files],
+            outputs=[condition_result]
         )
         
-        # Eventos para asociaciones de datos
+        # Eventos para asociaciones
         first_excel.change(
             fn=processor.load_first_excel,
             inputs=[first_excel],
@@ -671,23 +525,18 @@ def create_interface():
             outputs=[associations_display]
         )
         
-        # Actualizar estado de preparación cuando se hace clic en continuar
-        continue_btn1.click(
-            fn=processor.check_ready_status,
-            outputs=[ready_status, process_btn]
-        )
-        
-        continue_btn2.click(
-            fn=processor.check_ready_status,
-            outputs=[ready_status, process_btn]
+        # Eventos de General Documents
+        general_files.change(
+            fn=processor.load_general_documents,
+            inputs=[general_files],
+            outputs=[general_status]
         )
         
+        # Eventos de procesamiento
         process_btn.click(
-            fn=lambda: processor.process_documents(),
+            fn=lambda: processor.process_documents(None),
+            inputs=[],
             outputs=[process_status, download_file]
-        ).then(
-            fn=lambda: gr.update(visible=True),
-            outputs=[download_file]
         )
     
     return demo