Update app.py

app.py

@@ -16,43 +16,63 @@ def image_to_base64(image):
     image.save(buffered, format="JPEG")
     return base64.b64encode(buffered.getvalue()).decode("utf-8")
 
-def parse_markdown_table_to_df(text):
+def parse_markdown_table_to_df(table_text):
     """Parse un tableau Markdown en Pandas DataFrame de manière robuste."""
-    # Extraire le tableau Markdown avec une regex
-    table_pattern = r'(\|.*?\n(?:\|[-| :]*?\n)?(?:\|.*?\n)+)'
-    match = re.search(table_pattern, text, re.DOTALL)
-    if not match:
-        return pd.DataFrame({"Erreur": ["Aucun tableau Markdown trouvé dans la réponse"]})
+    # Nettoyer les <br> en \n pour les sauts de ligne dans les cellules
+    table_text = re.sub(r'<br>', '\n', table_text)
 
-    table_text = match.group(1).strip()
     lines = table_text.split('\n')
 
     # Ignorer les lignes vides et la ligne des séparateurs (|---|)
-    lines = [line.strip() for line in lines if line.strip() and not re.match(r'\|[-| :]*\|', line)]
+    data_lines = []
+    separator_found = False
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            continue
+        if re.match(r'\|[-| :]+\|', stripped):
+            separator_found = True
+            continue
+        data_lines.append(stripped)
+
+    if not data_lines:
+        return pd.DataFrame({"Erreur": ["Aucun tableau Markdown trouvé dans la réponse"]})
 
-    if not lines:
-        return pd.DataFrame({"Erreur": ["Tableau vide ou mal formé"]})
+    # Extraire les en-têtes (première ligne)
+    header_line = data_lines[0]
+    headers = [h.strip() for h in header_line.split('|')[1:-1]]
+    num_columns = len(headers)
 
-    # Extraire les en-têtes
-    headers = [h.strip() for h in lines[0].split('|')[1:-1]]  # Ignore les | aux extrémités
-    if not headers:
+    if num_columns == 0:
         return pd.DataFrame({"Erreur": ["Aucun en-tête valide trouvé"]})
 
-    # Extraire les lignes de données
+    # Extraire les lignes de données (lignes suivantes)
     rows = []
-    for line in lines[1:]:
-        cells = [cell.strip() for cell in line.split('|')[1:-1]]  # Ignore les | aux extrémités
-        if len(cells) == len(headers):  # Vérifie l'alignement
-            rows.append(cells)
-        else:
-            # Si le nombre de colonnes ne correspond pas, remplir avec des chaînes vides
-            cells.extend([''] * (len(headers) - len(cells)))
-            rows.append(cells[:len(headers)])
+    for line in data_lines[1:]:
+        cells = line.split('|')[1:-1]
+        cleaned_cells = [cell.strip() for cell in cells]
+        # Gérer le mismatch de colonnes
+        if len(cleaned_cells) < num_columns:
+            cleaned_cells.extend([''] * (num_columns - len(cleaned_cells)))
+        elif len(cleaned_cells) > num_columns:
+            cleaned_cells = cleaned_cells[:num_columns]  # Tronquer si trop de colonnes
+        rows.append(cleaned_cells)
 
     # Créer le DataFrame
     df = pd.DataFrame(rows, columns=headers)
     return df if not df.empty else pd.DataFrame({"Erreur": ["Aucune donnée valide extraite"]})
 
+def extract_additional_text_and_table(response):
+    """Extraire le texte additionnel et le tableau Markdown de la réponse structurée."""
+    if 'Additional text:' in response and 'Table:' in response:
+        parts = response.split('Table:', 1)
+        additional_text = parts[0].replace('Additional text:', '').strip()
+        table_text = parts[1].strip() if len(parts) > 1 else ''
+    else:
+        additional_text = ''
+        table_text = response.strip()
+    return additional_text, table_text
+
 def process_image_and_get_response(image):
     """Process the uploaded image, send to Groq vision model, parse response to table, and generate Excel."""
     if image is None:
@@ -61,13 +81,20 @@ def process_image_and_get_response(image):
     # Convert image to base64
     base64_image = image_to_base64(image)
 
