Update app.py

app.py

@@ -6,6 +6,7 @@ from PIL import Image
 import io
 import base64
 import json
+import re
 
 app = Flask(__name__)
 
@@ -23,6 +24,50 @@ def index():
 def indexx():
     return render_template('maj.html')
 
+def process_markdown_and_code(text):
+    """Traite le texte pour identifier et formater le code et le markdown"""
+    # Convertit le texte en HTML formaté
+    # Cette fonction pourrait être étendue pour utiliser une bibliothèque de markdown
+    return text
+
+def format_code_execution_result(response_parts):
+    """Formate les résultats d'exécution de code pour l'affichage HTML"""
+    result = []
+    
+    for part in response_parts:
+        # Traitement du texte (équivalent à display(Markdown(part.text)))
+        if hasattr(part, 'text') and part.text is not None:
+            result.append({
+                'type': 'markdown',
+                'content': part.text
+            })
+        
+        # Traitement du code exécutable
+        if hasattr(part, 'executable_code') and part.executable_code is not None:
+            result.append({
+                'type': 'code',
+                'content': part.executable_code.code
+            })
+        
+        # Traitement des résultats d'exécution
+        if hasattr(part, 'code_execution_result') and part.code_execution_result is not None:
+            result.append({
+                'type': 'execution_result',
+                'content': part.code_execution_result.output
+            })
+        
+        # Traitement des images (équivalent à display(Image(data=part.inline_data.data)))
+        if hasattr(part, 'inline_data') and part.inline_data is not None:
+            # Encodage de l'image en base64 pour l'affichage HTML
+            img_data = base64.b64encode(part.inline_data.data).decode('utf-8')
+            result.append({
+                'type': 'image',
+                'content': img_data,
+                'format': 'png'  # Supposé comme png par défaut
+            })
+    
+    return result
+
 @app.route('/solve', methods=['POST'])
 def solve():
     try:
