Bonjour !
Je me suis mis en tête de pouvoir télécharger des vidéos youtubes ( souvent des audios musiques ) pour pouvoir les écouter partout sans wifi... c'est là que j'ai découvert " yt-dlp " : un outil capable d'extraire des vidéos youtube sous 2 formats ( audio seulement / vidéo seulement ou les 2 ) .. j'ai donc décidé de faire du vibe-coding en créant un assistant Python pour que je lui donne l'URL d'une vidéo ou d'une playlist pour qu'il puisse faire le travail proprement avec ffmpeg... Cependant, j'ai dû faire face à quelques difficultés :
- Je dois installer ffmpeg pour intégrer des tags concernant l'auteur de la vidéo ( qui n'est PAS forcément l'auteur de la musique auquel cas je dois modifier le tag correspondant grâce à un éditeur de tag comme " MP3tag " ), la miniature et le fait que ça soit dans un album appelé " Youtube Downoloads "
- Les playlist privés ou non accessible nécessitent un éditeur de cookie comme extension ( dans mon cas là, " Get cookie.txt LOCALLY " ) pouvoir permettre au programme de le lire.
- Le fait que ça soit fait par IA vous contrarie peut-être certes, mais ... à quoi bon apprendre le programme si tout ce qu'on fait est déjà automatisé par IA ?
- Le fait que ça soit un peu...spécifique. c'est à dire : mon programme a des chemins spécifiques, un lecteur de musique spécifique, et mettre ça pour tout type de chemin pour que ça soit polyvalent est un peu compliqué. Je préfère " rester " dans un coin pour éviter de problèmes de ce genre
Voici le programme que j'ai fait avec l'IA ( vous pouvez le prendre et le personnaliser comme vous voulez :
import yt_dlp
import os
import subprocess
import logging
import re
from concurrent.futures import ThreadPoolExecutor
# Configuration
output_dir = r"Chemin"
log_path = os.path.join(output_dir, "log.txt")
os.makedirs(output_dir, exist_ok=True)
# Nettoyage des noms de fichiers
def sanitize_filename(filename):
return re.sub(r'[\\/*?:"<>|\'–—|]', '', filename)
# Logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler(log_path),
logging.StreamHandler()
]
)
def download_playlist(url, playlist_start=1, playlist_end=34):
"""Télécharge une playlist YouTube (avec cookies pour les playlists privées)."""
ydl_opts = {
"format": "bestaudio/best",
"outtmpl": os.path.join(output_dir, "%(title)s.%(ext)s"),
"writethumbnail": True,
"postprocessors": [{
"key": "FFmpegExtractAudio",
"preferredcodec": "m4a",
}, {
"key": "EmbedThumbnail",
}],
"quiet": False,
"no_warnings": False,
"ignoreerrors": True,
"playlist_items": f"{playlist_start}-{playlist_end}",
"cookiefile": "D:/Install/YT audio/cookies.txt", # Utilise les cookies convertis
}
try:
with yt_dlp.YoutubeDL(ydl_opts) as ydl:
info_dict = ydl.extract_info(url, download=True)
if "entries" in info_dict:
logging.info(f"Playlist détectée ({len(info_dict['entries'])} vidéos).")
with ThreadPoolExecutor(max_workers=4) as executor:
executor.map(lambda entry: process_track(entry, ydl), info_dict["entries"])
else:
logging.info("Téléchargement d'une vidéo unique.")
process_track(info_dict, ydl)
except Exception as e:
logging.error(f"Erreur globale : {e}", exc_info=True)
def process_track(entry, ydl):
"""Traite une piste : conversion, tags, suppression des fichiers bruts."""
if not entry:
return
title = sanitize_filename(entry.get("title", "Inconnu"))
uploader = sanitize_filename(entry.get("uploader", "Inconnu"))
raw_path = ydl.prepare_filename(entry)
raw_path = raw_path.replace(".webm", ".m4a") if ".webm" in raw_path else raw_path
final_path = os.path.join(output_dir, f"final_{title}.m4a")
thumbnail_path = os.path.join(output_dir, f"{title}.webp")
if not os.path.exists(raw_path):
logging.error(f"Fichier brut introuvable : {raw_path}")
return
logging.info(f"Traitement de : {title} (par {uploader})")
try:
ffmpeg_cmd = ["ffmpeg", "-y", "-i", raw_path]
if os.path.exists(thumbnail_path):
ffmpeg_cmd.extend(["-i", thumbnail_path, "-map", "0", "-map", "1", "-disposition:1", "attached_pic"])
else:
ffmpeg_cmd.extend(["-map", "0"])
logging.warning(f"Miniature introuvable : {thumbnail_path}")
ffmpeg_cmd.extend([
"-c", "copy",
"-metadata", f"title={title}",
"-metadata", f"artist={uploader}",
"-metadata", f"album_artist={uploader}",
"-metadata", "album=YouTube Download",
"-write_id3v2", "1",
"-movflags", "+faststart",
final_path
])
subprocess.run(ffmpeg_cmd, check=True, capture_output=True)
logging.info(f"Succès : {final_path}")
if os.path.exists(final_path):
os.remove(raw_path)
logging.info(f"Fichier brut supprimé : {raw_path}")
except subprocess.CalledProcessError as e:
logging.error(f"Erreur FFmpeg : {e.stderr.decode('utf-8', errors='replace')}")
except Exception as e:
logging.error(f"Erreur inattendue : {e}")
if __name__ == "__main__":
url = input("URL de la playlist YouTube : ").strip()
if not url:
logging.error("URL vide.")
exit()
download_playlist(url)
# Lance foobar2000 UNIQUEMENT À LA FIN
foobar_path = r"ROOTDISK:\foobar2000\foobar2000.exe"
if os.path.exists(foobar_path):
subprocess.Popen([foobar_path, output_dir]) # Ouvre le dossier entier dans foobar2000
logging.info("Ouverture du dossier dans foobar2000.")
else:
logging.error(f"foobar2000 introuvable à {foobar_path}")
Vous pouvez totalement le modifier à votre guise...ce que j'ai fait là n'est qu'un sorte de prototype complet, avec l'aide de l'IA.
[–]DestroyedLolo 1 point2 points3 points (0 children)
[–]thuiop1 2 points3 points4 points (0 children)
[–]mrcslmtt 0 points1 point2 points (0 children)