spots-cli 0.1.0__py3-none-any.whl

spots_cli/services/spotify_metadata_service.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from datetime import datetime
+from logging import getLogger
+from spotipy.exceptions import SpotifyException
+from typing import Any, overload, TYPE_CHECKING
+
+from spots_cli.engine import storage
+from spots_cli.models import (
+    SongNotFound,
+    Metadata,
+    Sentinel,
+    MetadataProvider,
+    SpotifyUnavailableError,
+)
+
+if TYPE_CHECKING:
+    from spots_cli.bootstrap.container import Core, Clients
+    from spots_cli.clients import SpotifyClient
+
+
+logger = getLogger(__name__)
+
+
+class SpotifyMetadataService(MetadataProvider):
+    def __init__(
+        self,
+        *,
+        clients: Clients,
+        core: Core,
+    ):
+        self.clients = clients
+        self.core = core
+
+    def _spotify(self) -> SpotifyClient:
+        if not self.clients.spotify:
+            raise SpotifyUnavailableError(
+                "Spotify client is not configured. Enable Spotify features in your environment."
+            )
+        return self.clients.spotify
+
+    @overload
+    def get(self, *, track_id: str, search_result: None = None) -> Metadata: ...
+
+    @overload
+    def get(
+        self, *, track_id: None = None, search_result: dict[str, Any]
+    ) -> Metadata: ...
+
+    def get(
+        self,
+        *,
+        track_id: str | None = None,
+        search_result: dict[str, Any] | None = None,
+    ) -> Metadata:
+        logger.debug("Searching for metadata on Spotify...")
+
+        if track_id is not None:
+            query_id = track_id
+        if search_result is not None:
+            query_id = search_result["id"]
+        else:
+            raise ValueError("Either track_id or search_result must be provided")
+
+        # check cache first
+        url = "https://open.spotify.com/track/" + query_id
+        cache = storage.get(query=url, query_type="metadata")
+        if isinstance(cache, Sentinel):
+            raise SongNotFound(query_id)
+        elif isinstance(cache, Metadata):
+            return cache
+
+        # search song if id provided
+        if track_id is not None:
+            try:
+                # retrieve track from spotify
+                track = self._spotify().client.track(track_id)
+
+            except SpotifyException as e:
+                if e.http_status == 401:
+                    if "Invalid access token" in e.msg:
+                        raise RuntimeError("Authentication Failed") from e
+                    else:
+                        self._spotify().signin()
+                        track = self._spotify().client.track(track_id)
+                else:
+                    logger.error(
+                        f"Unexpected error occurred when retrieving Spotify metadata"
+                    )
+                    raise RuntimeError("Unhandled error in get") from e
+
+            if not track:
+                storage.new(query=url, result=Sentinel(), query_type="metadata")
+                raise SongNotFound(f"Spotify id: {track_id}")
+        elif search_result is not None:
+            track = search_result
+
+        album = track["album"]
+
+        # get track number
+        total_track = album["total_tracks"]
+        track_position = track["track_number"]
+        track_number = f"{track_position}/{total_track}"
+
+        # cover image
+        cover = album["images"][0]["url"]
+
+        # get release date
+        try:
+            release_date_str = album["release_date"]
+            release_date_obj = datetime.strptime(release_date_str, "%Y-%m-%d")
+            # release_date = release_date_obj.strftime("%Y")
+            release_date = release_date_obj.strftime("%Y-%m-%d")
+        except ValueError:
+            release_date = None
+
+        # get track name and artist
+        track_name = track["name"]
+
+        # artists
+        artist_list = [artist["name"] for artist in track["artists"]]
+        # remove featured artists from artists list
+        for artist in artist_list:
+            if artist.lower() in track_name.lower():
+                artist_list.remove(artist)
+
+        artist = ", ".join(artist_list)
+
+        track_url = track["external_urls"]["spotify"]
+        album_name = album["name"]
+
+        # get track lyrics
+        lyrics = self.core.lyrics.get_lyrics(title=track_name, artist=artist)
+
+        preview_url = track["preview_url"] or ""
+
+        first_artist = track["artists"][0]
+        metadata = Metadata(
+            track_name,
+            artist_id=first_artist["id"],
+            artist=artist,
+            link=track_url,
+            cover=cover,
+            tracknumber=track_number,
+            album=album_name,
+            lyrics=lyrics,
+            release_date=release_date,
+            preview_url=preview_url,
+        )
+
+        return metadata