@@ -40,13 +85,13 @@ def solve():
                     model="gemini-2.5-pro-exp-03-25",
                     contents=[
                         {'inline_data': {'mime_type': 'image/png', 'data': img_str}},
-                        """Résous ce problème en français en utilisant des formules mathématiques LaTeX quand nécessaire. 
-                        Présente ta réponse de manière claire et structurée."""
+                        """Résous ça en français with rendering latex"""
                     ],
                     config=types.GenerateContentConfig(
                         thinking_config=types.ThinkingConfig(
                             thinking_budget=8000
                         ),
+                        # Ajouter l'outil d'exécution de code
                         tools=[types.Tool(
                             code_execution=types.ToolCodeExecution
                         )]
@@ -55,45 +100,28 @@ def solve():
 
                 for chunk in response:
                     for part in chunk.candidates[0].content.parts:
-                        # Gestion des modes (thinking/answering)
                         if hasattr(part, 'thought') and part.thought:
                             if mode != "thinking":
                                 yield f'data: {json.dumps({"mode": "thinking"})}\n\n'
                                 mode = "thinking"
-                            yield f'data: {json.dumps({"content": part.thought})}\n\n'
-                        elif part.text is not None:
+                        else:
                             if mode != "answering":
                                 yield f'data: {json.dumps({"mode": "answering"})}\n\n'
                                 mode = "answering"
-                            yield f'data: {json.dumps({"content": part.text})}\n\n'
                         
-                        # Gestion du code exécutable
-                        elif hasattr(part, 'executable_code') and part.executable_code is not None:
-                            if mode != "answering":
-                                yield f'data: {json.dumps({"mode": "answering"})}\n\n'
-                                mode = "answering"
-                            # Formater le code pour l'affichage
-                            code_content = f"```python\n{part.executable_code.code}\n```"
-                            yield f'data: {json.dumps({"content": code_content})}\n\n'
+                        # Gestion des différents types de contenu
+                        if hasattr(part, 'text') and part.text is not None:
+                            yield f'data: {json.dumps({"content": part.text, "type": "text"})}\n\n'
                         
-                        # Gestion des résultats de l'exécution du code
-                        elif hasattr(part, 'code_execution_result') and part.code_execution_result is not None:
-                            if mode != "answering":
-                                yield f'data: {json.dumps({"mode": "answering"})}\n\n'
-                                mode = "answering"
-                            yield f'data: {json.dumps({"content": f"```\n{part.code_execution_result.output}\n```"})}\n\n'
+                        if hasattr(part, 'executable_code') and part.executable_code is not None:
+                            yield f'data: {json.dumps({"content": part.executable_code.code, "type": "code"})}\n\n'
                         
-                        # Gestion des images inline
-                        elif hasattr(part, 'inline_data') and part.inline_data is not None:
-                            if mode != "answering":
-                                yield f'data: {json.dumps({"mode": "answering"})}\n\n'
-                                mode = "answering"
-                            # Convertir l'image en base64 pour l'affichage HTML
-                            image_data = part.inline_data.data
-                            image_format = part.inline_data.mime_type.split('/')[-1]
-                            image_src = f"data:{part.inline_data.mime_type};base64,{image_data}"
-                            image_tag = f'<img src="{image_src}" alt="Generated Image" style="max-width:100%;">'
-                            yield f'data: {json.dumps({"content": image_tag})}\n\n'
+                        if hasattr(part, 'code_execution_result') and part.code_execution_result is not None:
+                            yield f'data: {json.dumps({"content": part.code_execution_result.output, "type": "result"})}\n\n'
+                        
+                        if hasattr(part, 'inline_data') and part.inline_data is not None:
+                            img_data = base64.b64encode(part.inline_data.data).decode('utf-8')
+                            yield f'data: {json.dumps({"content": img_data, "type": "image"})}\n\n'
 
             except Exception as e:
                 print(f"Error during generation: {e}")
@@ -113,7 +141,6 @@ def solve():
 
 @app.route('/solved', methods=['POST'])
 def solved():
-    # Version similaire avec le modèle flash
     try:
         image_data = request.files['image'].read()
         img = Image.open(io.BytesIO(image_data))
@@ -129,10 +156,10 @@ def solved():
                     model="gemini-2.5-flash-preview-04-17",
                     contents=[
                         {'inline_data': {'mime_type': 'image/png', 'data': img_str}},
-                        """Résous ce problème en français en utilisant des formules mathématiques LaTeX quand nécessaire.
-                        Présente ta réponse de manière claire et structurée."""
+                        """Résous ça en français with rendering latex. utilise python pour les calculs"""
                     ],
                     config=types.GenerateContentConfig(
+                        # Ajouter l'outil d'exécution de code
                         tools=[types.Tool(
                             code_execution=types.ToolCodeExecution
                         )]
@@ -141,45 +168,28 @@ def solved():
 
                 for chunk in response:
                     for part in chunk.candidates[0].content.parts:
-                        # Gestion des modes (thinking/answering)
                         if hasattr(part, 'thought') and part.thought:
                             if mode != "thinking":
                                 yield f'data: {json.dumps({"mode": "thinking"})}\n\n'
                                 mode = "thinking"
-                            yield f'data: {json.dumps({"content": part.thought})}\n\n'
-                        elif part.text is not None:
+                        else:
                             if mode != "answering":
                                 yield f'data: {json.dumps({"mode": "answering"})}\n\n'
                                 mode = "answering"
-                            yield f'data: {json.dumps({"content": part.text})}\n\n'
                         
-                        # Gestion du code exécutable
-                        elif hasattr(part, 'executable_code') and part.executable_code is not None:
-                            if mode != "answering":
-                                yield f'data: {json.dumps({"mode": "answering"})}\n\n'
-                                mode = "answering"
-                            # Formater le code pour l'affichage
-                            code_content = f"```python\n{part.executable_code.code}\n```"
-                            yield f'data: {json.dumps({"content": code_content})}\n\n'
+                        # Gestion des différents types de contenu
+                        if hasattr(part, 'text') and part.text is not None:
+                            yield f'data: {json.dumps({"content": part.text, "type": "text"})}\n\n'
                         
-                        # Gestion des résultats de l'exécution du code
-                        elif hasattr(part, 'code_execution_result') and part.code_execution_result is not None:
-                            if mode != "answering":
-                                yield f'data: {json.dumps({"mode": "answering"})}\n\n'
-                                mode = "answering"
-                            yield f'data: {json.dumps({"content": f"```\n{part.code_execution_result.output}\n```"})}\n\n'
+                        if hasattr(part, 'executable_code') and part.executable_code is not None:
+                            yield f'data: {json.dumps({"content": part.executable_code.code, "type": "code"})}\n\n'
                         
-                        # Gestion des images inline
-                        elif hasattr(part, 'inline_data') and part.inline_data is not None:
-                            if mode != "answering":
-                                yield f'data: {json.dumps({"mode": "answering"})}\n\n'
-                                mode = "answering"
-                            # Convertir l'image en base64 pour l'affichage HTML
-                            image_data = part.inline_data.data
-                            image_format = part.inline_data.mime_type.split('/')[-1]
-                            image_src = f"data:{part.inline_data.mime_type};base64,{image_data}"
-                            image_tag = f'<img src="{image_src}" alt="Generated Image" style="max-width:100%;">'
-                            yield f'data: {json.dumps({"content": image_tag})}\n\n'
+                        if hasattr(part, 'code_execution_result') and part.code_execution_result is not None:
+                            yield f'data: {json.dumps({"content": part.code_execution_result.output, "type": "result"})}\n\n'
+                        
+                        if hasattr(part, 'inline_data') and part.inline_data is not None:
+                            img_data = base64.b64encode(part.inline_data.data).decode('utf-8')
+                            yield f'data: {json.dumps({"content": img_data, "type": "image"})}\n\n'
 
             except Exception as e:
                 print(f"Error during generation: {e}")