a

app.py

@@ -1,23 +1,15 @@
 import gradio as gr
 import subprocess
 import logging
-import tempfile
 import os
+import tempfile
 import shlex
-from gradio_pdf import PDF
+from gradio_pdf import PDFViewer
 
 # Configuración de logs
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
-def verificar_comando(comando):
-    """Verifica si un comando está disponible en el sistema."""
-    try:
-        subprocess.run(f"which {comando}", shell=True, check=True, capture_output=True)
-        logger.info(f"Comando encontrado: {comando}")
-    except subprocess.CalledProcessError:
-        raise gr.Error(f"El comando '{comando}' no está disponible. Por favor, instálalo antes de continuar.")
-
 def ejecutar_comando(comando):
     """Ejecuta un comando de shell y maneja errores."""
     try:
@@ -31,19 +23,16 @@ def ejecutar_comando(comando):
 
 def reparar_pdf(input_pdf, output_pdf):
     """Repara un PDF usando qpdf."""
-    verificar_comando("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."""
-    verificar_comando("gs")
     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."""
-    verificar_comando("ocrmypdf")
     comando = f"ocrmypdf -l {idioma} --force-ocr --deskew --output-type pdf {shlex.quote(pdf_original)} {shlex.quote(archivo_salida)}"
     ejecutar_comando(comando)
 
@@ -52,14 +41,13 @@ def flujo_principal(pdf_file, idioma="spa"):
     if not pdf_file:
         raise gr.Error("No se subió ningún archivo.")
 
-    input_pdf = pdf_file
     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(input_pdf, reparado_pdf)
+        reparar_pdf(pdf_file, reparado_pdf)
 
         # Simplificar el PDF
         simplificar_pdf(reparado_pdf, simplificado_pdf)
@@ -67,43 +55,36 @@ def flujo_principal(pdf_file, idioma="spa"):
         # Procesar con OCR
         crear_pdf_con_texto_incrustado(simplificado_pdf, output_pdf, idioma)
 
-        return output_pdf
-    except gr.Error as e:
-        logger.error("Error durante el procesamiento del PDF.")
-        raise e
+        return output_pdf, output_pdf # Devolver dos veces para visor y descarga
+
+    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
+        # Limpiar archivos temporales no necesarios
         for temp_file in [reparado_pdf, simplificado_pdf]:
             if os.path.exists(temp_file):
                 os.remove(temp_file)
 
-# Interfaz Gradio mejorada
+
+# Interfaz Gradio
 with gr.Blocks() as interfaz:
-    gr.Markdown("## Visualizador de PDFs con OCR y gradio_pdf")
-
-    gr.Markdown("""
-    ### Funcionalidades que tendrás con `gradio_pdf`:
-    - **Cambiar páginas**: Sí, puedes navegar entre las páginas del PDF.
-    - **Visualizar texto OCR**: Si el OCR se aplicó correctamente, podrás ver el texto procesado en el PDF.
-    - **Seleccionar y copiar texto**:
-      - Depende del visor PDF que se use en `gradio_pdf`.
-      - Si el PDF tiene texto incrustado por el OCR (lo cual hace `ocrmypdf`), entonces será posible copiar el texto si el visor lo soporta.
-    - **Interactividad básica**: Zoom básico y navegación.
-    """)
+    gr.Markdown("## Procesador de PDFs con OCR")
 
     with gr.Row():
-        archivo_pdf = PDF(label="Sube tu archivo 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")
 
     with gr.Row():
-        pdf_procesado = PDF(label="PDF Procesado", height=800, interactive=True)
+        pdf_vista = PDFViewer(label="Visor PDF")
+        pdf_descarga = gr.File(label="Descargar PDF procesado", visible=False)
 
     boton_procesar.click(
         fn=flujo_principal,
         inputs=[archivo_pdf, idioma_ocr],
-        outputs=[pdf_procesado]
+        outputs=[pdf_vista, pdf_descarga],
     )
 
 if __name__ == "__main__":
-    interfaz.launch()
+    interfaz.launch()