Update app.py

app.py

@@ -12,7 +12,6 @@ app = Flask(__name__)
 app.secret_key = os.environ.get('FLASK_SECRET_KEY', 'une_cle_secrete_par_defaut_pour_dev')
 
 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)
@@ -35,6 +34,16 @@ class Podcast(db.Model):
     def __repr__(self):
         return f'<Podcast {self.name}>'
 
+# Moved db.create_all() here to ensure it runs on app initialization
+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.
+
 @app.route('/')
 def index():
     try:
@@ -122,27 +131,29 @@ def play_podcast_route(podcast_id):
             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
+            podcast.filename_cache = None # Clear invalid cache entry
 
     final_cached_filepath = None
     try:
         parsed_url = urlparse(podcast.url)
         path_parts = os.path.splitext(parsed_url.path)
-        extension = path_parts[1] if path_parts[1] else '.audio'
+        extension = path_parts[1] if path_parts[1] else '.audio' # Default extension
         
-        base_filename = str(podcast.id)
+        base_filename = str(podcast.id) # Use podcast ID for a unique, simple base name
         
         logger.info(f"Téléchargement de {podcast.url} pour le podcast ID {podcast.id}")
-        response = requests.get(podcast.url, stream=True, timeout=(10, 60))
+        # Increased timeout for potentially large files; connect timeout, read timeout
+        response = requests.get(podcast.url, stream=True, timeout=(10, 60)) 
         response.raise_for_status()
 
+        # Try to get a better extension from Content-Type header
         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'
+            elif 'mp4' in content_type: extension = '.m4a' # Often audio in mp4 container
 
         cached_filename_with_ext = f"{base_filename}{extension}"
         final_cached_filepath = os.path.join(AUDIO_CACHE_DIR, cached_filename_with_ext)
@@ -163,18 +174,21 @@ def play_podcast_route(podcast_id):
         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}")
         return jsonify({'error': f'Impossible de télécharger le podcast: {e}'}), 500
     except Exception as e:
-        db.session.rollback()
+        db.session.rollback() # Rollback DB session on unexpected error
         logger.error(f"Erreur inattendue lors du traitement du podcast {podcast.id}: {e}")
-        return jsonify({'error': f'Erreur inattendue: {e}'}), 500
-    finally:
+        # 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)):
-            try:
-                os.remove(final_cached_filepath)
-                logger.info(f"Fichier partiel nettoyé : {final_cached_filepath}")
-            except OSError as e_clean:
-                logger.error(f"Erreur lors du nettoyage du fichier partiel {final_cached_filepath}: {e_clean}")
+             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):
@@ -182,11 +196,7 @@ def serve_cached_audio(filename):
     return send_from_directory(AUDIO_CACHE_DIR, filename)
 
 if __name__ == '__main__':
-    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}")
-            logger.error("Assurez-vous que votre serveur PostgreSQL est en cours d'exécution et que la base de données existe.")
+    # 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.
     app.run(debug=True, host='0.0.0.0', port=int(os.environ.get('PORT', 5000)))