Update app.py

app.py

@@ -1,31 +1,33 @@
-# --- START OF CORRECTED_AGAIN app.py ---
+# --- START OF CORRECTED app.py (v3 - Fixes AttributeError) ---
 
 from flask import Flask, render_template, request, jsonify, Response, stream_with_context
-# Utilisation de l'import et de l'initialisation de votre code original
+# 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 des exceptions potentielles si elles sont dans google.api_core
-# from google.api_core import exceptions as api_exceptions
+# Correct import for GoogleAPIError with the original genai client
+from google.api_core.exceptions import GoogleAPIError # <-- IMPORTATION CORRIGÉE
 import os
 from PIL import Image
 import io
 import base64
 import json
-import traceback # Import traceback pour un meilleur log des erreurs
+import re
 
 app = Flask(__name__)
 
 GOOGLE_API_KEY = os.environ.get("GEMINI_API_KEY")
 
-# Utilisation de l'initialisation de votre code original
+# 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. API calls will likely fail.")
-    # Consider adding a check before allowing API calls if the key is missing
+    print("WARNING: GEMINI_API_KEY environment variable not set.")
+    # Handle this case appropriately, e.g., exit or show an error on the page
+    # In a real application, you might want to raise an error or redirect
 
 # --- Routes for index and potentially the Pro version (kept for context) ---
 @app.route('/')
@@ -56,7 +58,7 @@ def solve():
 
         buffered = io.BytesIO()
         img.save(buffered, format="PNG")
-        img_str = base64.b64encode(buffered.getvalue()).decode() # Keep base64 for this route
+        img_str = base64.b64encode(buffered.getvalue()).decode()
 
         def generate():
             mode = 'starting'
@@ -80,7 +82,6 @@ def solve():
                 )
 
                 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:
                             if hasattr(part, 'thought') and part.thought:
@@ -107,7 +108,7 @@ def solve():
                                     mode = "answering"
                                 if hasattr(part, 'text') and part.text:
                                     yield 'data: ' + json.dumps({"content": part.text}) + '\n\n'
-                    # Handle prompt feedback or finish reasons in streaming
+                    # Handle cases where a chunk might not have candidates/parts, 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)
@@ -121,7 +122,6 @@ def solve():
                             yield 'data: ' + json.dumps({"error": error_msg}) + '\n\n'
                         break # Stop processing on finish reason
 
-
             except Exception as e:
                 print(f"Error during streaming generation: {e}")
                 yield 'data: ' + json.dumps({"error": str(e)}) + '\n\n'
@@ -136,14 +136,11 @@ def solve():
         )
 
     except Exception as 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
+        print(f"Error in /solve endpoint: {e}")
         return jsonify({'error': f'Failed to process request: {str(e)}'}), 500
 
 
-# --- MODIFIED /solved route (Free version, non-streaming) - Corrected Exception Handling ---
+# --- MODIFIED /solved route (Free version, non-streaming) using original SDK syntax ---
 @app.route('/solved', methods=['POST'])
 def solved():
     try:
@@ -159,21 +156,19 @@ def solved():
         except Exception as img_err:
             return jsonify({'error': f'Invalid image file: {str(img_err)}'}), 400
 
-        buffered = io.BytesIO() # Keep BytesIO
+        buffered = io.BytesIO() # Corrected spelling BytesBytesIO -> BytesIO
         img.save(buffered, format="PNG")
-        img_str = base64.b64encode(buffered.getvalue()).decode() # Keep base64
+        img_str = base64.b64encode(buffered.getvalue()).decode()
 
-        # Use the non-streaming generate_content method
         model_name = "gemini-2.5-flash-preview-04-17" # Your original free model name
 
         contents = [
-             {'inline_data': {'mime_type': 'image/png', 'data': img_str}}, # Use inline_data with base64
+             {'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 ``` ... ```."""
         ]
 
-        # Call the non-streaming generation method using the original client object
         response = client.models.generate_content(
             model=model_name,
             contents=contents,
@@ -182,10 +177,8 @@ def solved():
                     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:
@@ -194,81 +187,66 @@ def solved():
                     full_solution += part.text
                 elif hasattr(part, 'executable_code') and part.executable_code:
                     full_solution += f"\n\n```python\n{part.executable_code.code}\n```\n\n"
-                # 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
+                # Check for the result attribute name based on your SDK version's structure
                 elif hasattr(part, 'code_execution_result') and hasattr(part.code_execution_result, 'output'):
                      output_str = part.code_execution_result.output
                      full_solution += f"\n\n**Résultat d'exécution:**\n```\n{output_str}\n```\n\n"
-                # Note: 'thought' parts are ignored
+                 # Check for prompt_feedback on the response object for non-streaming
+            if response.prompt_feedback and response.prompt_feedback.block_reason:
+                block_reason = response.prompt_feedback.block_reason.name
+                # Add block reason to the solution or handle as error
+                if not full_solution.strip(): # If no other content generated
+                     full_solution = f"Le contenu a été bloqué pour des raisons de sécurité: {block_reason}."
+                else: # If some content was generated before blocking
+                     full_solution += f"\n\n**Attention:** La réponse a pu être incomplète car le contenu a été bloqué: {block_reason}."
 
-        # Handle cases where the response is empty or blocked
+
+        # Ensure we have some content, otherwise return a message or specific error
         if not full_solution.strip():
-             # 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:
-                 # 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.")
+             # Check for finish reasons on candidates
+             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 [] # You could log or use these
+             print(f"Generation finished with reason (no content): {finish_reason}")
+             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."
+             elif finish_reason == 'OTHER' or finish_reason == 'UNKNOWN': # Catch general failures
+                 full_solution = "Désolé, je n'ai pas pu générer de solution complète pour cette image."
+             # If finish_reason is 'STOP' but no content, the generic message below applies
+
+             if not full_solution.strip(): # Fallback if reason didn't give a specific message
+                 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
         return jsonify({'solution': full_solution.strip()})
 
-    # --- 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
+    # Catch specific API errors from google.api_core.exceptions
+    except GoogleAPIError as api_error: # <-- UTILISATION CORRIGÉE
+        print(f"GenAI API Error: {api_error}")
+        # Provide more user-friendly error messages based on potential API errors
+        error_message = str(api_error)
+        if "RESOURCE_EXHAUSTED" in error_message:
+             user_error = "Vous avez atteint votre quota d'utilisation de l'API. Veuillez réessayer plus tard ou vérifier votre console Google Cloud."
+        elif "400 Bad Request" in error_message or "INVALID_ARGUMENT" in error_message:
+             user_error = f"La requête à l'API est invalide : {error_message}. L'image n'a peut-être pas été comprise."
+        elif "403 Forbidden" in error_message or "PERMISSION_DENIED" in error_message:
+             user_error = "Erreur d'authentification ou de permissions avec l'API. Vérifiez votre clé API."
+        elif "50" in error_message: # Catch 5xx errors
+             user_error = f"Erreur serveur de l'API : {error_message}. Veuillez réessayer plus tard."
+        else:
+             user_error = f'Erreur de l\'API GenAI: {error_message}'
+
+        return jsonify({'error': user_error}), api_error.code if hasattr(api_error, 'code') else 500 # Return appropriate status code if available
 
     except Exception as 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
+        # 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: {str(e)}'}), 500
+        return jsonify({'error': f'Une erreur interne est survenue lors du traitement: {str(e)}'}), 500
 
 
 if __name__ == '__main__':
@@ -276,4 +254,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_AGAIN app.py ---
+# --- END OF CORRECTED app.py (v3 - Fixes AttributeError) ---