Descargar Excel

batch_processor.py

@@ -5,6 +5,7 @@ Procesamiento por lotes y navegación de resultados
 
 import os
 from PIL import Image
+import pandas as pd
 
 
 class BatchProcessor:
@@ -18,42 +19,103 @@ class BatchProcessor:
             invoice_processor: Instancia de InvoiceProcessor
         """
         self.invoice_processor = invoice_processor
+        self.master_dataframe = None  # DataFrame maestro con todas las facturas
     
     def process_batch(self, file_list):
         """
-        Procesa un lote de archivos de facturas.
+        Procesa un lote de archivos de facturas y crea el DataFrame maestro.
         
         Args:
             file_list: Lista de archivos cargados
             
         Returns:
-            tuple: (results, initial_index, status, first_image, first_table, first_filename)
+            tuple: (results, initial_index, status, first_image, first_table, first_filename, master_df)
         """
         if not file_list:
-            return [], 0, "Por favor, carga al menos un archivo.", None, [], ""
+            return [], 0, "Por favor, carga al menos un archivo.", None, [], "", None
         
         results = []
-        for file in file_list:
+        df_data = []  # Lista para construir el DataFrame
+        
+        print("\n" + "=" * 80)
+        print("PROCESAMIENTO POR LOTES - CREANDO DATAFRAME MAESTRO")
+        print("=" * 80)
+        
+        for idx, file in enumerate(file_list):
             try:
                 image = Image.open(file.name).convert("RGB")
                 filename = os.path.basename(file.name)
                 
+                print(f"\n[{idx + 1}/{len(file_list)}] Procesando: {filename}")
+                
                 _, annotated_image, table_data, _ = self.invoice_processor.process_invoice(
                     image, filename
                 )
                 
+                # Convertir tabla a diccionario para el DataFrame
+                row_dict = {'Nombre_Archivo': filename}
+                for etiqueta, valor in table_data:
+                    row_dict[etiqueta] = valor
+                
+                df_data.append(row_dict)
+                
                 results.append({
                     "filename": filename,
                     "image": annotated_image,
-                    "table": table_data
+                    "table": table_data,
+                    "df_index": idx  # Índice en el DataFrame
                 })
+                
+                print(f"  ✓ Agregado al DataFrame: {filename}")
+                
             except Exception as e:
+                print(f"  ✗ Error procesando {os.path.basename(file.name)}: {e}")
                 results.append({
                     "filename": os.path.basename(file.name),
                     "image": None,
-                    "table": [["ERROR FATAL", f"No se pudo cargar o procesar: {e}"]]
+                    "table": [["ERROR FATAL", f"No se pudo cargar o procesar: {e}"]],
+                    "df_index": idx
+                })
+                # Agregar fila con errores al DataFrame
+                df_data.append({
+                    'Nombre_Archivo': os.path.basename(file.name),
+                    'ERROR': str(e)
                 })
         
+        # Crear DataFrame maestro
+        self.master_dataframe = pd.DataFrame(df_data)
+        
+        # Reordenar columnas
+        columnas_ordenadas = [
+            'Nombre_Archivo',
+            'PROVEEDOR_RAZON_SOCIAL',
+            'PROVEEDOR_CUIT',
+            'COMPROBANTE_NUMERO',
+            'FECHA',
+            'JURISDICCION_GASTO',
+            'TIPO',
+            'CONCEPTO_GASTO',
+            'ALICUOTA',
+            'IVA',
+            'NETO',
+            'TOTAL'
+        ]
+        
+        # Filtrar columnas existentes
+        columnas_existentes = [col for col in columnas_ordenadas if col in self.master_dataframe.columns]
+        # Agregar columnas no previstas
+        for col in self.master_dataframe.columns:
+            if col not in columnas_existentes:
+                columnas_existentes.append(col)
+        
+        self.master_dataframe = self.master_dataframe[columnas_existentes]
+        
+        print("\n" + "=" * 80)
+        print("DATAFRAME MAESTRO CREADO")
+        print(f"Dimensiones: {self.master_dataframe.shape}")
+        print(f"Columnas: {list(self.master_dataframe.columns)}")
+        print("=" * 80 + "\n")
+        
         # Preparar resultados iniciales
         initial_index = 0
         first_result = results[initial_index]
@@ -66,8 +128,68 @@ class BatchProcessor:
             status,
             first_result["image"],
             first_result["table"],
-            first_result["filename"]
+            first_result["filename"],
+            self.master_dataframe
         )
+    
+    def update_dataframe(self, df, df_index, edited_table):
+        """
+        Actualiza el DataFrame maestro con los valores editados.
+        IMPORTANTE: Crea una nueva instancia del DataFrame para forzar actualización en Gradio.
+        
+        Args:
+            df: DataFrame maestro
+            df_index: Índice de la fila a actualizar
+            edited_table: Tabla editada [[etiqueta, valor], ...]
+            
+        Returns:
+            pd.DataFrame: Nuevo DataFrame actualizado
+        """
+        if df is None or df.empty:
+            print("⚠️ DataFrame está vacío o es None")
+            return df
+            
+        if df_index >= len(df):
+            print(f"⚠️ Índice {df_index} fuera de rango (DataFrame tiene {len(df)} filas)")
+            return df
+        
+        print(f"\n{'='*80}")
+        print(f"[DATAFRAME UPDATE] Actualizando fila {df_index}")
+        print(f"{'='*80}")
+        print(f"Antes de actualizar:")
+        print(df.iloc[df_index].to_dict())
+        
+        # IMPORTANTE: Crear una copia PROFUNDA del DataFrame
+        # Esto asegura que Gradio detecte el cambio de estado
+        import pandas as pd
+        df_updated = pd.DataFrame(df.values.copy(), columns=df.columns)
+        
+        # Actualizar valores en el DataFrame
+        cambios = []
+        for row in edited_table:
+            if len(row) >= 2:
+                etiqueta = str(row[0]).strip()
+                valor = str(row[1]).strip()
+                
+                if etiqueta in df_updated.columns:
+                    df_updated.at[df_index, etiqueta] = valor
+                    cambios.append(f"  ✓ {etiqueta}: '{valor}'")
+                else:
+                    print(f"  ⚠️ Columna '{etiqueta}' no existe en DataFrame")
+        
+        print("\nCambios aplicados:")
+        for cambio in cambios:
+            print(cambio)
+        
+        print(f"\nDespués de actualizar:")
+        print(df_updated.iloc[df_index].to_dict())
+        print(f"{'='*80}\n")
+        
+        return df_updated
+    
+    def get_master_dataframe(self):
+        """Retorna el DataFrame maestro."""
+        return self.master_dataframe
 
 
 

interface.py

@@ -21,10 +21,114 @@ class GradioInterface:
         self.batch_processor = batch_processor
         self.navigator = result_navigator
     
+    def update_current_result(self, all_results, current_index, edited_table, master_df):
+        """
+        Actualiza los resultados y el DataFrame maestro cuando el usuario edita la tabla.
+        
+        Args:
+            all_results: Lista de todos los resultados
+            current_index: Índice actual
+            edited_table: Tabla editada por el usuario
+            master_df: DataFrame maestro
+            
+        Returns:
+            tuple: (all_results actualizado, master_df actualizado)
+        """
+        if not all_results or current_index >= len(all_results):
+            print("⚠️ No hay resultados para actualizar")
+            return all_results, master_df
+        
+        print(f"\n{'='*80}")
+        print(f"GUARDANDO CAMBIOS MANUALES")
+        print(f"{'='*80}")
+        print(f"Factura: {all_results[current_index]['filename']}")
+        print(f"Índice: {current_index}")
+        
+        # Actualizar la tabla del resultado actual
+        all_results[current_index]['table'] = edited_table
+        
+        # Actualizar el DataFrame maestro
+        df_index = all_results[current_index].get('df_index', current_index)
+        
+        print(f"\nActualizando DataFrame en fila {df_index}:")
+        for row in edited_table:
+            if len(row) >= 2:
+                print(f"  {row[0]}: {row[1]}")
+        
+        updated_df = self.batch_processor.update_dataframe(master_df, df_index, edited_table)
+        
+        print(f"\n✓ Cambios guardados en el DataFrame maestro")
+        print(f"{'='*80}\n")
+        
+        return all_results, updated_df
+    
+    def verify_dataframe_state(self, master_df):
+        """Verifica y muestra el estado actual del DataFrame."""
+        if master_df is None:
+            return "❌ DataFrame es None"
+        if master_df.empty:
+            return "❌ DataFrame está vacío"
+        return f"✓ DataFrame OK: {master_df.shape[0]} filas, {master_df.shape[1]} columnas"
+    
+    def generate_excel(self, master_df):
+        """
+        Genera un archivo Excel con el DataFrame maestro completo.
+        
+        Args:
+            master_df: DataFrame maestro con todas las facturas validadas y corregidas
+            
+        Returns:
+            str: Ruta al archivo Excel generado o None
+        """
+        from datetime import datetime
+        import os
+        
+        print("\n" + "=" * 80)
+        print("GENERANDO EXCEL DESDE DATAFRAME MAESTRO")
+        print("=" * 80)
+        
+        if master_df is None:
+            print("❌ ERROR: master_df es None")
+            return None
+            
+        if master_df.empty:
+            print("❌ ERROR: master_df está vacío")
+            return None
+        
+        print(f"✓ DataFrame recibido correctamente")
+        print(f"Tipo: {type(master_df)}")
+        print(f"Dimensiones: {master_df.shape}")
+        print(f"Columnas: {list(master_df.columns)}")
+        
+        print(f"\n{'='*80}")
+        print("CONTENIDO COMPLETO DEL DATAFRAME:")
+        print(f"{'='*80}")
+        print(master_df.to_string())
+        print(f"{'='*80}\n")
+        
+        # Generar nombre de archivo con timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"facturas_lote_{timestamp}.xlsx"
+        filepath = os.path.join(os.getcwd(), filename)
+        
+        # Guardar Excel directamente desde el DataFrame
+        print(f"Guardando Excel en: {filepath}")
+        master_df.to_excel(filepath, index=False, engine='openpyxl')
+        
+        print(f"✓ Excel generado exitosamente con {len(master_df)} facturas")
+        print("=" * 80 + "\n")
+        
+        return filepath
+    
     def enable_buttons(self, all_results):
-        """Habilita los botones de navegación si hay resultados."""
+        """Habilita los botones de navegación, guardar y descarga si hay resultados."""
         has_results = len(all_results) > 0
-        return gr.update(interactive=has_results), gr.update(interactive=has_results)
+        return (
+            gr.update(interactive=has_results),  # prev_button
+            gr.update(interactive=has_results),  # save_button
+            gr.update(interactive=has_results),  # next_button
+            gr.update(interactive=has_results)   # download_button
+        )
     
     def build_interface(self):
         """
