spots-cli 0.1.0__py3-none-any.whl

spots_cli/__init__.py

@@ -0,0 +1,125 @@
+from logging import getLogger
+from os.path import exists
+
+from .bootstrap.container import Container
+from .models import (
+    MediaResourceSingle,
+    SongNotFound,
+    TitleExistsError,
+    InvalidSearchFormat,
+    InvalidURL,
+)
+
+logger = getLogger(__name__)
+
+
+class Spots:
+    def __init__(self):
+        from spots_cli.setup_env import main as setup, FILENAME as setup_file
+
+        if not exists(setup_file):
+            setup()
+
+        self.container = Container()
+        self.downloader = self.container.app.downloader
+
+    def download(self, query: str):
+        """Downloads a song
+
+        Args:
+            query (str): The query to be downloaded. Can be either a query to be searched for, or a direct Spotify or YouTube download url.
+        """
+        # handle direct link
+        if "https://" in query:
+            logger.info(f"Processing url: {query}")
+            try:
+                resolved_url = self.container.app.resolver.resolve(url=query)
+            except InvalidURL as e:
+                logger.info(e)
+                return
+
+            # handle single
+            if isinstance(resolved_url, MediaResourceSingle):
+                try:
+                    logger.info(f"{query} found, downloading now...")
+                    self.downloader.download(
+                        video_info=resolved_url.video_info,
+                        metadata=resolved_url.metadata,
+                    )
+                    self.container.core.storage.save()
+                except (TitleExistsError, SongNotFound) as e:
+                    logger.info(e)
+                    return
+            else:
+                playlist_info = resolved_url.playlist_info
+                playlist_songs = zip(
+                    playlist_info.provider_metadata, playlist_info.youtube_metadata
+                )
+
+                for index, [provider, youtube] in enumerate(playlist_songs):
+                    logger.info(
+                        f"Processing song: {index + 1}/{len(playlist_info.provider_metadata)}"
+                    )
+                    try:
+                        self.downloader.download(video_info=youtube, metadata=provider)
+                    except (SongNotFound, TitleExistsError) as e:
+                        logger.info(e)
+                        continue
+                self.container.core.storage.save()
+        # search query
+        else:
+            try:
+                logger.info(f"Searching for {query}...")
+                provider_result = self.container.domain.provider_search.search_track(
+                    query
+                )
+            except SongNotFound:
+                logger.debug(
+                    "Query not found by provider, falling back to YouTube video details."
+                )
+                provider_result = None
+            except InvalidSearchFormat as e:
+                logger.error(e)
+                return
+
+            search_result = self.container.domain.youtube_search.video_search(
+                query=query, is_general_search=True
+            )
+
+            if search_result.is_cached:
+                best_match = search_result.result[0]
+            else:
+                best_match = (
+                    self.container.core.matcher.find_best_match(
+                        search_results=search_result.result, metadata=provider_result
+                    )
+                    if provider_result
+                    else search_result.result[0]
+                )
+
+            metadata = (
+                provider_result
+                if provider_result
+                else self.container.domain.youtube_metadata.get(best_match)
+            )
+
+            try:
+                logger.info(f"{query} found, downloading now...")
+                self.downloader.download(video_info=best_match, metadata=metadata)
+            except (SongNotFound, TitleExistsError) as e:
+                logger.info(e)
+
+            self.container.core.storage.new(
+                query=query, result=best_match, query_type="youtube"
+            )
+            self.container.core.storage.save()
+
+    def transfer_spotify_likes(self):
+        """Transfers all spotify likes to YouTube library"""
+        try:
+            self.container.app.youtube_user_playlist.transfer_spotify_likes_to_yt()
+        except SongNotFound:
+            logger.info("No liked songs found.")
+
+
+__all__ = ["Spots"]

spots_cli/app/__init__.py

@@ -0,0 +1,5 @@
+from spots_cli.app.media_resolver import MediaResolver
+from spots_cli.app.downloader import Downloader
+from spots_cli.app.youtube_user_playlist import YouTubeUserPlaylist
+from spots_cli.app.spotify_playlist_compilation import SpotifyPlaylistCompilation
+from spots_cli.app.domain_resolver import DomainResolver

