gamdl 3.1__tar.gz → 3.2__tar.gz

{gamdl-3.1 → gamdl-3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gamdl
-Version: 3.1
+Version: 3.2
 Summary: A command-line app for downloading Apple Music songs, music videos and post videos.
 License-Expression: MIT
 Project-URL: Repository, https://github.com/glomatico/gamdl

gamdl-3.2/gamdl/__init__.py

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

{gamdl-3.1 → gamdl-3.2}/gamdl/cli/cli.py

@@ -17,9 +17,7 @@ from ..downloader import (
     AppleMusicMusicVideoDownloader,
     AppleMusicSongDownloader,
     AppleMusicUploadedVideoDownloader,
-    DownloadItem,
     GamdlDownloaderDependencyNotFoundError,
-    GamdlDownloaderFlatFilterExcludedError,
     GamdlDownloaderMediaFileExistsError,
     GamdlDownloaderSyncedLyricsOnlyError,
 )
@@ -31,6 +29,7 @@ from ..interface import (
     AppleMusicUploadedVideoInterface,
     GamdlInterfaceArtistMediaTypeError,
     GamdlInterfaceDecryptionNotAvailableError,
+    GamdlInterfaceFlatFilterExcludedError,
     GamdlInterfaceFormatNotAvailableError,
     GamdlInterfaceMediaNotStreamableError,
     GamdlInterfaceUrlParseError,
@@ -152,7 +151,6 @@ async def main(config: CliConfig):
         synced_lyrics_format=config.synced_lyrics_format,
         codec_priority=config.song_codec_piority,
         use_album_date=config.use_album_date,
-        skip_decryption_key_non_legacy=config.use_wrapper,
         skip_stream_info=config.synced_lyrics_only,
         ask_codec_function=interactive_prompts.ask_song_codec,
     )
@@ -262,8 +260,21 @@ async def main(config: CliConfig):
                     )
                     else "Unknown Title"
                 )
+                media_type = (
+                    download_item.media.media_metadata["type"]
+                    if download_item.media.media_metadata
+                    else None
+                )
 
-                track_log.info(f'Downloading "{media_title}"')
+                if download_item.media.partial and media_type in {
+                    None,
+                    "songs",
+                    "library-songs",
+                    "music-videos",
+                    "library-music-videos",
+                    "uploaded-videos",
+                }:
+                    track_log.info(f'Downloading "{media_title}"')
 
                 try:
                     await downloader.download(download_item)
@@ -275,7 +286,7 @@ async def main(config: CliConfig):
                     GamdlDownloaderSyncedLyricsOnlyError,
                     GamdlDownloaderMediaFileExistsError,
                     GamdlDownloaderDependencyNotFoundError,
-                    GamdlDownloaderFlatFilterExcludedError,
+                    GamdlInterfaceFlatFilterExcludedError,
                 ) as e:
                     track_log.warning(f'Skipping "{media_title}": {e}')
                     continue

{gamdl-3.1 → gamdl-3.2}/gamdl/downloader/base.py

@@ -27,7 +27,6 @@ class AppleMusicBaseDownloader:
         mp4decrypt_path: str = "mp4decrypt",
         ffmpeg_path: str = "ffmpeg",
         mp4box_path: str = "MP4Box",
-        use_wrapper: bool = False,
         wrapper_decrypt_ip: str = "127.0.0.1:10020",
         download_mode: DownloadMode = DownloadMode.YTDLP,
         album_folder_template: str = "{album_artist}/{album}",
@@ -50,7 +49,6 @@ class AppleMusicBaseDownloader:
         self.mp4decrypt_path = mp4decrypt_path
         self.ffmpeg_path = ffmpeg_path
         self.mp4box_path = mp4box_path
-        self.use_wrapper = use_wrapper
         self.wrapper_decrypt_ip = wrapper_decrypt_ip
         self.download_mode = download_mode
         self.album_folder_template = album_folder_template

