muget 1.0.0__tar.gz

muget-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Meikoy-Chan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

muget-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

muget-1.0.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: muget
+Version: 1.0.0
+Summary: YouTube Music downloader with tagging support
+Author: Meikoy-Chan
+License: MIT
+Project-URL: Homepage, https://github.com/meikoy-chan/muget
+Project-URL: Bug Reports, https://github.com/meikoy-chan/muget/issues
+Keywords: youtube-music,downloader,yt-dlp,music
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click
+Requires-Dist: colorama
+Requires-Dist: mutagen
+Requires-Dist: Pillow
+Requires-Dist: requests
+Requires-Dist: yt-dlp
+Requires-Dist: ytmusicapi
+Requires-Dist: InquirerPy
+Requires-Dist: yt_dlp_ejs
+Dynamic: license-file
+
+# Muget
+
+YouTube Music downloader with automatic tagging and cover art.
+
+## Installation
+
+```bash
+pip install muget
+```
+
+Usage
+
+```bash
+muget "https://music.youtube.com/playlist?list=..."
+muget -o "./Music" "https://music.youtube.com/album/..."
+```
+
+Requirements
+
+· FFmpeg (required)
+· aria2c (optional, for faster downloads)
+
+Features
+
+· Download tracks, albums, and playlists
+· Automatic metadata tagging
+· Cover art embedding
+· Synced lyrics support

muget-1.0.0/README.md

@@ -0,0 +1,28 @@
+# Muget
+
+YouTube Music downloader with automatic tagging and cover art.
+
+## Installation
+
+```bash
+pip install muget
+```
+
+Usage
+
+```bash
+muget "https://music.youtube.com/playlist?list=..."
+muget -o "./Music" "https://music.youtube.com/album/..."
+```
+
+Requirements
+
+· FFmpeg (required)
+· aria2c (optional, for faster downloads)
+
+Features
+
+· Download tracks, albums, and playlists
+· Automatic metadata tagging
+· Cover art embedding
+· Synced lyrics support

muget-1.0.0/muget/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

muget-1.0.0/muget/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

muget-1.0.0/muget/cli.py