spots_cli/services/spotify_search_service.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+from logging import getLogger
+from re import escape, search
+from tenacity import stop_after_delay
+from typing import Any, TYPE_CHECKING
+
+from spots_cli.engine import retry
+from spots_cli.models import (
+    SongNotFound,
+    Metadata,
+    PlaylistInfo,
+    SearchProvider,
+    Sentinel,
+    ArtistInfo,
+    SpotifyUnavailableError,
+    InvalidSearchFormat,
+)
+from spots_cli.utils import search_fallbacks
+
+if TYPE_CHECKING:
+    from spotipy import Spotify
+    from spots_cli.bootstrap.container import Clients, Core
+    from spots_cli.models import MetadataProvider
+
+
+logger = getLogger(__name__)
+
+
+class SpotifySearchService(SearchProvider):
+    def __init__(
+        self,
+        *,
+        metadata: MetadataProvider,
+        clients: Clients,
+        core: Core,
+        fallback_providers: list[SearchProvider] = [],
+    ):
+        self.fallback_providers = fallback_providers
+        self.clients = clients
+        self.core = core
+        self.metadata = metadata
+
+    def _spotify(self) -> Spotify:
+        if not self.clients.spotify:
+            raise SpotifyUnavailableError(
+                "Spotify client is not configured. Enable Spotify features in your environment."
+            )
+        return self.clients.spotify.client
+
+    def search_artist(self, artist_query: str) -> ArtistInfo:
+        artist_url = "https://open.spotify.com/artist/"
+        artist_id = ""
+
+        # get artist by id
+        if artist_url in artist_query:
+            artist_id = artist_query.replace(artist_url, "").split("?")[0]
+            result = self._spotify().artist(artist_id)
+
+            if not result:
+                raise SongNotFound(artist_query)
+
+        else:
+            # search for the artist
+            result = self._spotify().search(artist_query, 1, type="artist")
+
+            if not result:
+                raise SongNotFound(artist_query)
+
+            result = result["artists"]["items"][0]
+
+        return result
+
+    def search_artist_top_tracks(self, *, artist_id: str) -> PlaylistInfo:
+        artist_details = self._spotify().artist(artist_id)
+        if not artist_details:
+            raise SongNotFound(artist_id)
+
+        artist_name = artist_details["name"]
+        artist_cover = artist_details["images"][0]["url"]
+
+        top_tracks_search = self._spotify().artist_top_tracks(artist_id)
+        if not top_tracks_search:
+            raise SongNotFound(artist_id)
+
+        # get metadata for each top track
+        top_tracks_playlist = [
+            self.metadata.get(track_id=top_track["id"])
+            for top_track in top_tracks_search["tracks"]
+        ]
+
+        return PlaylistInfo(
+            cover=artist_cover,
+            name="Top Tracks",
+            artist=artist_name,
+            provider_metadata=top_tracks_playlist,
+            youtube_metadata=[],
+        )
+
+    def search_playlist(self, playlist_url: str) -> PlaylistInfo:
+        playlist_result = self._spotify().playlist(playlist_url)
+
+        if not playlist_result:
+            raise SongNotFound(playlist_url)
+
+        # get playlist tracks
+        playlist_tracks: list[dict[str, Any]] = playlist_result["tracks"]["items"]
+
+        playlist_metadata = [
+            self.metadata.get(search_result=track) for track in playlist_tracks
+        ]
+
+        cover = playlist_result["images"][0]["url"]
+        playlist_name = playlist_result["name"]
+        artist = None
+
+        return PlaylistInfo(
+            cover=cover,
+            artist=artist,
+            name=playlist_name,
+            provider_metadata=playlist_metadata,
+            youtube_metadata=[],
+        )
+
+    def search_album(self, album_url: str) -> PlaylistInfo:
+        album_result = self._spotify().album(album_url)
+        if not album_result:
+            raise SongNotFound(album_url)
+
+        # artists
+        artist_list = [artist["name"] for artist in album_result["artists"]]
+
+        # get album tracks
+        playlist_tracks: list[dict[str, Any]] = album_result["tracks"]["items"]
+
+        playlist_metadata = [
+            self.metadata.get(search_result=track) for track in playlist_tracks
+        ]
+
+        cover = album_result["images"][0]["url"]
+        album_name = album_result["name"]
+        artist = ", ".join(artist_list)
+
+        return PlaylistInfo(
+            cover=cover,
+            artist=artist,
+            name=album_name,
+            provider_metadata=playlist_metadata,
+            youtube_metadata=[],
+        )
+
+    @retry(stop=stop_after_delay(60))
+    def search_track(self, query: str) -> Metadata:
+        """Searches for a title on spotify
+
+        Args:
+            query (str): the title to be searched for
+
+        Raises:
+            SongNotFound: the `query` is not found on spotify.
+            InvalidSearchFormat: if query format not: `Artist - Title`
+
+        Returns:
+            Metadata: The metadata of the title.
+        """
+        query = query.replace("–", "-")  # `–` != `-`
+
+        if "-" not in query:
+            error_txt = "Search format: `Artist` - `Title`"
+            logger.error(error_txt)
+            raise InvalidSearchFormat()
+
+        cache = self.core.storage.get(query=query, query_type="metadata")
+        if isinstance(cache, Sentinel):
+            raise SongNotFound(query)
+        elif isinstance(cache, Metadata):
+            return cache
+
+        # search for a single
+        single_result = self._spotify().search(query)
+
+        if not single_result:
+            return search_fallbacks(query=query, providers=self.fallback_providers)
+
+        try:
+            track_id = single_result["tracks"]["items"][0]["id"]
+        except IndexError:
+            raise SongNotFound(query)
+
+        single_data = self.metadata.get(track_id=track_id)
+
+        # get query artist
+        query_artist = query.split(" - ")[0].lower()
+        result_artist = single_data.artist.lower()
+        if len(query_artist) < len(result_artist):
+            artist_match = search(escape(query_artist), result_artist)
+        else:
+            artist_match = search(escape(result_artist), query_artist)
+
+        # if search result does not match query
+        # then query may be a single album
+        if not artist_match and not search(single_data.title.lower(), query.lower()):
+            logger.info("Searching for album version...")
+            # get album id of first result
+            results = self._spotify().search(query, type="album")
+
+            if not results:
+                logger.info(f"{query} not found")
+                return search_fallbacks(query=query, providers=self.fallback_providers)
+
+            try:
+                album_id = results["albums"]["items"][0]["id"]
+            except IndexError:
+                return search_fallbacks(query=query, providers=self.fallback_providers)
+
+            # get album search function
+            album_url = "https://open.spotify.com/album/" + album_id
+            album = self._spotify().album(album_url)
+
+            if not album:
+                logger.info(f"{query} not found")
+                return search_fallbacks(query=query, providers=self.fallback_providers)
+
+            # get id of first result
+            track_id = album["tracks"]["items"][0]["id"]
+
+            return self.metadata.get(track_id=track_id)
+
+        return single_data

