Amélioration robuste du traitement PDF avec PyMuPDF sans dépendance à Poppler

app.py

@@ -4,47 +4,11 @@ import os
 import json
 import time
 import base64
-import subprocess
+import fitz  # PyMuPDF pour la manipulation des PDF
 from PIL import Image
-from pdf2image import convert_from_path
-
-# Vérification de la disponibilité de Poppler
-def check_poppler():
-    poppler_path = None
-    potential_paths = [
-        '/usr/bin', 
-        '/usr/local/bin', 
-        '/opt/homebrew/bin',
-        '/app/bin'
-    ]
-    
-    for path in potential_paths:
-        if os.path.exists(os.path.join(path, 'pdftoppm')):
-            poppler_path = path
-            print(f"✅ Poppler trouvé dans: {poppler_path}")
-            return poppler_path
-            
-    # Essayer de localiser avec la commande which
-    try:
-        which_result = subprocess.run(['which', 'pdftoppm'], capture_output=True, text=True)
-        if which_result.returncode == 0:
-            poppler_bin = which_result.stdout.strip()
-            poppler_path = os.path.dirname(poppler_bin)
-            print(f"✅ Poppler trouvé via 'which' dans: {poppler_path}")
-            return poppler_path
-    except:
-        pass
-        
-    print("⚠️ AVERTISSEMENT: Poppler non trouvé dans les chemins standards!")
-    print("⚠️ Les fonctionnalités de prévisualisation et de traitement PDF pourraient ne pas fonctionner.")
-    print("⚠️ Veuillez installer Poppler:")
-    print("   - Linux: apt-get install poppler-utils")
-    print("   - macOS: brew install poppler")
-    print("   - Windows: Téléchargez depuis https://github.com/oschwartz10612/poppler-windows/")
-    return None
-
-# Vérifier Poppler au démarrage
-POPPLER_PATH = check_poppler()
+import io
+import tempfile
+import shutil
 
 # Configuration
 GOOGLE_API_KEY = "AIzaSyA4ma5pE1pPCzHHn-i9tDWuKqQEgSltMtI"
@@ -884,42 +848,55 @@ def format_table(table_data):
 
 def process_single_image(image):
     """Process a single image and extract information"""
-    response = model.generate_content(
-        [GEMINI_PROMPT, image],
-        generation_config={
-            "temperature": 0.1,
-            "top_p": 0.8,
-            "top_k": 40,
-            "max_output_tokens": 2048,
-        }
-    )
-    
     try:
-        response_text = response.text.strip()
-        if response_text.startswith("```json"):
-            response_text = response_text.replace("```json", "").replace("```", "").strip()
-        elif response_text.startswith("```"):
-            response_text = response_text.replace("```", "").strip()
+        print("Envoi de l'image à Gemini pour analyse...")
+        response = model.generate_content(
+            [GEMINI_PROMPT, image],
+            generation_config={
+                "temperature": 0.1,
+                "top_p": 0.8,
+                "top_k": 40,
+                "max_output_tokens": 2048,
+            }
+        )
         
-        json_data = json.loads(response_text)
-        
-        # Vérifier et corriger le format des tableaux si nécessaire
-        if "tables" in json_data and json_data["tables"]:
-            for i, table in enumerate(json_data["tables"]):
-                if "data" not in table or not table["data"]:
-                    table["data"] = []
-                    
-                # S'assurer que la table a un titre
-                if "title" not in table or not table["title"]:
-                    table["title"] = f"Tableau {i+1}"
-                    
-                # S'assurer que la table a une description
-                if "description" not in table:
-                    table["description"] = ""
-        
-        return json_data
+        try:
+            response_text = response.text.strip()
+            print(f"Réponse reçue de Gemini, longueur: {len(response_text)} caractères")
+            
+            # Nettoyage du texte JSON
+            if response_text.startswith("```json"):
+                response_text = response_text.replace("```json", "").replace("```", "").strip()
+            elif response_text.startswith("```"):
+                response_text = response_text.replace("```", "").strip()
+            
+            # Parse JSON
+            json_data = json.loads(response_text)
+            
+            # Vérifier et corriger le format des tableaux si nécessaire
+            if "tables" in json_data and json_data["tables"]:
+                for i, table in enumerate(json_data["tables"]):
+                    if "data" not in table or not table["data"]:
+                        table["data"] = []
+                        
+                    # S'assurer que la table a un titre
+                    if "title" not in table or not table["title"]:
+                        table["title"] = f"Tableau {i+1}"
+                        
+                    # S'assurer que la table a une description
+                    if "description" not in table:
+                        table["description"] = ""
+            
+            return json_data
+        except json.JSONDecodeError as e:
+            print(f"Erreur de décodage JSON: {str(e)}")
+            print(f"Contenu problématique: {response_text[:500]}...")
+            return {"error": "Erreur de format JSON dans la réponse"}
+        except Exception as e:
+            print(f"Erreur lors du traitement de la réponse Gemini: {str(e)}")
+            return {"error": str(e)}
     except Exception as e:
