spots-cli 0.1.0__py3-none-any.whl

spots_cli/cli.py

@@ -0,0 +1,42 @@
+from os.path import exists
+from logging import getLogger
+from typing import Callable
+import typer
+
+from spots_cli import setup_env, Spots
+from spots_cli.scripts import remove_duplicate_songs, update_history
+
+logger = getLogger(__name__)
+
+app = typer.Typer()
+
+
+@app.command()
+def setup():
+    setup_env.main()
+
+
+@app.command()
+def download(query: str):
+    app = Spots()
+    app.download(query)
+
+
+@app.command()
+def migrate_likes():
+    app = Spots()
+    app.transfer_spotify_likes()
+
+
+@app.command()
+def add_to_history(path_to_music: str):
+    update_history(path_to_music)
+
+
+@app.command()
+def remove_duplicates(path_to_music: str):
+    remove_duplicate_songs(path_to_music)
+
+
+def main():
+    app()

spots_cli/clients/__init__.py

@@ -0,0 +1,5 @@
+from spots_cli.clients.deezer import DeezerClient
+from spots_cli.clients.ytdl import YtDlpClient
+from spots_cli.clients.spotify import SpotifyClient
+from spots_cli.clients.youtube import YouTubeApiClient
+from spots_cli.clients.secrets_manager import SecretsManager

spots_cli/clients/deezer.py

@@ -0,0 +1,80 @@
+from logging import getLogger
+from requests.exceptions import HTTPError
+from tenacity import stop_after_delay
+from typing import Any, TypedDict, cast
+
+from spots_cli.engine import retry
+from spots_cli.models import SongNotFound, InvalidURL, ArtistInfo
+from spots_cli.utils import FetchResponseFailure, FetchResponseSuccess, fetch_data
+
+logger = getLogger(__name__)
+
+
+class DeezerResponseBase(TypedDict):
+    total: int
+    data: list[dict[str, Any]]
+
+
+class DeezerClient:
+
+    @retry(stop=stop_after_delay(60))
+    def _get_resource_by_url(self, resource_link: str) -> dict[str, Any]:
+        base_url = "https://api.deezer.com/"
+        if not resource_link.startswith(base_url):
+            raise InvalidURL(resource_link)
+
+        resource_response = fetch_data(resource_link)
+
+        if isinstance(resource_response, FetchResponseFailure):
+            resource_error = cast(FetchResponseFailure, resource_response)
+            error_msg = resource_error.error
+
+            if error_msg == "no data":
+                raise SongNotFound(f"Resource not found: {resource_link}")
+            else:
+                raise Exception(f"Unknown error occured: {error_msg}")
+
+        resource_success = cast(FetchResponseSuccess, resource_response)
+        resource_payload = cast(dict[str, Any], resource_success.data)
+        return resource_payload
+
+    def artist_top_tracks(
+        self, artist_id: int
+    ) -> tuple[ArtistInfo, list[dict[str, Any]]]:
+        base_url = f"https://api.deezer.com/artist/{artist_id}"
+        top_tracks_res = self._get_resource_by_url(f"{base_url}/top")
+
+        artist_info = self._get_resource_by_url(base_url)
+
+        top_tracks = cast(list[dict[str, Any]], top_tracks_res["data"])
+        return (
+            ArtistInfo(
+                name=artist_info["name"],
+                cover=artist_info["picture"],
+                id=artist_info["id"],
+            ),
+            top_tracks,
+        )
+
+    def track(self, track_id: int) -> dict[str, Any]:
+        track_url = f"https://api.deezer.com/track/{track_id}"
+        return self._get_resource_by_url(track_url)
+
+    @retry(stop=stop_after_delay(60))
+    def search(self, query: str) -> str:
+        try:
+            logger.debug(f"Searching for {query} on Deezer")
+            search_url = f"https://api.deezer.com/search?q={query}&limit=1"
+            res = fetch_data(search_url)
+            if res.success and res.data is not None:
+                res_json = cast(DeezerResponseBase, res.data)
+                if res_json["total"] == 0:
+                    logger.error("No results found")
+                    raise SongNotFound(query)
+
+                return str(res_json["data"][0]["id"])
+            else:
+                raise SongNotFound(query)
+        except HTTPError as e:
+            logger.error("An error occurred", e)
+            raise SongNotFound(query)

spots_cli/clients/secrets_manager.py

@@ -0,0 +1,25 @@
+from os import getenv, environ
+from typing import Literal, overload
+from dotenv import load_dotenv
+
+from spots_cli.utils import get_config_path
+
+load_dotenv(dotenv_path=get_config_path() / ".env")
+
+
+class SecretsManager:
+    @overload
+    @staticmethod
+    def read(*, key: str, alt: str) -> str: ...
+
+    @overload
+    @staticmethod
+    def read(*, key: str, alt: Literal[None] = None) -> str | None: ...
+
+    @staticmethod
+    def read(*, key, alt=None):
+        return getenv(key) or alt
+
+    @staticmethod
+    def write(*, key: str, value: str):
+        environ[key] = value

