Update app.py

app.py

@@ -2,33 +2,43 @@
 
 import os
 import logging
-from flask import Flask, make_response, render_template, request, redirect, url_for, session, jsonify, flash, Response, stream_with_context
+import json
+from flask import (
+    Flask, make_response, render_template, request, redirect, url_for,
+    session, jsonify, flash, Response, stream_with_context
+)
 from datetime import datetime, timedelta
 import psycopg2
 from psycopg2.extras import RealDictCursor
 from google import genai
 from google.genai import types
-from utils import load_prompt # Assurez-vous que utils.py et la fonction load_prompt existent
 
-# --- Configuration ---
-logging.basicConfig(level=logging.INFO)
+# Import de la fonction de chargement des prompts depuis notre module utilitaire
+from utils import load_prompt
+
+# --- Configuration de l'application ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # Initialisation de Flask
 app = Flask(__name__)
-app.secret_key = os.environ.get("FLASK_SECRET_KEY", "uyyhhy77uu")
-app.permanent_session_lifetime = timedelta(days=200)
+app.secret_key = os.environ.get("FLASK_SECRET_KEY", "uyyhhy77uu-default-secret-key")
 
-# URLs et Clés API
+# Configuration des variables d'environnement
 DATABASE_URL = os.environ.get("DATABASE")
 GOOGLE_API_KEY = os.environ.get("TOKEN")
 
-# Configuration du client Gemini
+# Configuration du client Google GenAI
 try:
-    client = genai.Client(api_key=GOOGLE_API_KEY)
+    if not GOOGLE_API_KEY:
+        logging.warning("La variable d'environnement TOKEN (GOOGLE_API_KEY) n'est pas définie.")
+        client = None
+    else:
+        client = genai.Client(api_key=GOOGLE_API_KEY)
 except Exception as e:
-    logging.error(f"Erreur lors de l'initialisation du client GenAI: {e}")
+    logging.error(f"Erreur critique lors de l'initialisation du client GenAI: {e}")
     client = None
 
