Update app.py

app.py

@@ -11,11 +11,13 @@ logger = logging.getLogger(__name__)
 app = Flask(__name__)
 app.secret_key = os.environ.get('FLASK_SECRET_KEY', 'une_cle_secrete_par_defaut_pour_dev')
 
+# Configuration de la base de données PostgreSQL
 app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://Podcast_owner:npg_gFdMDLO9lVa0@ep-delicate-surf-a4v7wopn-pooler.us-east-1.aws.neon.tech/Podcast?sslmode=require'
 app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
 
 db = SQLAlchemy(app)
 
+# Configuration du répertoire de cache audio
 AUDIO_CACHE_DIR = '/tmp/audio_cache'
 try:
     os.makedirs(AUDIO_CACHE_DIR, exist_ok=True)
@@ -23,26 +25,29 @@ try:
 except OSError as e:
     logger.error(f"Impossible de créer le répertoire de cache audio à {AUDIO_CACHE_DIR}: {e}")
 
+# Modèle de base de données pour les Podcasts
 class Podcast(db.Model):
     __tablename__ = 'podcast'
     id = db.Column(db.Integer, primary_key=True)
     name = db.Column(db.String(200), nullable=False)
     url = db.Column(db.String(500), nullable=False, unique=True)
     subject = db.Column(db.String(100), nullable=False)
-    filename_cache = db.Column(db.String(255), nullable=True)
+    filename_cache = db.Column(db.String(255), nullable=True) # Nom du fichier dans le cache
 
     def __repr__(self):
         return f'<Podcast {self.name}>'
 
-# Moved db.create_all() here to ensure it runs on app initialization
+# Création des tables de la base de données si elles n'existent pas
+# Ceci est déplacé ici pour s'assurer qu'il s'exécute au démarrage de l'application,
+# que ce soit via `flask run` ou un serveur WSGI.
 with app.app_context():
     try:
         db.create_all()
         logger.info("Tables de base de données vérifiées/créées (si elles n'existaient pas).")
     except Exception as e:
         logger.error(f"Erreur lors de la création des tables de la base de données: {e}")
-        # Depending on the severity, you might want to exit or re-raise the exception.
-        # For now, it logs the error, and the app will likely fail on subsequent DB operations if this fails.
+        # Il est crucial de gérer cette erreur. Si la base de données n'est pas accessible ou
+        # si les tables ne peuvent pas être créées, l'application ne fonctionnera pas correctement.
 
 @app.route('/')
 def index():
@@ -51,7 +56,7 @@ def index():
     except Exception as e:
         logger.error(f"Erreur lors de la récupération des podcasts: {e}")
         flash("Erreur lors du chargement des podcasts depuis la base de données.", "error")
-        podcasts = []
+        podcasts = [] # Fournir une liste vide en cas d'erreur pour que le template fonctionne
     return render_template('index.html', podcasts=podcasts)
 
 @app.route('/gestion', methods=['GET', 'POST'])
@@ -64,6 +69,7 @@ def gestion():
         if not name or not url or not subject:
             flash('Tous les champs sont requis !', 'error')
         else:
+            # Vérifier si un podcast avec la même URL existe déjà
             existing_podcast = Podcast.query.filter_by(url=url).first()
             if existing_podcast:
                 flash('Un podcast avec cette URL existe déjà.', 'warning')
@@ -73,12 +79,13 @@ def gestion():
                     db.session.add(new_podcast)
                     db.session.commit()
                     flash('Podcast ajouté avec succès !', 'success')
-                    return redirect(url_for('gestion'))
+                    return redirect(url_for('gestion')) # Rediriger pour éviter la resoumission du formulaire
                 except Exception as e:
-                    db.session.rollback()
+                    db.session.rollback() # Annuler les changements en cas d'erreur
                     logger.error(f"Erreur lors de l'ajout du podcast: {e}")
                     flash(f"Erreur lors de l'ajout du podcast: {e}", 'error')
     
+    # Charger les podcasts pour l'affichage sur la page de gestion (méthode GET ou après POST)
     try:
         podcasts = Podcast.query.order_by(Podcast.name).all()
     except Exception as e:
@@ -91,11 +98,12 @@ def gestion():
 @app.route('/delete_podcast/<int:podcast_id>', methods=['POST'])
 def delete_podcast(podcast_id):
     try:
-        podcast_to_delete = db.session.get(Podcast, podcast_id)
+        podcast_to_delete = db.session.get(Podcast, podcast_id) # Utilisation de db.session.get pour Flask-SQLAlchemy >= 3.0
         if not podcast_to_delete:
             flash('Podcast non trouvé.', 'error')
             return redirect(url_for('gestion'))
 
