Update app.py

app.py

@@ -5,12 +5,39 @@ from PIL import Image
 import tempfile
 import PIL.Image
 import subprocess
-
+import logging
+from urllib.parse import urlparse
+import requests
+import time
+import ssl
+from logging.handlers import RotatingFileHandler
 
 app = Flask(__name__)
 
+# Configuration des logs
+log_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+log_file = 'app.log'
+
+# Handler pour fichier avec rotation
+file_handler = RotatingFileHandler(log_file, maxBytes=10485760, backupCount=5)  # 10MB par fichier, max 5 fichiers
+file_handler.setFormatter(log_formatter)
+
+# Handler pour console
+console_handler = logging.StreamHandler()
+console_handler.setFormatter(log_formatter)
+
+# Configuration du logger principal
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.addHandler(file_handler)
+logger.addHandler(console_handler)
+
 # Configuration de l'API Gemini
 token = os.environ.get("TOKEN")
+if not token:
+    logger.error("Token API non trouvé dans les variables d'environnement")
+    raise ValueError("Token API manquant")
+
 genai.configure(api_key=token)
 
 generation_config = {
@@ -25,14 +52,11 @@ safety_settings = [
     {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
 ]
 
-
 @app.route('/')
 def generale():
+    logger.info("Accès à la page principale")
     return render_template("generale.html")
 
-
-
-
 def upload_and_process_file(file_path):
     """Upload et traite un fichier avec l'API Gemini avec gestion des erreurs améliorée"""
     max_retries = 3
@@ -40,19 +64,21 @@ def upload_and_process_file(file_path):
     
     for attempt in range(max_retries):
         try:
-            print(f"Tentative d'upload {attempt + 1}/{max_retries} pour {file_path}")
+            logger.info(f"Tentative d'upload {attempt + 1}/{max_retries} pour {file_path}")
             
             # Vérification du fichier
             if not os.path.exists(file_path):
+                logger.error(f"Fichier non trouvé: {file_path}")
                 raise FileNotFoundError(f"Le fichier {file_path} n'existe pas")
                 
             file_size = os.path.getsize(file_path)
             if file_size == 0:
+                logger.error(f"Fichier vide: {file_path}")
                 raise ValueError(f"Le fichier {file_path} est vide")
                 
             # Upload du fichier
             uploaded_file = genai.upload_file(path=file_path)
-            print(f"Upload réussi: {uploaded_file.uri}")
+            logger.info(f"Upload réussi: {uploaded_file.uri}")
 
             # Attente du traitement
             timeout = 300  # 5 minutes
@@ -60,61 +86,56 @@ def upload_and_process_file(file_path):
             
             while uploaded_file.state.name == "PROCESSING":
                 if time.time() - start_time > timeout:
+                    logger.error("Timeout pendant le traitement du fichier")
                     raise TimeoutError("Timeout pendant le traitement du fichier")
                 
-                print(f"En attente du traitement... Temps écoulé: {int(time.time() - start_time)}s")
+                logger.debug(f"En attente du traitement... Temps écoulé: {int(time.time() - start_time)}s")
                 time.sleep(10)
                 uploaded_file = genai.get_file(uploaded_file.name)
 
             if uploaded_file.state.name == "FAILED":
+                logger.error(f"Échec du traitement: {uploaded_file.state.name}")
                 raise ValueError(f"Échec du traitement: {uploaded_file.state.name}")
                 
-            print(f"Traitement terminé avec succès: {uploaded_file.uri}")
+            logger.info(f"Traitement terminé avec succès: {uploaded_file.uri}")
             return uploaded_file
 
         except ssl.SSLError as e:
-            print(f"Erreur SSL lors de l'upload (tentative {attempt + 1}): {e}")
+            logger.error(f"Erreur SSL lors de l'upload (tentative {attempt + 1}): {e}")
             if attempt < max_retries - 1:
                 time.sleep(retry_delay * (attempt + 1))
             else:
                 raise
                 
         except Exception as e:
-            print(f"Erreur lors de l'upload (tentative {attempt + 1}): {e}")
+            logger.error(f"Erreur lors de l'upload (tentative {attempt + 1}): {e}")
             if attempt < max_retries - 1:
                 time.sleep(retry_delay * (attempt + 1))
             else:
                 raise
-                
-                
 
 def is_youtube_url(url):
     """Vérifie si l'URL est une URL YouTube"""
     parsed = urlparse(url)
     return any(domain in parsed.netloc for domain in ['youtube.com', 'youtu.be'])
 
-
-
-
 def download_youtube_video(url):
     """Télécharge une vidéo YouTube en utilisant subprocess avec youtube-dl"""
     try:
         with tempfile.TemporaryDirectory() as temp_dir:
             output_template = os.path.join(temp_dir, '%(title)s.%(ext)s')
             
-            # Commande youtube-dl avec options
             command = [
                 'youtube-dl',
-                '--format', 'best[filesize<500M]',  # Limite la taille du fichier
+                '--format', 'best[filesize<50M]',
                 '--quiet',
                 '--no-warnings',
                 '--output', output_template,
                 url
             ]
             
-            print(f"Téléchargement de la vidéo: {url}")
+            logger.info(f"Début du téléchargement de la vidéo: {url}")
             
-            # Exécution de la commande
             process = subprocess.Popen(
                 command,
                 stdout=subprocess.PIPE,
@@ -122,42 +143,43 @@ def download_youtube_video(url):
                 universal_newlines=True
             )
             
-            # Attente et récupération du résultat
             stdout, stderr = process.communicate()
             
             if process.returncode != 0:
+                logger.error(f"Erreur youtube-dl: {stderr}")
                 raise Exception(f"Erreur youtube-dl: {stderr}")
             
-            # Recherche du fichier téléchargé dans le dossier temporaire
             downloaded_files = os.listdir(temp_dir)
             if not downloaded_files:
+                logger.error("Aucun fichier n'a été téléchargé")
                 raise FileNotFoundError("Aucun fichier n'a été téléchargé")
             
             video_path = os.path.join(temp_dir, downloaded_files[0])
             
-            # Copie vers un fichier temporaire permanent
             temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(video_path)[1])
             with open(video_path, 'rb') as f:
                 temp_file.write(f.read())
             
-            print(f"Vidéo téléchargée avec succès: {temp_file.name}")
+            logger.info(f"Vidéo téléchargée avec succès: {temp_file.name}")
             return temp_file.name
                 
     except Exception as e:
-        print(f"Erreur lors du téléchargement de la vidéo: {e}")
+        logger.error(f"Erreur lors du téléchargement de la vidéo: {e}")
         return None
 
 def telecharger_pdf(url):
     """Télécharge un PDF et retourne le chemin du fichier"""
     try:
+        logger.info(f"Début du téléchargement du PDF: {url}")
         response = requests.get(url)
         response.raise_for_status()
 
         with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as temp_file:
             temp_file.write(response.content)
+            logger.info(f"PDF téléchargé avec succès: {temp_file.name}")
             return temp_file.name
     except Exception as e:
-        print(f"Erreur lors du téléchargement du PDF : {e}")
+        logger.error(f"Erreur lors du téléchargement du PDF: {e}")
         return None
 
 def allowed_file(filename):
@@ -167,11 +189,15 @@ def allowed_file(filename):
 
 @app.route('/submit', methods=['POST'])
 def submit_question():
+    logger.info("Nouvelle soumission reçue")
     question = request.form.get('question')
     urls = request.form.getlist('urls')
     files = request.files.getlist('files')
     
-    print("URLs reçues:", urls)
+    logger.info(f"Question reçue: {question}")
+    logger.info(f"URLs reçues: {urls}")
+    logger.info(f"Nombre de fichiers reçus: {len(files)}")
+    
     content = [question]
     temp_files = []
     
@@ -179,51 +205,62 @@ def submit_question():
         # Traitement des fichiers uploadés
         for file in files:
             if file and allowed_file(file.filename):
+                logger.info(f"Traitement du fichier: {file.filename}")
                 with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as temp_file:
                     file.save(temp_file.name)
                     temp_files.append(temp_file.name)
                     if file.filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif')):
                         content.append(PIL.Image.open(temp_file.name))
+                        logger.info(f"Image ajoutée au contenu: {file.filename}")
                     else:
                         uploaded_file = upload_and_process_file(temp_file.name)
                         content.append(uploaded_file)
+                        logger.info(f"Fichier uploadé et ajouté au contenu: {file.filename}")
 
         # Traitement des URLs
         for url in urls:
-            print(f"Traitement de l'URL : {url}")
+            logger.info(f"Traitement de l'URL: {url}")
             if is_youtube_url(url):
                 video_path = download_youtube_video(url)
                 if video_path:
                     temp_files.append(video_path)
                     uploaded_file = upload_and_process_file(video_path)
                     content.append(uploaded_file)
+                    logger.info(f"Vidéo YouTube traitée et ajoutée au contenu: {url}")
             elif url.lower().endswith('.pdf'):
                 pdf_path = telecharger_pdf(url)
                 if pdf_path:
                     temp_files.append(pdf_path)
                     uploaded_file = upload_and_process_file(pdf_path)
                     content.append(uploaded_file)
-
-       
-       
+                    logger.info(f"PDF téléchargé et ajouté au contenu: {url}")
 
         # Génération de contenu avec Gemini
+        logger.info("Initialisation du modèle Gemini")
         model = genai.GenerativeModel(
             model_name="models/gemini-2.0-flash-exp",
             safety_settings=safety_settings,
             system_instruction="Tu es un assistant intelligent. ton but est d'assister au mieux que tu peux. tu as été créé par Aenir et tu t'appelles Mariam."
         )
+        
+        logger.info("Génération de la réponse")
         response = model.generate_content(content, request_options={"timeout": 600})
+        logger.info("Réponse générée avec succès")
+        
         return jsonify({"response": response.text})
 
     except Exception as e:
+        logger.error(f"Erreur lors du traitement de la requête: {e}", exc_info=True)
         return jsonify({"error": str(e)}), 500
     finally:
         # Nettoyage des fichiers temporaires
         for temp_file in temp_files:
             try:
                 os.unlink(temp_file)
+                logger.debug(f"Fichier temporaire supprimé: {temp_file}")
             except Exception as e:
-                print(f"Erreur lors de la suppression du fichier temporaire {temp_file}: {e}") 
-
+                logger.error(f"Erreur lors de la suppression du fichier temporaire {temp_file}: {e}")
 
+if __name__ == '__main__':
+    logger.info("Démarrage de l'application")
+    app.run()