+# Paramètres de sécurité pour l'API Gemini
 SAFETY_SETTINGS = [
     {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
     {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
@@ -36,18 +46,25 @@ SAFETY_SETTINGS = [
     {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
 ]
 
-# --- Helpers ---
+# --- Helpers de base de données ---
 def create_connection():
-    return psycopg2.connect(DATABASE_URL)
+    """Crée et retourne une connexion à la base de données PostgreSQL."""
+    try:
+        return psycopg2.connect(DATABASE_URL)
+    except psycopg2.OperationalError as e:
+        logging.error(f"Impossible de se connecter à la base de données : {e}")
+        return None
 
-# --- Routes Principales ---
+# --- Route principale pour l'affichage de la page ---
 @app.route('/')
 def philosophie():
+    """Affiche la page principale de l'assistant philosophique."""
     return render_template("philosophie.html")
 
-# --- Routes API (Non-Streaming) ---
+# --- Routes API pour les données des cours (Non-Streaming) ---
 @app.route('/api/philosophy/courses', methods=['GET'])
 def get_philosophy_courses():
+    """Récupère la liste de tous les cours de philosophie."""
     try:
         with create_connection() as conn:
             with conn.cursor(cursor_factory=RealDictCursor) as cur:
@@ -56,68 +73,81 @@ def get_philosophy_courses():
         return jsonify(courses)
     except Exception as e:
         logging.error(f"Erreur lors de la récupération des cours : {e}")
-        return jsonify({"error": "Erreur interne du serveur."}), 500
+        return jsonify({"error": "Erreur interne du serveur lors de la récupération des cours."}), 500
 
 @app.route('/api/philosophy/courses/<int:course_id>', methods=['GET'])
 def get_philosophy_course(course_id):
+    """Récupère les détails d'un cours spécifique par son ID."""
     try:
         with create_connection() as conn:
             with conn.cursor(cursor_factory=RealDictCursor) as cur:
-                cur.execute("SELECT id, title, content, author, created_at, updated_at FROM cours_philosophie WHERE id = %s", (course_id,))
+                cur.execute("SELECT content, author, updated_at FROM cours_philosophie WHERE id = %s", (course_id,))
                 course = cur.fetchone()
         if course:
             return jsonify(course)
         return jsonify({"error": "Cours non trouvé"}), 404
     except Exception as e:
-        logging.error(f"Erreur lors de la récupération du cours : {e}")
-        return jsonify({"error": "Erreur interne du serveur."}), 500
-
-# --- Routes de Génération (Streaming) ---
-
-def process_and_stream(model_id, prompt_content):
-    """Génère et stream le contenu depuis le modèle Gemini."""
+        logging.error(f"Erreur lors de la récupération du cours ID {course_id} : {e}")
+        return jsonify({"error": "Erreur interne du serveur lors de la récupération du cours."}), 500
+
+# --- Logique de Génération en Streaming ---
+def process_and_stream_with_thinking(model_id, prompt_content):
+    """
+    Génère et streame le contenu avec la pensée activée, en envoyant des objets JSON.
+    Chaque objet JSON est délimité par un retour à la ligne.
+    """
     if not client:
-        yield "Erreur: Le client API n'est pas configuré."
+        error_data = json.dumps({"type": "error", "content": "Le service IA n'est pas correctement configuré. Veuillez contacter l'administrateur."}) + "\n"
+        yield error_data
         return
 
     try:
+        config = types.GenerateContentConfig(
+            safety_settings=SAFETY_SETTINGS,
+            thinking_config=types.ThinkingConfig(include_thoughts=True)
+        )
+
         stream = client.models.generate_content_stream(
-            model=model_id,
-            contents=prompt_content,
-            config=types.GenerateContentConfig(safety_settings=SAFETY_SETTINGS)
+            model=model_id, contents=prompt_content, config=config
         )
+        
         for chunk in stream:
-            if chunk.text:
-                yield chunk.text
+            for part in chunk.candidates[0].content.parts:
+                if not part.text:
+                    continue
+                
+                data_type = "thought" if part.thought else "answer"
+                data = {"type": data_type, "content": part.text}
+                yield json.dumps(data, ensure_ascii=False) + "\n"
+
     except Exception as e:
         logging.error(f"Erreur de streaming Gemini ({model_id}): {e}")
-        yield f"\n\n**Erreur de génération :** {str(e)}"
+        error_data = json.dumps({"type": "error", "content": f"Une erreur est survenue avec le service IA : {e}"}) + "\n"
+        yield error_data
 
+# --- Routes de Génération en Streaming ---
 @app.route('/stream_philo', methods=['POST'])
 @app.route('/stream_philo_deepthink', methods=['POST'])
 def stream_philo_text():
+    """Gère les requêtes de génération de texte en streaming."""
     data = request.json
     phi_prompt = data.get('question', '').strip()
     phi_type = data.get('type', '1')
     course_id = data.get('courseId')
 
     if not phi_prompt:
-        return Response("Erreur: Veuillez saisir un sujet.", status=400, mimetype='text/plain')
+        return Response("Erreur: Le champ 'sujet' est obligatoire.", status=400)
     
-    # Déterminer le modèle et le fichier de prompt
     is_deepthink = 'deepthink' in request.path
     model_id = "gemini-2.5-pro" if is_deepthink else "gemini-2.5-flash"
-    prompt_files = {'1': 'philo_type1.txt', '2': 'philo_type2.txt'}
-    prompt_file = prompt_files.get(phi_type)
-
+    prompt_file = {'1': 'philo_type1.txt', '2': 'philo_type2.txt'}.get(phi_type)
+    
     if not prompt_file:
-        return Response(f"Erreur: Type de sujet '{phi_type}' non valide.", status=400, mimetype='text/plain')
+         return Response(f"Erreur: Type de sujet '{phi_type}' invalide.", status=400)
 
-    # Charger et formater le prompt
     prompt_template = load_prompt(prompt_file)
     final_prompt = prompt_template.format(phi_prompt=phi_prompt)
 
-    # Ajouter le contenu du cours si disponible
     if course_id:
         try:
             with create_connection() as conn:
@@ -128,90 +158,96 @@ def stream_philo_text():
                         final_prompt += f"\n\n--- EXTRAIT DE COURS POUR CONTEXTE ---\n{result['content']}"
         except Exception as e:
             logging.error(f"Erreur DB pour le cours {course_id}: {e}")
-            # Continuer sans le contenu du cours en cas d'erreur
-
-    def generate():
-        yield from process_and_stream(model_id, final_prompt)
 
-    return Response(stream_with_context(generate()), mimetype='text/plain')
+    return Response(stream_with_context(process_and_stream_with_thinking(model_id, final_prompt)), mimetype='application/x-json-stream; charset=utf-8')
 
 @app.route('/stream_philo_image', methods=['POST'])
 def stream_philo_image():
+    """Gère les requêtes d'analyse d'image en streaming."""
     if 'image' not in request.files:
-        return Response("Erreur: Fichier image manquant.", status=400, mimetype='text/plain')
+        return Response("Erreur: Fichier image manquant.", status=400)
 
     image_file = request.files['image']
-    if not image_file.filename:
-        return Response("Erreur: Aucun fichier sélectionné.", status=400, mimetype='text/plain')
+    if not image_file or not image_file.filename:
+        return Response("Erreur: Aucun fichier sélectionné.", status=400)
 
     try:
         img_bytes = image_file.read()
         image_part = types.Part.from_bytes(data=img_bytes, mime_type=image_file.mimetype)
         
         prompt_text = load_prompt('philo_image_analysis.txt')
-        
         contents = [prompt_text, image_part]
         
-        # Le modèle vision pro est souvent le meilleur pour les images
+        # Le modèle "pro" est plus performant pour l'analyse d'image complexe
         model_id = "gemini-2.5-pro"
 
-        def generate():
-            yield from process_and_stream(model_id, contents)
-
-        return Response(stream_with_context(generate()), mimetype='text/plain')
+        return Response(stream_with_context(process_and_stream_with_thinking(model_id, contents)), mimetype='application/x-json-stream; charset=utf-8')
 
     except Exception as e:
         logging.error(f"Erreur lors du traitement de l'image : {e}")
-        return Response("Erreur interne lors du traitement de l'image.", status=500, mimetype='text/plain')
-
+        return Response("Erreur interne lors de la préparation de l'image.", status=500)
 
 # --- Routes d'Administration (inchangées) ---
 @app.route('/admin/philosophy/courses', methods=['GET', 'POST', 'DELETE'])
 def manage_philosophy_courses():
-    # ... (Le code de cette route reste le même qu'avant)
+    """Gère le CRUD pour les cours de philosophie."""
     if request.method == 'GET':
         try:
-            conn = psycopg2.connect(DATABASE_URL)
-            cur = conn.cursor(cursor_factory=RealDictCursor)
-            cur.execute("SELECT * FROM cours_philosophie")
-            courses = cur.fetchall()
-            cur.close()
-            conn.close()
+            with create_connection() as conn:
+                with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                    cur.execute("SELECT * FROM cours_philosophie ORDER BY updated_at DESC")
+                    courses = cur.fetchall()
             return render_template('philosophy_courses.html', courses=courses)
         except Exception as e:
             flash(f'Erreur lors de la récupération des cours : {e}', 'danger')
-            return redirect(url_for('manage_philosophy_courses'))
+            return redirect(url_for('some_admin_dashboard_route')) # Remplacez par une route de fallback
 
     elif request.method == 'POST':
-        if 'title' in request.form: 
+        # La logique de suppression est maintenant dans une route DELETE dédiée pour être plus RESTful
+        # Mais on garde la logique formulaire pour la simplicité
+        if 'delete_course_id' in request.form:
+             try:
+                course_id = request.form.get('delete_course_id')
+                with create_connection() as conn:
+                    with conn.cursor() as cur:
+                        cur.execute("DELETE FROM cours_philosophie WHERE id = %s", (course_id,))
+                        conn.commit()
+                flash('Cours supprimé avec succès !', 'success')
+             except Exception as e:
+                flash(f'Erreur lors de la suppression du cours : {e}', 'danger')
+        else: # Logique d'ajout/modification
             try:
                 title = request.form.get('title')
                 content = request.form.get('content')
                 author = request.form.get('author')
-                conn = psycopg2.connect(DATABASE_URL)
-                cur = conn.cursor()
-                cur.execute("INSERT INTO cours_philosophie (title, content, author) VALUES (%s, %s, %s)", (title, content, author))
-                conn.commit()
-                cur.close()
-                conn.close()
+                with create_connection() as conn:
+                    with conn.cursor() as cur:
+                        cur.execute(
+                            "INSERT INTO cours_philosophie (title, content, author) VALUES (%s, %s, %s)",
+                            (title, content, author)
+                        )
+                        conn.commit()
                 flash('Cours ajouté avec succès !', 'success')
-                return redirect(url_for('manage_philosophy_courses'))
-            except Exception as e:
-                flash(f'Erreur lors de l\'ajout du cours : {e}', 'danger')
-                return redirect(url_for('manage_philosophy_courses'))
-        else:
-            try:
-                course_id = request.form.get('id')
-                conn = psycopg2.connect(DATABASE_URL)
-                cur = conn.cursor()
-                cur.execute("DELETE FROM cours_philosophie WHERE id = %s", (course_id,))
-                conn.commit()
-                cur.close()
-                conn.close()
-                flash('Cours supprimé avec succès !', 'success')
-                return redirect(url_for('manage_philosophy_courses'))
             except Exception as e:
-                flash(f'Erreur lors de la suppression du cours : {e}', 'danger')
-                return redirect(url_for('manage_philosophy_courses'))
+                flash(f"Erreur lors de l'ajout du cours : {e}", 'danger')
+        
+        return redirect(url_for('manage_philosophy_courses'))
+    
+    # Pour la suppression via DELETE http method (par ex: avec du JS)
+    elif request.method == 'DELETE':
+        course_id = request.form.get('id')
+        try:
+            with create_connection() as conn:
+                with conn.cursor() as cur:
+                    cur.execute("DELETE FROM cours_philosophie WHERE id = %s", (course_id,))
+                    conn.commit()
+            return jsonify({'success': True, 'message': 'Cours supprimé'}), 200
+        except Exception as e:
+            return jsonify({'success': False, 'message': str(e)}), 500
+
+if __name__ == '__main__':
+    # Utiliser debug=True uniquement pour le développement local
+    # Pour la production, utilisez un serveur WSGI comme Gunicorn ou uWSGI
+    app.run(debug=True, port=5000)
 
 # --- END OF FILE app.py ---