spots-cli 0.1.0__py3-none-any.whl

spots_cli/app/spotify_playlist_compilation.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from logging import getLogger
+from spots_cli.models.errors import EmptySpotifyLikes, SongNotFound
+from spotipy.exceptions import SpotifyException
+from tenacity import stop_after_delay
+from spots_cli.engine import retry
+from typing import TYPE_CHECKING
+
+from spots_cli.models import PlaylistInfo, SpotifyUnavailableError
+
+if TYPE_CHECKING:
+    from spots_cli.bootstrap.container import Core, Domain, Clients
+    from spots_cli.app import DomainResolver
+    from spots_cli.services.spotify_search_service import SpotifySearchService
+    from spots_cli.services.spotify_metadata_service import SpotifyMetadataService
+
+
+logger = getLogger(__name__)
+
+
+@dataclass
+class ArtistResult:
+    playlist: list[PlaylistInfo]
+    name: str
+    cover: str
+
+
+class SpotifyPlaylistCompilation:
+    """A service for retrieving a collection of playlists from Spotify"""
+
+    def __init__(
+        self,
+        *,
+        core: Core,
+        domain: Domain,
+        clients: Clients,
+        metadata: SpotifyMetadataService,
+        spotify_search: SpotifySearchService,
+        domain_resolver: DomainResolver,
+    ) -> None:
+        self.domain_resolver = domain_resolver
+        self.spotify_search = spotify_search
+        self.core = core
+        self.domain = domain
+        self.clients = clients
+        self.metadata = metadata
+
+    @retry(stop=stop_after_delay(60))
+    def artist_albums(
+        self, *, artist: str, essentials_playlist: str | None = None
+    ) -> ArtistResult:
+        """
+        Retrieves the albums of a given artist.
+
+        Args:
+            artist (str): The name of the artist. Can be either then name of artist or spotify url to artist
+            essentials_playlist (str | None, optional): A spotify playlist to scrape. Defaults to None.
+        """
+
+        artist_search = self.spotify_search.search_artist(artist)
+        artist_name = artist_search.name
+        artist_id = artist_search.id
+        artist_cover = artist_search.cover
+
+        all_artist_albums: list[PlaylistInfo] = []
+
+        # get artist's This Is playlist
+        if essentials_playlist:
+            essentials_playlist_data = self.core.scraper.scrape_spotify_playlist(
+                essentials_playlist
+            )
+
+            scraped_playlist = [
+                track
+                for track_id in essentials_playlist_data.ids
+                if (track := self.metadata.get(track_id=track_id))
+            ]
+            domain_matches = self.domain_resolver.filter_matching_domain_results(
+                provider_results=scraped_playlist
+            )
+
+            scraped_cover = essentials_playlist_data.cover
+            scraped_title = essentials_playlist_data.name
+            essential_cover = (
+                scraped_cover
+                if scraped_cover
+                else self.clients.secrets.read(
+                    key="static_playlist_cover_name", alt="youtube-playlist.jpg"
+                )
+            )
+            essential_title = (
+                scraped_title if scraped_title else f"This is {artist_name}"
+            )
+            scraped_data = {
+                "cover": essential_cover,
+                "name": essential_title,
+                "artist": artist_name,
+            }
+
+            all_artist_albums.append(
+                PlaylistInfo(
+                    cover=scraped_data["cover"],
+                    name=scraped_data["name"],
+                    artist=scraped_data["artist"],
+                    provider_metadata=domain_matches.provider,
+                    youtube_metadata=domain_matches.youtube,
+                )
+            )
+
+        # top tracks
+        try:
+            top_tracks = self.spotify_search.search_artist_top_tracks(
+                artist_id=artist_id
+            )
+            all_artist_albums.append(top_tracks)
+        except SongNotFound:
+            pass
+
+        # retrieve artist albums
+        if not self.clients.spotify:
+            raise SpotifyUnavailableError(
+                "Spotify client is not configured. Enable Spotify features in your environment."
+            )
+
+        result = self.clients.spotify.client.artist_albums(artist_id)
+        if not result:
+            return ArtistResult(
+                playlist=all_artist_albums, name=artist_name, cover=artist_cover
+            )
+
+        # filter albums for the specified artist
+        artist_albums = list(
+            filter(
+                lambda item: any(
+                    artist_obj["name"].lower() == artist.lower()
+                    for artist_obj in item["artists"]
+                ),
+                result["items"],
+            )
+        )
+
+        artist_albums = result["items"]
+
+        for item in artist_albums:
+            # get all tracks of album
+            album_url = "https://open.spotify.com/album/" + item["id"]
+
+            all_artist_albums.append(self.spotify_search.search_album(album_url))
+
+        return ArtistResult(
+            playlist=all_artist_albums, name=artist_name, cover=artist_cover
+        )
+
+    def user_saved_tracks(self) -> PlaylistInfo:
+        """retrieves a user's saved tracks
+
+        Returns:
+            list[Metadata]: A list of Metadata objects or None
+
+        Raises:
+            EmptySpotifyLikes: When no likes returned
+        """
+        cached_likes = self.core.storage.get_spotify_likes()
+        cover = "avatar.jpg"
+        username = self.clients.secrets.read(key="username")
+        if not username:
+            raise RuntimeError("No username provided in `.env` file")
+        if not cached_likes:
+            raise SongNotFound("Spotify likes")
+        domain_matches = self.domain_resolver.filter_matching_domain_results(
+            provider_results=list(cached_likes.values())
+        )
+        return PlaylistInfo(
+            cover=cover,
+            name=username,
+            provider_metadata=domain_matches.provider,
+            youtube_metadata=domain_matches.youtube,
+        )
+
+        # NOTE: Spotify now requires a paid subscription to use the API
+        logger.info("Searching for user saved tracks...")
+        limit = 50
+        user_tracks = None
+
+        try:
+            user_tracks = self.clients.spotify.spotify.current_user_saved_tracks(
+                limit=limit
+            )
+        except SpotifyException:
+            self.clients.spotify.signin()
+            user_tracks = self.clients.spotify.spotify.current_user_saved_tracks(
+                limit=limit
+            )
+
+        if not user_tracks:
+            raise EmptySpotifyLikes
+
+        total_tracks = user_tracks["total"]
+        # get first 50 tracks's ids
+        id_list = [track["track"]["id"] for track in user_tracks["items"]]
+
+        # check if there are more tracks
+        next_page = user_tracks["next"]
+        if next_page:
+            index = limit
+
+            # paginate through the rest of the tracks
+            while index <= total_tracks:
+                user_tracks = self.clients.spotify.spotify.current_user_saved_tracks(
+                    offset=index, limit=limit
+                )
+
+                if user_tracks:
+                    # append the next set of ids
+                    for track in user_tracks["items"]:
+                        id_list.append(track["track"]["id"])
+
+                index += limit
+
+        # get metadata for each track
+        metadata_list = []
+        for index, track_id in enumerate(id_list):
+            print(f"Getting liked song {index + 1}/{len(id_list)}")
+            # get track data
+            metadata = self.orchestration.metadata.spotify_metadata.get(
+                track_id=track_id
+            )
+            metadata_list.append(metadata)
+
+            # add to likes cache
+            title = f"{metadata.artist} - {metadata.title}"
+            storage.new(query=title, result=metadata, query_type="spotify_likes")
+
+            if (index % 10 == 0) or (index == (len(id_list) - 1)):
+                storage.save()
+
+        domain_matches = self.orchestration.search.filter_matching_domain_results(
+            spotify_results=metadata_list
+        )
+        cover = "avatar.jpg"
+        username = self.clients.secrets.read(key="username")
+        if not username:
+            raise RuntimeError("No username provided in `.env` file")
+        return PlaylistInfo(
+            cover=cover,
+            name=username,
+            spotify_metadata=domain_matches.spotify,
+            youtube_metadata=domain_matches.youtube,
+        )