@@ -0,0 +1,416 @@
+from __future__ import annotations
+
+import inspect
+import json
+import logging
+import shutil
+from enum import Enum
+from pathlib import Path
+
+import click
+import colorama
+
+from . import __version__
+from .constants import EXCLUDED_CONFIG_FILE_PARAMS, PREMIUM_FORMATS, X_NOT_FOUND_STRING
+from .custom_logger_formatter import CustomLoggerFormatter
+from .downloader import Downloader
+from .enums import CoverFormat, DownloadMode
+from .utils import color_text, prompt_path
+
+logger = logging.getLogger("muget")
+
+downloader_sig = inspect.signature(Downloader.__init__)
+
+
+def get_param_string(param: click.Parameter) -> str:
+    if isinstance(param.default, Enum):
+        return param.default.value
+    elif isinstance(param.default, Path):
+        return str(param.default)
+    else:
+        return param.default
+
+
+def write_default_config_file(ctx: click.Context):
+    ctx.params["config_path"].parent.mkdir(parents=True, exist_ok=True)
+    config_file = {
+        param.name: get_param_string(param)
+        for param in ctx.command.params
+        if param.name not in EXCLUDED_CONFIG_FILE_PARAMS
+    }
+    ctx.params["config_path"].write_text(json.dumps(config_file, indent=4))
+
+
+def load_config_file(
+    ctx: click.Context,
+    param: click.Parameter,
+    no_config_file: bool,
+) -> click.Context:
+    if no_config_file:
+        return ctx
+    if not ctx.params["config_path"].exists():
+        write_default_config_file(ctx)
+    config_file = dict(json.loads(ctx.params["config_path"].read_text()))
+    for param in ctx.command.params:
+        if (
+            config_file.get(param.name) is not None
+            and not ctx.get_parameter_source(param.name)
+            == click.core.ParameterSource.COMMANDLINE
+        ):
+            ctx.params[param.name] = param.type_cast_value(ctx, config_file[param.name])
+    return ctx
+
+
+@click.command()
+@click.help_option("-h", "--help")
+@click.version_option(__version__, "-v", "--version")
+# CLI specific options
+@click.argument(
+    "urls",
+    nargs=-1,
+    type=str,
+    required=True,
+)
+@click.option(
+    "--save-cover",
+    "-s",
+    is_flag=True,
+    help="Save cover as a separate file.",
+)
+@click.option(
+    "--overwrite",
+    is_flag=True,
+    help="Overwrite existing files.",
+)
+@click.option(
+    "--read-urls-as-txt",
+    "-r",
+    is_flag=True,
+    help="Interpret URLs as paths to text files containing URLs separated by newlines.",
+)
+@click.option(
+    "--config-path",
+    type=Path,
+    default=Path.home() / ".muget" / "config.json",
+    help="Path to config file.",
+)
+@click.option(
+    "--log-level",
+    type=str,
+    default="INFO",
+    help="Log level.",
+)
+@click.option(
+    "--no-exceptions",
+    is_flag=True,
+    help="Don't print exceptions.",
+)
+# Downloader specific options
+@click.option(
+    "--output-path",
+    "-o",
+    type=Path,
+    default=downloader_sig.parameters["output_path"].default,
+    help="Path to output directory.",
+)
+@click.option(
+    "--temp-path",
+    type=Path,
+    default=downloader_sig.parameters["temp_path"].default,
+    help="Path to temporary directory.",
+)
+@click.option(
+    "--cookies-path",
+    "-c",
+    type=Path,
+    default=downloader_sig.parameters["cookies_path"].default,
+    help="Path to .txt cookies file for yt-dlp (premium formats).",
+)
+@click.option(
+    "--browser-json-path",  # NUEVA OPCIÓN
+    "-b",
+    type=Path,
+    default=None,
+    help="Path to browser.json file for ytmusicapi (private playlists).",
+)
+@click.option(
+    "--ffmpeg-path",
+    type=str,
+    default=downloader_sig.parameters["ffmpeg_path"].default,
+    help="Path to FFmpeg binary.",
+)
+@click.option(
+    "--aria2c-path",
+    type=str,
+    default=downloader_sig.parameters["aria2c_path"].default,
+    help="Path to aria2c binary.",
+)
+@click.option(
+    "--download-mode",
+    type=DownloadMode,
+    default=downloader_sig.parameters["download_mode"].default,
+    help="Download mode.",
+)
+@click.option(
+    "--po-token",
+    type=str,
+    default=downloader_sig.parameters["po_token"].default,
+    help="Proof of Origin (PO) Token.",
+)
+@click.option(
+    "--itag",
+    "-i",
+    type=str,
+    default=downloader_sig.parameters["itag"].default,
+    help="Itag (audio codec/quality).",
+)
+@click.option(
+    "--cover-size",
+    type=int,
+    default=downloader_sig.parameters["cover_size"].default,
+    help="Cover size.",
+)
+@click.option(
+    "--cover-format",
+    type=CoverFormat,
+    default=downloader_sig.parameters["cover_format"].default,
+    help="Cover format.",
+)
+@click.option(
+    "--cover-quality",
+    type=int,
+    default=downloader_sig.parameters["cover_quality"].default,
+    help="Cover JPEG quality.",
+)
+@click.option(
+    "--template-folder",
+    type=str,
+    default=downloader_sig.parameters["template_folder"].default,
+    help="Template of the album folders as a format string.",
+)
+@click.option(
+    "--template-file",
+    type=str,
+    default=downloader_sig.parameters["template_file"].default,
+    help="Template of the song files as a format string.",
+)
+@click.option(
+    "--template-date",
+    type=str,
+    default=downloader_sig.parameters["template_date"].default,
+    help="Date tag template.",
+)
+@click.option(
+    "--exclude-tags",
+    "-e",
+    type=str,
+    default=downloader_sig.parameters["exclude_tags"].default,
+    help="Comma-separated tags to exclude.",
+)
+@click.option(
+    "--no-synced-lyrics",
+    is_flag=True,
+    help="Don't save synced lyrics.",
+)
+@click.option(
+    "--synced-lyrics-only",
+    is_flag=True,
+    help="Skip track download and only save synced lyrics.",
+)
+@click.option(
+    "--truncate",
+    type=int,
+    default=downloader_sig.parameters["truncate"].default,
+    help="Maximum length of the file/folder names.",
+)
+# This option should always be last
+@click.option(
+    "--no-config-file",
+    "-n",
+    is_flag=True,
+    callback=load_config_file,
+    help="Don't load the config file.",
+)
+def main(
+    urls: tuple[str],
+    save_cover: bool,
+    overwrite: bool,
+    read_urls_as_txt: bool,
+    config_path: Path,
+    log_level: str,
+    no_exceptions: bool,
+    output_path: Path,
+    temp_path: Path,
+    cookies_path: Path,
+    browser_json_path: Path,  # NUEVO PARÁMETRO
+    ffmpeg_path: str,
+    aria2c_path: str,
+    download_mode: DownloadMode,
+    po_token: str,
+    itag: str,
+    cover_size: int,
+    cover_format: CoverFormat,
+    cover_quality: int,
+    template_folder: str,
+    template_file: str,
+    template_date: str,
+    exclude_tags: str,
+    no_synced_lyrics: bool,
+    synced_lyrics_only: bool,
+    truncate: int,
+    no_config_file: bool,
+):
+    colorama.just_fix_windows_console()
+    logger.setLevel(log_level)
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(CustomLoggerFormatter())
+    logger.addHandler(stream_handler)
+    
+    if itag in PREMIUM_FORMATS and cookies_path is None and po_token is None:
+        logger.critical("Cookies file or PO Token is required for premium formats")
+        return
+    if po_token is None and cookies_path is not None:
+        logger.warning("PO Token not provided, downloading may fail")
+    
+    if not shutil.which(ffmpeg_path):
+        logger.critical(X_NOT_FOUND_STRING.format("FFmpeg", ffmpeg_path))
+        return
+    if download_mode == DownloadMode.ARIA2C and not shutil.which(aria2c_path):
+        logger.critical(X_NOT_FOUND_STRING.format("aria2c", aria2c_path))
+        return
+    
+    if cookies_path is not None:
+        cookies_path = prompt_path(
+            True,
+            cookies_path,
+        )
+    
+    if browser_json_path is not None and not browser_json_path.exists():
+        logger.warning(f"browser.json not found at {browser_json_path}. YTMusic will work in anonymous mode.")
+        browser_json_path = None
+
+    if read_urls_as_txt:
+        _urls = []
+        for url in urls:
+            if Path(url).exists():
+                _urls.extend(Path(url).read_text().splitlines())
+        urls = _urls
+    
+    logger.info("Starting Muget")
+    downloader = Downloader(
+        output_path,
+        temp_path,
+        cookies_path,
+        browser_json_path,  # NUEVO ARGUMENTO
+        ffmpeg_path,
+        aria2c_path,
+        itag,
+        download_mode,
+        po_token,
+        cover_size,
+        cover_format,
+        cover_quality,
+        template_folder,
+        template_file,
+        template_date,
+        exclude_tags,
+        truncate,
+    )
+    
+    error_count = 0
+    download_queue = []
+    for url_index, url in enumerate(urls, start=1):
+        url_progress = color_text(f"URL {url_index}/{len(urls)}", colorama.Style.DIM)
+        try:
+            logger.info(f'({url_progress}) Checking "{url}"')
+            download_queue = list(downloader.get_download_queue(url))
+        except Exception as e:
+            error_count += 1
+            logger.error(
+                f'({url_progress}) Failed to check "{url}"',
+                exc_info=not no_exceptions,
+            )
+            continue
+        
+        for queue_index, queue_item in enumerate(download_queue, start=1):
+            queue_progress = color_text(
+                f"Track {queue_index}/{len(download_queue)} from URL {url_index}/{len(urls)}",
+                colorama.Style.DIM,
+            )
+            try:
+                # Si el título no está disponible (ej. desde URL directa), obtenerlo ahora
+                if not queue_item.get("title"):
+                    watch_playlist_temp = downloader.get_ytmusic_watch_playlist(queue_item["id"])
+                    if watch_playlist_temp and watch_playlist_temp.get("tracks"):
+                        queue_item["title"] = watch_playlist_temp["tracks"][0].get("title", "Unknown Title")
+                    else:
+                        queue_item["title"] = "Unknown Title"
+                
+                logger.info(f'({queue_progress}) Downloading "{queue_item["title"]}"')
+                logger.debug("Getting tags")
+                ytmusic_watch_playlist = downloader.get_ytmusic_watch_playlist(
+                    queue_item["id"]
+                )
+                if not ytmusic_watch_playlist:
+                    logger.warning(
+                        f"({queue_progress}) Track doesn't have an album or is not available, skipping"
+                    )
+                    continue
+                tags = downloader.get_tags(ytmusic_watch_playlist)
+                final_path = downloader.get_final_path(tags)
+                synced_lyrics_path = downloader.get_synced_lyrics_path(final_path)
+                if synced_lyrics_only:
+                    pass
+                elif final_path.exists() and not overwrite:
+                    logger.warning(
+                        f'({queue_progress}) Track already exists at "{final_path}", skipping'
+                    )
+                else:
+                    video_id = ytmusic_watch_playlist["tracks"][0]["videoId"]
+                    track_temp_path = downloader.get_track_temp_path(video_id)
+                    remuxed_path = downloader.get_remuxed_path(video_id)
+                    cover_url = downloader.get_cover_url(ytmusic_watch_playlist)
+                    cover_file_extension = downloader.get_cover_file_extension(
+                        cover_url
+                    )
+                    cover_path = downloader.get_cover_path(
+                        final_path, cover_file_extension
+                    )
+                    logger.debug(f'Downloading to "{track_temp_path}"')
+                    downloader.download(video_id, track_temp_path)
+                    logger.debug(f'Remuxing to "{remuxed_path}"')
+                    downloader.remux(track_temp_path, remuxed_path)
+                    logger.debug("Applying tags")
+                    downloader.apply_tags(remuxed_path, tags, cover_url)
+                    logger.debug(f'Moving to "{final_path}"')
+                    downloader.move_to_output_path(remuxed_path, final_path)
+                if no_synced_lyrics or not tags.get("lyrics"):
+                    pass
+                elif synced_lyrics_path.exists() and not overwrite:
+                    logger.debug(
+                        f'Synced lyrics already exists at "{synced_lyrics_path}", skipping'
+                    )
+                else:
+                    logger.debug("Getting synced lyrics")
+                    synced_lyrics = downloader.get_synced_lyrics(ytmusic_watch_playlist)
+                    if synced_lyrics:
+                        logger.debug(f'Saving synced lyrics to "{synced_lyrics_path}"')
+                        downloader.save_synced_lyrics(synced_lyrics_path, synced_lyrics)
+                if not save_cover:
+                    pass
+                elif cover_path.exists() and not overwrite:
+                    logger.debug(f'Cover already exists at "{cover_path}", skipping')
+                else:
+                    logger.debug(f'Saving cover to "{cover_path}"')
+                    downloader.save_cover(cover_path, cover_url)
+            except Exception as e:
+                error_count += 1
+                logger.error(
+                    f'({queue_progress}) Failed to download "{queue_item["title"]}"',
+                    exc_info=not no_exceptions,
+                )
+            finally:
+                if temp_path.exists():
+                    logger.debug(f'Cleaning up "{temp_path}"')
+                    downloader.cleanup_temp_path()
+    logger.info(f"Done ({error_count} error(s))")