@@ -45,6 +149,7 @@ class GradioInterface:
             # Estados
             all_results_state = gr.State(value=[])
             current_index_state = gr.State(value=0)
+            master_dataframe_state = gr.State(value=None)  # DataFrame maestro
             
             # Sección de carga y procesamiento
             with gr.Row():
@@ -57,13 +162,22 @@ class GradioInterface:
                         interactive=True
                     )
                 
-                # Columna derecha: Botón y estado
+                # Columna derecha: Botones y estado
                 with gr.Column(scale=1):
-                    process_button = gr.Button(
-                        "🚀 Procesar Lote de Facturas", 
-                        variant="primary",
-                        size="lg"
-                    )
+                    with gr.Row():
+                        process_button = gr.Button(
+                            "🚀 Procesar Lote de Facturas", 
+                            variant="primary",
+                            size="lg",
+                            scale=2
+                        )
+                        download_button = gr.Button(
+                            "📥 Descargar XLSX",
+                            variant="secondary",
+                            size="lg",
+                            scale=1,
+                            interactive=False
+                        )
                     status_output = gr.Textbox(
                         label="📊 Estado del Procesamiento",
                         value="Carga tus facturas y haz clic en 'Procesar'",
@@ -72,6 +186,9 @@ class GradioInterface:
             
             gr.Markdown("---")
             
+            # Componente para descarga de Excel
+            excel_file = gr.File(label="📥 Archivo Excel Generado", visible=False)
+            
             # Sección de resultados: Imagen a la izquierda, datos a la derecha
             with gr.Row():
                 # Columna izquierda: Imagen
@@ -97,6 +214,12 @@ class GradioInterface:
                             interactive=False,
                             size="lg"
                         )
