Update app.py

app.py

@@ -4,67 +4,123 @@ import tempfile
 import os
 from pdf2image import convert_from_path
 import logging
+import time
 
-# ===== HEALTH CHECK =====
-def verify_libreoffice():
-    try:
-        subprocess.run(["libreoffice", "--version"], check=True, capture_output=True)
-        return True
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        return False
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-if not verify_libreoffice():
-    raise RuntimeError("❌ LibreOffice not installed. Check your .dockerfile!")
+# ===== HEALTH CHECKS =====
+def system_check():
+    """Verify all required binaries exist."""
+    required = ["libreoffice", "pdftoppm"]
+    missing = []
+    for cmd in required:
+        try:
+            subprocess.run([cmd, "--version"], 
+                          check=True, 
+                          stdout=subprocess.PIPE, 
+                          stderr=subprocess.PIPE)
+            logger.info(f"✅ {cmd} is installed")
+        except Exception:
+            missing.append(cmd)
+    
+    if missing:
+        logger.critical(f"❌ Missing: {', '.join(missing)}")
+        raise RuntimeError("System dependencies missing. Check .dockerfile")
+
+# Run checks on startup
+system_check()
 
-# ===== MAIN CONVERSION FUNCTION =====
-def convert_docx_to_image(docx_path: str) -> str:
+# ===== CORE CONVERSION =====
+def convert_docx_to_image(docx_path: str):
+    """Convert DOCX to PNG with error recovery."""
+    start_time = time.time()
+    
     with tempfile.TemporaryDirectory() as tmpdir:
         try:
             # Step 1: DOCX → PDF
             pdf_path = os.path.join(tmpdir, "output.pdf")
             cmd = [
-                "libreoffice", 
+                "libreoffice",
                 "--headless",
                 "--convert-to", "pdf",
                 "--outdir", tmpdir,
                 docx_path
             ]
-            subprocess.run(cmd, check=True, timeout=30)
+            
+            logger.info("Starting DOCX to PDF conversion...")
+            subprocess.run(cmd, check=True, timeout=60)
             
             if not os.path.exists(pdf_path):
-                raise FileNotFoundError("PDF was not generated")
+                raise FileNotFoundError("PDF not generated")
             
             # Step 2: PDF → PNG
+            logger.info("Converting PDF to PNG...")
             images = convert_from_path(
                 pdf_path,
                 dpi=300,
-                output_folder=tmpdir,
                 fmt="png",
-                single_file=True
+                poppler_path="/usr/bin",  # Critical for Hugging Face
+                thread_count=4
             )
+            
+            if not images:
+                raise ValueError("No images generated")
+            
             output_path = os.path.join(tmpdir, "output.png")
             images[0].save(output_path, "PNG")
+            
+            logger.info(f"Conversion successful in {time.time()-start_time:.2f}s")
             return output_path
-
+            
+        except subprocess.TimeoutExpired:
+            logger.error("Conversion timed out after 60s")
+            raise gr.Error("Timeout: Try a smaller file or upgrade hardware")
         except Exception as e:
-            logging.error(f"Conversion failed: {str(e)}", exc_info=True)
-            raise gr.Error(f"Conversion error: {str(e)}")
+            logger.error(f"Conversion failed: {str(e)}", exc_info=True)
+            raise gr.Error(f"Error: {str(e)}")
 
 # ===== GRADIO UI =====
-with gr.Blocks() as app:
-    gr.Markdown("## 📄 DOCX to Image (Pixel-Perfect)")
+with gr.Blocks(title="DOCX to Image Converter") as app:
+    gr.Markdown("## 📄→🖼️ Professional DOCX to Image")
+    
     with gr.Row():
         input_file = gr.File(
-            label="Upload DOCX",
+            label="Upload DOCX File",
             file_types=[".docx"],
             type="filepath"
         )
-        output_image = gr.Image(label="Output Image", type="filepath")
+        output_image = gr.Image(
+            label="Converted Image",
+            type="filepath",
+            interactive=False
+        )
+    
+    status = gr.Textbox(label="Conversion Status", visible=False)
+    
+    convert_btn = gr.Button("Convert", variant="primary")
     
-    gr.Button("Convert").click(
-        fn=convert_docx_to_image,
+    # Detailed output for debugging
+    with gr.Accordion("Advanced Info", open=False):
+        gr.Markdown("""
+        **Technical Details:**
+        - Uses LibreOffice 7.5 for perfect rendering
+        - 300 DPI high-quality output
+        - Handles tables, fonts, and complex layouts
+        """)
+
+    def process(file_path: str):
+        try:
+            image_path = convert_docx_to_image(file_path)
+            return image_path, "✅ Conversion successful!"
+        except Exception as e:
+            return None, f"❌ Error: {str(e)}"
+
+    convert_btn.click(
+        fn=process,
         inputs=input_file,
-        outputs=output_image
+        outputs=[output_image, status]
     )
 
 app.launch(server_name="0.0.0.0")