{gamdl-3.1 → gamdl-3.2}/gamdl/downloader/downloader.py

@@ -5,12 +5,10 @@ from typing import AsyncGenerator
 import structlog
 
 from ..interface.types import AppleMusicMedia
-
 from .constants import TEMP_PATH_TEMPLATE
 from .enums import DownloadMode, RemuxMode
 from .exceptions import (
     GamdlDownloaderDependencyNotFoundError,
-    GamdlDownloaderFlatFilterExcludedError,
     GamdlDownloaderMediaFileExistsError,
     GamdlDownloaderSyncedLyricsOnlyError,
 )
@@ -60,7 +58,10 @@ class AppleMusicDownloader:
         self,
         media: AppleMusicMedia,
     ) -> DownloadItem:
-        if media.error or media.flat_filter_result:
+        if media.error:
+            return DownloadItem(media)
+
+        if media.partial:
             return DownloadItem(media)
 
         elif media.media_metadata["type"] in {"songs", "library-songs"}:
@@ -80,10 +81,8 @@ class AppleMusicDownloader:
             if item.media.error:
                 raise item.media.error
 
-            if item.media.flat_filter_result:
-                raise GamdlDownloaderFlatFilterExcludedError(
-                    item.media.media_metadata["id"]
-                )
+            if item.media.partial:
+                return
 
             await self._initial_processing(item)
             await self._download(item)

{gamdl-3.1 → gamdl-3.2}/gamdl/downloader/exceptions.py

@@ -18,8 +18,3 @@ class GamdlDownloaderMediaFileExistsError(GamdlDownloaderError):
 class GamdlDownloaderDependencyNotFoundError(GamdlDownloaderError):
     def __init__(self, dependency_name: str) -> None:
         super().__init__(f"Required dependency not found: {dependency_name}")
-
-
-class GamdlDownloaderFlatFilterExcludedError(GamdlDownloaderError):
-    def __init__(self, media_id: str) -> None:
-        super().__init__(f"Media is excluded by flat filter: {media_id}")

{gamdl-3.1 → gamdl-3.2}/gamdl/interface/exceptions.py

@@ -38,5 +38,14 @@ class GamdlInterfaceUrlParseError(GamdlInterfaceError):
 
 
 class GamdlInterfaceArtistMediaTypeError(GamdlInterfaceError):
-    def __init__(self, media_type: str):
-        super().__init__(f"Artist has no media of type: {media_type}")
+    def __init__(self, media_id: str, media_type: str):
+        super().__init__(
+            f"Artist has no media of type (media ID: {media_id}): {media_type}"
+        )
+
+
+class GamdlInterfaceFlatFilterExcludedError(GamdlInterfaceError):
+    def __init__(self, media_id: str, result: Any):
+        super().__init__(f"Media excluded by flat filter: {media_id}")
+
+        self.result = result

gamdl-3.2/gamdl/interface/interface.py