muget-1.0.0/muget/constants.py

@@ -0,0 +1,30 @@
+EXCLUDED_CONFIG_FILE_PARAMS = (
+    "urls",
+    "config_path",
+    "read_urls_as_txt",
+    "no_config_file",
+    "version",
+    "help",
+    "browser_json_path",  # AÑADIDO: Excluir esta opción del archivo de configuración
+)
+
+MP4_TAGS_MAP = {
+    "album": "\xa9alb",
+    "album_artist": "aART",
+    "artist": "\xa9ART",
+    "date": "\xa9day",
+    "lyrics": "\xa9lyr",
+    "media_type": "stik",
+    "rating": "rtng",
+    "title": "\xa9nam",
+    "url": "\xa9url",
+}
+
+X_NOT_FOUND_STRING = '{} not found at "{}"'
+
+IMAGE_FILE_EXTENSION_MAP = {
+    "jpeg": ".jpg",
+    "tiff": ".tif",
+}
+
+PREMIUM_FORMATS = ["141", "774"]

muget-1.0.0/muget/custom_logger_formatter.py

@@ -0,0 +1,24 @@
+import logging
+
+import colorama
+
+from .utils import color_text
+
+
+class CustomLoggerFormatter(logging.Formatter):
+    base_format = "[%(levelname)-8s %(asctime)s]"
+    format_colors = {
+        logging.DEBUG: colorama.Style.DIM,
+        logging.INFO: colorama.Fore.GREEN,
+        logging.WARNING: colorama.Fore.YELLOW,
+        logging.ERROR: colorama.Fore.RED,
+        logging.CRITICAL: colorama.Fore.RED,
+    }
+    date_format = "%H:%M:%S"
+
+    def format(self, record: logging.LogRecord) -> str:
+        return logging.Formatter(
+            color_text(self.base_format, self.format_colors.get(record.levelno))
+            + " %(message)s",
+            datefmt=self.date_format,
+        ).format(record)

