from flask import Flask, render_template, request, redirect, url_for, flash, jsonify, send_from_directory from flask_sqlalchemy import SQLAlchemy import os import requests from urllib.parse import urlparse import logging logging.basicConfig(level=logging.INFO) 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) logger.info(f"Répertoire de cache audio configuré sur : {AUDIO_CACHE_DIR}") 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) # Nom du fichier dans le cache def __repr__(self): return f'' # 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}") # 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(): try: podcasts = Podcast.query.order_by(Podcast.name).all() 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 = [] # 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']) def gestion(): if request.method == 'POST': name = request.form.get('name') url = request.form.get('url') subject = request.form.get('subject') 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') else: try: new_podcast = Podcast(name=name, url=url, subject=subject) db.session.add(new_podcast) db.session.commit() flash('Podcast ajouté avec succès !', 'success') return redirect(url_for('gestion')) # Rediriger pour éviter la resoumission du formulaire except Exception as e: 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: logger.error(f"Erreur lors de la récupération des podcasts pour la gestion: {e}") flash("Erreur lors du chargement des podcasts pour la gestion.", "error") podcasts = [] return render_template('gestion.html', podcasts=podcasts) @app.route('/delete_podcast/', methods=['POST']) def delete_podcast(podcast_id): try: 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): try: os.remove(cached_file_path) logger.info(f"Fichier cache {podcast_to_delete.filename_cache} supprimé.") 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() flash('Podcast supprimé avec succès.', 'success') except Exception as e: db.session.rollback() logger.error(f"Erreur lors de la suppression du podcast ID {podcast_id}: {e}") flash(f"Erreur lors de la suppression du podcast: {e}", 'error') return redirect(url_for('gestion')) @app.route('/play/') def play_podcast_route(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): logger.info(f"Service du podcast {podcast.id} depuis le cache: {podcast.filename_cache}") audio_url = url_for('serve_cached_audio', filename=podcast.filename_cache) return jsonify({'audio_url': audio_url}) else: # 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 # 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) _, url_ext = os.path.splitext(parsed_url.path) extension = url_ext if url_ext else '.audio' # Extension par défaut # 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}") # Timeout: (connect_timeout, read_timeout) response = requests.get(podcast.url, stream=True, timeout=(10, 60)) response.raise_for_status() # Lèvera une exception pour les codes d'erreur HTTP (4xx ou 5xx) # 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' # 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): # 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() audio_url = url_for('serve_cached_audio', filename=cached_filename_with_ext) return jsonify({'audio_url': audio_url}) 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}") 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() # Assurer la cohérence de la session DB logger.error(f"Erreur inattendue lors du traitement du podcast {podcast.id}: {e}") 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 @app.route('/audio_cache/') 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__': # 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)))