@@ -0,0 +1,470 @@
+import asyncio
+from typing import Any, AsyncGenerator, Callable
+
+import structlog
+
+from ..utils import safe_gather
+from .constants import VALID_URL_PATTERN
+from .enums import ArtistMediaType
+from .exceptions import (
+    GamdlInterfaceMediaNotAllowedError,
+    GamdlInterfaceUrlParseError,
+    GamdlInterfaceArtistMediaTypeError,
+    GamdlInterfaceFlatFilterExcludedError,
+)
+from .music_video import AppleMusicMusicVideoInterface
+from .song import AppleMusicSongInterface
+from .types import AppleMusicMedia, AppleMusicUrlInfo
+from .uploaded_video import AppleMusicUploadedVideoInterface
+
+logger = structlog.get_logger(__name__)
+
+
+class AppleMusicInterface:
+    def __init__(
+        self,
+        song: AppleMusicSongInterface,
+        music_video: AppleMusicMusicVideoInterface,
+        uploaded_video: AppleMusicUploadedVideoInterface,
+        artist_select_media_type_function: (
+            Callable[[list[ArtistMediaType], dict], ArtistMediaType | None] | None
+        ) = None,
+        artist_select_items_function: (
+            Callable[[ArtistMediaType, list[dict]], list[dict] | None] | None
+        ) = None,
+        flat_filter_function: Callable[[dict], Any] | None = None,
+        concurrency: int = 1,
+        disallowed_media_types: list[str] | None = None,
+    ) -> None:
+        self.song = song
+        self.music_video = music_video
+        self.uploaded_video = uploaded_video
+        self.artist_select_media_type_function = artist_select_media_type_function
+        self.artist_select_items_function = artist_select_items_function
+        self.flat_filter_function = flat_filter_function
+        self.concurrency = concurrency
+        self.disallowed_media_types = disallowed_media_types
+
+        self.base = song.base
+
+    @staticmethod
+    def get_url_info(url: str) -> AppleMusicUrlInfo | None:
+        log = logger.bind(action="get_url_info", url=url)
+
+        match = VALID_URL_PATTERN.match(url)
+        if not match:
+            log.debug("invalid_url_pattern")
+
+            return None
+
+        url_match = AppleMusicUrlInfo(
+            **match.groupdict(),
+        )
+
+        log.debug("success", url_info=url_match)
+
+        return url_match
+
+    async def _run_flat_filter(self, media: AppleMusicMedia) -> None:
+        if not self.flat_filter_function or not media.partial:
+            return
+
+        result = self.flat_filter_function(media.media_metadata)
+        if asyncio.iscoroutine(result):
+            result = await result
+
+        if result:
+            raise GamdlInterfaceFlatFilterExcludedError(media.media_id, result)
+
+    def _run_media_type_filter(self, media: AppleMusicMedia) -> None:
+        if not self.disallowed_media_types or not media.partial:
+            return
+
+        if media.media_metadata["type"] in self.disallowed_media_types:
+            raise GamdlInterfaceMediaNotAllowedError(
+                media.media_metadata["type"],
+                media.media_id,
+            )
+
+    async def _collect_generator(
+        self, generator_or_coroutine: AsyncGenerator[AppleMusicMedia, None]
+    ) -> list[AppleMusicMedia]:
+        results = []
+        async for result in generator_or_coroutine:
+            results.append(result)
+        return results
+
+    async def _get_song_media(
+        self,
+        media_id: str,
+        index: int | None = None,
+        total: int | None = None,
+        media_metadata: dict | None = None,
+        playlist_metadata: dict | None = None,
+    ) -> AsyncGenerator[AppleMusicMedia, None]:
+        media = AppleMusicMedia(
+            media_id=media_id,
+        )
+
+        if index is not None:
+            media.index = index
+        if total is not None:
+            media.total = total
+
+        media.media_metadata = media_metadata
+        media.playlist_metadata = playlist_metadata
+
+        try:
+            async for media in self.song.get_media(media):
+                yield media
+
+                self._run_media_type_filter(media)
+                await self._run_flat_filter(media)
+        except Exception as e:
+            media.partial = False
+            media.error = e
+            yield media
+            return
+
+    async def _get_music_video_media(
+        self,
+        media_id: str,
+        index: int | None = None,
+        total: int | None = None,
+        media_metadata: dict | None = None,
+        playlist_metadata: dict | None = None,
+    ) -> AsyncGenerator[AppleMusicMedia, None]:
+        media = AppleMusicMedia(
+            media_id=media_id,
+        )
+
+        if index is not None:
+            media.index = index
+        if total is not None:
+            media.total = total
+
+        media.media_metadata = media_metadata
+        media.playlist_metadata = playlist_metadata
+
+        try:
+            async for media in self.music_video.get_media(media):
+                yield media
+
+                self._run_media_type_filter(media)
+                await self._run_flat_filter(media)
+        except Exception as e:
+            media.partial = False
+            media.error = e
+            yield media
+            return
+
+    async def _get_uploaded_video_media(
+        self,
+        media_id: str,
+    ) -> AsyncGenerator[AppleMusicMedia, None]:
+        media = AppleMusicMedia(
+            media_id=media_id,
+        )
+
+        try:
+            async for media in self.music_video.get_media(media):
+                yield
+
+                self._run_media_type_filter(media)
+                await self._run_flat_filter(media)
+        except Exception as e:
+            media.partial = False
+            media.error = e
+            yield media
+            return
+
+    async def _get_album_media(
+        self,
+        media_id: str,
+        is_library: bool = False,
+    ) -> AsyncGenerator[AppleMusicMedia, None]:
+        base_media = AppleMusicMedia(media_id)
+
+        try:
+            base_media.media_metadata = (
+                await self.base.apple_music_api.get_library_album(
+                    media_id,
+                )
+                if is_library
+                else await self.base.apple_music_api.get_album(
+                    media_id,
+                )
+            )["data"][0]
+
+            self._run_media_type_filter(base_media)
+            await self._run_flat_filter(base_media)
+        except Exception as e:
+            base_media.partial = False
+            base_media.error = e
+            yield base_media
+            return
+
+        yield base_media
+
+        tracks = base_media.media_metadata["relationships"]["tracks"]["data"]
+        tasks = [
+            (
+                self._get_song_media(
+                    media_id=track["id"],
+                    index=index,
+                    total=base_media.media_metadata["attributes"]["trackCount"],
+                    media_metadata=track,
+                )
+                if track["type"] in {"songs", "library-songs"}
+                else self._get_music_video_media(
+                    media_id=track["id"],
+                    index=index,
+                    total=base_media.media_metadata["attributes"]["trackCount"],
+                    media_metadata=track,
+                )
+            )
+            for index, track in enumerate(tracks)
+        ]
+
+        if self.concurrency == 1:
+            for task in tasks:
+                async for media in task:
+                    yield media
+        else:
+            collected_tasks = [self._collect_generator(task) for task in tasks]
+            batches = await safe_gather(*collected_tasks, limit=self.concurrency)
+            for batch in batches:
+                for media in batch:
+                    yield media
+
+    async def _get_playlist_media(
+        self,
+        media_id: str,
+        is_library: bool = False,
+    ) -> AsyncGenerator[AppleMusicMedia, None]:
+        base_media = AppleMusicMedia(media_id)
+
+        try:
+            base_media.media_metadata = (
+                await self.base.apple_music_api.get_library_playlist(
+                    media_id,
+                )
+                if is_library
+                else await self.base.apple_music_api.get_playlist(
+                    media_id,
+                )
+            )["data"][0]
+
+            self._run_media_type_filter(base_media)
+            await self._run_flat_filter(base_media)
+
+            tracks = base_media.media_metadata["relationships"]["tracks"]["data"]
+            next_uri = base_media.media_metadata["relationships"]["tracks"].get("next")
+            href_uri = base_media.media_metadata["relationships"]["tracks"].get("href")
+            while next_uri:
+                extended_data = await self.base.apple_music_api.get_extended_api_data(
+                    next_uri,
+                    href_uri,
+                )
+                tracks.extend(extended_data["data"])
+                next_uri = extended_data.get("next")
+        except Exception as e:
+            base_media.partial = False
+            base_media.error = e
+            yield base_media
+            return
+
+        yield base_media
+
+        tasks = [
+            (
+                self._get_song_media(
+                    media_id=track["id"],
+                    index=index,
+                    total=base_media.media_metadata["attributes"]["trackCount"],
+                    media_metadata=track,
+                    playlist_metadata=base_media.media_metadata,
+                )
+                if track["type"] in {"songs", "library-songs"}
+                else self._get_music_video_media(
+                    media_id=track["id"],
+                    index=index,
+                    total=base_media.media_metadata["attributes"]["trackCount"],
+                    media_metadata=track,
+                    playlist_metadata=base_media.media_metadata,
+                )
+            )
+            for index, track in enumerate(tracks)
+        ]
+
+        if self.concurrency == 1:
+            for task in tasks:
+                async for media in task:
+                    yield media
+        else:
+            collected_tasks = [self._collect_generator(task) for task in tasks]
+            batches = await safe_gather(*collected_tasks, limit=self.concurrency)
+            for batch in batches:
+                for media in batch:
+                    yield media
+
+    async def _get_artist_media(
+        self,
+        media_id: str,
+    ) -> AsyncGenerator[AppleMusicMedia, None]:
+        base_media = AppleMusicMedia(media_id)
+
+        try:
+            base_media.media_metadata = (
+                await self.base.apple_music_api.get_artist(
+                    media_id,
+                )
+            )["data"][0]
+
+            self._run_media_type_filter(base_media)
+            await self._run_flat_filter(base_media)
+
+            if self.artist_select_media_type_function:
+                artist_media_type = self.artist_select_media_type_function(
+                    list(ArtistMediaType),
+                    base_media.media_metadata,
+                )
+                if asyncio.iscoroutine(artist_media_type):
+                    artist_media_type = await artist_media_type
+            else:
+                artist_media_type = list(ArtistMediaType)[0]
+
+            relation_key, type_key = artist_media_type.path_key
+
+            items_relation = base_media.media_metadata.get(relation_key, {}).get(
+                type_key, {}
+            )
+            items = items_relation.get("data", [])
+            if not items:
+                raise GamdlInterfaceArtistMediaTypeError(
+                    base_media.media_id,
+                    str(artist_media_type),
+                )
+
+            next_uri = items_relation.get("next")
+            href_uri = items_relation.get("href")
+            while next_uri:
+                extended_data = await self.base.apple_music_api.get_extended_api_data(
+                    next_uri,
+                    href_uri,
+                )
+                items.extend(extended_data.get("data", []))
+                next_uri = extended_data.get("next")
+        except Exception as e:
+            yield AppleMusicMedia(
+                media_id=media_id,
+                media_metadata=None,
+                error=e,
+            )
+            return
+
+        yield base_media
+
+        if self.artist_select_items_function:
+            selected_items = self.artist_select_items_function(
+                artist_media_type,
+                items,
+            )
+            if asyncio.iscoroutine(selected_items):
+                selected_items = await selected_items
+        else:
+            selected_items = items[:1]
+
+        tasks = []
+        for index, item in enumerate(selected_items):
+            if item["type"] in {"songs", "library-songs"}:
+                tasks.append(
+                    self._get_song_media(
+                        media_id=item["id"],
+                        index=index,
+                        total=len(selected_items),
+                        media_metadata=item,
+                    )
+                )
+            elif item["type"] in {"albums", "library-albums"}:
+                tasks.append(
+                    self._get_album_media(
+                        media_id=item["id"],
+                    )
+                )
+            else:
+                tasks.append(
+                    self._get_music_video_media(
+                        media_id=item["id"],
+                        index=index,
+                        total=len(selected_items),
+                        media_metadata=item,
+                    )
+                )
+
+        if self.concurrency == 1:
+            for task in tasks:
+                async for media in task:
+                    yield media
+        else:
+            collected_tasks = [self._collect_generator(task) for task in tasks]
+            batches = await safe_gather(*collected_tasks, limit=self.concurrency)
+            for batch in batches:
+                for media in batch:
+                    yield media
+
+    async def get_media_from_url(
+        self,
+        url: str,
+    ) -> AsyncGenerator[AppleMusicMedia, None]:
+        url_info = self.get_url_info(url)
+
+        if not url_info:
+            raise GamdlInterfaceUrlParseError(url)
+
+        if self.disallowed_media_types and url_info.type in self.disallowed_media_types:
+            raise GamdlInterfaceMediaNotAllowedError(
+                url_info.type,
+            )
+
+        if url_info.type == "song" or url_info.sub_id:
+            async for media in self._get_song_media(
+                media_id=url_info.sub_id or url_info.id,
+                index=0,
+                total=1,
+            ):
+                yield media
+
+        elif url_info.type == "music-video":
+            async for media in self._get_music_video_media(
+                media_id=url_info.id,
+                index=0,
+                total=1,
+            ):
+                yield media
+
+        elif url_info.type == "album" or url_info.library_type == "albums":
+            async for media in self._get_album_media(
+                media_id=url_info.library_id or url_info.id,
+                is_library=bool(url_info.library_type),
+            ):
+                yield media
+
+        elif url_info.type == "playlist" or url_info.library_type == "playlist":
+            async for media in self._get_playlist_media(
+                media_id=url_info.library_id or url_info.id,
+                is_library=bool(url_info.library_type),
+            ):
+                yield media
+
+        elif url_info.type == "post":
+            async for media in self._get_uploaded_video_media(
+                media_id=url_info.id,
+            ):
+                yield media
+
+        elif url_info.type == "artist":
+            async for media in self._get_artist_media(
+                media_id=url_info.id,
+            ):
+                yield media

