Update app.py

app.py

@@ -4,10 +4,8 @@ import os
 import base64
 from io import BytesIO
 import pandas as pd
-from markdown import markdown
-from bs4 import BeautifulSoup
+import re
 import tempfile
-import re  # Ajouté pour extraire le tableau Markdown de la réponse complète
 
 # Initialize Groq client
 client = Groq(api_key=os.getenv("GROQ_API_KEY"))
@@ -15,49 +13,45 @@ client = Groq(api_key=os.getenv("GROQ_API_KEY"))
 def image_to_base64(image):
     """Convert PIL image to base64 string for Groq API."""
     buffered = BytesIO()
-    image.save(buffered, format="JPEG")  # Ou PNG si besoin
+    image.save(buffered, format="JPEG")
     return base64.b64encode(buffered.getvalue()).decode("utf-8")
 
-def extract_markdown_table(text):
-    """Extraire uniquement la partie tableau Markdown de la réponse texte complète."""
-    # Utilise une regex pour trouver le bloc commençant par | et contenant des lignes de tableau
-    table_pattern = r'(\|.*?\n(?:\|.*?\n)+)'
+def parse_markdown_table_to_df(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 match:
-        return match.group(1).strip()
-    return None
+    if not match:
+        return pd.DataFrame({"Erreur": ["Aucun tableau Markdown trouvé dans la réponse"]})
 
-def parse_markdown_table_to_df(text):
-    """Parse un tableau Markdown en Pandas DataFrame, de manière plus robuste."""
-    # Extraire d'abord le tableau pur
-    table_md = extract_markdown_table(text)
-    if not table_md:
-        return None
+    table_text = match.group(1).strip()
+    lines = table_text.split('\n')
 
-    # Convertir Markdown en HTML
-    html = markdown(table_md)
+    # 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)]
 
-    # Utiliser pandas.read_html pour parser directement le tableau HTML
-    try:
-        dfs = pd.read_html(html)
-        if dfs:
-            df = dfs[0]  # Prend le premier tableau trouvé
-            # Nettoyer les colonnes et lignes (strip espaces)
-            df.columns = [col.strip() if isinstance(col, str) else col for col in df.columns]
-            df = df.applymap(lambda x: x.strip() if isinstance(x, str) else x)
-            return df if not df.empty else None
-    except ValueError:
-        pass  # Si pas de tableau valide
-
-    # Fallback avec BeautifulSoup si read_html échoue
-    soup = BeautifulSoup(html, "html.parser")
-    table = soup.find("table")
-    if not table:
-        return None
-    headers = [th.text.strip() for th in table.find_all("th")]
-    rows = [[td.text.strip() for td in tr.find_all("td")] for tr in table.find_all("tr")[1:]]
-    df = pd.DataFrame(rows, columns=headers) if headers and rows else pd.DataFrame(rows)
-    return df if not df.empty else None
+    if not lines:
+        return pd.DataFrame({"Erreur": ["Tableau vide ou mal formé"]})
+
+    # 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:
+        return pd.DataFrame({"Erreur": ["Aucun en-tête valide trouvé"]})
+
+    # Extraire les lignes de données
+    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)])
+
+    # 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 process_image_and_get_response(image):
     """Process the uploaded image, send to Groq vision model, parse response to table, and generate Excel."""
@@ -67,12 +61,18 @@ def process_image_and_get_response(image):
     # Convert image to base64
     base64_image = image_to_base64(image)
 
-    # Ton prompt optimisé
-    prompt = "Extrait le tableau en entier de cette image et recopie-le à l'identique ici pour que je puisse le copier coller. Utilise un format de tableau Markdown (avec des | et --- pour les séparateurs) pour une structure parfaite. Ne ajoute rien d'autre que le tableau Markdown."
+    # Prompt optimisé pour un Markdown propre
+    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."
+    )
 
     try:
         completion = client.chat.completions.create(
-            model="meta-llama/llama-4-scout-17b-16e-instruct",  # Ton modèle vision
+            model="meta-llama/llama-4-scout-17b-16e-instruct",
             messages=[
                 {
                     "role": "user",
@@ -85,30 +85,29 @@ def process_image_and_get_response(image):
                     ]
                 }
             ],
-            temperature=0.5,  # Pour plus de précision sur l'extraction
-            max_completion_tokens=2048,  # Fonctionne avec la nouvelle version groq
+            temperature=0.5,
+            max_completion_tokens=2048,
             top_p=1,
-            stream=False,  # Simplifie le parsing
+            stream=False,
             stop=None
         )
 
-        response = completion.choices[0].message.content
+        response = completion.choices[0].message.content.strip()
 
-        # Parse la réponse en DataFrame pour Excel
+        # Parse la réponse en DataFrame
         df = parse_markdown_table_to_df(response)
         excel_file = None
-        if df is not None and not df.empty:
+        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:
                     df.to_excel(writer, sheet_name='Tableau_Extrait', index=False)
                 excel_file = tmp.name
         else:
-            # Fallback amélioré : Si parsing échoue, crée un Excel avec la réponse brute dans une cellule unique
-            df_fallback = pd.DataFrame({"Réponse brute": [response]})
+            # 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_fallback.to_excel(writer, sheet_name='Réponse_Brute', index=False)
+                    df.to_excel(writer, sheet_name='Erreur', index=False)
                 excel_file = tmp.name
 
         return response, excel_file