a

app.py

@@ -1,95 +1,67 @@
 import gradio as gr
 import subprocess
 import logging
-import os
 import tempfile
-import shlex
-from gradio_pdf import PDF
-import shutil
+import os
 
-# Configuración de logs
-logger = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+# Configurar logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-def ejecutar_comando(comando):
+def ejecutar_comando(comando, mensaje_exito="", mensaje_error=""):
     """Ejecuta un comando de shell y maneja errores."""
     try:
         resultado = subprocess.run(comando, shell=True, check=True, capture_output=True, text=True)
-        logger.info(f"Comando ejecutado: {comando}\nSalida:\n{resultado.stdout}")
+        if mensaje_exito:
+            logging.info(f"{mensaje_exito}. Salida:\n{resultado.stdout}")
         return resultado.stdout
     except subprocess.CalledProcessError as e:
-        error_message = f"Error al ejecutar el comando: {comando}\nError: {e}\nSalida de error:\n{e.stderr}"
-        logger.error(error_message)
+        error_message = f"{mensaje_error}. Error: {e}\nSalida de error:\n{e.stderr}"
+        logging.error(error_message)
         raise RuntimeError(error_message)
 
-def reparar_pdf(input_pdf, output_pdf):
-    """Repara un PDF usando qpdf."""
-    comando = f"qpdf --linearize {shlex.quote(input_pdf)} {shlex.quote(output_pdf)}"
-    ejecutar_comando(comando)
-
-def simplificar_pdf(input_pdf, output_pdf):
-    """Simplifica un PDF usando Ghostscript."""
-    comando = f"gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/screen -dNOPAUSE -dBATCH -sOutputFile={shlex.quote(output_pdf)} {shlex.quote(input_pdf)}"
-    ejecutar_comando(comando)
-
-def crear_pdf_con_texto_incrustado(pdf_original, archivo_salida, idioma="spa"):
-    """Procesa un PDF con OCR usando OCRmyPDF."""
-    comando = f"ocrmypdf -l {idioma} --force-ocr --deskew --output-type pdf {shlex.quote(pdf_original)} {shlex.quote(archivo_salida)}"
-    ejecutar_comando(comando)
-
-def flujo_principal(pdf_file, idioma="spa"):
-    """Procesa un PDF subido con reparación, simplificación y OCR."""
-    if not pdf_file:
+def procesar_pdf_con_ocr(pdf_subido, idioma="spa"):
+    """Procesa un PDF subido con OCR y devuelve la ruta del archivo procesado."""
+    if not pdf_subido:
         raise gr.Error("No se subió ningún archivo.")
 
-    reparado_pdf = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf").name
-    simplificado_pdf = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf").name
-    output_pdf = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf").name
-
     try:
-        # Reparar el PDF
-        reparar_pdf(pdf_file, reparado_pdf)
-
-        # Simplificar el PDF
-        simplificar_pdf(reparado_pdf, simplificado_pdf)
+        input_pdf = pdf_subido.name
+        output_pdf = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf").name
 
-        # Procesar con OCR
-        crear_pdf_con_texto_incrustado(simplificado_pdf, output_pdf, idioma)
-
-        return output_pdf  # Devolver el archivo para descarga y vista previa
+        ejecutar_comando(
+            f"ocrmypdf -l {idioma} --force-ocr --deskew --output-type pdf {input_pdf} {output_pdf}",
+            mensaje_exito="OCR completado",
+            mensaje_error="Error en OCR"
+        )
 
+        return output_pdf  # Ruta del archivo procesado
     except Exception as e:
-        logger.error(f"Error durante el procesamiento del PDF: {str(e)}")
-        raise gr.Error(f"Error al procesar el PDF: {str(e)}")
-    finally:
-        # Limpiar archivos temporales no necesarios
-        for temp_file in [reparado_pdf, simplificado_pdf]:
-            if os.path.exists(temp_file):
-                os.remove(temp_file)
+        logging.error(f"Error al procesar el PDF: {e}")
+        raise gr.Error(f"Ocurrió un error al procesar el archivo: {e}")
 
 # Interfaz Gradio
-with gr.Blocks() as interfaz:
-    gr.Markdown("## Procesador de PDFs con OCR")
+def interfaz_ocr():
+    """Crea la interfaz Gradio para el flujo de OCR."""
+    with gr.Blocks() as app:
+        gr.Markdown("## Procesador de PDFs con OCR")
 
-    with gr.Row():
-        archivo_pdf = PDF(label="Sube tu archivo PDF")  # Entrada usando PDF
+        archivo_pdf = gr.File(label="Sube tu archivo PDF")
         idioma_ocr = gr.Dropdown(["spa", "eng", "fra", "deu"], label="Idioma OCR", value="spa")
-        boton_procesar = gr.Button("Procesar OCR")
+        boton_procesar = gr.Button("Procesar")
+
+        salida_descarga = gr.File(label="Descargar PDF Procesado")
 
-    with gr.Row():
-        pdf_vista = PDF(label="Visor PDF procesado", interactive=False)  # Salida usando PDF para visualización
-        pdf_descarga = gr.File(label="Descargar PDF procesado con OCR", interactive=False)
+        def procesar_y_descargar(pdf_file, idioma):
+            """Procesa el PDF subido y lo devuelve para descarga."""
+            return procesar_pdf_con_ocr(pdf_file, idioma)
 
-    def procesamiento_y_descarga(pdf_file, idioma):
-        """Realiza el procesamiento del PDF y devuelve tanto la vista previa como la ruta de descarga."""
-        archivo_procesado = flujo_principal(pdf_file, idioma)
-        return archivo_procesado, archivo_procesado
+        boton_procesar.click(
+            fn=procesar_y_descargar,
+            inputs=[archivo_pdf, idioma_ocr],
+            outputs=[salida_descarga],
+        )
 
-    boton_procesar.click(
-        fn=procesamiento_y_descarga,
-        inputs=[archivo_pdf, idioma_ocr],
-        outputs=[pdf_vista, pdf_descarga],
-    )
+    return app
 
 if __name__ == "__main__":
-    interfaz.launch()
+    interfaz_ocr().launch()