Update app.py

app.py

@@ -1,93 +1,84 @@
+import gradio as gr
 import requests
+from bs4 import BeautifulSoup
 import re
 import os
-import zipfile
-import tempfile
-import gradio as gr
-from pathlib import Path
-from bs4 import BeautifulSoup
+from urllib.parse import urlparse
+from zipfile import ZipFile
 
-def sanitize_filename(name):
-    return re.sub(r'[\\/*?:"<>|]', "", name).strip().replace(" ", "_")[:100]
+def extract_podcast_episodes(url):
+    headers = {"User-Agent": "Mozilla/5.0"}
+    response = requests.get(url, headers=headers)
+    response.raise_for_status()
 
-def extract_episode_links(html_text, base_url):
-    soup = BeautifulSoup(html_text, "html.parser")
+    soup = BeautifulSoup(response.text, "html.parser")
+
+    # Titre principal du podcast (pour filtrer les titres)
+    main_title = soup.find("h1").get_text(strip=True).lower()
+
+    # Section contenant les épisodes listés explicitement
     episodes = []
-    seen_urls = set()
+    for article in soup.select("article"):
+        title_tag = article.find("h3")
+        if not title_tag:
+            continue
+        title = title_tag.get_text(strip=True)
+        if not any(word in title.lower() for word in main_title.split()):
+            continue
 
-    # Analyse de chaque bloc d'épisode
-    for audio_tag in soup.find_all("audio"):
-        source = audio_tag.find("source")
-        if source and source.get("src", "").endswith(".mp3"):
-            title = (
-                audio_tag.get("aria-label")
-                or audio_tag.get("title")
-                or source.get("title")
-                or "episode"
-            )
-            url = source["src"]
-            if not url.startswith("http"):
-                url = requests.compat.urljoin(base_url, url)
+        # Cherche lien MP3 directement dans l'article
+        mp3_url = None
+        for a in article.find_all("a", href=True):
+            if a["href"].endswith(".mp3"):
+                mp3_url = a["href"]
+                break
 
-            if url not in seen_urls:
-                seen_urls.add(url)
-                episodes.append((title, url))
+        if mp3_url:
+            episodes.append({"title": title, "url": mp3_url})
 
     return episodes
 
-def download_podcast_series(url):
-    try:
-        r = requests.get(url, timeout=10)
-        r.raise_for_status()
-    except Exception as e:
-        return f"Erreur lors du chargement de la page : {e}", None
-
-    html_text = r.text
-    episodes = extract_episode_links(html_text, url)
+def download_and_zip_episodes(url):
+    episodes = extract_podcast_episodes(url)
 
     if not episodes:
-        return "Aucun épisode audio trouvé sur la page.", None
-
-    with tempfile.TemporaryDirectory() as temp_dir:
-        zip_path = os.path.join(temp_dir, "podcast.zip")
-        used_filenames = set()
+        return "Aucun épisode valide trouvé", None
 
-        with zipfile.ZipFile(zip_path, "w") as zipf:
-            for idx, (title, mp3_url) in enumerate(episodes, 1):
-                base_name = f"{idx:02d}-" + sanitize_filename(title)
-                filename = base_name + ".mp3"
+    os.makedirs("downloads", exist_ok=True)
+    zip_filename = "episodes_radiofrance.zip"
+    zip_path = os.path.join("downloads", zip_filename)
 
-                # Éviter les doublons de nom
-                count = 1
-                while filename in used_filenames:
-                    filename = f"{base_name}_{count}.mp3"
-                    count += 1
-                used_filenames.add(filename)
+    with ZipFile(zip_path, "w") as zipf:
+        for i, episode in enumerate(episodes, start=1):
+            mp3_url = episode["url"]
+            title = episode["title"]
+            ext = os.path.splitext(urlparse(mp3_url).path)[1]
+            filename = f"{i:02d} - {title}{ext}".replace("/", "_")
 
-                try:
-                    audio = requests.get(mp3_url, stream=True, timeout=15)
-                    audio.raise_for_status()
-                    temp_mp3_path = os.path.join(temp_dir, filename)
-                    with open(temp_mp3_path, "wb") as f:
-                        for chunk in audio.iter_content(8192):
-                            f.write(chunk)
-                    zipf.write(temp_mp3_path, arcname=filename)
-                except Exception as e:
-                    print(f"Erreur lors du téléchargement de {mp3_url} : {e}")
+            try:
+                mp3_response = requests.get(mp3_url, stream=True)
+                mp3_response.raise_for_status()
+                local_path = os.path.join("downloads", filename)
+                with open(local_path, "wb") as f:
+                    for chunk in mp3_response.iter_content(1024):
+                        f.write(chunk)
+                zipf.write(local_path, arcname=filename)
+                os.remove(local_path)
+            except Exception as e:
+                print(f"Erreur lors du téléchargement de {mp3_url}: {e}")
 
-        return "Téléchargement terminé !", zip_path
+    return f"{len(episodes)} épisode(s) téléchargé(s)", zip_path
 
-interface = gr.Interface(
-    fn=download_podcast_series,
-    inputs=gr.Textbox(label="URL du podcast radio (ex: France Culture)", placeholder="https://www.radiofrance.fr/franceculture/podcasts/serie-le-capitaine-fracasse-de-theophile-gautier"),
+iface = gr.Interface(
+    fn=download_and_zip_episodes,
+    inputs=gr.Textbox(label="URL de la page podcast de France Culture"),
     outputs=[
-        gr.Textbox(label="Statut"),
-        gr.File(label="Fichier ZIP des épisodes")
+        gr.Text(label="Résultat"),
+        gr.File(label="Fichier ZIP")
     ],
-    title="Téléchargeur de Podcast Radio (.mp3)",
-    description="Collez un lien vers une série de podcast Radio France (ex: France Culture). Seuls les fichiers .mp3 correspondant aux épisodes seront extraits et regroupés dans un fichier ZIP téléchargeable.",
-    allow_flagging="never"
+    title="Téléchargeur de Podcast France Culture",
+    description="Saisissez l’URL d’une série sur France Culture (ex: https://www.radiofrance.fr/franceculture/podcasts/...) pour télécharger uniquement les bons épisodes listés sur la page."
 )
 
 if __name__ == "__main__":
-    interface.launch()
+    iface.launch()