+                        save_button = gr.Button(
+                            "💾 Guardar Cambios",
+                            variant="secondary",
+                            size="lg",
+                            interactive=False
+                        )
                         next_button = gr.Button(
                             "Siguiente ➡️", 
                             interactive=False,
@@ -106,7 +229,7 @@ class GradioInterface:
                     table_output = gr.Dataframe(
                         headers=["Etiqueta", "Valor"],
                         label="📋 Resultados de NER",
-                        interactive=False,
+                        interactive=True,  # ✅ Permitir edición
                         col_count=(2, "fixed"),
                         datatype=["str", "str"]
                     )
@@ -121,12 +244,45 @@ class GradioInterface:
                     status_output,
                     image_output,
                     table_output,
-                    filename_output
+                    filename_output,
+                    master_dataframe_state  # ✅ Captura el DataFrame maestro
                 ]
             ).then(
                 fn=self.enable_buttons,
                 inputs=[all_results_state],
-                outputs=[prev_button, next_button]
+                outputs=[prev_button, save_button, next_button, download_button]
+            )
+            
+            # Evento para guardar cambios manualmente
+            save_button.click(
+                fn=self.update_current_result,
+                inputs=[all_results_state, current_index_state, table_output, master_dataframe_state],
+                outputs=[all_results_state, master_dataframe_state]
+            ).then(
+                fn=lambda idx, df: f"✓ Cambios guardados en factura {idx + 1}. DataFrame tiene {len(df) if df is not None else 0} filas",
+                inputs=[current_index_state, master_dataframe_state],
+                outputs=[status_output]
+            )
+            
+            # Evento para actualizar resultados cuando se edita la tabla (auto-save)
+            table_output.change(
+                fn=self.update_current_result,
+                inputs=[all_results_state, current_index_state, table_output, master_dataframe_state],
+                outputs=[all_results_state, master_dataframe_state]
+            )
+            
+            # Evento de descarga usando el DataFrame maestro
+            download_button.click(
+                fn=self.verify_dataframe_state,
+                inputs=[master_dataframe_state],
+                outputs=[status_output]
+            ).then(
+                fn=self.generate_excel,
+                inputs=[master_dataframe_state],
+                outputs=[excel_file]
+            ).then(
+                fn=lambda: gr.update(visible=True),
+                outputs=[excel_file]
             )
             
             prev_button.click(

requirements.txt

@@ -4,4 +4,6 @@ torch>=2.0.0
 torchvision>=0.15.0
 python-doctr>=0.6.0
 Pillow>=9.0.0
-numpy>=1.24.0
+numpy>=1.24.0
+pandas>=2.0.0
+openpyxl>=3.1.0