-        print(f"Error parsing JSON: {str(e)}")
+        print(f"Erreur lors de l'appel à Gemini: {str(e)}")
         return {"error": str(e)}
 
 def merge_results(results):
@@ -958,46 +935,76 @@ def process_document(file, progress=gr.Progress()):
         
     try:
         if file.name.lower().endswith('.pdf'):
-            # Utiliser le chemin Poppler détecté au démarrage
-            if POPPLER_PATH:
-                images = convert_from_path(
-                    file.name, 
-                    poppler_path=POPPLER_PATH,
-                    use_pdftocairo=True,
-                    dpi=150
-                )
-            else:
-                print("Trying without poppler_path")
-                images = convert_from_path(
-                    file.name, 
-                    use_pdftocairo=True,
-                    dpi=150
-                )
+            # Créer une copie temporaire du fichier au cas où il serait déplacé/modifié pendant le traitement
+            temp_dir = tempfile.mkdtemp()
+            temp_pdf = os.path.join(temp_dir, "temp.pdf")
+            shutil.copy2(file.name, temp_pdf)
             
-            if len(images) > 10:
-                return {"error": TEXT["error"]["too_many_pages"]}
+            try:
+                # Ouvrir le PDF avec PyMuPDF
+                doc = fitz.open(temp_pdf)
                 
-            results = []
-            for i, image in enumerate(images):
-                progress(i / len(images), desc=TEXT["processing"])
-                result = process_single_image(image)
-                if result and "error" not in result:
-                    results.append(result)
+                if doc.page_count > 10:
+                    # Nettoyer les fichiers temporaires
+                    shutil.rmtree(temp_dir, ignore_errors=True)
+                    return {"error": TEXT["error"]["too_many_pages"]}
+
+                print(f"Traitement d'un PDF de {doc.page_count} pages")
+                results = []
+                
+                for i in range(doc.page_count):
+                    progress((i+1) / doc.page_count, desc=f"{TEXT['processing']} page {i+1}/{doc.page_count}")
+                    try:
+                        page = doc[i]
+                        # Augmenter la résolution pour une meilleure qualité
+                        zoom = 2.0  # zoom factor
+                        mat = fitz.Matrix(zoom, zoom)
+                        pix = page.get_pixmap(matrix=mat, alpha=False)
+                        
+                        # Convertir le pixmap en PIL Image
+                        img_data = pix.tobytes("jpeg")
+                        pil_img = Image.open(io.BytesIO(img_data))
+                        
+                        # Traiter l'image avec le modèle Gemini
+                        result = process_single_image(pil_img)
+                        if result and "error" not in result:
+                            results.append(result)
+                            print(f"Page {i+1} traitée avec succès")
+                        else:
+                            print(f"Pas d'informations extraites de la page {i+1}")
+                    except Exception as e:
+                        print(f"Erreur lors du traitement de la page {i+1}: {str(e)}")
+                
+                # Fermer le document PDF
+                doc.close()
+                
+                # Nettoyer les fichiers temporaires
+                shutil.rmtree(temp_dir, ignore_errors=True)
+                
+                if results:
+                    return merge_results(results)
+                else:
+                    return {"error": TEXT["error"]["no_info"]}
             
-            if results:
-                return merge_results(results)
-            else:
-                return {"error": TEXT["error"]["no_info"]}
+            except Exception as e:
+                print(f"Erreur lors du traitement du PDF: {str(e)}")
+                # Nettoyer les fichiers temporaires
+                shutil.rmtree(temp_dir, ignore_errors=True)
+                return {"error": str(e)}
                 
         elif file.name.lower().endswith(('.png', '.jpg', '.jpeg')):