-    # Prompt optimisé pour un Markdown propre
+    # Prompt optimisé pour structure, précision et inclusion des infos supplémentaires
     prompt = (
-        "Extrait le tableau en entier de cette image et recopie-le à l'identique ici au format Markdown. "
-        "Utilise des | pour les colonnes et une ligne |---|---| pour les séparateurs. "
-        "N'inclus aucun texte avant ou après le tableau. "
-        "Assure-toi que chaque ligne a exactement le même nombre de colonnes que les en-têtes, "
-        "en remplissant les cellules vides avec '' si nécessaire."
+        "Analyse l'image et extrait tout le contenu. "
+        "D'abord, extrait tout texte additionnel autour ou en dehors du tableau (titres, notes, pieds de page, etc.), en le recopiant mot pour mot. "
+        "Ensuite, extrait le tableau en entier, en recopiant toutes les lignes et colonnes à l'identique, y compris les lignes vides ou partielles. "
+        "Utilise un format Markdown pour le tableau avec des | pour les colonnes et une ligne |---|---| pour les séparateurs. "
+        "Assure-toi que CHAQUE ligne (en-têtes, séparateurs, données) a EXACTEMENT le même nombre de colonnes (compte les | : il doit y en avoir 10 pour 9 colonnes, incluant les | de début et fin). "
+        "Pour les sauts de ligne dans une cellule, utilise \n au lieu de <br>. "
+        "Remplis les cellules vides avec '' si nécessaire pour maintenir l'alignement. "
+        "N'ajoute aucun texte explicatif dans le tableau. "
+        "Structure ta réponse exactement comme suit :\n"
+        "Additional text: [tout le texte additionnel, s'il y en a ; sinon, laisse vide]\n"
+        "Table:\n"
+        "[le tableau Markdown ici]"
     )
 
     try:
@@ -85,8 +112,8 @@ def process_image_and_get_response(image):
                     ]
                 }
             ],
-            temperature=0.5,
-            max_completion_tokens=2048,
+            temperature=0.2,  # Réduit pour plus de précision et respect de la structure
+            max_completion_tokens=4096,  # Augmenté pour tableaux complexes
             top_p=1,
             stream=False,
             stop=None
@@ -94,21 +121,27 @@ def process_image_and_get_response(image):
 
         response = completion.choices[0].message.content.strip()
 
-        # Parse la réponse en DataFrame
-        df = parse_markdown_table_to_df(response)
+        # Extraire texte additionnel et tableau
+        additional_text, table_text = extract_additional_text_and_table(response)
+
+        # Parse le tableau en DataFrame
+        df = parse_markdown_table_to_df(table_text)
+
         excel_file = None
-        if not df.empty and "Erreur" not in df.columns:
-            # Crée un fichier Excel temporaire
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as tmp:
-                with pd.ExcelWriter(tmp.name, engine='openpyxl') as writer:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as tmp:
+            with pd.ExcelWriter(tmp.name, engine='openpyxl') as writer:
+                # Feuille pour le tableau
+                if not df.empty and "Erreur" not in df.columns:
                     df.to_excel(writer, sheet_name='Tableau_Extrait', index=False)
-                excel_file = tmp.name
-        else:
-            # Si parsing échoue, crée un Excel avec un message d'erreur
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as tmp:
-                with pd.ExcelWriter(tmp.name, engine='openpyxl') as writer:
-                    df.to_excel(writer, sheet_name='Erreur', index=False)
-                excel_file = tmp.name
+                else:
+                    pd.DataFrame({"Message": ["Erreur lors du parsing du tableau"]}).to_excel(writer, sheet_name='Tableau_Extrait', index=False)
+
+                # Feuille pour le texte additionnel, si présent
+                if additional_text:
+                    additional_df = pd.DataFrame({"Texte Additionnel": additional_text.split('\n')})
+                    additional_df.to_excel(writer, sheet_name='Infos_Supplementaires', index=False)
+
+            excel_file = tmp.name
 
         return response, excel_file
 
@@ -120,11 +153,11 @@ iface = gr.Interface(
     fn=process_image_and_get_response,
     inputs=gr.Image(type="pil", label="Uploader une image contenant un tableau"),
     outputs=[
-        gr.Textbox(label="Réponse de l'IA (tableau Markdown pour copier-coller)"),
-        gr.File(label="Télécharger le fichier Excel")
+        gr.Textbox(label="Réponse de l'IA (texte additionnel + tableau Markdown pour copier-coller)"),
+        gr.File(label="Télécharger le fichier Excel (avec tableau et infos supp.)")
     ],
     title="Extraction de Tableau depuis Image avec Groq et Export Excel",
-    description="Uploader une image avec un tableau. L'IA extrait et formate en Markdown, puis génère un Excel rempli."
+    description="Uploader une image avec un tableau. L'IA extrait le texte additionnel et le tableau, puis génère un Excel avec des feuilles séparées."
 )
 
 # Launch the interface