spots_cli/clients/spotify.py

@@ -0,0 +1,79 @@
+from dotenv import load_dotenv
+from logging import getLogger
+from os import getenv
+from spotipy.exceptions import SpotifyException
+from spotipy.oauth2 import SpotifyClientCredentials
+from spotipy import Spotify
+from spotipy.util import prompt_for_user_token
+
+load_dotenv()
+
+logger = getLogger(__name__)
+
+DEFAULT_USER_SCOPE = "user-library-read"
+
+
+class SpotifyClient:
+    """A class to retrieve metadata for a spotify track, album or playlist
+
+    Attributes:
+        track_url (str): The spotify url to be processed
+    """
+
+    def __init__(self) -> None:
+        """Initializes a spotify.spotify"""
+
+        auth_manager = SpotifyClientCredentials()
+        self.client = Spotify(auth_manager=auth_manager)
+
+    def get_user(self) -> str | None:
+        """Retrieves the current user
+
+        Returns:
+            str: The user's display name
+        """
+        if not getenv("username"):
+            return None
+
+        user = None
+
+        try:
+            self.signin()
+            user = self.client.current_user()
+        except SpotifyException as e:
+            logger.error(f"An error occured while signin user in::\n\t{e.msg}")
+
+        if user:
+            return user["display_name"]
+
+        return None
+
+    def signin(self) -> None:
+        """signs into a user's spotify account"""
+        # sign user in if username present in env
+        username = getenv("username")
+        if not username:
+            logger.info("Set Spotify `username` in `.env`")
+            raise Exception("No `username` declared in environment variables")
+
+        scope = getenv("scope") or DEFAULT_USER_SCOPE
+
+        logger.info(f"Signing in to {username} on Spotify with scope: {scope}")
+
+        try:
+            # throws error if user not signed in
+            self.client.current_user()
+            return
+        except SpotifyException as e:
+            if e.code == -1:
+                token = prompt_for_user_token(username, scope)
+            else:
+                raise
+
+        if token:
+            logger.info("Signed in")
+            self.client = Spotify(auth=token)
+
+            return
+        else:
+            raise Exception("Can't get token for", username)

spots_cli/clients/youtube.py

@@ -0,0 +1,66 @@
+import os
+import pickle
+from importlib.resources import files
+from os.path import exists
+from googleapiclient.discovery import build
+from google_auth_oauthlib.flow import InstalledAppFlow
+from google.auth.transport.requests import Request
+
+from spots_cli.utils import get_config_path
+
+SCOPES = ["https://www.googleapis.com/auth/youtube.force-ssl"]
+config_dir = get_config_path()
+PICKLE_TOKEN = f"{config_dir}/token.pickle"
+
+
+class YouTubeApiClient:
+    """
+    Service for interacting with the YouTube API
+
+    Attributes:
+        @service (Unknown): The youtube api service.
+
+    Methods
+        @like_video
+
+    This service handles:
+    - Adding a video to YouTube likes library
+    """
+
+    def __init__(self):
+        """
+        Initialize the YouTubeApiClient.
+
+        Sets up the api client.
+        """
+        self.secrets_file = str(files("spots_cli.config").joinpath("client_secrets.json"))
+        if not exists(self.secrets_file):
+            raise RuntimeError("Provide path to cookies for YouTube account access.")
+
+        self.service = self._build_service()
+
+    def _build_service(self):
+        """
+        Build service for interacting with YouTube API
+
+        Returns:
+            Unknown: YouTube client.
+        """
+        creds = None
+        if os.path.exists(PICKLE_TOKEN):
+            with open(PICKLE_TOKEN, "rb") as f:
+                creds = pickle.load(f)
+
+        if not creds or not creds.valid:
+            if creds and creds.expired and creds.refresh_token:
+                creds.refresh(Request())
+            else:
+                flow = InstalledAppFlow.from_client_secrets_file(
+                    self.secrets_file, SCOPES
+                )
+                creds = flow.run_local_server(port=0)
+
+            with open(PICKLE_TOKEN, "wb") as f:
+                pickle.dump(creds, f)
+
+        return build("youtube", "v3", credentials=creds)