+        # Supprimer le fichier cache associé s'il existe
         if podcast_to_delete.filename_cache:
             cached_file_path = os.path.join(AUDIO_CACHE_DIR, podcast_to_delete.filename_cache)
             if os.path.exists(cached_file_path):
@@ -105,6 +113,9 @@ def delete_podcast(podcast_id):
                 except OSError as e:
                     logger.error(f"Erreur lors de la suppression du fichier cache {podcast_to_delete.filename_cache}: {e}")
                     flash(f'Erreur lors de la suppression du fichier cache {podcast_to_delete.filename_cache}.', 'error')
+            else:
+                logger.warning(f"Fichier cache {podcast_to_delete.filename_cache} listé dans la DB mais non trouvé sur le disque pour suppression.")
+
 
         db.session.delete(podcast_to_delete)
         db.session.commit()
@@ -117,12 +128,13 @@ def delete_podcast(podcast_id):
 
 @app.route('/play/<int:podcast_id>')
 def play_podcast_route(podcast_id):
-    podcast = db.session.get(Podcast, podcast_id)
+    podcast = db.session.get(Podcast, podcast_id) # Utilisation de db.session.get
 
     if not podcast:
         logger.warning(f"Tentative de lecture d'un podcast non trouvé: ID {podcast_id}")
         return jsonify({'error': 'Podcast non trouvé'}), 404
 
+    # Vérifier si le fichier est déjà en cache
     if podcast.filename_cache:
         cached_filepath = os.path.join(AUDIO_CACHE_DIR, podcast.filename_cache)
         if os.path.exists(cached_filepath):
@@ -130,39 +142,47 @@ def play_podcast_route(podcast_id):
             audio_url = url_for('serve_cached_audio', filename=podcast.filename_cache)
             return jsonify({'audio_url': audio_url})
         else:
-            logger.warning(f"Fichier cache {podcast.filename_cache} pour podcast {podcast.id} non trouvé. Re-téléchargement.")
-            podcast.filename_cache = None # Clear invalid cache entry
+            # Le fichier cache est référencé mais n'existe pas, il faut le re-télécharger
+            logger.warning(f"Fichier cache {podcast.filename_cache} pour podcast {podcast.id} non trouvé sur le disque. Re-téléchargement.")
+            podcast.filename_cache = None # Marquer comme non-caché pour forcer le re-téléchargement
+            # Pas besoin de db.session.commit() ici immédiatement, sera fait après le téléchargement réussi
 
-    final_cached_filepath = None
+    # Si le fichier n'est pas en cache ou si le cache était invalide
+    final_cached_filepath = None # Initialiser pour la clause finally
     try:
+        # Déterminer l'extension à partir de l'URL ou du Content-Type
         parsed_url = urlparse(podcast.url)
-        path_parts = os.path.splitext(parsed_url.path)
-        extension = path_parts[1] if path_parts[1] else '.audio' # Default extension
+        _, url_ext = os.path.splitext(parsed_url.path)
+        extension = url_ext if url_ext else '.audio' # Extension par défaut
         
-        base_filename = str(podcast.id) # Use podcast ID for a unique, simple base name
+        # Utiliser l'ID du podcast pour un nom de fichier unique et simple
+        base_filename = str(podcast.id)
         
         logger.info(f"Téléchargement de {podcast.url} pour le podcast ID {podcast.id}")
-        # Increased timeout for potentially large files; connect timeout, read timeout
+        # Timeout: (connect_timeout, read_timeout)
         response = requests.get(podcast.url, stream=True, timeout=(10, 60)) 
-        response.raise_for_status()
+        response.raise_for_status() # Lèvera une exception pour les codes d'erreur HTTP (4xx ou 5xx)
 
-        # Try to get a better extension from Content-Type header
+        # Essayer d'obtenir une meilleure extension à partir de l'en-tête Content-Type
         content_type = response.headers.get('Content-Type')
         if content_type:
             if 'mpeg' in content_type: extension = '.mp3'
             elif 'ogg' in content_type: extension = '.ogg'
             elif 'wav' in content_type: extension = '.wav'
             elif 'aac' in content_type: extension = '.aac'
-            elif 'mp4' in content_type: extension = '.m4a' # Often audio in mp4 container
+            elif 'mp4' in content_type: extension = '.m4a' # Souvent utilisé pour l'audio dans un conteneur mp4
 