muget-1.0.0/muget/downloader.py

@@ -0,0 +1,563 @@
+from __future__ import annotations
+
+import datetime
+import functools
+import io
+import json
+import logging
+import re
+import shutil
+import subprocess
+import typing
+from pathlib import Path
+
+import requests
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+from mutagen.mp4 import MP4, MP4Cover
+from PIL import Image
+from yt_dlp import YoutubeDL
+from ytmusicapi import YTMusic
+
+from .constants import IMAGE_FILE_EXTENSION_MAP, MP4_TAGS_MAP
+from .enums import CoverFormat, DownloadMode
+
+logger = logging.getLogger("muget")
+
+
+class Downloader:
+    def __init__(
+        self,
+        output_path: Path = Path("./YouTube Music"),
+        temp_path: Path = Path("./temp"),
+        cookies_path: Path = None,
+        browser_json_path: Path = None,
+        ffmpeg_path: str = "ffmpeg",
+        aria2c_path: str = "aria2c",
+        itag: str = "140",
+        download_mode: DownloadMode = DownloadMode.YTDLP,
+        po_token: str = None,
+        cover_size: int = 16383,
+        cover_format: CoverFormat = CoverFormat.JPG,
+        cover_quality: int = 94,
+        template_folder: str = "{album_artist}/{album}",
+        template_file: str = "{track:02d} {title}",
+        template_date: str = "%Y-%m-%dT%H:%M:%SZ",
+        exclude_tags: str = None,
+        truncate: int = None,
+        silent: bool = False,
+    ):
+        self.output_path = output_path
+        self.temp_path = temp_path
+        self.cookies_path = cookies_path
+        self.browser_json_path = browser_json_path
+        self.ffmpeg_path = ffmpeg_path
+        self.aria2c_path = aria2c_path
+        self.itag = itag
+        self.download_mode = download_mode
+        self.po_token = po_token
+        self.cover_size = cover_size
+        self.cover_format = cover_format
+        self.cover_quality = cover_quality
+        self.template_folder = template_folder
+        self.template_file = template_file
+        self.template_date = template_date
+        self.exclude_tags = exclude_tags
+        self.truncate = truncate
+        self.silent = silent
+        self._set_ytmusic_instance()
+        self._set_ytdlp_options()
+        self._set_exclude_tags()
+        self._set_truncate()
+
+    def _set_ytmusic_instance(self):
+        """Configura la instancia de YTMusic usando browser.json si está disponible."""
+        if self.browser_json_path and self.browser_json_path.exists():
+            try:
+                with open(self.browser_json_path, 'r', encoding='utf-8') as f:
+                    json.load(f)  # Validar que es JSON válido
+                self.ytmusic = YTMusic(str(self.browser_json_path))
+                logger.debug(f"YTMusic autenticado con browser.json desde {self.browser_json_path}")
+            except Exception as e:
+                logger.warning(f"Error cargando browser.json: {e}. Usando modo anónimo.")
+                self.ytmusic = YTMusic()
+        else:
+            if self.browser_json_path:
+                logger.warning(f"browser.json no encontrado en {self.browser_json_path}. Usando modo anónimo.")
+            self.ytmusic = YTMusic()
+
+    def _set_ytdlp_options(self):
+        """Configura opciones de yt-dlp SOLO para descarga de audio."""
+        self.ytdlp_options = {
+            "quiet": True,
+            "no_warnings": True,
+            "noprogress": self.silent,
+            "extract_flat": False,
+        }
+        
+        if self.cookies_path is not None or self.po_token is not None:
+            self.ytdlp_options["extractor_args"] = {
+                "youtube": {
+                    "player_client": ["web_music"],
+                }
+            }
+            if self.po_token is not None:
+                self.ytdlp_options["extractor_args"]["youtube"]["po_token"] = [
+                    f"web_music.gvs+{self.po_token}"
+                ]
+        
+        if self.cookies_path is not None:
+            self.ytdlp_options["cookiefile"] = str(self.cookies_path)
+
+    def _set_exclude_tags(self):
+        self.exclude_tags = (
+            [i.lower() for i in self.exclude_tags.split(",")]
+            if self.exclude_tags is not None
+            else []
+        )
+
+    def _set_truncate(self):
+        if self.truncate is not None:
+            self.truncate = None if self.truncate < 4 else self.truncate
+
+    def get_download_queue(
+        self,
+        url: str,
+    ) -> typing.Generator[dict, None, None]:
+        """Obtiene la cola de descarga usando SOLO ytmusicapi."""
+        # Detectar tipo de URL
+        if "browse" in url:
+            browse_id = url.split("browse/")[-1].split("?")[0]
+            yield from self._get_download_queue_from_browse_id(browse_id)
+        elif "playlist" in url:
+            playlist_id = self._extract_playlist_id(url)
+            yield from self._get_download_queue_from_playlist_id(playlist_id)
+        elif "watch" in url or "v=" in url:
+            video_id = self._extract_video_id(url)
+            yield from self._get_download_queue_from_video_id(video_id)
+        elif "channel" in url:
+            channel_id = self._extract_channel_id(url)
+            yield from self._get_download_queue_artist(channel_id)
+        else:
+            yield from self._get_download_queue_from_browse_id(url)
+
+    def _extract_video_id(self, url: str) -> str:
+        if "v=" in url:
+            return url.split("v=")[1].split("&")[0]
+        return url.split("/")[-1].split("?")[0]
+
+    def _extract_playlist_id(self, url: str) -> str:
+        if "list=" in url:
+            return url.split("list=")[1].split("&")[0]
+        return url.split("/")[-1].split("?")[0]
+
+    def _extract_channel_id(self, url: str) -> str:
+        if "channel/" in url:
+            return url.split("channel/")[1].split("?")[0]
+        return url.split("/")[-1].split("?")[0]
+
+    def _get_download_queue_from_browse_id(
+        self,
+        browse_id: str,
+    ) -> typing.Generator[dict, None, None]:
+        """Procesa browse_id como álbum o playlist."""
+        # Intentar como álbum
+        try:
+            album = self.ytmusic.get_album(browse_id)
+            if album and album.get("tracks"):
+                for track in album["tracks"]:
+                    if track.get("videoId"):
+                        yield {
+                            "id": track["videoId"],
+                            "title": track.get("title"),
+                            "artists": track.get("artists", []),
+                            "album": album,
+                        }
+                return
+        except Exception:
+            pass
+        
+        # Intentar como playlist
+        try:
+            playlist = self.ytmusic.get_playlist(browse_id, limit=1000)
+            if playlist and playlist.get("tracks"):
+                for track in playlist["tracks"]:
+                    if track.get("videoId"):
+                        yield {
+                            "id": track["videoId"],
+                            "title": track.get("title"),
+                            "artists": track.get("artists", []),
+                            "playlist": playlist,
+                        }
+                return
+        except Exception as e:
+            logger.debug(f"Error procesando browse_id {browse_id}: {e}")
+
+    def _get_download_queue_from_playlist_id(
+        self,
+        playlist_id: str,
+    ) -> typing.Generator[dict, None, None]:
+        """Obtiene tracks de una playlist (soporta privadas con browser.json)."""
+        try:
+            playlist = self.ytmusic.get_playlist(playlist_id, limit=1000)
+            if playlist and playlist.get("tracks"):
+                for track in playlist["tracks"]:
+                    if track.get("videoId"):
+                        yield {
+                            "id": track["videoId"],
+                            "title": track.get("title"),
+                            "artists": track.get("artists", []),
+                            "playlist": playlist,
+                        }
+            else:
+                logger.warning(f"No se encontraron tracks en la playlist {playlist_id}")
+        except Exception as e:
+            logger.error(f"Error accediendo a la playlist {playlist_id}: {e}")
+            if "private" in str(e).lower():
+                logger.error("La playlist puede ser privada. Usa --browser-json-path con autenticación válida.")
+
+    def _get_download_queue_from_video_id(
+        self,
+        video_id: str,
+    ) -> typing.Generator[dict, None, None]:
+        yield {
+            "id": video_id,
+            "title": None,
+            "artists": [],
+        }
+
+    def _get_download_queue_artist(
+        self,
+        channel_id: str,
+    ) -> typing.Generator[dict, None, None]:
+        """Interactúa con el usuario para seleccionar álbumes/singles de un artista."""
+        artist = self.ytmusic.get_artist(channel_id)
+        media_type = inquirer.select(
+            message=f'Select which type to download for artist "{artist["name"]}":',
+            choices=[
+                Choice(name="Albums", value="albums"),
+                Choice(name="Singles", value="singles"),
+            ],
+            validate=lambda result: artist.get(result, {}).get("results"),
+            invalid_message="The artist doesn't have any items of this type",
+        ).execute()
+        
+        artist_items = (
+            self.ytmusic.get_artist_albums(
+                artist[media_type]["browseId"], artist[media_type]["params"]
+            )
+            if artist[media_type].get("browseId") and artist[media_type].get("params")
+            else artist[media_type]["results"]
+        )
+        
+        choices = [
+            Choice(
+                name=" | ".join(
+                    [
+                        item.get("year", "Unknown"),
+                        item["title"],
+                    ]
+                ),
+                value=item,
+            )
+            for item in artist_items
+        ]
+        
+        selected = inquirer.select(
+            message="Select which items to download: (Year | Title)",
+            choices=choices,
+            multiselect=True,
+        ).execute()
+        
+        for item in selected:
+            yield from self._get_download_queue_from_browse_id(item["browseId"])
+
+    @staticmethod
+    def _get_artist(artist_list: list) -> str:
+        if not artist_list:
+            return "Unknown Artist"
+        if len(artist_list) == 1:
+            return artist_list[0]["name"]
+        return (
+            ", ".join([i["name"] for i in artist_list][:-1])
+            + f' & {artist_list[-1]["name"]}'
+        )
+
+    def get_ytmusic_watch_playlist(self, video_id: str) -> dict | None:
+        """Obtiene watch playlist para un video."""
+        try:
+            ytmusic_watch_playlist = self.ytmusic.get_watch_playlist(video_id)
+            if not ytmusic_watch_playlist or not ytmusic_watch_playlist.get("tracks"):
+                return None
+            if not ytmusic_watch_playlist["tracks"][0].get("album"):
+                return None
+            return ytmusic_watch_playlist
+        except Exception as e:
+            logger.debug(f"Error obteniendo watch playlist para {video_id}: {e}")
+            return None
+
+    @functools.lru_cache()
+    def get_ytmusic_album(self, browse_id: str) -> dict:
+        """Obtiene información de un álbum."""
+        try:
+            return self.ytmusic.get_album(browse_id)
+        except Exception as e:
+            logger.debug(f"Error obteniendo álbum {browse_id}: {e}")
+            return {}
+
+    @staticmethod
+    def _get_datetime_obj(date: str) -> datetime.datetime | None:
+        try:
+            return datetime.datetime.strptime(date, "%Y")
+        except ValueError:
+            return None
+
+    def get_tags(self, ytmusic_watch_playlist: dict) -> dict:
+        """Extrae tags completas de un track usando ytmusicapi."""
+        video_id = ytmusic_watch_playlist["tracks"][0]["videoId"]
+        album_info = self.get_ytmusic_album(
+            ytmusic_watch_playlist["tracks"][0]["album"]["id"]
+        )
+        
+        track_number = 1
+        is_explicit = False
+        if album_info and album_info.get("tracks"):
+            for idx, track in enumerate(album_info["tracks"], start=1):
+                if track.get("videoId") == video_id:
+                    track_number = idx
+                    is_explicit = track.get("isExplicit", False)
+                    break
+        
+        tags = {
+            "album": album_info.get("title", "Unknown Album") if album_info else "Unknown Album",
+            "album_artist": self._get_artist(album_info.get("artists", [])) if album_info else "Unknown Artist",
+            "artist": self._get_artist(ytmusic_watch_playlist["tracks"][0].get("artists", [])),
+            "url": f"https://music.youtube.com/watch?v={video_id}",
+            "media_type": 1,
+            "title": ytmusic_watch_playlist["tracks"][0].get("title", "Unknown Title"),
+            "track_total": album_info.get("trackCount", 0) if album_info else 0,
+            "track": track_number,
+            "video_id": video_id,
+            "rating": 1 if is_explicit else 0,
+        }
+        
+        # Letras no sincronizadas
+        if ytmusic_watch_playlist.get("lyrics"):
+            try:
+                lyrics_data = self.ytmusic.get_lyrics(ytmusic_watch_playlist["lyrics"])
+                if lyrics_data and lyrics_data.get("lyrics"):
+                    tags["lyrics"] = lyrics_data["lyrics"]
+            except Exception as e:
+                logger.debug(f"No se pudieron obtener letras: {e}")
+        
+        # Fecha
+        if album_info and album_info.get("year"):
+            dt_obj = self._get_datetime_obj(album_info["year"])
+            if dt_obj:
+                tags["date"] = dt_obj.strftime(self.template_date)
+        
+        return tags
+
+    def get_synced_lyrics(self, ytmusic_watch_playlist: dict) -> str | None:
+        """Obtiene letras sincronizadas usando una instancia anónima."""
+        if not ytmusic_watch_playlist.get("lyrics"):
+            return None
+    
+        try:
+            # Crear una instancia anónima SOLO para letras
+            yt_anonymous = YTMusic()  # Sin autenticación
+        
+            lyrics_data = yt_anonymous.get_lyrics(
+                ytmusic_watch_playlist["lyrics"],
+                True  # Con timestamps
+            )
+        
+            if (lyrics_data is not None 
+                and lyrics_data.get("lyrics") 
+                and lyrics_data.get("hasTimestamps")):
+            
+                lines = []
+                for line in lyrics_data["lyrics"]:
+                    timestamp = datetime.datetime.fromtimestamp(
+                        line.start_time / 1000.0, 
+                        tz=datetime.timezone.utc
+                    )
+                    lrc_timestamp = timestamp.strftime("%M:%S.%f")[:-4]
+                    lines.append(f"[{lrc_timestamp}]{line.text}")
+            
+                return "\n".join(lines) + "\n"
+            
+        except Exception as e:
+            logger.debug(f"No se pudieron obtener letras sincronizadas: {e}")
+    
+        return None
+
+    def get_synced_lyrics_path(self, final_path: Path) -> Path:
+        return final_path.with_suffix(".lrc")
+
+    def save_synced_lyrics(self, synced_lyrics_path: Path, synced_lyrics: str):
+        if synced_lyrics:
+            synced_lyrics_path.parent.mkdir(parents=True, exist_ok=True)
+            synced_lyrics_path.write_text(synced_lyrics, encoding="utf8")
+
+    def get_sanitized_string(self, dirty_string: str, is_folder: bool) -> str:
+        dirty_string = re.sub(r'[\\/:*?"<>|;]', "_", dirty_string)
+        if is_folder:
+            if self.truncate:
+                dirty_string = dirty_string[:self.truncate]
+            if dirty_string.endswith("."):
+                dirty_string = dirty_string[:-1] + "_"
+        else:
+            if self.truncate:
+                dirty_string = dirty_string[:self.truncate - 4]
+        return dirty_string.strip()
+
+    def get_track_temp_path(self, video_id: str) -> Path:
+        return self.temp_path / f"{video_id}_temp.m4a"
+
+    def get_remuxed_path(self, video_id: str) -> Path:
+        return self.temp_path / f"{video_id}_remuxed.m4a"
+
+    def get_cover_path(self, final_path: Path, file_extension: str) -> Path:
+        return final_path.parent / ("Cover" + file_extension)
+
+    def get_final_path(self, tags: dict) -> Path:
+        tags_for_filename = tags.copy()
+        
+        # Asegurar tipos numéricos
+        for key in ['track', 'track_total', 'disc', 'disc_total']:
+            if key in tags_for_filename:
+                value = tags_for_filename[key]
+                try:
+                    if isinstance(value, str) and '/' in value:
+                        value = value.split('/')[0]
+                    tags_for_filename[key] = int(value) if value is not None else 0
+                except (ValueError, TypeError):
+                    tags_for_filename[key] = 0
+        
+        tags_for_filename.setdefault('track', 0)
+        tags_for_filename.setdefault('title', 'Unknown Title')
+        tags_for_filename.setdefault('artist', 'Unknown Artist')
+        
+        folder_parts = self.template_folder.split("/")
+        file_parts = self.template_file.split("/")
+        
+        processed_folders = []
+        for part in folder_parts:
+            try:
+                formatted = part.format(**tags_for_filename)
+            except (KeyError, ValueError):
+                formatted = part
+            processed_folders.append(self.get_sanitized_string(formatted, True))
+        
+        processed_file_parts = []
+        for part in file_parts[:-1]:
+            try:
+                formatted = part.format(**tags_for_filename)
+            except (KeyError, ValueError):
+                formatted = part
+            processed_file_parts.append(self.get_sanitized_string(formatted, True))
+        
+        try:
+            last_part = file_parts[-1].format(**tags_for_filename)
+        except (KeyError, ValueError):
+            last_part = file_parts[-1]
+        
+        final_filename = self.get_sanitized_string(last_part, False) + ".m4a"
+        processed_file_parts.append(final_filename)
+        
+        return self.output_path.joinpath(*processed_folders).joinpath(*processed_file_parts)
+
+    def download(self, video_id: str, temp_path: Path):
+        """Descarga SOLO el audio usando yt-dlp."""
+        with YoutubeDL(
+            {
+                **self.ytdlp_options,
+                "external_downloader": (
+                    {"default": self.aria2c_path} if self.download_mode == DownloadMode.ARIA2C else None
+                ),
+                "fixup": "never",
+                "format": self.itag,
+                "outtmpl": str(temp_path),
+            }
+        ) as ydl:
+            ydl.download(f"https://music.youtube.com/watch?v={video_id}")
+
+    def remux(self, temp_path: Path, remuxed_path: Path):
+        command = [self.ffmpeg_path, "-loglevel", "error", "-i", temp_path]
+        if self.itag not in ("141", "140", "139"):
+            command.extend(["-f", "mp4"])
+        subprocess.run(
+            [
+                *command,
+                "-movflags",
+                "+faststart",
+                "-c",
+                "copy",
+                remuxed_path,
+            ],
+            check=True,
+        )
+
+    @staticmethod
+    @functools.lru_cache()
+    def get_url_response_bytes(url: str) -> bytes:
+        return requests.get(url).content
+
+    def get_cover_url(self, ytmusic_watch_playlist: dict) -> str:
+        thumb_url = ytmusic_watch_playlist["tracks"][0]["thumbnail"][0]["url"].split("=")[0]
+        if self.cover_format == CoverFormat.RAW:
+            return thumb_url + "=d"
+        return thumb_url + f'=w{self.cover_size}-l{self.cover_quality}-{"rj" if self.cover_format == CoverFormat.JPG else "rp"}'
+
+    def get_cover_file_extension(self, cover_url: str) -> str:
+        img = Image.open(io.BytesIO(self.get_url_response_bytes(cover_url)))
+        fmt = img.format.lower()
+        return IMAGE_FILE_EXTENSION_MAP.get(fmt, f".{fmt}")
+
+    def apply_tags(self, path: Path, tags: dict, cover_url: str):
+        to_apply = [k for k in tags.keys() if k not in self.exclude_tags]
+        mp4_tags = {}
+        
+        for tag in to_apply:
+            if tag in ("disc", "disc_total"):
+                if "disk" not in mp4_tags:
+                    mp4_tags["disk"] = [[0, 0]]
+                if tag == "disc":
+                    mp4_tags["disk"][0][0] = tags[tag]
+                elif tag == "disc_total":
+                    mp4_tags["disk"][0][1] = tags[tag]
+            elif tag in ("track", "track_total"):
+                if "trkn" not in mp4_tags:
+                    mp4_tags["trkn"] = [[0, 0]]
+                if tag == "track":
+                    mp4_tags["trkn"][0][0] = tags[tag]
+                elif tag == "track_total":
+                    mp4_tags["trkn"][0][1] = tags[tag]
+            elif MP4_TAGS_MAP.get(tag) and tags.get(tag) is not None:
+                mp4_tags[MP4_TAGS_MAP[tag]] = [tags[tag]]
+        
+        if "cover" not in self.exclude_tags and self.cover_format != CoverFormat.RAW:
+            mp4_tags["covr"] = [
+                MP4Cover(
+                    self.get_url_response_bytes(cover_url),
+                    MP4Cover.FORMAT_JPEG if self.cover_format == CoverFormat.JPG else MP4Cover.FORMAT_PNG,
+                )
+            ]
+        
+        mp4 = MP4(path)
+        mp4.clear()
+        mp4.update(mp4_tags)
+        mp4.save()
+
+    def move_to_output_path(self, remuxed_path: Path, final_path: Path):
+        final_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(remuxed_path, final_path)
+
+    @functools.lru_cache()
+    def save_cover(self, cover_path: Path, cover_url: str):
+        cover_path.write_bytes(self.get_url_response_bytes(cover_url))
+
+    def cleanup_temp_path(self):
+        if self.temp_path.exists():
+            shutil.rmtree(self.temp_path)