spots_cli/app/domain_resolver.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Sequence, overload
+
+from spots_cli.models import Metadata, SongNotFound, Sentinel, YTVideoInfo
+
+if TYPE_CHECKING:
+    from spots_cli.bootstrap.container import Core
+    from spots_cli.models import SearchProvider
+    from spots_cli.services import YoutubeSearchService
+
+
+@dataclass
+class MatchingDomainResults:
+    provider: list[Metadata]
+    youtube: list[YTVideoInfo]
+
+
+@dataclass
+class ResolvedDomainResult:
+    provider: Metadata
+    youtube: YTVideoInfo
+
+
+class DomainResolver:
+    def __init__(
+        self,
+        core: Core,
+        provider_search: SearchProvider,
+        youtube_search: YoutubeSearchService,
+    ) -> None:
+        self.core = core
+        self.provider_search = provider_search
+        self.youtube_search = youtube_search
+
+    @overload
+    def filter_matching_domain_results(
+        self,
+        *,
+        provider_results: Sequence[Metadata | Sentinel],
+        youtube_results: None = None,
+    ) -> MatchingDomainResults: ...
+
+    @overload
+    def filter_matching_domain_results(
+        self,
+        *,
+        provider_results: None = None,
+        youtube_results: Sequence[YTVideoInfo | Sentinel],
+    ) -> MatchingDomainResults: ...
+
+    def filter_matching_domain_results(
+        self,
+        *,
+        provider_results: Sequence[Metadata | Sentinel] | None = None,
+        youtube_results: Sequence[YTVideoInfo | Sentinel] | None = None,
+    ) -> MatchingDomainResults:
+        provider_playlist: list[Metadata] = []
+        youtube_videos: list[YTVideoInfo] = []
+
+        if youtube_results is not None:
+            for index, video in enumerate(youtube_results):
+                if isinstance(video, Sentinel):
+                    continue
+
+                video_title = video.full_title
+
+                try:
+                    spotify_search_result = self.provider_search.search_track(
+                        video_title
+                    )
+                except SongNotFound:
+                    self.core.storage.new(
+                        query=video_title, result=Sentinel(), query_type="metadata"
+                    )
+                    self.core.storage.new(
+                        query=video_title, result=Sentinel(), query_type="youtube"
+                    )
+                    continue
+
+                tracks_match = self.core.matcher.match_tracks(
+                    video_info=video, metadata=spotify_search_result
+                )
+                if not tracks_match:
+                    self.core.storage.new(
+                        query=video_title, result=Sentinel(), query_type="metadata"
+                    )
+                    self.core.storage.new(
+                        query=video_title, result=Sentinel(), query_type="youtube"
+                    )
+                    continue
+                else:
+                    self.core.storage.new(
+                        query=video_title,
+                        result=spotify_search_result,
+                        query_type="metadata",
+                    )
+                    self.core.storage.new(
+                        query=video_title, result=video, query_type="youtube"
+                    )
+                    provider_playlist.append(spotify_search_result)
+                    youtube_videos.append(video)
+
+                if (index % 10 == 0) or index == (len(youtube_results) - 1):
+                    self.core.storage.save()
+
+        if provider_results is not None:
+            for track in provider_results:
+                if isinstance(track, Sentinel):
+                    continue
+
+                provider_title = track.full_title
+
+                try:
+                    youtube_search_results = self.youtube_search.video_search(
+                        query=provider_title, is_general_search=True
+                    )
+                except SongNotFound:
+                    self.core.storage.new(
+                        query=provider_title, result=Sentinel(), query_type="metadata"
+                    )
+                    self.core.storage.new(
+                        query=provider_title, result=Sentinel(), query_type="youtube"
+                    )
+                    continue
+
+                if youtube_search_results.is_cached:
+                    cache = youtube_search_results.result[0]
+                    if isinstance(cache, Sentinel):
+                        continue
+                    else:
+                        provider_playlist.append(track)
+                        youtube_videos.append(cache)
+
+                else:
+                    try:
+                        best_match = self.core.matcher.find_best_match(
+                            search_results=youtube_search_results.result, metadata=track
+                        )
+                    except SongNotFound:
+                        self.core.storage.new(
+                            query=provider_title,
+                            result=Sentinel(),
+                            query_type="metadata",
+                        )
+                        self.core.storage.new(
+                            query=provider_title,
+                            result=Sentinel(),
+                            query_type="youtube",
+                        )
+                        continue
+
+                    provider_playlist.append(track)
+                    youtube_videos.append(best_match)
+
+        return MatchingDomainResults(provider=provider_playlist, youtube=youtube_videos)

