Update app.py

app.py

@@ -8,22 +8,15 @@ from werkzeug.utils import secure_filename
 import tempfile
 from datetime import datetime
 import uuid
-from pathlib import Path
 
 app = Flask(__name__)
 app.secret_key = os.urandom(24)
 load_dotenv()
 
-# Configuration des dossiers
-UPLOAD_FOLDER = Path('uploads')
-TEMP_FOLDER = Path('temp')
-UPLOAD_FOLDER.mkdir(exist_ok=True)
-TEMP_FOLDER.mkdir(exist_ok=True)
-
-# Configuration de Google AI
+# Configure Google AI
 genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
 
-# Paramètres de sécurité
+# Safety settings
 safety_settings = [
     {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
     {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
@@ -31,38 +24,26 @@ safety_settings = [
     {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
 ]
 
-# Prompt système
+# System prompt
 SYSTEM_PROMPT = """
-Tu es Mariam, une assistante IA créée par Youssouf. Tu es serviable, polie et tu t'exprimes en français.
-Tu dois toujours :
-- Répondre en français
-- Être précise et concise dans tes réponses
-- Utiliser un ton professionnel mais amical
-- Proposer des solutions pratiques aux problèmes
-- Demander des clarifications si nécessaire
+# Prompt System pour Mariam, IA conçu par youssouf 
+[Your existing system prompt content here]
 """
 
-# Initialisation du modèle Gemini
-model = genai.GenerativeModel('gemini-pro',
-                            safety_settings=safety_settings)
+# Initialize Gemini model
+model = genai.GenerativeModel('gemini-2.0-flash-exp', 
+                            tools='code_execution',
+                            safety_settings=safety_settings,
+                            system_instruction=SYSTEM_PROMPT)
 
-# Stockage des conversations
-conversations = {}
+# Store chat sessions
 chat_sessions = {}
 
-# Extensions de fichiers autorisées
-ALLOWED_EXTENSIONS = {'jpg', 'jpeg', 'png', 'pdf', 'txt', 'doc', 'docx'}
-
-def allowed_file(filename):
-    """Vérifie si l'extension du fichier est autorisée"""
-    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
-
 def perform_web_search(query):
-    """Effectue une recherche web via l'API Serper"""
     conn = http.client.HTTPSConnection("google.serper.dev")
     payload = json.dumps({"q": query})
     headers = {
-        'X-API-KEY': os.getenv('SERPER_API_KEY'),
+        'X-API-KEY': '9b90a274d9e704ff5b21c0367f9ae1161779b573',
         'Content-Type': 'application/json'
     }
     try:
@@ -71,240 +52,134 @@ def perform_web_search(query):
         data = json.loads(res.read().decode("utf-8"))
         return data
     except Exception as e:
-        print(f"Erreur de recherche web: {e}")
+        print(f"Web search error: {e}")
         return None
     finally:
         conn.close()
 
 def format_search_results(data):
-    """Formate les résultats de recherche"""
     if not data:
         return "Aucun résultat trouvé"
     
-    formatted_results = []
-    
-    # Traitement du Knowledge Graph
+    result = []
     if 'knowledgeGraph' in data:
         kg = data['knowledgeGraph']
-        formatted_results.append(f"### {kg.get('title', '')}")
-        if 'description' in kg:
-            formatted_results.append(f"{kg['description']}\n")
+        result.append({
+            'type': 'knowledge',
+            'title': kg.get('title', ''),
+            'description': kg.get('description', ''),
+            'category': kg.get('type', '')
+        })
     
-    # Traitement des résultats organiques
     if 'organic' in data:
-        formatted_results.append("### Résultats de recherche:")
-        for item in data['organic'][:3]:  # Limite aux 3 premiers résultats
-            formatted_results.append(f"- **{item['title']}**")
-            formatted_results.append(f"  {item['snippet']}\n")
+        for item in data['organic'][:3]:
+            result.append({
+                'type': 'organic',
+                'title': item['title'],
+                'snippet': item['snippet'],
+                'link': item['link']
+            })
     
-    return "\n".join(formatted_results)
+    return result
 
-def create_new_conversation():
-    """Crée une nouvelle conversation"""
-    conversation_id = str(uuid.uuid4())
-    conversations[conversation_id] = {
-        'id': conversation_id,
-        'created_at': datetime.now().isoformat(),
-        'messages': []
-    }
-    chat_sessions[conversation_id] = model.start_chat(history=[])
-    return conversation_id
-
-@app.route('/')
-def home():
-    """Page d'accueil"""
-    if 'user_id' not in session:
-        session['user_id'] = str(uuid.uuid4())
-    return render_template('index.html')
+UPLOAD_FOLDER = 'temp'
+ALLOWED_EXTENSIONS = {'jpg', 'jpeg', 'png', 'pdf', 'txt', 'mp3', 'mp4'}
 
-@app.route('/conversations', methods=['GET'])
-def get_conversations():
-    """Récupère la liste des conversations"""
-    user_conversations = [
-        {
-            'id': conv_id,
-            'created_at': conv['created_at'],
-            'preview': conv['messages'][0]['content'][:50] + '...' if conv['messages'] else 'Nouvelle conversation'
-        }
-        for conv_id, conv in conversations.items()
-    ]
-    return jsonify(user_conversations)
-
-@app.route('/conversation', methods=['POST'])
-def create_conversation():
-    """Crée une nouvelle conversation"""
-    conversation_id = create_new_conversation()
-    return jsonify({
-        'id': conversation_id,
-        'created_at': conversations[conversation_id]['created_at']
-    })
-
-@app.route('/conversation/<conversation_id>', methods=['GET'])
-def get_conversation(conversation_id):
-    """Récupère une conversation spécifique"""
-    if conversation_id not in conversations:
-        return jsonify({'error': 'Conversation non trouvée'}), 404
-    return jsonify(conversations[conversation_id])
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
-# Dans app.py, modifiez la fonction send_message :
+@app.route('/')
+def home():
+    if 'session_id' not in session:
+        session['session_id'] = str(uuid.uuid4())
+        session['messages'] = []
+    return render_template('index.html', messages=session.get('messages', []))
 
 @app.route('/send_message', methods=['POST'])
 def send_message():
-    """Traite l'envoi d'un message"""
     try:
         data = request.json
         message = data.get('message')
-        conversation_id = data.get('conversation_id')
-        web_search = data.get('web_search', False)
-
+        web_search_enabled = data.get('web_search', False)
+        
         if not message:
-            return jsonify({'error': 'Message manquant'}), 400
+            return jsonify({'error': 'No message provided'}), 400
 
-        # Crée une nouvelle conversation si nécessaire
-        if not conversation_id or conversation_id not in conversations:
-            conversation_id = create_new_conversation()
-        
-        # Récupère ou crée la session de chat
-        if conversation_id not in chat_sessions:
-            # Reconstruit l'historique complet pour Gemini
-            history = []
-            if conversation_id in conversations:
-                for msg in conversations[conversation_id]['messages']:
-                    role = 'user' if msg['role'] == 'user' else 'model'
-                    history.append({
-                        'role': role,
-                        'parts': [msg['content']]
-                    })
-            chat_sessions[conversation_id] = model.start_chat(history=history)
+        # Ensure session is initialized
+        if 'session_id' not in session:
+            session['session_id'] = str(uuid.uuid4())
+            session['messages'] = []
+
+        session_id = session['session_id']
 
-        # Effectue une recherche web si activée
-        search_results = ""
-        if web_search:
-            results = perform_web_search(message)
-            if results:
-                search_results = format_search_results(results)
-                message = f"{message}\n\nContexte de recherche web:\n{search_results}"
+        # Initialize chat session if needed
+        if session_id not in chat_sessions:
+            chat_sessions[session_id] = model.start_chat(history=[])
 
-        # Envoie le message au modèle
-        response = chat_sessions[conversation_id].send_message(message)
+        # Perform web search if enabled
+        if web_search_enabled:
+            web_results = perform_web_search(message)
+            if web_results:
+                formatted_results = format_search_results(web_results)
+                message = f"""Question: {message}\n\nRésultats de recherche web:\n{formatted_results}\n\nPourrais-tu analyser ces informations et me donner une réponse complète?"""
 
-        # Enregistre les messages
-        conversations[conversation_id]['messages'].append({
+        # Send message to Gemini
+        response = chat_sessions[session_id].send_message(message)
+        
+        # Update message history in session
+        if 'messages' not in session:
+            session['messages'] = []
+            
+        current_messages = session['messages']
+        current_messages.append({
             'role': 'user',
-            'content': message,
-            'timestamp': datetime.now().isoformat()
+            'content': message
         })
-        conversations[conversation_id]['messages'].append({
+        current_messages.append({
             'role': 'assistant',
-            'content': response.text,
-            'timestamp': datetime.now().isoformat()
+            'content': response.text
         })
-
+        session['messages'] = current_messages
+        
         return jsonify({
-            'conversation_id': conversation_id,
             'response': response.text
         })
 
     except Exception as e:
-        print(f"Erreur lors de l'envoi du message: {e}")
+        print(f"Error in send_message: {e}")
         return jsonify({'error': str(e)}), 500
 
-# Ajoutez cette nouvelle route pour gérer le changement de conversation
-@app.route('/switch_conversation', methods=['POST'])
-def switch_conversation():
-    """Gère le changement de conversation"""
-    try:
-        data = request.json
-        conversation_id = data.get('conversation_id')
-        
-        if not conversation_id:
-            return jsonify({'error': 'ID de conversation manquant'}), 400
-            
-        if conversation_id not in conversations:
-            return jsonify({'error': 'Conversation non trouvée'}), 404
-            
-        # Recrée la session avec l'historique complet
-        history = []
-        for msg in conversations[conversation_id]['messages']:
-            role = 'user' if msg['role'] == 'user' else 'model'
-            history.append({
-                'role': role,
-                'parts': [msg['content']]
-            })
-            
-        chat_sessions[conversation_id] = model.start_chat(history=history)
-        
-        return jsonify({'success': True})
-        
-    except Exception as e:
-        print(f"Erreur lors du changement de conversation: {e}")
-        return jsonify({'error': str(e)}), 500
-
-
 @app.route('/upload', methods=['POST'])
 def upload_file():
-    """Gère l'upload de fichiers"""
     if 'file' not in request.files:
-        return jsonify({'error': 'Aucun fichier fourni'}), 400
-
+        return jsonify({'error': 'No file part'}), 400
+    
     file = request.files['file']
     if file.filename == '':
-        return jsonify({'error': 'Nom de fichier vide'}), 400
-
+        return jsonify({'error': 'No selected file'}), 400
+    
     if file and allowed_file(file.filename):
+        filename = secure_filename(file.filename)
+        filepath = os.path.join(UPLOAD_FOLDER, filename)
+        file.save(filepath)
+        
         try:
-            # Sécurise le nom du fichier
-            filename = secure_filename(file.filename)
-            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-            safe_filename = f"{timestamp}_{filename}"
-            
-            # Sauvegarde le fichier
-            filepath = UPLOAD_FOLDER / safe_filename
-            file.save(filepath)
-
-            return jsonify({
-                'success': True,
-                'filename': safe_filename,
-                'message': 'Fichier uploadé avec succès'
-            })
-
+            gemini_file = genai.upload_file(filepath)
+            return jsonify({'success': True, 'filename': filename})
         except Exception as e:
-            return jsonify({'error': f'Erreur lors de l\'upload: {str(e)}'}), 500
-
-    return jsonify({'error': 'Type de fichier non autorisé'}), 400
+            return jsonify({'error': str(e)}), 500
+    
+    return jsonify({'error': 'Invalid file type'}), 400
 
 @app.route('/clear_chat', methods=['POST'])
 def clear_chat():
-    """Efface une conversation"""
-    data = request.json
-    conversation_id = data.get('conversation_id')
-    
-    if conversation_id:
-        if conversation_id in conversations:
-            del conversations[conversation_id]
-        if conversation_id in chat_sessions:
-            del chat_sessions[conversation_id]
-            
+    session_id = session.get('session_id')
+    if session_id in chat_sessions:
+        del chat_sessions[session_id]
+    session['messages'] = []
     return jsonify({'success': True})
 
-@app.route('/download/<filename>')
-def download_file(filename):
-    """Télécharge un fichier"""
-    try:
-        return send_from_directory(UPLOAD_FOLDER, filename, as_attachment=True)
-    except Exception as e:
-        return jsonify({'error': f'Erreur lors du téléchargement: {str(e)}'}), 500
-
-@app.errorhandler(404)
-def not_found_error(error):
-    """Gère les erreurs 404"""
-    return jsonify({'error': 'Page non trouvée'}), 404
-
-@app.errorhandler(500)
-def internal_error(error):
-    """Gère les erreurs 500"""
-    return jsonify({'error': 'Erreur interne du serveur'}), 500
-
 if __name__ == '__main__':
-    app.run(debug=True)
+    app.run()