muget-1.0.0/muget/enums.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class CoverFormat(Enum):
+    JPG = "jpg"
+    PNG = "png"
+    RAW = "raw"
+
+
+class DownloadMode(Enum):
+    YTDLP = "ytdlp"
+    ARIA2C = "aria2c"

muget-1.0.0/muget/utils.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+
+import click
+import colorama
+
+
+def color_text(text: str, color) -> str:
+    return color + text + colorama.Style.RESET_ALL
+
+
+def prompt_path(is_file: bool, initial_path: Path) -> Path:
+    path_validator = click.Path(
+        exists=True,
+        file_okay=is_file,
+        dir_okay=not is_file,
+        path_type=Path,
+    )
+    while True:
+        try:
+            path_obj = path_validator.convert(initial_path.absolute(), None, None)
+            break
+        except click.BadParameter as e:
+            path_str = click.prompt(
+                str(e)
+                + " Move it to that location, type the path or drag and drop it here. Then, press enter to continue",
+                default=str(initial_path),
+                show_default=False,
+            )
+            path_str = path_str.strip('"')
+            initial_path = Path(path_str)
+    return path_obj

muget-1.0.0/muget.egg-info/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: muget
+Version: 1.0.0
+Summary: YouTube Music downloader with tagging support
+Author: Meikoy-Chan
+License: MIT
+Project-URL: Homepage, https://github.com/meikoy-chan/muget
+Project-URL: Bug Reports, https://github.com/meikoy-chan/muget/issues
+Keywords: youtube-music,downloader,yt-dlp,music
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click
+Requires-Dist: colorama
+Requires-Dist: mutagen
+Requires-Dist: Pillow
+Requires-Dist: requests
+Requires-Dist: yt-dlp
+Requires-Dist: ytmusicapi
+Requires-Dist: InquirerPy
+Requires-Dist: yt_dlp_ejs
+Dynamic: license-file
+
+# Muget
+
+YouTube Music downloader with automatic tagging and cover art.
+
+## Installation
+
+```bash
+pip install muget
+```
+
+Usage
+
+```bash
+muget "https://music.youtube.com/playlist?list=..."
+muget -o "./Music" "https://music.youtube.com/album/..."
+```
+
+Requirements
+
+· FFmpeg (required)
+· aria2c (optional, for faster downloads)
+
+Features
+
+· Download tracks, albums, and playlists
+· Automatic metadata tagging
+· Cover art embedding
+· Synced lyrics support