-            image = Image.open(file.name)
-            return process_single_image(image)
+            try:
+                image = Image.open(file.name)
+                return process_single_image(image)
+            except Exception as e:
+                print(f"Erreur lors du traitement de l'image: {str(e)}")
+                return {"error": str(e)}
             
         else:
             return {"error": TEXT["error"]["file_not_found"]}
             
     except Exception as e:
-        print(f"Error processing document: {str(e)}")
+        print(f"Erreur inattendue dans process_document: {str(e)}")
         return {"error": str(e)}
 
 def update_preview(file):
@@ -1005,45 +1012,59 @@ def update_preview(file):
     if not file:
         return []
         
-    if file.name.lower().endswith('.pdf'):
-        try:
-            # Utiliser le chemin Poppler détecté au démarrage
-            if POPPLER_PATH:
-                images = convert_from_path(
-                    file.name, 
-                    first_page=1, 
-                    last_page=3, 
-                    poppler_path=POPPLER_PATH,
-                    use_pdftocairo=True,
-                    dpi=150
-                )
-            else:
-                # Essayer sans spécifier le chemin, en utilisant des options simplifiées
-                print("Trying without poppler_path")
-                images = convert_from_path(
-                    file.name, 
-                    first_page=1, 
-                    last_page=3,
-                    use_pdftocairo=True,
-                    dpi=150
-                )
-            
-            image_paths = []
+    try:
+        if file.name.lower().endswith('.pdf'):
+            # Créer une copie temporaire du fichier au cas où il serait déplacé/modifié pendant le traitement
+            temp_dir = tempfile.mkdtemp()
+            temp_pdf = os.path.join(temp_dir, "temp.pdf")
+            shutil.copy2(file.name, temp_pdf)
             
-            for i, img in enumerate(images):
-                temp_filename = f"temp_preview_{i}.jpg"
-                img.save(temp_filename)
-                image_paths.append(temp_filename)
+            try:
+                # Utiliser PyMuPDF pour convertir les pages en images
+                doc = fitz.open(temp_pdf)
+                image_paths = []
                 
-            print(f"Successfully created {len(image_paths)} preview images")
-            return image_paths
-        except Exception as e:
-            print(f"Error converting PDF to images: {str(e)}")
-            # En cas d'erreur, retourner une image d'erreur qui sera affichée
+                # Ne traiter que les 3 premières pages
+                max_pages = min(3, doc.page_count)
+                print(f"PDF a {doc.page_count} pages, prévisualisant {max_pages} pages")
+                
+                for i in range(max_pages):
+                    try:
+                        page = doc[i]
+                        # Augmenter la résolution pour une meilleure qualité
+                        zoom = 2.0  # zoom factor
+                        mat = fitz.Matrix(zoom, zoom)
+                        pix = page.get_pixmap(matrix=mat, alpha=False)
+                        
+                        # Sauvegarder l'image
+                        temp_filename = f"temp_preview_{i}.jpg"
+                        pix.save(temp_filename, "jpeg")
+                        image_paths.append(temp_filename)
+                        print(f"Page {i+1} convertie et sauvegardée dans {temp_filename}")
+                    except Exception as e:
+                        print(f"Erreur lors du traitement de la page {i+1}: {str(e)}")
+                
+                # Fermer le document PDF
+                doc.close()
+                print(f"Prévisualisation créée avec succès: {len(image_paths)} images")
+                
+                # Nettoyer les fichiers temporaires
+                shutil.rmtree(temp_dir, ignore_errors=True)
+                
+                return image_paths
+            except Exception as e:
+                print(f"Erreur lors de la conversion PDF: {str(e)}")
+                # Nettoyer les fichiers temporaires
+                shutil.rmtree(temp_dir, ignore_errors=True)
+                return []
+                
+        elif file.name.lower().endswith(('.png', '.jpg', '.jpeg')):
+            return [file.name]
+        else:
+            print(f"Format de fichier non pris en charge: {file.name}")
             return []
-    elif file.name.lower().endswith(('.png', '.jpg', '.jpeg')):
-        return [file.name]
-    else:
+    except Exception as e:
+        print(f"Erreur inattendue dans update_preview: {str(e)}")
         return []
 
 def process_and_display(file):