Delete app.py

app.py

@@ -1,520 +0,0 @@
-# --- START OF FILE app.py ---
-
-import os
-import json
-import mimetypes
-from flask import Flask, request, session, jsonify, redirect, url_for, flash, render_template
-from dotenv import load_dotenv
-from google import genai
-from google.genai import types
-import requests
-from werkzeug.utils import secure_filename
-import markdown # Pour convertir la réponse en HTML
-from flask_session import Session # <-- Importer Session
-import pprint # Pour un affichage plus lisible des structures complexes (optionnel)
-
-# --- Configuration Initiale ---
-load_dotenv()
-
-app = Flask(__name__)
-
-# --- Configuration Flask Standard ---
-# Clé secrète FORTEMENT recommandée (vous l'avez déjà)
-# Gardez-la secrète en production !
-app.config['SECRET_KEY'] = os.getenv('FLASK_SECRET_KEY', 'une-super-cle-secrete-a-changer')
-
-# Configuration pour les uploads (vous l'avez déjà)
-UPLOAD_FOLDER = 'temp'
-ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg'}
-app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-app.config['MAX_CONTENT_LENGTH'] = 25 * 1024 * 1024  # Limite de taille (ex: 25MB)
-
-# Créer le dossier temp s'il n'existe pas (vous l'avez déjà)
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-print(f"Dossier d'upload configuré : {os.path.abspath(UPLOAD_FOLDER)}")
-
-# --- Configuration pour Flask-Session (Backend Filesystem) ---
-app.config['SESSION_TYPE'] = 'filesystem'  # Indique d'utiliser le stockage par fichiers
-app.config['SESSION_PERMANENT'] = False  # La session expire quand le navigateur est fermé
-app.config['SESSION_USE_SIGNER'] = True  # Signe l'ID de session dans le cookie pour sécurité
-app.config['SESSION_FILE_DIR'] = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'flask_session') # Chemin où stocker les fichiers de session
-
-app.config['SESSION_COOKIE_SAMESITE'] = 'None'
-# Nécessite HTTPS pour que 'None' fonctionne
-app.config['SESSION_COOKIE_SECURE'] = True
-
-# Crée le dossier pour les sessions filesystem s'il n'existe pas
-os.makedirs(app.config['SESSION_FILE_DIR'], exist_ok=True)
-print(f"Dossier pour les sessions serveur configuré : {app.config['SESSION_FILE_DIR']}")
-
-# --- Initialisation de Flask-Session ---
-server_session = Session(app)
-
-# --- Configuration de l'API Gemini ---
-MODEL_FLASH = 'gemini-2.0-flash'
-MODEL_PRO = 'gemini-2.5-pro-exp-03-25'
-SYSTEM_INSTRUCTION = "Tu es un assistant intelligent et amical nommé Mariam. Tu assistes les utilisateurs au mieux de tes capacités. Tu as été créé par Aenir."
-
-# Nouveaux réglages de sécurité avec le nouveau SDK
-SAFETY_SETTINGS = [
-    types.SafetySetting(
-        category=types.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
-        threshold=types.HarmBlockThreshold.BLOCK_NONE,
-    ),
-    types.SafetySetting(
-        category=types.HarmCategory.HARM_CATEGORY_HARASSMENT,
-        threshold=types.HarmBlockThreshold.BLOCK_NONE,
-    ),
-    types.SafetySetting(
-        category=types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
-        threshold=types.HarmBlockThreshold.BLOCK_NONE,
-    ),
-    types.SafetySetting(
-        category=types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
-        threshold=types.HarmBlockThreshold.BLOCK_NONE,
-    )
-]
-
-GEMINI_CONFIGURED = False
-genai_client = None
-try:
-    gemini_api_key = os.getenv("GOOGLE_API_KEY")
-    if not gemini_api_key:
-        print("ERREUR: Clé API GOOGLE_API_KEY manquante dans le fichier .env")
-    else:
-        # Initialisation du client avec le nouveau SDK
-        genai_client = genai.Client(api_key=gemini_api_key)
-        
-        # Vérification de la disponibilité des modèles
-        try:
-            # Le nouveau SDK peut avoir une méthode différente pour lister les modèles
-            models = genai_client.list_models()
-            models_list = [model.name for model in models]
-            
-            # Vérifier si les modèles requis sont disponibles
-            if any(MODEL_FLASH in model for model in models_list) and any(MODEL_PRO in model for model in models_list):
-                print(f"Configuration Gemini effectuée. Modèles requis ({MODEL_FLASH}, {MODEL_PRO}) disponibles.")
-                print(f"System instruction: {SYSTEM_INSTRUCTION}")
-                GEMINI_CONFIGURED = True
-            else:
-                print(f"ERREUR: Les modèles requis ({MODEL_FLASH}, {MODEL_PRO}) ne sont pas tous disponibles via l'API.")
-                print(f"Modèles trouvés: {models_list}")
-        except Exception as e_models:
-            print(f"ERREUR lors de la vérification des modèles: {e_models}")
-            # En cas d'échec de la vérification des modèles, supposons que les modèles sont disponibles
-            print("Tentative de continuer sans vérification des modèles disponibles.")
-            GEMINI_CONFIGURED = True
-
-except Exception as e:
-    print(f"ERREUR Critique lors de la configuration initiale de Gemini : {e}")
-    print("L'application fonctionnera sans les fonctionnalités IA.")
-
-# --- Fonctions Utilitaires ---
-
-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_with_gemini(query, client, model_id):
-    """Effectue une recherche web via l'API Google Search intégrée à Gemini."""
-    try:
-        print(f"--- LOG WEBSEARCH: Recherche Google avec Gemini pour: '{query}'")
-        
-        # Utiliser l'outil de recherche Google intégré à Gemini
-        response = client.models.generate_content(
-            model=model_id,
-            contents=query,
-            config=types.GenerateContentConfig(
-                tools=[{"google_search": {}}]
-            )
-        )
-        
-        print("--- LOG WEBSEARCH: Résultats de recherche Google obtenus.")
-        
-        # Extraction des informations de recherche pour le débogage
-        if hasattr(response, 'candidates') and response.candidates:
-            if hasattr(response.candidates[0], 'grounding_metadata'):
-                search_queries = getattr(response.candidates[0].grounding_metadata, 'web_search_queries', None)
-                if search_queries:
-                    print(f"--- LOG WEBSEARCH: Requêtes utilisées: {search_queries}")
-                
-                grounding_chunks = getattr(response.candidates[0].grounding_metadata, 'grounding_chunks', None)
-                if grounding_chunks:
-                    sources = [getattr(chunk, 'web', None) for chunk in grounding_chunks]
-                    source_titles = [getattr(source, 'title', 'Sans titre') for source in sources if source]
-                    print(f"--- LOG WEBSEARCH: Sources utilisées: {', '.join(source_titles)}")
-        
-        return response
-        
-    except Exception as e:
-        print(f"--- LOG WEBSEARCH: Erreur lors de la recherche web avec Gemini : {e}")
-        return None
-
-def format_search_response(response):
-    """Extrait et met en forme le texte de la réponse de recherche web."""
-    if not response: 
-        return "Aucun résultat de recherche web trouvé pertinent."
-    
-    try:
-        return response.text
-    except Exception as e:
-        print(f"--- LOG WEBSEARCH: Erreur lors de l'extraction du texte de la réponse : {e}")
-        return "Impossible d'extraire les résultats de recherche."
-
-def prepare_gemini_history(chat_history):
-    """Convertit l'historique stocké en session au format attendu par Gemini API."""
-    print(f"--- DEBUG [prepare_gemini_history]: Entrée avec {len(chat_history)} messages") # LOG 1
-    # Avec le nouveau SDK, la structure de l'historique pourrait être différente
-    gemini_history = []
-    for i, message in enumerate(list(chat_history)): # Utiliser list() pour itérer sur une copie
-        role = 'user' if message.get('role') == 'user' else 'model'  # 'model' au lieu de 'assistant' pour le nouveau SDK
-        text_part = message.get('raw_text')
-        # Log détaillé pour chaque message traité
-        print(f"  [prepare_gemini_history] Message {i} (rôle session: {message.get('role')}, rôle gemini: {role}): raw_text présent? {'Oui' if text_part is not None else 'NON'}, contenu début: '{str(text_part)[:60]}...'") # LOG 2
-
-        if text_part: # Important: Ne pas ajouter de messages vides à l'historique Gemini
-            gemini_history.append({
-                'role': role,
-                'parts': [text_part]
-            })
-        else:
-            # Log si un message est ignoré car vide
-            print(f"  AVERTISSEMENT [prepare_gemini_history]: raw_text vide ou absent pour le message {i}, ignoré pour l'historique Gemini.") # LOG 3
-
-    print(f"--- DEBUG [prepare_gemini_history]: Sortie avec {len(gemini_history)} messages formatés pour Gemini") # LOG 4
-    return gemini_history
-
-# --- Routes Flask ---
-
-@app.route('/')
-def root():
-    """Sert la page HTML principale."""
-    print("--- LOG: Appel route '/' ---")
-    return render_template('index.html')
-
-@app.route('/api/history', methods=['GET'])
-def get_history():
-    """Fournit l'historique de chat stocké en session au format JSON."""
-    print("\n--- DEBUG [/api/history]: Début requête GET ---") # LOG 5
-    if 'chat_history' not in session:
-        session['chat_history'] = []
-        print("  [/api/history]: Session 'chat_history' initialisée (vide).")
-
-    display_history = []
-    current_history = session.get('chat_history', [])
-    print(f"  [/api/history]: Historique récupéré de la session serveur: {len(current_history)} messages.") # LOG 6
-
-    # Optionnel: Afficher la structure brute pour un debug profond
-    # print("  [/api/history]: Contenu brut de l'historique session:")
-    # pprint.pprint(current_history)
-
-    for i, msg in enumerate(current_history):
-         # Vérifier la structure de chaque message récupéré
-         if isinstance(msg, dict) and 'role' in msg and 'text' in msg:
-             display_history.append({
-                 'role': msg.get('role'),
-                 'text': msg.get('text') # On envoie bien le HTML ('text') au frontend
-             })
-         else:
-             # Log si un message dans la session est mal formé
-             print(f"  AVERTISSEMENT [/api/history]: Format invalide dans l'historique session au message {i}: {msg}") # LOG 7
-
-    print(f"  [/api/history]: Historique préparé pour le frontend: {len(display_history)} messages.") # LOG 8
-    return jsonify({'success': True, 'history': display_history})
-
-@app.route('/api/chat', methods=['POST'])
-def chat_api():
-    """Gère les nouvelles requêtes de chat via AJAX."""
-    print(f"\n---===================================---")
-    print(f"--- DEBUG [/api/chat]: Nouvelle requête POST ---")
-
-    if not GEMINI_CONFIGURED or not genai_client:
-        print("--- ERREUR [/api/chat]: Tentative d'appel sans configuration Gemini valide.")
-        return jsonify({'success': False, 'error': "Le service IA n'est pas configuré correctement."}), 503
-
-    # Récupération des données du formulaire
-    prompt = request.form.get('prompt', '').strip()
-    use_web_search = request.form.get('web_search', 'false').lower() == 'true'
-    file = request.files.get('file')
-    use_advanced = request.form.get('advanced_reasoning', 'false').lower() == 'true'
-
-    print(f"  [/api/chat]: Prompt reçu: '{prompt[:50]}...'")
-    print(f"  [/api/chat]: Recherche Web: {use_web_search}, Raisonnement Avancé: {use_advanced}")
-    print(f"  [/api/chat]: Fichier: {file.filename if file else 'Aucun'}")
-
-    # Validation
-    if not prompt and not file:
-        print("--- ERREUR [/api/chat]: Prompt et fichier vides.")
-        return jsonify({'success': False, 'error': 'Veuillez fournir un message ou un fichier.'}), 400
-
-    # --- Log de l'état de l'historique AVANT toute modification ---
-    if 'chat_history' not in session:
-        session['chat_history'] = []
-    history_before_user_add = list(session.get('chat_history', [])) # Copie pour le log
-    print(f"--- DEBUG [/api/chat]: Historique en session AVANT ajout user message: {len(history_before_user_add)} messages") # LOG 9
-
-    uploaded_file_part = None
-    uploaded_filename = None
-    filepath_to_delete = None
-
-    # --- Gestion de l'upload de fichier (avec logs) ---
-    if file and file.filename != '':
-        print(f"--- LOG [/api/chat]: Traitement du fichier '{file.filename}'")
-        if allowed_file(file.filename):
-            try:
-                filename = secure_filename(file.filename)
-                filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-                file.save(filepath)
-                filepath_to_delete = filepath
-                uploaded_filename = filename
-                print(f"  [/api/chat]: Fichier '{filename}' sauvegardé dans '{filepath}'")
-                mime_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
-                print(f"  [/api/chat]: Préparation du fichier pour Gemini (Mime: {mime_type})...")
-                
-                # Avec le nouveau SDK, la méthode d'upload a peut-être changé
-                with open(filepath, "rb") as f:
-                    file_data = f.read()
-                
-                # Création d'une partie de type fichier pour l'API
-                uploaded_file_part = {
-                    "inline_data": {
-                        "mime_type": mime_type,
-                        "data": file_data
-                    }
-                }
-                print(f"  [/api/chat]: Fichier préparé pour Gemini.")
-            except Exception as e:
-                print(f"--- ERREUR [/api/chat]: Échec traitement/upload fichier '{filename}': {e}")
-                if filepath_to_delete and os.path.exists(filepath_to_delete):
-                    try: os.remove(filepath_to_delete)
-                    except OSError as del_e: print(f"  Erreur suppression fichier temp après erreur: {del_e}")
-                return jsonify({'success': False, 'error': f"Erreur traitement fichier: {e}"}), 500
-        else:
-            print(f"--- ERREUR [/api/chat]: Type de fichier non autorisé: {file.filename}")
-            return jsonify({'success': False, 'error': f"Type de fichier non autorisé."}), 400
-
-    # --- Préparation du message utilisateur pour l'historique et Gemini ---
-    raw_user_text = prompt
-    display_user_text = f"[{uploaded_filename}] {prompt}" if uploaded_filename and prompt else (prompt or f"[{uploaded_filename}]")
-    user_history_entry = {
-        'role': 'user',
-        'text': display_user_text,
-        'raw_text': raw_user_text,
-    }
-
-    # Ajout à l'historique de session (vérifier que c'est une liste)
-    if not isinstance(session.get('chat_history'), list):
-        print("--- ERREUR [/api/chat]: 'chat_history' n'est pas une liste! Réinitialisation.")
-        session['chat_history'] = []
-    session['chat_history'].append(user_history_entry)
-
-    # --- Log de l'état de l'historique APRES ajout du message utilisateur ---
-    history_after_user_add = list(session.get('chat_history', [])) # Nouvelle copie
-    print(f"--- DEBUG [/api/chat]: Historique en session APRES ajout user message: {len(history_after_user_add)} messages") # LOG 10
-
-    # --- Sélection du modèle ---
-    selected_model_name = MODEL_PRO if use_advanced else MODEL_FLASH
-
-    # --- Préparation des contenus pour l'appel Gemini ---
-    final_prompt_for_gemini = raw_user_text
-    
-    # Gérer le cas où seul un fichier est envoyé
-    if uploaded_file_part and not raw_user_text:
-        raw_user_text = f"Décris le contenu de ce fichier : {uploaded_filename}"
-        final_prompt_for_gemini = raw_user_text
-        print(f"  [/api/chat]: Fichier seul détecté, prompt généré: '{final_prompt_for_gemini}'")
-
-    # --- Recherche Web si demandée ---
-    web_search_results = None
-    if use_web_search and final_prompt_for_gemini:
-        print(f"--- LOG [/api/chat]: Activation recherche web pour: '{final_prompt_for_gemini[:60]}...'")
-        web_search_response = perform_web_search_with_gemini(final_prompt_for_gemini, genai_client, selected_model_name)
-        if web_search_response:
-            web_search_results = format_search_response(web_search_response)
-            print(f"  [/api/chat]: Résultats de recherche obtenus.")
-            # Avec le nouveau SDK et l'outil de recherche intégré, pas besoin de reformater le prompt
-            # car la recherche est gérée directement par l'API
-
-    # Préparer l'historique des messages PRÉCÉDENTS pour Gemini
-    history_for_gemini_prep = list(session.get('chat_history', []))[:-1]  # Sans le dernier message utilisateur
-    gemini_history_to_send = prepare_gemini_history(history_for_gemini_prep)
-
-    # --- Appel à l'API Gemini ---
-    try:
-        print(f"--- DEBUG [/api/chat]: Préparation de l'envoi à l'API Gemini (Modèle: {selected_model_name}) ---") # LOG 11
-        
-        # Construire le contenu pour l'appel avec le nouveau SDK
-        contents = []
-        
-        # Ajouter l'historique
-        for message in gemini_history_to_send:
-            contents.append({
-                "role": message["role"],
-                "parts": message["parts"]
-            })
-        
-        # Ajouter le message actuel de l'utilisateur
-        current_user_parts = []
-        
-        # Si un fichier est présent, l'ajouter d'abord
-        if uploaded_file_part:
-            current_user_parts.append(uploaded_file_part)
-        
-        # Ajouter le texte du message
-        if final_prompt_for_gemini:
-            current_user_parts.append(final_prompt_for_gemini)
-        
-        if current_user_parts:
-            contents.append({
-                "role": "user",
-                "parts": current_user_parts
-            })
-        
-        # Log détaillé de ce qui est envoyé
-        print(f"  Nombre total de messages pour Gemini: {len(contents)}")
-        for i, content in enumerate(contents):
-            role = content.get("role")
-            parts = content.get("parts", [])
-            parts_info = []
-            
-            for part in parts:
-                if isinstance(part, str):
-                    parts_info.append(f"Text({len(part)} chars): '{part[:50]}...'")
-                elif isinstance(part, dict) and "inline_data" in part:
-                    parts_info.append(f"File(mime={part['inline_data']['mime_type']})")
-                else:
-                    parts_info.append(f"Part({type(part)})")
-            
-            print(f"    Message {i} (role: {role}): {', '.join(parts_info)}")
-        
-        # Configuration de l'appel à l'API
-        generate_config = types.GenerateContentConfig(
-            system_instruction=SYSTEM_INSTRUCTION,
-            safety_settings=SAFETY_SETTINGS
-        )
-        
-        # Ajouter la configuration de recherche web si demandée
-        if use_web_search:
-            generate_config.tools = [{"google_search": {}}]
-        
-        # Appel à l'API avec le nouveau SDK
-        print(f"--- LOG [/api/chat]: Envoi de la requête à {selected_model_name}...")
-        response = genai_client.models.generate_content(
-            model=selected_model_name,
-            contents=contents,
-            config=generate_config
-        )
-        
-        # --- Traitement de la réponse (avec logs) ---
-        response_text_raw = ""
-        response_html = ""
-        
-        try:
-            # Extraction du texte de la réponse avec le nouveau SDK
-            if hasattr(response, 'text'):
-                response_text_raw = response.text
-                print(f"--- LOG [/api/chat]: Réponse reçue de Gemini (brute, début): '{response_text_raw[:100]}...'")
-            elif hasattr(response, 'parts'):
-                response_text_raw = ' '.join([str(part) for part in response.parts])
-                print(f"--- LOG [/api/chat]: Réponse extraite des parts: '{response_text_raw[:100]}...'")
-            else:
-                # Gestion des erreurs de sécurité ou autres
-                if hasattr(response, 'prompt_feedback'):
-                    feedback = response.prompt_feedback
-                    if feedback:
-                        block_reason = getattr(feedback, 'block_reason', None)
-                        if block_reason:
-                            response_text_raw = f"Désolé, ma réponse a été bloquée ({block_reason})."
-                        else:
-                            response_text_raw = "Désolé, je n'ai pas pu générer de réponse (restrictions de sécurité)."
-                else:
-                    response_text_raw = "Désolé, je n'ai pas pu générer de réponse."
-                
-                print(f"  [/api/chat]: Message d'erreur généré: '{response_text_raw}'")
-            
-            # Conversion Markdown
-            response_html = markdown.markdown(response_text_raw, extensions=['fenced_code', 'tables', 'nl2br'])
-            if response_html != response_text_raw:
-                print(f"  [/api/chat]: Réponse convertie en HTML.")
-                
-        except Exception as e_resp:
-            print(f"--- ERREUR [/api/chat]: Erreur lors du traitement de la réponse Gemini : {e_resp}")
-            print(f"  Réponse brute: {response}")
-            response_text_raw = f"Désolé, erreur inattendue ({type(e_resp).__name__})."
-            response_html = markdown.markdown(response_text_raw)
-        
-        # --- Ajout de la réponse Assistant à l'historique de session ---
-        assistant_history_entry = {
-            'role': 'assistant',
-            'text': response_html,
-            'raw_text': response_text_raw
-        }
-        
-        if not isinstance(session.get('chat_history'), list):
-            print("--- ERREUR [/api/chat]: 'chat_history' n'est pas liste avant ajout assistant! Réinitialisation.")
-            session['chat_history'] = [user_history_entry] # Garder au moins user msg
-        
-        session['chat_history'].append(assistant_history_entry)
-        
-        # --- Log de l'état final de l'historique pour ce tour ---
-        history_final_turn = list(session.get('chat_history', []))
-        print(f"--- DEBUG [/api/chat]: Historique en session FINAL après ajout assistant: {len(history_final_turn)} messages") # LOG 14
-        
-        # --- Renvoyer la réponse au frontend ---
-        print(f"--- LOG [/api/chat]: Envoi de la réponse HTML au client.")
-        print(f"---==================================---\n")
-        return jsonify({'success': True, 'message': response_html})
-        
-    except Exception as e:
-        print(f"--- ERREUR CRITIQUE [/api/chat]: Échec appel Gemini ou traitement réponse : {e}")
-        # Tentative de retrait du dernier message utilisateur en cas d'erreur
-        current_history = session.get('chat_history')
-        if isinstance(current_history, list) and current_history:
-            try:
-                if current_history[-1].get('role') == 'user':
-                    current_history.pop()
-                    print("  [/api/chat]: Dernier message user retiré de l'historique suite à l'erreur.")
-                else:
-                    print("  [/api/chat]: Dernier message n'était pas 'user', historique non modifié après erreur.")
-            except Exception as pop_e:
-                print(f"  Erreur lors tentative retrait message user: {pop_e}")
-        print(f"---==================================---\n")
-        return jsonify({'success': False, 'error': f"Erreur interne: {e}"}), 500
-    
-    finally:
-        # --- Nettoyage des fichiers locaux ---
-        if filepath_to_delete and os.path.exists(filepath_to_delete):
-            try:
-                os.remove(filepath_to_delete)
-                print(f"--- LOG [/api/chat FINALLY]: Fichier temporaire local '{filepath_to_delete}' supprimé.")
-            except OSError as e_del_local:
-                print(f"--- ERREUR [/api/chat FINALLY]: Échec suppression fichier local '{filepath_to_delete}': {e_del_local}")
-
-
-@app.route('/clear', methods=['POST'])
-def clear_chat():
-    """Efface l'historique de chat dans la session."""
-    print("\n--- DEBUG [/clear]: Requête POST reçue ---")
-    session.clear() # Efface toutes les données de la session serveur actuelle
-    print("  [/clear]: Session serveur effacée.")
-    is_ajax = 'XMLHttpRequest' == request.headers.get('X-Requested-With') or \
-              'application/json' in request.headers.get('Accept', '')
-    if is_ajax:
-         print("  [/clear]: Réponse JSON (AJAX).")
-         return jsonify({'success': True, 'message': 'Historique effacé.'})
-    else:
-        print("  [/clear]: Réponse Flash + Redirect (non-AJAX).")
-        flash("Conversation effacée.", "info")
-        return redirect(url_for('root'))
-
-
-# --- Démarrage de l'application ---
-if __name__ == '__main__':
-    print("--- Démarrage du serveur Flask ---")
-    port = int(os.environ.get('PORT', 5001))
-    # Mettre debug=True pour le développement et voir les logs facilement.
-    # ATTENTION: NE PAS UTILISER debug=True en production !
-    app.run(debug=True, host='0.0.0.0', port=port)
-
-# --- END OF FILE app.py ---