spots_cli/app/youtube_user_playlist.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+from googleapiclient.errors import HttpError
+from logging import getLogger
+from socket import timeout as SocketTimeout
+from tenacity import stop_after_attempt, wait_exponential
+from typing import TYPE_CHECKING
+
+from spots_cli.engine import retry
+from spots_cli.models import (
+    SongNotFound,
+    YouTubeQuotaExceeded,
+    Sentinel,
+    YTVideoInfo,
+    Metadata,
+    YouTubeUnavailableError,
+)
+
+if TYPE_CHECKING:
+    from spots_cli.bootstrap.container import Core, Clients
+    from spots_cli.app.spotify_playlist_compilation import SpotifyPlaylistCompilation
+    from spots_cli.services.youtube_search_service import YoutubeSearchService
+    from spots_cli.clients import YouTubeApiClient
+
+
+logger = getLogger(__name__)
+
+
+class YouTubeUserPlaylist:
+    def __init__(
+        self,
+        *,
+        clients: Clients,
+        core: Core,
+        spotify_playlist_compiler: SpotifyPlaylistCompilation,
+        search: YoutubeSearchService,
+    ):
+        self.search = search
+        self.core = core
+        self.clients = clients
+        self.spotify_playlist_compiler = spotify_playlist_compiler
+
+    def _youtube(self) -> YouTubeApiClient:
+        if not self.clients.youtube:
+            raise YouTubeUnavailableError(
+                "YouTube client is not configured. Enable YouTube features in your environment."
+            )
+        return self.clients.youtube
+
+    def get_liked_videos(self, *, max_results=50) -> list[str]:
+        """
+        Fetch videos from the user's YouTube liked videos playlist.
+
+        Args:
+            max_results (int, Optional): The max items per pagination. Defaults to 50.
+        """
+        liked_videos = []
+        next_page_token = None
+
+        while True:
+            request = (
+                self._youtube()
+                .service.playlistItems()
+                .list(
+                    part="snippet,contentDetails",
+                    playlistId="LL",
+                    maxResults=max_results,
+                    pageToken=next_page_token,
+                )
+            )
+
+            response = request.execute()
+
+            for item in response.get("items", []):
+                video_id = item["contentDetails"]["videoId"]
+                watch_url = f"https://www.youtube.com/watch?v={video_id}"
+                liked_videos.append(watch_url)
+
+            next_page_token = response.get("nextPageToken")
+            if not next_page_token:
+                break
+
+        return liked_videos
+
+    @retry(stop=stop_after_attempt(5), wait=wait_exponential(min=1, max=10))
+    def _like_video(self, video_id: str):
+        """
+        Like a video with retry on transient failures.
+
+        Args:
+            video_id (str): the id of the video to be added.
+        """
+        try:
+            self._youtube().service.videos().rate(id=video_id, rating="like").execute()
+        except (SocketTimeout, TimeoutError) as e:
+            # Retryable network error
+            logger.info(f"[Network Timeout] Retrying like for {video_id}: {e}")
+            raise  # Tenacity will retry
+        except HttpError as e:
+            # API-level error (bad ID, auth, quota, etc.)
+            raise
+
+    def like_video(self, *, video: YTVideoInfo, metadata: Metadata) -> bool:
+        """
+        Adds a video to YouTube likes.
+
+        Args:
+            video (YTVideoInfo): the video to be added.
+            metadata (Metadata): the metadata for the video.
+
+        Returns:
+            bool: True if added to likes
+        """
+        video_id = video.id
+        title = f"{video.uploader} - {video.title}"
+        titles_match = self.core.matcher.match_tracks(
+            video_info=video, metadata=metadata
+        )
+        if titles_match:
+            try:
+                logger.info(f"Trying to add {title} to likes")
+                self._like_video(video_id)
+                return True
+            except HttpError as e:
+                status = getattr(e.resp, "status", None)
+                details = getattr(e, "error_details", None)
+                if status == 403 and isinstance(details, list) and details:
+                    reason = details[0].get("reason")
+
+                    if reason == "videoRatingDisabled":
+                        return False
+                    elif reason == "quotaExceeded":
+                        raise YouTubeQuotaExceeded()
+                    else:
+                        logger.error("Unexpected reason:")
+                        logger.error(reason)
+                        raise
+                raise
+            except Exception as e:
+                raise
+
+        logger.debug(f"No match found for {title}")
+        return False
+
+    def transfer_spotify_likes_to_yt(self):
+        """
+        Adds each track in a users Spotify liked library, to the users YouTube likes
+        """
+        # get user liked tracks from spotify
+        tracks = self.spotify_playlist_compiler.user_saved_tracks()
+
+        # save newly added liked tracks
+        self.core.storage.save()
+
+        unexpected_errors = []
+        playlist_len = len(tracks.provider_metadata)
+
+        # try to find the youtube video for each track
+        for index, track in enumerate(tracks.provider_metadata):
+            spotify_title = f"{track.artist} - {track.title}"
+
+            if self.core.storage.get(query=spotify_title, query_type="yt_likes"):
+                logger.info(f"🗄 Already Liked: {spotify_title}")
+                continue
+
+            video_added_to_likes = False
+
+            try:
+                search_results = self.search.video_search(
+                    query=spotify_title, is_general_search=True
+                )
+            except SongNotFound:
+                continue
+            except Exception as e:
+                unexpected_errors.append(str(e))
+                continue
+
+            try:
+                best_match = self.core.matcher.find_best_match(
+                    search_results=search_results.result, metadata=track
+                )
+                video_added_to_likes = self.like_video(video=best_match, metadata=track)
+                if video_added_to_likes:
+                    self.core.storage.new(
+                        query=spotify_title,
+                        result=best_match,
+                        query_type="yt_likes",
+                    )
+                else:
+                    logger.info(f"Failed to add {spotify_title} to likes")
+                    self.core.storage.new(
+                        query=spotify_title, result=Sentinel(), query_type="yt_likes"
+                    )
+                    continue
+            except SongNotFound:
+                continue
+            except YouTubeQuotaExceeded:
+                self.core.storage.save()
+                logger.error("Quota exceeded")
+                raise
+            except Exception as e:
+                unexpected_errors.append(str(e))
+                continue
+
+            if (index % 10 == 0) or (index == (playlist_len - 1)):
+                self.core.storage.save()
+
+            logger.info(f"✅ Liked: {spotify_title}")
+
+        self.core.storage.save()
+
+        if len(unexpected_errors):
+            logger.error("Unexpected errors occurred")
+            for unexpected in unexpected_errors:
+                logger.error(unexpected)

