Update app.py

app.py

@@ -1,46 +1,73 @@
+# --- START OF CORRECTED app.py ---
+
 from flask import Flask, render_template, request, jsonify, Response, stream_with_context
+# Revert to the original google.genai import and usage
 from google import genai
+# Make sure types is imported from google.genai if needed for specific model config
 from google.genai import types
 import os
 from PIL import Image
 import io
 import base64
 import json
+import re # Import regex if needed for advanced text processing (though less likely without streaming logic parsing)
 
 app = Flask(__name__)
 
 GOOGLE_API_KEY = os.environ.get("GEMINI_API_KEY")
 
+# Use the original client initialization
 client = genai.Client(
     api_key=GOOGLE_API_KEY,
 )
 
+# Ensure API key is available (good practice)
+if not GOOGLE_API_KEY:
+    print("WARNING: GEMINI_API_KEY environment variable not set.")
+    # Handle this case appropriately, e.g., exit or show an error on the page
+
+# --- Routes for index and potentially the Pro version (kept for context) ---
 @app.route('/')
 def index():
-    return render_template('index.html')
+    # Assuming index.html is for the Pro version or another page
+    return render_template('index.html') # Or redirect to /free if it's the main page
 
 @app.route('/free')
 def indexx():
+    # This route serves the free version HTML
     return render_template('maj.html')
 
+# --- Original /solve route (Pro version, streaming) - Kept for reference ---
+# If you want the Pro version (/solve) to also be non-streaming, apply similar changes as below
 @app.route('/solve', methods=['POST'])
 def solve():
     try:
+        if 'image' not in request.files or not request.files['image'].filename:
+            return jsonify({'error': 'No image file provided'}), 400
+
         image_data = request.files['image'].read()
-        img = Image.open(io.BytesIO(image_data))
+        if not image_data:
+            return jsonify({'error': 'Empty image file provided'}), 400
+
+        try:
+            img = Image.open(io.BytesIO(image_data))
+        except Exception as img_err:
+             return jsonify({'error': f'Invalid image file: {str(img_err)}'}), 400
 
         buffered = io.BytesIO()
         img.save(buffered, format="PNG")