spots_cli/app/downloader.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from hashlib import md5
+from os.path import join, exists
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from spots_cli.models import TitleExistsError, Metadata, YTVideoInfo
+
+if TYPE_CHECKING:
+    from spots_cli.bootstrap.container import Core, Clients
+
+
+class Downloader:
+    """A service for interacting with YouTube."""
+
+    def __init__(self, *, core: Core, clients: Clients):
+        self.core = core
+        self.clients = clients
+
+    def download(
+        self, *, video_info: YTVideoInfo, metadata: Metadata, directory_path: str = ""
+    ) -> bool:
+        """Downloads a YouTube video as mp3
+
+        Args:
+            video_info (YTVideoInfo): the extracted info.
+            directory_path (str, Optional): the folder to be downloaded to. Defaults to the root of the Music folder.
+
+        Returns:
+            bool: True if downloaded successfully.
+        """
+        url = "https://youtube.com/watch?v=" + video_info.id
+        title = f"{video_info.uploader} - {video_info.title}"
+
+        # normalize title
+        # '/' will read file name as folder in *nix systems
+        filename = title.replace("/", "|")
+        # Check if the file name length is too long, truncate if necessary
+        max_filename_length = 255  # Maximum allowed file name length on most systems
+        if len(filename) > max_filename_length:
+            file_hash = md5(filename.encode()).hexdigest()
+            filename = file_hash[:25]
+
+        # check if downloaded already
+        if self.core.history.read(filename):
+            raise TitleExistsError(filename)
+
+        download_folder = Path.home() / "Downloads"
+        download_folder = download_folder if exists(download_folder) else Path.home()
+
+        download_path = join(
+            download_folder, directory_path, f"{filename}.{video_info.audio_ext}"
+        )
+        converted_path = join(download_folder, directory_path, f"{filename}.mp3")
+
+        # set template for download titles
+        self.clients.ytdlp.options = {"outtmpl": download_path}
+
+        # download video
+        self.clients.ytdlp.client.download([url])
+
+        self.clients.ytdlp.reset_options()
+
+        # post download processing
+        converted = self.core.converter.convert_to_mp3(
+            old_file=download_path, new_file=converted_path
+        )
+        if converted:
+            metadata_updated = self.core.converter.update_metadata(
+                audio_path=converted_path, metadata=metadata
+            )
+            if metadata_updated:
+                self.core.history.write(filename)
+        else:
+            return False
+
+        return True

