Update app.py

app.py

@@ -1,30 +1,31 @@
-# --- START OF CORRECTED app.py ---
+# --- START OF CORRECTED_AGAIN app.py ---
 
 from flask import Flask, render_template, request, jsonify, Response, stream_with_context
-# Revert to the original google.genai import and usage
+# Utilisation de l'import et de l'initialisation de votre code original
 from google import genai
-# Make sure types is imported from google.genai if needed for specific model config
 from google.genai import types
+# Import des exceptions potentielles si elles sont dans google.api_core
+# from google.api_core import exceptions as api_exceptions
 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)
+import traceback # Import traceback pour un meilleur log des erreurs
 
 app = Flask(__name__)
 
 GOOGLE_API_KEY = os.environ.get("GEMINI_API_KEY")
 
-# Use the original client initialization
+# Utilisation de l'initialisation de votre code original
 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
+    print("WARNING: GEMINI_API_KEY environment variable not set. API calls will likely fail.")
+    # Consider adding a check before allowing API calls if the key is missing
 
 # --- Routes for index and potentially the Pro version (kept for context) ---
 @app.route('/')
@@ -37,8 +38,7 @@ 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
+# --- Original /solve route (Pro version, streaming) - Kept as is ---
 @app.route('/solve', methods=['POST'])
 def solve():
     try:
@@ -56,16 +56,14 @@ def solve():
 
         buffered = io.BytesIO()
         img.save(buffered, format="PNG")
-        img_str = base64.b64encode(buffered.getvalue()).decode() # Keep base64 for this route as in original
+        img_str = base64.b64encode(buffered.getvalue()).decode() # Keep base64 for this route
 
         def generate():
             mode = 'starting'
             try:
                 response = client.models.generate_content_stream(
-                    # 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.
                         Si nécessaire, utilise du code Python pour effectuer les calculs complexes.
@@ -81,11 +79,10 @@ def solve():
                     )
                 )
 
-                # Process the streaming response as you had it
                 for chunk in response:
+                     # Process chunks as in your original streaming logic
                     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'
@@ -110,7 +107,7 @@ def solve():
                                     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
+                    # Handle prompt feedback or finish reasons in streaming
                     elif chunk.prompt_feedback and chunk.prompt_feedback.block_reason:
                         error_msg = f"Prompt blocked: {chunk.prompt_feedback.block_reason.name}"
                         print(error_msg)
@@ -139,12 +136,14 @@ def solve():
         )
 
     except Exception as e:
-        print(f"Error in /solve endpoint: {e}")
+        # Log the full error for debugging
+        print(f"Error in /solve endpoint (setup or initial request): {e}")
+        print(traceback.format_exc())
         # 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 ---
+# --- MODIFIED /solved route (Free version, non-streaming) - Corrected Exception Handling ---
 @app.route('/solved', methods=['POST'])
 def solved():
     try:
@@ -160,17 +159,15 @@ def solved():
         except Exception as img_err:
             return jsonify({'error': f'Invalid image file: {str(img_err)}'}), 400
 
-        buffered = io.BytesBytesIO()
+        buffered = io.BytesIO() # Keep BytesIO
         img.save(buffered, format="PNG")
-        img_str = base64.b64encode(buffered.getvalue()).decode()
+        img_str = base64.b64encode(buffered.getvalue()).decode() # Keep base64
 
         # 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
 
-        # Prepare the content using inline_data with base64 string as in your original code
         contents = [
-             {'inline_data': {'mime_type': 'image/png', 'data': img_str}},
+             {'inline_data': {'mime_type': 'image/png', 'data': img_str}}, # Use inline_data with base64
             """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 ``` ... ```."""
@@ -181,7 +178,6 @@ def solved():
             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()
                 )]
@@ -194,61 +190,85 @@ def solved():
         # 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
+                # Check for the result attribute name - reverting to your original structure if possible
+                # Based on your original code, code_execution_result seemed to be the attribute
                 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
+                # Note: 'thought' parts are ignored
 
-        # Ensure we have some content, otherwise return a message
+        # Handle cases where the response is empty or blocked
         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:
+             # Check for prompt feedback blocking or finish reasons
+             if 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}."
+                 print(f"Generation blocked by prompt feedback: {block_reason}") # Log it
+
+             elif response.candidates and response.candidates[0].finish_reason:
+                 finish_reason = response.candidates[0].finish_reason.name
+                 # Provide specific messages for known non-STOP finish reasons
+                 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."
+                 else:
+                      # Generic message for other finish reasons (e.g., MAX_TOKENS)
+                      full_solution = f"La génération s'est terminée prématurément ({finish_reason}). Le problème est peut-être trop complexe ou nécessite plus de tokens."
+                 print(f"Generation finished early: {finish_reason}") # Log it
              else:
-                 full_solution = "Désolé, je n'ai pas pu générer de solution complète pour cette image."
+                 # Fallback if no specific reason is found but the response is empty
+                 full_solution = "Désolé, je n'ai pas pu générer de solution pour cette image."
+                 print("Generation resulted in empty content without specific block/finish reason.")
 
 
         # 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
+    # --- Corrected Exception Handling ---
+    # Catching a more general Google API error if available, otherwise just Exception
+    # The specific exception name might depend on the exact SDK version.
+    # We'll try a common one first. If this still gives AttributeError,
+    # we'll rely on the generic Exception catch below.
+    try:
+         # Attempt to import the specific exception type dynamically
+         # This is safer than assuming its location
+         from google.api_core.exceptions import GoogleAPIError
+         # If the import succeeds, catch that specific error
+         except GoogleAPIError as api_error:
+             print(f"Google API Error caught: {api_error}")
+             # Provide error details to the client, avoiding revealing full traceback
+             error_message = "Une erreur est survenue lors de la communication avec l'API GenAI."
+             # Attempt to extract a more specific message if possible from the error object
+             if hasattr(api_error, 'message'):
+                  error_message = f"Erreur API: {api_error.message}"
+             elif hasattr(api_error, 'details'):
+                   error_message = f"Erreur API: {api_error.details}"
+             else:
+                  error_message = f"Erreur API: {str(api_error)}" # Fallback to string representation
+
+             # Check for common error phrases to provide user-friendly messages
+             if "blocked" in str(api_error).lower() or "safety" in str(api_error).lower():
+                 error_message = 'Le contenu a été bloqué par l\'API pour des raisons de sécurité.'
+                 return jsonify({'error': error_message}), 400 # Use 400 for client-side issue (the prompt)
+
+             return jsonify({'error': error_message}), 500 # Use 500 for server-side API issues
+         except ImportError:
+             # If GoogleAPIError is not found in api_core, we'll fall through to the generic Exception catch
+             print("Could not import google.api_core.exceptions.GoogleAPIError. Using generic exception handling.")
+             pass # Continue to the next except block
+
     except Exception as e:
-        # Log the full error for debugging
-        import traceback
-        print(f"Error in /solved endpoint: {e}")
+        # Catch any other unexpected errors during processing or API call
+        print(f"An unexpected error occurred in /solved endpoint: {e}")
+        # Log the full traceback for server-side debugging
         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
+        return jsonify({'error': f'Une erreur interne est survenue: {str(e)}'}), 500
 
 
 if __name__ == '__main__':
@@ -256,4 +276,4 @@ if __name__ == '__main__':
     # Remove debug=True in production
     app.run(debug=True, host='0.0.0.0', port=5000) # Example port
 
-# --- END OF CORRECTED app.py ---
+# --- END OF CORRECTED_AGAIN app.py ---