-        img_str = base64.b64encode(buffered.getvalue()).decode()
+        img_str = base64.b64encode(buffered.getvalue()).decode() # Keep base64 for this route as in original
 
         def generate():
             mode = 'starting'
             try:
                 response = client.models.generate_content_stream(
-                    model="gemini-2.5-pro-exp-03-25",
+                    # Use the model name for the Pro version as in your original code
+                    model="gemini-2.5-pro-exp-03-25", # Your original model name
                     contents=[
+                        # Pass image as inline_data with base64 as in your original code
                         {'inline_data': {'mime_type': 'image/png', 'data': img_str}},
-                        """Résous cet exercice en français avec du LaTeX. 
+                        """Résous cet exercice en français avec du LaTeX.
                         Si nécessaire, utilise du code Python pour effectuer les calculs complexes.
                         Présente ta solution de façon claire et espacée."""
                     ],
@@ -54,35 +81,52 @@ def solve():
                     )
                 )
 
+                # Process the streaming response as you had it
                 for chunk in response:
-                    for part in chunk.candidates[0].content.parts:
-                        if hasattr(part, 'thought') and part.thought:
-                            if mode != "thinking":
-                                yield 'data: ' + json.dumps({"mode": "thinking"}) + '\n\n'
-                                mode = "thinking"
-                        elif hasattr(part, 'executable_code') and part.executable_code:
-                            if mode != "executing_code":
-                                yield 'data: ' + json.dumps({"mode": "executing_code"}) + '\n\n'
-                                mode = "executing_code"
-                            code_block_open = "```python\n"
-                            code_block_close = "\n```"
-                            yield 'data: ' + json.dumps({"content": code_block_open + part.executable_code.code + code_block_close}) + '\n\n'
-                        elif hasattr(part, 'code_execution_result') and part.code_execution_result:
-                            if mode != "code_result":
-                                yield 'data: ' + json.dumps({"mode": "code_result"}) + '\n\n'
-                                mode = "code_result"
-                            result_block_open = "Résultat d'exécution:\n```\n"
-                            result_block_close = "\n```"
-                            yield 'data: ' + json.dumps({"content": result_block_open + part.code_execution_result.output + result_block_close}) + '\n\n'
-                        else:
-                            if mode != "answering":
-                                yield 'data: ' + json.dumps({"mode": "answering"}) + '\n\n'
-                                mode = "answering"
-                            if hasattr(part, 'text') and part.text:
-                                yield 'data: ' + json.dumps({"content": part.text}) + '\n\n'
+                    if chunk.candidates and chunk.candidates[0].content and chunk.candidates[0].content.parts:
+                        for part in chunk.candidates[0].content.parts:
+                            # Keep your original logic for emitting different modes in the stream
+                            if hasattr(part, 'thought') and part.thought:
+                                if mode != "thinking":
+                                    yield 'data: ' + json.dumps({"mode": "thinking"}) + '\n\n'
+                                    mode = "thinking"
+                            elif hasattr(part, 'executable_code') and part.executable_code:
+                                if mode != "executing_code":
+                                    yield 'data: ' + json.dumps({"mode": "executing_code"}) + '\n\n'
+                                    mode = "executing_code"
+                                code_block_open = "```python\n"
+                                code_block_close = "\n```"
+                                yield 'data: ' + json.dumps({"content": code_block_open + part.executable_code.code + code_block_close}) + '\n\n'
+                            elif hasattr(part, 'code_execution_result') and part.code_execution_result:
+                                if mode != "code_result":
+                                    yield 'data: ' + json.dumps({"mode": "code_result"}) + '\n\n'
+                                    mode = "code_result"
+                                result_block_open = "Résultat d'exécution:\n```\n"
+                                result_block_close = "\n```"
+                                yield 'data: ' + json.dumps({"content": result_block_open + part.code_execution_result.output + result_block_close}) + '\n\n'
+                            else: # Assuming it's text
+                                if mode != "answering":
+                                    yield 'data: ' + json.dumps({"mode": "answering"}) + '\n\n'
+                                    mode = "answering"
+                                if hasattr(part, 'text') and part.text:
+                                    yield 'data: ' + json.dumps({"content": part.text}) + '\n\n'
+                    # Handle cases where a chunk might not have candidates/parts immediately, or handle errors
+                    elif chunk.prompt_feedback and chunk.prompt_feedback.block_reason:
+                        error_msg = f"Prompt blocked: {chunk.prompt_feedback.block_reason.name}"
+                        print(error_msg)
+                        yield 'data: ' + json.dumps({"error": error_msg}) + '\n\n'
+                        break # Stop processing on block
+                    elif chunk.candidates and chunk.candidates[0].finish_reason:
+                        finish_reason = chunk.candidates[0].finish_reason.name
+                        if finish_reason != 'STOP':
+                            error_msg = f"Generation finished early: {finish_reason}"
+                            print(error_msg)
+                            yield 'data: ' + json.dumps({"error": error_msg}) + '\n\n'
+                        break # Stop processing on finish reason
+
 
             except Exception as e:
-                print(f"Error during generation: {e}")
+                print(f"Error during streaming generation: {e}")
                 yield 'data: ' + json.dumps({"error": str(e)}) + '\n\n'
 
         return Response(
@@ -95,78 +139,121 @@ def solve():
         )
 
     except Exception as e:
-        return jsonify({'error': str(e)}), 500
+        print(f"Error in /solve endpoint: {e}")
+        # Return JSON error for fetch API if streaming setup fails
+        return jsonify({'error': f'Failed to process request: {str(e)}'}), 500
 
+
+# --- MODIFIED /solved route (Free version, non-streaming) using original SDK syntax ---
 @app.route('/solved', methods=['POST'])
 def solved():
     try:
+        if 'image' not in request.files or not request.files['image'].filename:
+            return jsonify({'error': 'No image file provided'}), 400
+
         image_data = request.files['image'].read()
-        img = Image.open(io.BytesIO(image_data))
+        if not image_data:
+            return jsonify({'error': 'Empty image file provided'}), 400
 
-        buffered = io.BytesIO()
+        try:
+            img = Image.open(io.BytesIO(image_data))
+        except Exception as img_err:
+            return jsonify({'error': f'Invalid image file: {str(img_err)}'}), 400
+
+        buffered = io.BytesBytesIO()
         img.save(buffered, format="PNG")
         img_str = base64.b64encode(buffered.getvalue()).decode()
 
-        def generate():
-            mode = 'starting'
-            try:
-                response = client.models.generate_content_stream(
-                    model="gemini-2.5-flash-preview-04-17",
-                    contents=[
-                        {'inline_data': {'mime_type': 'image/png', 'data': img_str}},
-                        """Résous cet exercice en français avec du rendu latex.
-                        Si nécessaire, utilise du code Python pour effectuer les calculs complexes.
-                        Présente ta solution de façon claire et espacée."""
-                    ],
-                    config=types.GenerateContentConfig(
-                        tools=[types.Tool(
-                            code_execution=types.ToolCodeExecution()
-                        )]
-                    )
-                )
-
-                for chunk in response:
-                    for part in chunk.candidates[0].content.parts:
-                        if hasattr(part, 'thought') and part.thought:
-                            if mode != "thinking":
-                                yield 'data: ' + json.dumps({"mode": "thinking"}) + '\n\n'
-                                mode = "thinking"
-                        elif hasattr(part, 'executable_code') and part.executable_code:
-                            if mode != "executing_code":
-                                yield 'data: ' + json.dumps({"mode": "executing_code"}) + '\n\n'
-                                mode = "executing_code"
-                            code_block_open = "```python\n"
-                            code_block_close = "\n```"
-                            yield 'data: ' + json.dumps({"content": code_block_open + part.executable_code.code + code_block_close}) + '\n\n'
-                        elif hasattr(part, 'code_execution_result') and part.code_execution_result:
-                            if mode != "code_result":
-                                yield 'data: ' + json.dumps({"mode": "code_result"}) + '\n\n'
-                                mode = "code_result"
-                            result_block_open = "Résultat d'exécution:\n```\n"
-                            result_block_close = "\n```"
-                            yield 'data: ' + json.dumps({"content": result_block_open + part.code_execution_result.output + result_block_close}) + '\n\n'
-                        else:
-                            if mode != "answering":
-                                yield 'data: ' + json.dumps({"mode": "answering"}) + '\n\n'
-                                mode = "answering"
-                            if hasattr(part, 'text') and part.text:
-                                yield 'data: ' + json.dumps({"content": part.text}) + '\n\n'
+        # Use the non-streaming generate_content method
+        # Use the model name for the Free version as in your original code
+        model_name = "gemini-2.5-flash-preview-04-17" # Your original free model name
 
-            except Exception as e:
-                print(f"Error during generation: {e}")
-                yield 'data: ' + json.dumps({"error": str(e)}) + '\n\n'
+        # Prepare the content using inline_data with base64 string as in your original code
+        contents = [
+             {'inline_data': {'mime_type': 'image/png', 'data': img_str}},
+            """Résous cet exercice en français en utilisant le format LaTeX pour les mathématiques si nécessaire.
+            Si tu dois effectuer des calculs complexes, utilise l'outil d'exécution de code Python fourni.
+            Présente ta solution de manière claire et bien structurée. Formate le code Python dans des blocs délimités par ```python ... ``` et les résultats d'exécution dans des blocs ``` ... ```."""
+        ]
 
-        return Response(
-            stream_with_context(generate()),
-            mimetype='text/event-stream',
-            headers={
-                'Cache-Control': 'no-cache',
-                'X-Accel-Buffering': 'no'
-            }
+        # Call the non-streaming generation method using the original client object
+        response = client.models.generate_content(
+            model=model_name,
+            contents=contents,
+            config=types.GenerateContentConfig(
+                # Removed thinking_config as it's not relevant for non-streaming output
+                tools=[types.Tool(
+                    code_execution=types.ToolCodeExecution()
+                )]
+            )
+            # Note: No stream=True here for non-streaming
         )
 
+        # Aggregate the response parts into a single string
+        full_solution = ""
+        # Check if the response has candidates and parts
+        if response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
+            for part in response.candidates[0].content.parts:
+                # Process parts based on attribute existence
+                if hasattr(part, 'text') and part.text:
+                    full_solution += part.text
+                elif hasattr(part, 'executable_code') and part.executable_code:
+                    # Format code block using Markdown, as the frontend expects this
+                    full_solution += f"\n\n```python\n{part.executable_code.code}\n```\n\n"
+                # Check for the result attribute name based on your SDK version's structure
+                # It might be `code_execution_result` as in your original code, or nested
+                elif hasattr(part, 'code_execution_result') and hasattr(part.code_execution_result, 'output'):
+                     # Format execution result block using Markdown
+                     output_str = part.code_execution_result.output
+                     full_solution += f"\n\n**Résultat d'exécution:**\n```\n{output_str}\n```\n\n"
+                 # Add other potential part types if necessary (e.g., function_call, etc.)
+                # Note: 'thought' parts are ignored as requested
+
+        # Ensure we have some content, otherwise return a message
+        if not full_solution.strip():
+             # Check for finish reasons or safety ratings
+             finish_reason = response.candidates[0].finish_reason.name if response.candidates and response.candidates[0].finish_reason else "UNKNOWN"
+             safety_ratings = response.candidates[0].safety_ratings if response.candidates else []
+             print(f"Generation finished with reason: {finish_reason}, Safety: {safety_ratings}") # Log details
+             if finish_reason == 'SAFETY':
+                 full_solution = "Désolé, je ne peux pas fournir de réponse en raison de restrictions de sécurité."
+             elif finish_reason == 'RECITATION':
+                  full_solution = "Désolé, la réponse ne peut être fournie en raison de la politique sur les récitations."
+             # Also check prompt feedback for blocking reasons
+             elif response.prompt_feedback and response.prompt_feedback.block_reason:
+                 block_reason = response.prompt_feedback.block_reason.name
+                 full_solution = f"Le contenu a été bloqué pour des raisons de sécurité: {block_reason}."
+             else:
+                 full_solution = "Désolé, je n'ai pas pu générer de solution complète pour cette image."
+
+
+        # Return the complete solution as JSON
+        # Use strip() to remove leading/trailing whitespace from the full solution
+        return jsonify({'solution': full_solution.strip()})
+
+    # Catch specific API errors from your original SDK
+    except genai.core.exceptions.GoogleAPIError as api_error:
+        print(f"GenAI API Error: {api_error}")
+        # Check if the error response has details, like safety block
+        error_detail = str(api_error)
+        if "safety" in error_detail.lower():
+            return jsonify({'error': 'Le contenu a été bloqué pour des raisons de sécurité par l\'API.'}), 400
+        elif "blocked" in error_detail.lower():
+             return jsonify({'error': 'La requête a été bloquée par l\'API.'}), 400
+        else:
+             return jsonify({'error': f'Erreur de l\'API GenAI: {error_detail}'}), 500
     except Exception as e:
-        return jsonify({'error': str(e)}), 500
+        # Log the full error for debugging
+        import traceback
+        print(f"Error in /solved endpoint: {e}")
+        print(traceback.format_exc())
+        # Provide a generic error message to the user
+        return jsonify({'error': f'Une erreur interne est survenue lors du traitement: {str(e)}'}), 500
+
 
 if __name__ == '__main__':
-    app.run(debug=True)
+    # Set host='0.0.0.0' to make it accessible on your network if needed
+    # Remove debug=True in production
+    app.run(debug=True, host='0.0.0.0', port=5000) # Example port
+
+# --- END OF CORRECTED app.py ---