spots_cli/clients/ytdl.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from logging import getLogger
+from typing import TYPE_CHECKING
+from yt_dlp import YoutubeDL
+
+from spots_cli.utils import get_config_path, detect_browser
+
+if TYPE_CHECKING:
+    from yt_dlp import _Params
+    from spots_cli.clients import SecretsManager
+
+
+logger = getLogger(__name__)
+
+
+class YtDlpClient:
+    """
+    A service for interacting with the YouTube DL library.
+
+    Attributes:
+        @ydl (YoutubeDL): YouTube DL client.
+        @video_to_mp3 (VideoToMp3Service): Service for post-video-downloaded processing.
+        @directory_path (str, optional): The directory to save the audio. Defaults to ''.
+
+    Methods:
+        @download_youtube_video
+    """
+
+    def __init__(
+        self,
+        *,
+        extra_options: _Params = {},
+        secrets: SecretsManager,
+    ):
+        """
+        Initialize the YtDlpClient.
+
+        Sets up youtube clients.
+        """
+        self.default_options: _Params = {
+            "js_runtimes": {"node": {}},
+            "remote_components": {"ejs:github"},
+            "format": "bestaudio/best",
+            "outtmpl": "%(title)s.%(ext)s",
+            "quiet": True,
+            "noplaylist": True,
+            "cachedir": str(get_config_path() / "yt_cache"),
+        }
+        self.client_options: _Params = self.default_options | extra_options
+
+        browser = detect_browser()
+        if browser:
+            self.client_options["cookiesfrombrowser"] = browser
+            cookies_path = secrets.read(key="YOUTUBE_COOKIES_PATH")
+            if cookies_path:
+                self.client_options["cookiefile"] = cookies_path
+
+        self.client = YoutubeDL(self.client_options)
+
+    @property
+    def options(self) -> _Params:
+        return self.client_options
+
+    @options.setter
+    def options(self, extra_options: _Params) -> None:
+        self.client_options = self.client_options | extra_options
+        self.client = YoutubeDL(self.client_options)
+
+    def reset_options(self) -> None:
+        self.client_options = self.default_options
+        self.client = YoutubeDL(self.default_options)

spots_cli/core/__init__.py

@@ -0,0 +1,6 @@
+from spots_cli.core.web_scraper import WebScraper
+from spots_cli.core.lyrics_finder import LyricsFinder
+from spots_cli.core.history_manager import HistoryManager
+from spots_cli.core.pattern_matcher import PatternMatcher
+from spots_cli.core.video_converter import VideoConverter
+from spots_cli.core.youtube_extractor import YouTubeExtractor

spots_cli/core/history_manager.py

@@ -0,0 +1,39 @@
+from os import path
+
+from spots_cli.utils import get_config_path
+
+
+class HistoryManager:
+    def __init__(self):
+        self.__history_file = get_config_path() / ".spots_download_history.txt"
+
+    def history_file_exists(self):
+        if not path.isfile(self.__history_file):
+            with open(self.__history_file, "w", newline=""):
+                pass
+
+    def read(self, title: str) -> bool:
+        """Checks if a title is in history
+
+        Args:
+            title (str, optional): The title to be checked.
+        """
+
+        title_exists = False
+
+        with open(self.__history_file, "r") as file:
+            history = file.read().split("\n")
+            for song in history:
+                if title == song:
+                    title_exists = True
+
+        return title_exists
+
+    def write(self, title: str):
+        """Adds a downloaded song's title to history
+
+        Args:
+            title (str, optional): The title to be added.
+        """
+        with open(self.__history_file, "a", newline="") as file:
+            file.write(f"{title}\n")

spots_cli/core/lyrics_finder.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from logging import getLogger
+from lyricsgenius import Genius
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from spots_cli.clients import SecretsManager
+    from spots_cli.core import WebScraper
+
+
+logger = getLogger(__name__)
+
+
+class LyricsFinder:
+    """
+    A service for retrieving lyrics for a song
+
+    Args:
+        scraper (WebScrapeService): The web scraper client.
+
+    Attributes:
+        genius: Genius api client.
+    """
+
+    def __init__(self, *, scraper: WebScraper, secrets_manager: SecretsManager):
+        self.secrets_manager = secrets_manager
+        self.scraper = scraper
+        genius_key = self.secrets_manager.read(key="lyricsgenius_key")
+        self.genius = Genius(genius_key) if genius_key else None
+
+    def get_lyrics(self, *, artist: str, title: str) -> str:
+        """Retrieve lyrics using Genius. Falls back to using alternatives provided by the scraper.
+
+        Args:
+            artist (str): The artist.
+            title (str): The title.
+
+        Returns:
+            str: The lyrics if found, else an empty string.
+        """
+        try:
+            if self.genius:
+                logger.debug("Searching for lyrics on Genius")
+                song = self.genius.search_song(title, artist)
+
+                if not song or "Verse" not in song.lyrics or title not in song.title:
+                    logger.debug("Genius lyrics not found. Searching AZLyrics")
+                    lyrics = self.scraper.scrape_azlyrics(artist=artist, title=title)
+                else:
+                    lyrics = song.lyrics
+            else:
+                logger.debug("Genius API not available. Falling back to AZLyrics")
+                lyrics = self.scraper.scrape_azlyrics(artist=artist, title=title)
+        except Exception as e:
+            logger.error(e)
+            lyrics = ""
+        return lyrics