spots_cli/services/youtube_metadata_service.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from logging import getLogger
+from typing import TYPE_CHECKING
+
+from spots_cli.models import YTVideoInfo, Metadata, SongNotFound
+
+if TYPE_CHECKING:
+    from spots_cli.bootstrap.container import Core, Clients
+    from spots_cli.models import SearchProvider
+
+
+logger = getLogger(__name__)
+
+
+class YouTubeMetadataService:
+
+    def __init__(self, search: SearchProvider, core: Core, clients: Clients):
+        self.core = core
+        self.clients = clients
+        self.search = search
+
+    def get(self, video_info: YTVideoInfo) -> Metadata:
+        """Retrieves the metadata for a video
+
+        Args:
+            video_info (YTVideoInfo): The youtube video info.
+
+        Returns:
+            Metadata: the metadata of youtube song
+        """
+        logger.debug(f"Retrieving metadata for YouTube video: {video_info.title}")
+
+        # get cover from static folder
+        cover = self.clients.secrets.read(
+            key="static_cover_name", alt="single-cover.jpg"
+        )
+
+        search_title = video_info.full_title
+        youtube_url = f"https://youtube.com/watch?v={video_info.id}"
+
+        try:
+            logger.info("Searching for metadata from Provider")
+            search_result = self.search.search_track(search_title)
+        except SongNotFound:
+            spotify_title = self.core.extractor.remove_odd_keywords(video_info.title)
+            spotify_artist = self.core.extractor.remove_odd_keywords(
+                video_info.uploader
+            )
+            return Metadata(
+                title=spotify_title,
+                artist=spotify_artist,
+                link=youtube_url,
+                cover=cover,
+                artist_id="",
+            )
+
+        metadata = search_result
+
+        tracks_match = self.core.matcher.match_tracks(
+            video_info=video_info, metadata=metadata
+        )
+
+        if tracks_match:
+            return metadata
+        else:
+            return Metadata(
+                title=video_info.title,
+                artist=video_info.uploader,
+                link=youtube_url,
+                cover=cover,
+                artist_id="",
+            )