muget-1.0.0/muget.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+muget/__init__.py
+muget/__main__.py
+muget/cli.py
+muget/constants.py
+muget/custom_logger_formatter.py
+muget/downloader.py
+muget/enums.py
+muget/utils.py
+muget.egg-info/PKG-INFO
+muget.egg-info/SOURCES.txt
+muget.egg-info/dependency_links.txt
+muget.egg-info/entry_points.txt
+muget.egg-info/requires.txt
+muget.egg-info/top_level.txt

muget-1.0.0/muget.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

muget-1.0.0/muget.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+muget = muget.cli:main

muget-1.0.0/muget.egg-info/requires.txt

@@ -0,0 +1,9 @@
+click
+colorama
+mutagen
+Pillow
+requests
+yt-dlp
+ytmusicapi
+InquirerPy
+yt_dlp_ejs

muget-1.0.0/muget.egg-info/top_level.txt

@@ -0,0 +1 @@
+muget

muget-1.0.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "muget"
+version = "1.0.0"
+description = "YouTube Music downloader with tagging support"
+authors = [
+    {name="Meikoy-Chan"}
+]
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+keywords = ["youtube-music", "downloader", "yt-dlp", "music"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+dependencies = [
+    "click",
+    "colorama",
+    "mutagen",
+    "Pillow",
+    "requests",
+    "yt-dlp",
+    "ytmusicapi",
+    "InquirerPy",
+    "yt_dlp_ejs"
+]
+
+[project.scripts]
+muget = "muget.cli:main"
+
+[project.urls]
+"Homepage" = "https://github.com/meikoy-chan/muget"
+"Bug Reports" = "https://github.com/meikoy-chan/muget/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["muget*"]

muget-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+