{gamdl-3.1 → gamdl-3.2}/gamdl/interface/music_video.py

@@ -1,6 +1,6 @@
 import asyncio
 import urllib.parse
-from typing import Callable
+from typing import AsyncGenerator, Callable
 
 import m3u8
 import structlog
@@ -378,35 +378,36 @@ class AppleMusicMusicVideoInterface:
 
     async def get_media(
         self,
-        music_video_metadata: dict,
-        playlist_metadata: dict | None = None,
-        playlist_track: dict | None = None,
-    ) -> AppleMusicMedia:
-        media = AppleMusicMedia(
-            media_id=self.base.parse_catalog_media_id(music_video_metadata),
-            media_metadata=music_video_metadata,
-        )
+        media: AppleMusicMedia,
+    ) -> AsyncGenerator[AppleMusicMedia, None]:
+        if not media.media_metadata:
+            media.media_metadata = (
+                await self.base.apple_music_api.get_music_video(media.media_id)
+            )["data"][0]
+
+        media.media_id = self.base.parse_catalog_media_id(media.media_metadata)
 
-        if not self.base.is_media_streamable(music_video_metadata):
+        yield media
+
+        if not self.base.is_media_streamable(media.media_metadata):
             raise GamdlInterfaceMediaNotStreamableError(media.media_id)
 
-        if playlist_metadata and playlist_track:
-            media.playlist_metadata = playlist_metadata
+        if media.playlist_metadata:
             media.playlist_tags = self.base.get_playlist_tags(
-                playlist_metadata,
-                playlist_track,
+                media.playlist_metadata,
+                media.index,
             )
 
-        media.cover = await self.base.get_cover(music_video_metadata)
+        media.cover = await self.base.get_cover(media.media_metadata)
 
-        itunes_page_metadata = await self.get_itunes_page_metadata(music_video_metadata)
+        itunes_page_metadata = await self.get_itunes_page_metadata(media.media_metadata)
         media.tags = await self.get_tags(
-            music_video_metadata,
+            media.media_metadata,
             itunes_page_metadata,
         )
 
         media.stream_info = await self.get_stream_info(
-            music_video_metadata,
+            media.media_metadata,
             itunes_page_metadata,
         )
         if not media.stream_info:
@@ -423,4 +424,6 @@ class AppleMusicMusicVideoInterface:
 
         media.decryption_key = await self.get_decryption_key(media.stream_info)
 
-        return media
+        media.partial = False
+
+        yield media