spots_cli/app/media_resolver.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from logging import getLogger
+from os.path import join
+from tenacity import stop_after_delay
+from typing import TYPE_CHECKING, Any, cast
+
+from spots_cli.engine import retry
+from spots_cli.models import (
+    InvalidURL,
+    SongNotFound,
+    MediaResourceSingle,
+    MediaResourcePlaylist,
+    PlaylistInfo,
+    Sentinel,
+    YTVideoInfo,
+)
+
+if TYPE_CHECKING:
+    from spots_cli.bootstrap.container import Core, Domain, Clients
+    from spots_cli.app import DomainResolver
+
+
+logger = getLogger(__name__)
+
+
+class MediaResolver:
+    def __init__(
+        self,
+        core: Core,
+        domain: Domain,
+        clients: Clients,
+        domain_resolver: DomainResolver,
+    ) -> None:
+        self.domain_resolver = domain_resolver
+        self.core = core
+        self.domain = domain
+        self.clients = clients
+
+    @retry(stop=stop_after_delay(60))
+    def resolve(self, *, url: str) -> MediaResourceSingle | MediaResourcePlaylist:
+        """Converts a youtube or spotify url to mp3, or a youtube video to mp3
+
+        Args:
+            url (str): url to be converted
+            single: (bool, optional): don't search for recommended tracks if false. Defaults to False
+
+        Raises:
+            InvalidURL: if provided url not available
+        """
+        # process spotify link
+        if "spotify" in url:
+            # single
+            if "track" in url:
+                # retrieve Spotify data
+                logger.debug("Resource type: single")
+
+                track_id = url.split("/")[-1]
+                metadata = self.domain.provider_metadata.get(track_id=track_id)
+
+                # search on YouTube
+                youtube_results = self.domain.youtube_search.video_search(
+                    query=metadata.full_title, is_general_search=True
+                )
+                best_match = self.core.matcher.find_best_match(
+                    search_results=youtube_results.result, metadata=metadata
+                )
+
+                return MediaResourceSingle(
+                    resource_type="single",
+                    metadata=metadata,
+                    video_info=best_match,
+                )
+            # playlist
+            else:
+                logger.debug("Resource type: playlist")
+                playlist_info = self.domain.provider_search.search_playlist(url)
+
+                return MediaResourcePlaylist(
+                    resource_type="playlist", playlist_info=playlist_info
+                )
+
+        # process youtube link
+        elif "youtu" in url:
+            logger.debug("URL type: YouTube")
+            # playlist
+            if "playlist" in url:
+                logger.debug("Resource type: playlist")
+                playlist_search = self.clients.ytdlp.client.extract_info(
+                    url, download=False
+                )
+
+                if not playlist_search:
+                    raise SongNotFound(url)
+
+                playlist_search = cast(dict[str, Any], playlist_search)
+
+                videos_list = [
+                    YTVideoInfo(
+                        id=result["id"],
+                        filesize=self.domain.youtube_search.get_video_size(result),
+                        title=result["title"],
+                        uploader=result["uploader"],
+                        audio_ext=result["audio_ext"],
+                    )
+                    for result in playlist_search["entries"]
+                ]
+
+                domain_matches = self.domain_resolver.filter_matching_domain_results(
+                    youtube_results=videos_list
+                )
+
+                cover = self.clients.secrets.read(
+                    key="static_playlist_cover_name", alt="youtube-playlist.jpg"
+                )
+                playlist_name = playlist_search["title"]
+
+                playlist_info = PlaylistInfo(
+                    name=playlist_name,
+                    cover=cover,
+                    provider_metadata=domain_matches.provider,
+                    youtube_metadata=domain_matches.youtube,
+                )
+
+                return MediaResourcePlaylist(
+                    resource_type="playlist", playlist_info=playlist_info
+                )
+            else:
+                logger.debug("Resource type: single")
+
+                video_info = self.domain.youtube_search.video_search(
+                    query=url, is_general_search=False
+                )
+                if video_info.is_cached:
+                    cached_metadata = self.core.storage.get(
+                        query=url, query_type="metadata"
+                    )
+                    return MediaResourceSingle(
+                        resource_type="single",
+                        metadata=cached_metadata,
+                        video_info=video_info.result,
+                    )
+
+                yt_title = video_info.result.full_title
+                try:
+                    metadata = self.domain.provider_search.search_track(yt_title)
+                except SongNotFound:
+                    self.core.storage.new(
+                        query=yt_title, result=Sentinel(), query_type="metadata"
+                    )
+                    self.core.storage.new(
+                        query=yt_title, result=Sentinel(), query_type="youtube"
+                    )
+                    raise
+
+                tracks_match = self.core.matcher.match_tracks(
+                    metadata=metadata, video_info=video_info.result
+                )
+                if not tracks_match:
+                    self.core.storage.new(
+                        query=yt_title, result=Sentinel(), query_type="metadata"
+                    )
+                    self.core.storage.new(
+                        query=yt_title, result=Sentinel(), query_type="youtube"
+                    )
+                    raise SongNotFound(yt_title)
+                else:
+                    self.core.storage.new(
+                        query=yt_title, result=metadata, query_type="metadata"
+                    )
+                    self.core.storage.new(
+                        query=yt_title, result=video_info.result, query_type="youtube"
+                    )
+                    return MediaResourceSingle(
+                        resource_type="single",
+                        metadata=metadata,
+                        video_info=video_info.result,
+                    )
+        else:
+            raise InvalidURL(url)