+        # Construire le nom de fichier final avec l'extension déterminée
         cached_filename_with_ext = f"{base_filename}{extension}"
         final_cached_filepath = os.path.join(AUDIO_CACHE_DIR, cached_filename_with_ext)
 
+        # Écrire le contenu dans le fichier cache
         with open(final_cached_filepath, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192):
+            for chunk in response.iter_content(chunk_size=8192): # Taille de chunk raisonnable
                 f.write(chunk)
         logger.info(f"Téléchargement terminé: {final_cached_filepath}")
 
+        # Mettre à jour la base de données avec le nom du fichier en cache
         podcast.filename_cache = cached_filename_with_ext
         db.session.commit()
         
@@ -171,32 +191,33 @@ def play_podcast_route(podcast_id):
 
     except requests.exceptions.Timeout:
         logger.error(f"Timeout lors du téléchargement de {podcast.url}")
+        # Nettoyer le fichier partiel si le téléchargement a échoué
+        if final_cached_filepath and os.path.exists(final_cached_filepath):
+            try: os.remove(final_cached_filepath); logger.info(f"Fichier partiel (Timeout) nettoyé : {final_cached_filepath}")
+            except OSError as e_clean: logger.error(f"Erreur nettoyage fichier partiel (Timeout) {final_cached_filepath}: {e_clean}")
         return jsonify({'error': 'Le téléchargement du podcast a pris trop de temps.'}), 504
     except requests.exceptions.RequestException as e:
         logger.error(f"Erreur de téléchargement pour {podcast.url}: {e}")
-        # Clean up partial download if it exists and wasn't successfully associated
-        if final_cached_filepath and os.path.exists(final_cached_filepath) and (not podcast or podcast.filename_cache != os.path.basename(final_cached_filepath)):
-             try: os.remove(final_cached_filepath); logger.info(f"Fichier partiel (RequestException) nettoyé : {final_cached_filepath}")
-             except OSError as e_clean: logger.error(f"Erreur nettoyage fichier partiel (RequestException) {final_cached_filepath}: {e_clean}")
+        if final_cached_filepath and os.path.exists(final_cached_filepath):
+            try: os.remove(final_cached_filepath); logger.info(f"Fichier partiel (RequestException) nettoyé : {final_cached_filepath}")
+            except OSError as e_clean: logger.error(f"Erreur nettoyage fichier partiel (RequestException) {final_cached_filepath}: {e_clean}")
         return jsonify({'error': f'Impossible de télécharger le podcast: {e}'}), 500
     except Exception as e:
-        db.session.rollback() # Rollback DB session on unexpected error
+        db.session.rollback() # Assurer la cohérence de la session DB
         logger.error(f"Erreur inattendue lors du traitement du podcast {podcast.id}: {e}")
-        # Clean up partial download similar to above
-        if final_cached_filepath and os.path.exists(final_cached_filepath) and (not podcast or podcast.filename_cache != os.path.basename(final_cached_filepath)):
+        if final_cached_filepath and os.path.exists(final_cached_filepath):
              try: os.remove(final_cached_filepath); logger.info(f"Fichier partiel (Exception) nettoyé : {final_cached_filepath}")
              except OSError as e_clean: logger.error(f"Erreur nettoyage fichier partiel (Exception) {final_cached_filepath}: {e_clean}")
         return jsonify({'error': f'Erreur inattendue: {e}'}), 500
-    # The finally block for cleanup was a bit complex; simplified by handling cleanup in error cases.
-    # If successful, filename_cache is set, so it won't be cleaned.
 
 @app.route('/audio_cache/<path:filename>')
 def serve_cached_audio(filename):
     logger.debug(f"Service du fichier cache: {filename} depuis {AUDIO_CACHE_DIR}")
+    # Assurez-vous que le chemin est sécurisé et ne permet pas de sortir du répertoire de cache
+    # send_from_directory s'en charge généralement.
     return send_from_directory(AUDIO_CACHE_DIR, filename)
 
 if __name__ == '__main__':
-    # The db.create_all() call is now above, so it's not needed here.
-    # The line `app.run(...):19:12 =====` from the problem description seems to have a typo.
-    # Corrected to a standard app.run() call.
+    # db.create_all() est maintenant appelé au niveau global du module.
+    # La ligne `app.run(...):19:12 =====` dans le log original contenait une syntaxe incorrecte, corrigée ici.
     app.run(debug=True, host='0.0.0.0', port=int(os.environ.get('PORT', 5000)))