Update app.py

app.py

@@ -1,311 +1,206 @@
-from flask import Flask, render_template, request, jsonify, Response, session
-import os
+from flask import Flask, request, render_template, jsonify, Response
 import json
-import base64
+import os
 from google import genai
 from google.genai import types
+import base64
 from werkzeug.utils import secure_filename
-import uuid
-from datetime import datetime
-import io
-from typing import Optional, List, Dict, Union
+import mimetypes
 
 app = Flask(__name__)
-app.secret_key = 'your-secret-key-here'  # Changez cette clé !
-
-# Configuration de l'upload
-UPLOAD_FOLDER = 'uploads'
-ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'pdf', 'mp4', 'mov', 'txt', 'csv', 'json'}
-MAX_CONTENT_LENGTH = 16 * 1024 * 1024  # 16MB max file size
-
-app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-app.config['MAX_CONTENT_LENGTH'] = MAX_CONTENT_LENGTH
-
-# Créer le dossier uploads s'il n'existe pas
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max file size
 
-# Initialisation du client Gemini
+# Configuration du client Gemini
 API_KEY = "AIzaSyAMYpF67aqFnWDJESWOx1dC-w3sEU29VcM"
 client = genai.Client(api_key=API_KEY)
 
-# Configuration des modèles disponibles
-MODELS = {
-    "Gemini 2.5 Flash": "gemini-2.5-flash",
-    "Gemini 2.5 Pro": "gemini-2.5-pro",
-    "Gemini 2.5 Flash Lite": "gemini-2.5-flash-lite",
-    "Gemini 2.0 Flash": "gemini-2.0-flash"
+# Configuration par défaut
+MODEL = "gemini-2.5-flash"
+DEFAULT_CONFIG = {
+    "temperature": 0.7,
+    "max_output_tokens": 8192,
+    "top_p": 0.9,
+    "top_k": 40
 }
 
-def allowed_file(filename):
-    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+# Outils activés par défaut
+DEFAULT_TOOLS = [
+    types.Tool(code_execution=types.ToolCodeExecution()),
+    types.Tool(google_search=types.GoogleSearch()),
+    types.Tool(url_context=types.UrlContext())
+]
 
-def configure_tools() -> List[types.Tool]:
-    """Configure tous les outils par défaut"""
-    tools = []
-    tools.append(types.Tool(code_execution=types.ToolCodeExecution()))
-    tools.append(types.Tool(google_search=types.GoogleSearch()))
-    tools.append(types.Tool(url_context=types.UrlContext()))
-    return tools
-
-def get_generation_config(
-    model: str,
-    thinking_enabled: bool = True,
-    include_thoughts: bool = False
-) -> types.GenerateContentConfig:
-    """Configuration optimisée par défaut"""
-    config_dict = {
-        "temperature": 0.7,
-        "max_output_tokens": 8192,
-        "top_p": 0.9,
-        "top_k": 40,
-        "tools": configure_tools()
-    }
-    
-    if thinking_enabled:
-        config_dict["thinking_config"] = types.ThinkingConfig(
-            thinking_budget=-1,  # Dynamique par défaut
-            include_thoughts=include_thoughts
-        )
-    
-    return types.GenerateContentConfig(**config_dict)
-
-def process_uploaded_file(file) -> Optional[types.Part]:
-    """Traite les fichiers uploadés"""
-    if not file:
-        return None
-    
-    file_bytes = file.read()
-    mime_type = file.content_type
-    
-    # Réinitialiser le pointeur du fichier
-    file.seek(0)
-    
-    # Gestion des différents types de fichiers
-    if mime_type.startswith("image/"):
-        return types.Part.from_bytes(data=file_bytes, mime_type=mime_type)
-    elif mime_type == "application/pdf":
-        return types.Part.from_bytes(data=file_bytes, mime_type=mime_type)
-    elif mime_type.startswith("video/"):
-        return types.Part.from_bytes(data=file_bytes, mime_type=mime_type)
-    elif mime_type in ["text/plain", "text/csv", "application/json"]:
-        return types.Part.from_bytes(data=file_bytes, mime_type=mime_type)
-    
-    return None
+# Stockage des conversations (en production, utilisez une base de données)
+conversations = {}
 
 @app.route('/')
 def index():
-    """Page principale"""
-    return render_template('index.html', models=MODELS)
+    return render_template('index.html')
 
-@app.route('/send_message', methods=['POST'])
-def send_message():
-    """Endpoint pour envoyer un message avec streaming"""
-    def generate():
-        try:
-            # Récupération des données
-            data = request.get_json()
-            message = data.get('message', '')
-            model = data.get('model', 'gemini-2.5-flash')
-            thinking_enabled = data.get('thinking_enabled', True)
-            include_thoughts = data.get('include_thoughts', False)
-            
-            if not message.strip():
-                yield f"data: {json.dumps({'error': 'Message vide'})}\n\n"
-                return
-            
-            # Configuration de génération
-            generation_config = get_generation_config(
-                model=model,
-                thinking_enabled=thinking_enabled,
-                include_thoughts=include_thoughts
+@app.route('/chat', methods=['POST'])
+def chat():
+    try:
+        data = request.get_json()
+        message = data.get('message', '')
+        thinking_enabled = data.get('thinking_enabled', True)
+        conversation_id = data.get('conversation_id', 'default')
+        
+        # Configuration du thinking
+        config_dict = DEFAULT_CONFIG.copy()
+        if thinking_enabled:
+            config_dict["thinking_config"] = types.ThinkingConfig(
+                thinking_budget=-1,  # Dynamic thinking
+                include_thoughts=True
             )
-            
-            # Initialisation ou récupération du chat
-            chat_id = session.get('chat_id')
-            if not chat_id:
-                chat_id = str(uuid.uuid4())
-                session['chat_id'] = chat_id
-                session['chat'] = client.chats.create(
-                    model=model,
-                    config=generation_config
-                )
-            
-            chat = session.get('chat')
-            if not chat:
-                session['chat'] = client.chats.create(
-                    model=model,
-                    config=generation_config
-                )
-                chat = session['chat']
-            
-            # Préparation du contenu
-            contents = [message]
-            
-            # Envoi du message avec streaming
-            response_stream = chat.send_message_stream(
-                contents,
+        
+        config_dict["tools"] = DEFAULT_TOOLS
+        generation_config = types.GenerateContentConfig(**config_dict)
+        
+        # Gestion de la conversation
+        if conversation_id not in conversations:
+            conversations[conversation_id] = client.chats.create(
+                model=MODEL,
                 config=generation_config
             )
-            
-            # Streaming de la réponse
-            full_response = ""
-            thoughts_content = ""
-            
-            for chunk in response_stream:
-                for part in chunk.candidates[0].content.parts:
-                    if part.text:
-                        if part.thought and include_thoughts:
-                            thoughts_content += part.text
-                            yield f"data: {json.dumps({'type': 'thought', 'content': part.text})}\n\n"
-                        else:
-                            full_response += part.text
-                            yield f"data: {json.dumps({'type': 'text', 'content': part.text})}\n\n"
-            
-            # Message de fin
-            yield f"data: {json.dumps({'type': 'end', 'full_response': full_response})}\n\n"
-            
-        except Exception as e:
-            yield f"data: {json.dumps({'error': str(e)})}\n\n"
-    
-    return Response(generate(), mimetype='text/event-stream')
+        
+        chat = conversations[conversation_id]
+        
+        # Génération de la réponse avec streaming
+        def generate():
+            try:
+                response_stream = chat.send_message_stream(
+                    message,
+                    config=generation_config
+                )
+                
+                full_response = ""
+                thoughts = ""
+                
+                for chunk in response_stream:
+                    for part in chunk.candidates[0].content.parts:
+                        if part.text:
+                            if part.thought and thinking_enabled:
+                                thoughts += part.text
+                                yield f"data: {json.dumps({'type': 'thought', 'content': part.text})}\n\n"
+                            else:
+                                full_response += part.text
+                                yield f"data: {json.dumps({'type': 'text', 'content': part.text})}\n\n"
+                
+                # Signal de fin
+                yield f"data: {json.dumps({'type': 'end'})}\n\n"
+                
+            except Exception as e:
+                yield f"data: {json.dumps({'type': 'error', 'content': str(e)})}\n\n"
+        
+        return Response(generate(), mimetype='text/plain')
+        
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
 
-@app.route('/upload_file', methods=['POST'])
+@app.route('/upload', methods=['POST'])
 def upload_file():
-    """Endpoint pour uploader des fichiers"""
     try:
         if 'file' not in request.files:
-            return jsonify({'error': 'Aucun fichier fourni'}), 400
+            return jsonify({'error': 'No file uploaded'}), 400
         
         file = request.files['file']
         if file.filename == '':
-            return jsonify({'error': 'Aucun fichier sélectionné'}), 400
+            return jsonify({'error': 'No file selected'}), 400
         
-        if file and allowed_file(file.filename):
-            filename = secure_filename(file.filename)
-            file_id = str(uuid.uuid4())
-            file_path = os.path.join(app.config['UPLOAD_FOLDER'], f"{file_id}_{filename}")
-            
-            # Sauvegarder le fichier
-            file.save(file_path)
-            
-            # Traiter le fichier pour Gemini
-            with open(file_path, 'rb') as f:
-                file_part = process_uploaded_file(f)
-            
-            if file_part:
-                # Stocker les informations du fichier en session
-                if 'uploaded_files' not in session:
-                    session['uploaded_files'] = {}
-                
-                session['uploaded_files'][file_id] = {
-                    'filename': filename,
-                    'path': file_path,
-                    'mime_type': file.content_type
-                }
-                
-                return jsonify({
-                    'success': True,
-                    'file_id': file_id,
-                    'filename': filename,
-                    'mime_type': file.content_type
-                })
-            else:
-                # Supprimer le fichier si le traitement a échoué
-                os.remove(file_path)
-                return jsonify({'error': 'Type de fichier non supporté'}), 400
+        # Lire le fichier
+        file_bytes = file.read()
+        mime_type = file.content_type or mimetypes.guess_type(file.filename)[0]
+        
+        # Encoder en base64 pour le stockage temporaire
+        file_b64 = base64.b64encode(file_bytes).decode()
+        
+        return jsonify({
+            'success': True,
+            'filename': file.filename,
+            'mime_type': mime_type,
+            'data': file_b64
+        })
         
-        return jsonify({'error': 'Type de fichier non autorisé'}), 400
-    
     except Exception as e:
         return jsonify({'error': str(e)}), 500
 
-@app.route('/send_message_with_file', methods=['POST'])
-def send_message_with_file():
-    """Endpoint pour envoyer un message avec fichier attaché"""
-    def generate():
-        try:
-            data = request.get_json()
-            message = data.get('message', '')
-            model = data.get('model', 'gemini-2.5-flash')
-            thinking_enabled = data.get('thinking_enabled', True)
-            include_thoughts = data.get('include_thoughts', False)
-            file_id = data.get('file_id')
-            
-            if not message.strip():
-                yield f"data: {json.dumps({'error': 'Message vide'})}\n\n"
-                return
-            
-            # Configuration de génération
-            generation_config = get_generation_config(
-                model=model,
-                thinking_enabled=thinking_enabled,
-                include_thoughts=include_thoughts
+@app.route('/chat_with_file', methods=['POST'])
+def chat_with_file():
+    try:
+        data = request.get_json()
+        message = data.get('message', '')
+        file_data = data.get('file_data')
+        thinking_enabled = data.get('thinking_enabled', True)
+        conversation_id = data.get('conversation_id', 'default')
+        
+        # Configuration du thinking
+        config_dict = DEFAULT_CONFIG.copy()
+        if thinking_enabled:
+            config_dict["thinking_config"] = types.ThinkingConfig(
+                thinking_budget=-1,
+                include_thoughts=True
             )
-            
-            # Récupération du chat
-            chat = session.get('chat')
-            if not chat:
-                session['chat'] = client.chats.create(
-                    model=model,
-                    config=generation_config
-                )
-                chat = session['chat']
-            
-            # Préparation du contenu
-            contents = [message]
-            
-            # Ajout du fichier si présent
-            if file_id and 'uploaded_files' in session and file_id in session['uploaded_files']:
-                file_info = session['uploaded_files'][file_id]
-                with open(file_info['path'], 'rb') as f:
-                    file_part = process_uploaded_file(f)
-                    if file_part:
-                        contents.append(file_part)
-            
-            # Envoi du message avec streaming
-            response_stream = chat.send_message_stream(
-                contents,
+        
+        config_dict["tools"] = DEFAULT_TOOLS
+        generation_config = types.GenerateContentConfig(**config_dict)
+        
+        # Gestion de la conversation
+        if conversation_id not in conversations:
+            conversations[conversation_id] = client.chats.create(
+                model=MODEL,
                 config=generation_config
             )
-            
-            # Streaming de la réponse
-            full_response = ""
-            
-            for chunk in response_stream:
-                for part in chunk.candidates[0].content.parts:
-                    if part.text:
-                        if part.thought and include_thoughts:
-                            yield f"data: {json.dumps({'type': 'thought', 'content': part.text})}\n\n"
-                        else:
-                            full_response += part.text
-                            yield f"data: {json.dumps({'type': 'text', 'content': part.text})}\n\n"
-            
-            # Message de fin
-            yield f"data: {json.dumps({'type': 'end', 'full_response': full_response})}\n\n"
-            
-        except Exception as e:
-            yield f"data: {json.dumps({'error': str(e)})}\n\n"
-    
-    return Response(generate(), mimetype='text/event-stream')
+        
+        chat = conversations[conversation_id]
+        
+        # Préparation du contenu avec fichier
+        contents = [message]
+        
+        if file_data:
+            file_bytes = base64.b64decode(file_data['data'])
+            file_part = types.Part.from_bytes(
+                data=file_bytes,
+                mime_type=file_data['mime_type']
+            )
+            contents.append(file_part)
+        
+        # Génération de la réponse avec streaming
+        def generate():
+            try:
+                response_stream = chat.send_message_stream(
+                    contents,
+                    config=generation_config
+                )
+                
+                for chunk in response_stream:
+                    for part in chunk.candidates[0].content.parts:
+                        if part.text:
+                            if part.thought and thinking_enabled:
+                                yield f"data: {json.dumps({'type': 'thought', 'content': part.text})}\n\n"
+                            else:
+                                yield f"data: {json.dumps({'type': 'text', 'content': part.text})}\n\n"
+                
+                yield f"data: {json.dumps({'type': 'end'})}\n\n"
+                
+            except Exception as e:
+                yield f"data: {json.dumps({'type': 'error', 'content': str(e)})}\n\n"
+        
+        return Response(generate(), mimetype='text/plain')
+        
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
 
-@app.route('/reset_chat', methods=['POST'])
-def reset_chat():
-    """Reset la conversation"""
+@app.route('/reset_conversation', methods=['POST'])
+def reset_conversation():
     try:
-        session.pop('chat_id', None)
-        session.pop('chat', None)
+        data = request.get_json()
+        conversation_id = data.get('conversation_id', 'default')
         
-        # Nettoyer les fichiers uploadés
-        if 'uploaded_files' in session:
-            for file_info in session['uploaded_files'].values():
-                try:
-                    if os.path.exists(file_info['path']):
-                        os.remove(file_info['path'])
-                except:
-                    pass
-            session.pop('uploaded_files', None)
+        if conversation_id in conversations:
+            del conversations[conversation_id]
         
         return jsonify({'success': True})
+        
     except Exception as e:
         return jsonify({'error': str(e)}), 500