spots_cli/bootstrap/__init__.py

@@ -0,0 +1 @@
+from spots_cli.bootstrap.container import Container

spots_cli/bootstrap/container.py

@@ -0,0 +1,230 @@
+from dataclasses import dataclass
+from logging import DEBUG, ERROR, basicConfig, INFO, getLogger
+from os.path import exists
+
+from spots_cli.app import (
+    Downloader,
+    MediaResolver,
+    YouTubeUserPlaylist,
+    SpotifyPlaylistCompilation,
+    DomainResolver,
+)
+from spots_cli.clients import (
+    YtDlpClient,
+    SpotifyClient,
+    SecretsManager,
+    YouTubeApiClient,
+    DeezerClient,
+)
+from spots_cli.core import (
+    WebScraper,
+    LyricsFinder,
+    HistoryManager,
+    PatternMatcher,
+    VideoConverter,
+    YouTubeExtractor,
+)
+from spots_cli.engine import FileStorage
+from spots_cli.models import MetadataProvider, SearchProvider
+from spots_cli.services import (
+    YoutubeSearchService,
+    YouTubeMetadataService,
+    ProvidersMetadata,
+    ProviderSearchContainer,
+    SpotifySearchService,
+    SpotifyMetadataService,
+)
+from spots_cli.integrations import SpotifyUserPlaylistModify
+from spots_cli.utils import get_config_path
+
+logger = getLogger(__name__)
+
+
+@dataclass
+class Core:
+    history: HistoryManager
+    lyrics: LyricsFinder
+    matcher: PatternMatcher
+    converter: VideoConverter
+    scraper: WebScraper
+    extractor: YouTubeExtractor
+    storage: FileStorage
+
+
+@dataclass
+class Clients:
+    spotify: SpotifyClient | None
+    youtube: YouTubeApiClient | None
+    ytdlp: YtDlpClient
+    secrets: SecretsManager
+    deezer: DeezerClient
+
+
+@dataclass
+class Domain:
+    provider_search: SearchProvider
+    provider_metadata: MetadataProvider
+    youtube_search: YoutubeSearchService
+    youtube_metadata: YouTubeMetadataService
+
+
+@dataclass
+class App:
+    downloader: Downloader
+    resolver: MediaResolver
+    spotify_playlist_compiler: SpotifyPlaylistCompilation
+    youtube_user_playlist: YouTubeUserPlaylist
+    spotify_playlist_modify: SpotifyUserPlaylistModify
+    domain_resolver: DomainResolver
+
+
+class Container:
+    def __init__(self):
+        self.__path = get_config_path() / ".bootstrapped"
+
+        secrets = SecretsManager()
+        environment_mode = secrets.read(key="environment_mode", alt="PRODUCTION")
+        basicConfig(level=INFO if environment_mode.lower() == "production" else DEBUG)
+        getLogger("googleapiclient.discovery_cache").setLevel(ERROR)
+
+        logger.debug("Bootstrapping app...")
+
+        self.initial_setup()
+
+        logger.debug("Setting up core components...")
+        self.core = self._build_core()
+        self.clients = self._build_clients()
+        self.domain = self._build_domain()
+        self.app = self._build_application()
+        logger.debug("Components setup complete.")
+
+        # cache
+        logger.debug("Loading cache into memory...")
+        self.core.storage.cache_file_exists()
+        self.core.storage.reload()
+        logger.debug("Cache loaded.")
+
+        logger.debug("Bootstrap complete. App ready for use.")
+
+    def initial_setup(self) -> None:
+        if not exists(self.__path):
+            logger.debug("Running initial setup...")
+            logger.debug("Creating internal files used for tracking downloads...")
+
+            # downloads history
+            logger.debug("Creating downloads history file...")
+            history = HistoryManager()
+            history.history_file_exists()
+            logger.debug("History file created.")
+
+            with open(self.__path, "w"):
+                pass
+
+            logger.debug("Download manager files setup complete.")
+
+    def _build_clients(self) -> Clients:
+        secrets = SecretsManager()
+
+        youtube = None
+        if secrets.read(key="youtube_account_access", alt="false").lower() == "true":
+            youtube = YouTubeApiClient()
+
+        spotify = None
+        if (
+            secrets.read(key="spotify_features_available", alt="false").lower()
+            == "true"
+        ):
+            spotify = SpotifyClient()
+
+        return Clients(
+            spotify=spotify,
+            youtube=youtube,
+            ytdlp=YtDlpClient(secrets=secrets),
+            secrets=secrets,
+            deezer=DeezerClient(),
+        )
+
+    def _build_core(self) -> Core:
+        scraper = WebScraper()
+        secrets_manager = SecretsManager()
+        extractor = YouTubeExtractor()
+
+        return Core(
+            storage=FileStorage(),
+            history=HistoryManager(),
+            lyrics=LyricsFinder(scraper=scraper, secrets_manager=secrets_manager),
+            matcher=PatternMatcher(extractor=extractor),
+            converter=VideoConverter(),
+            scraper=WebScraper(),
+            extractor=YouTubeExtractor(),
+        )
+
+    def _build_domain(self) -> Domain:
+        youtube_search = YoutubeSearchService(clients=self.clients, core=self.core)
+
+        provider_metadata = ProvidersMetadata(
+            clients=self.clients,
+            core=self.core,
+        )
+
+        provider_search = ProviderSearchContainer(
+            clients=self.clients, metadata=provider_metadata.metadata, core=self.core
+        )
+
+        youtube_metadata = YouTubeMetadataService(
+            search=provider_search.main, clients=self.clients, core=self.core
+        )
+
+        return Domain(
+            youtube_search=youtube_search,
+            provider_search=provider_search.main,
+            provider_metadata=provider_metadata.metadata,
+            youtube_metadata=youtube_metadata,
+        )
+
+    def _build_application(self) -> App:
+        downloader = Downloader(core=self.core, clients=self.clients)
+
+        youtube_search = YoutubeSearchService(clients=self.clients, core=self.core)
+        domain_resolver = DomainResolver(
+            core=self.core,
+            youtube_search=youtube_search,
+            provider_search=self.domain.provider_search,
+        )
+
+        resolver = MediaResolver(
+            core=self.core,
+            domain=self.domain,
+            clients=self.clients,
+            domain_resolver=domain_resolver,
+        )
+        spotify_playlist_modify = SpotifyUserPlaylistModify(clients=self.clients)
+
+        spotify_metadata = SpotifyMetadataService(clients=self.clients, core=self.core)
+
+        spotify_search = SpotifySearchService(
+            metadata=spotify_metadata, clients=self.clients, core=self.core
+        )
+        spotify_playlist_compiler = SpotifyPlaylistCompilation(
+            core=self.core,
+            domain=self.domain,
+            clients=self.clients,
+            metadata=spotify_metadata,
+            spotify_search=spotify_search,
+            domain_resolver=domain_resolver,
+        )
+        youtube_user_playlist = YouTubeUserPlaylist(
+            search=youtube_search,
+            clients=self.clients,
+            core=self.core,
+            spotify_playlist_compiler=spotify_playlist_compiler,
+        )
+
+        return App(
+            downloader=downloader,
+            resolver=resolver,
+            spotify_playlist_modify=spotify_playlist_modify,
+            spotify_playlist_compiler=spotify_playlist_compiler,
+            youtube_user_playlist=youtube_user_playlist,
+            domain_resolver=domain_resolver,
+        )