spots_cli/services/youtube_search_service.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from logging import getLogger
+from math import ceil
+from tenacity import stop_after_delay
+from typing import Any, Literal, cast, overload, TYPE_CHECKING
+
+from spots_cli.engine import retry
+from spots_cli.models import (
+    SongNotFound,
+    SearchResponseSingle,
+    SearchResponseMultiple,
+    PlaylistInfo,
+    Sentinel,
+    YTVideoInfo,
+)
+
+if TYPE_CHECKING:
+    from yt_dlp import _Params
+    from spots_cli.bootstrap.container import Clients, Core
+
+
+logger = getLogger(__name__)
+
+
+class YoutubeSearchService:
+    """Responsible for searching for query on YouTube"""
+
+    def __init__(self, *, clients: Clients, core: Core):
+        self.clients = clients
+        self.core = core
+
+    def get_video_size(self, data: dict[str, Any]) -> int:
+        size = data.get("filesize") or data.get("filesize_approx")
+        return ceil(size / (1024 * 1024)) if size else 0
+
+    def youtube_playlist_search(self, link: str) -> PlaylistInfo:
+        playlist_opts: _Params = {
+            "quiet": True,
+            "extract_flat": True,
+            "playlistend": None,  # Extract full playlist,
+        }
+        self.clients.ytdlp.options = playlist_opts
+
+        try:
+            playlist_search = self.clients.ytdlp.client.extract_info(
+                link, download=False
+            )
+        except Exception as e:
+            logger.error(str(e))
+            raise
+
+        if not playlist_search:
+            raise SongNotFound(link)
+
+        playlist_search = cast(dict[str, Any], playlist_search)
+        playlist_name = playlist_search["title"]
+        playlist_cover = "youtube-playlist(mdesigns).jpg"
+
+        videos_list = [
+            YTVideoInfo(
+                title=result["title"],
+                uploader=result["uploader"],
+                filesize=self.get_video_size(result),
+                audio_ext=result["audio_ext"],
+                id=result["id"],
+            )
+            for result in playlist_search["entries"]
+        ]
+
+        self.clients.ytdlp.reset_options()
+
+        return PlaylistInfo(
+            name=playlist_name,
+            cover=playlist_cover,
+            youtube_metadata=videos_list,
+            provider_metadata=[],
+        )
+
+    @overload
+    def video_search(
+        self, *, query: str, is_general_search: Literal[False]
+    ) -> SearchResponseSingle: ...
+
+    @overload
+    def video_search(
+        self, *, query: str, is_general_search: Literal[True] = True
+    ) -> SearchResponseMultiple: ...
+
+    @retry(stop=stop_after_delay(60))
+    def video_search(
+        self, *, query, is_general_search=True
+    ) -> SearchResponseSingle | SearchResponseMultiple:
+        cache = self.core.storage.get(query=query, query_type="youtube")
+        if isinstance(cache, Sentinel):
+            raise SongNotFound(query)
+        elif isinstance(cache, YTVideoInfo):
+            return (
+                SearchResponseSingle(result=cache, is_cached=True)
+                if not is_general_search
+                else SearchResponseMultiple(result=[cache], is_cached=True)
+            )
+        else:
+            search_term = f"ytsearch5:{query}" if is_general_search else query
+            search_result = self.clients.ytdlp.client.extract_info(
+                search_term, download=False
+            )
+
+            if not search_result:
+                self.core.storage.new(
+                    query=query, result=Sentinel(), query_type="youtube"
+                )
+                raise SongNotFound(query)
+
+            if is_general_search and not search_result.get("entries"):
+                self.core.storage.new(
+                    query=query, result=Sentinel(), query_type="youtube"
+                )
+                raise SongNotFound(query)
+
+            search_result = cast(dict[str, Any], search_result)
+
+            if not is_general_search:
+
+                return SearchResponseSingle(
+                    result=YTVideoInfo(
+                        title=search_result["title"],
+                        uploader=search_result["uploader"],
+                        id=search_result["id"],
+                        filesize=self.get_video_size(search_result),
+                        audio_ext=search_result.get("audio_ext", "webm"),
+                    ),
+                    is_cached=False,
+                )
+            else:
+                result_objects: list[YTVideoInfo] = []
+                for result in search_result["entries"]:
+                    result_objects.append(
+                        YTVideoInfo(
+                            title=result["title"],
+                            uploader=result["uploader"],
+                            id=result["id"],
+                            filesize=self.get_video_size(result),
+                            audio_ext=result.get("audio_ext", "webm"),
+                        )
+                    )
+
+                return SearchResponseMultiple(result=result_objects, is_cached=False)
+
+    def artist_search(self, artist: str):
+        """
+        Search for for all videos by an artist name on youtube
+
+        Args:
+            artist (str): The name of the artist
+            default_cover (str): Fallback cover url
+
+        Returns:
+            List[Metadata]: A list of songs by `artist` found on YT
+        """
+        logger.info(f"[Search Artist on YouTube] Searching for {artist}'s songs on YT")
+
+        ydl_opts: _Params = {
+            "quiet": True,
+            "extract_flat": True,
+        }
+
+        self.clients.ytdlp.options = ydl_opts
+        search_results = self.clients.ytdlp.client.extract_info(artist, download=False)
+
+        if not search_results:
+            raise SongNotFound(artist)
+
+        video_record: dict[str, YTVideoInfo] = {}
+
+        search_results = cast(dict[str, Any], search_results)
+
+        playlist_len = len(search_results["entries"])
+        for index, entry in enumerate(search_results["entries"]):
+            logger.info(
+                f"[Search Artist on YouTube] Searching for track {index + 1}/{playlist_len} on YouTube..."
+            )
+            title = entry.get("title")
+
+            if not video_record.get(title):
+                try:
+                    id = entry.get("id")
+                    watch_url = f"https://www.youtube.com/watch?v={id}"
+                    metadata = self.video_search(
+                        query=watch_url, is_general_search=False
+                    )
+                    video_record[title] = metadata.result
+
+                    if (index % 10 == 0) or (index == (playlist_len - 1)):
+                        self.core.storage.save()
+
+                except SongNotFound:
+                    continue
+            else:
+                continue
+
+            self.clients.ytdlp.reset_options()
+
+            artist_playlist = list(video_record.values())
+            self.core.storage.new(
+                query=artist, result=artist_playlist, query_type="artist"
+            )
+
+            self.core.storage.save()
+
+            return artist_playlist