From c3e8a0f0db914f9139dc199ab812eb0631ad037d Mon Sep 17 00:00:00 2001 From: Ritiek Malhotra Date: Tue, 5 May 2020 02:25:05 +0530 Subject: [PATCH] Link arguments to spotipy helpers --- spotdl/command_line/arguments.py | 2 +- spotdl/command_line/lib.py | 120 +++++++++++++++++-------------- spotdl/helpers/spotify.py | 77 ++++++++++++-------- spotdl/util.py | 2 +- 4 files changed, 116 insertions(+), 85 deletions(-) diff --git a/spotdl/command_line/arguments.py b/spotdl/command_line/arguments.py index e67bcef..85b03d0 100644 --- a/spotdl/command_line/arguments.py +++ b/spotdl/command_line/arguments.py @@ -70,7 +70,7 @@ def get_arguments(argv=None, base_config_file=spotdl.config.default_config_file) "if `--write-to=` has been passed", ) group.add_argument( - "-b" + "-b", "--album", help="load tracks from album URL into .txt or if " "`--write-to=` has been passed" diff --git a/spotdl/command_line/lib.py b/spotdl/command_line/lib.py index 935517e..61335ce 100644 --- a/spotdl/command_line/lib.py +++ b/spotdl/command_line/lib.py @@ -21,6 +21,8 @@ import spotdl.config from spotdl.command_line.exceptions import NoYouTubeVideoFoundError from spotdl.command_line.exceptions import NoYouTubeVideoMatchError +from spotdl.helpers.spotify import SpotifyHelpers + import sys import os import urllib.request @@ -47,15 +49,20 @@ def search_metadata_on_spotify(query): def prompt_for_youtube_search_result(videos): - print("0. Skip downloading this track", file=sys.stderr) + max_index_length = len(str(len(videos))) + max_title_length = max(len(v["title"]) for v in videos) + print(" 0. Skip downloading this track", file=sys.stderr) for index, video in enumerate(videos, 1): - video_repr = "{index}. {title} ({url}) [{duration}]".format( + vid_details = "{index:>{max_index}}. {title:<{max_title}} {url} [{duration}]".format( index=index, + max_index=max_index_length, title=video["title"], + max_title=max_title_length, url=video["url"], duration=video["duration"], ) - print(video_repr, file=sys.stderr) + print(vid_details, file=sys.stderr) + print("", file=sys.stderr) selection = spotdl.util.prompt_user_for_selection(range(1, len(videos)+1)) @@ -121,7 +128,7 @@ def search_metadata(track, search_format="{artist} - {track-name} lyrics", manua youtube_videos = youtube_searcher.search(search_query) if not youtube_videos: raise NoYouTubeVideoFoundError( - 'YouTube returned no videos for the search query "{}"'.format(search_query) + 'YouTube returned no videos for the search query "{}".'.format(search_query) ) if manual: youtube_video = prompt_for_youtube_search_result(youtube_videos) @@ -130,7 +137,7 @@ def search_metadata(track, search_format="{artist} - {track-name} lyrics", manua if youtube_video is None: raise NoYouTubeVideoMatchError( - 'No matching videos found on YouTube for the search query "{}"'.format( + 'No apparent matching videos found on YouTube for the search query "{}"'.format( search_query ) ) @@ -177,9 +184,10 @@ class Spotdl: client_id=self.arguments["spotify_client_id"], client_secret=self.arguments["spotify_client_secret"] ) + spotify_tools = SpotifyHelpers() + # youtube_tools.set_api_key() logger.debug("Received arguments:\n{}".format(self.arguments)) - # youtube_tools.set_api_key() if self.arguments["song"]: for track in self.arguments["song"]: if track == "-": @@ -205,27 +213,21 @@ class Spotdl: self.arguments["list"], ) elif self.arguments["playlist"]: - spotify_tools.write_playlist( - playlist_url=self.arguments["playlist"], text_file=self.arguments["write_to"] - ) + playlist = spotify_tools.fetch_playlist(self.arguments["playlist"]) + spotify_tools.write_playlist_tracks(playlist, self.arguments["write_to"]) elif self.arguments["album"]: - spotify_tools.write_album( - album_url=self.arguments["album"], text_file=self.arguments["write_to"] - ) + album = spotify_tools.fetch_album(self.arguments["album"]) + spotify_tools.write_album_tracks(album, self.arguments["write_to"]) elif self.arguments["all_albums"]: - spotify_tools.write_all_albums_from_artist( - artist_url=self.arguments["all_albums"], text_file=self.arguments["write_to"] - ) + albums = spotify_tools.fetch_albums_from_artist(self.arguments["all_albums"]) + spotify_tools.write_all_albums(albums, self.arguments["write_to"]) elif self.arguments["username"]: - spotify_tools.write_user_playlist( - username=self.arguments["username"], text_file=self.arguments["write_to"] - ) + playlist_url = spotify_tools.prompt_for_user_playlist(self.arguments["username"]) + playlist = spotify_tools.fetch_playlist(playlist_url) + spotify_tools.write_playlist_tracks(playlist, self.arguments["write_to"]) def download_track(self, track): logger.info('Downloading "{}"'.format(track)) - track_splits = track.split(":") - if len(track_splits) == 2: - youtube_track, spotify_track = track_splits try: metadata = search_metadata( track, @@ -237,8 +239,19 @@ class Spotdl: else: self.download_track_from_metadata(metadata) + def should_we_overwrite_existing_file(self): + if self.arguments["overwrite"] == "force": + logger.info("Forcing overwrite on existing file.") + to_overwrite = True + elif self.arguments["overwrite"] == "prompt": + to_overwrite = input("Overwrite? (y/N): ").lower() == "y" + else: + logger.info("Not overwriting existing file.") + to_overwrite = False + + return to_overwrite + def download_track_from_metadata(self, metadata): - # TODO: Add `-m` flag track = Track(metadata, cache_albumart=(not self.arguments["no_metadata"])) stream = metadata["streams"].get( quality=self.arguments["quality"], @@ -264,28 +277,19 @@ class Spotdl: ) ) - to_skip = self.arguments["dry_run"] - if not to_skip and os.path.isfile(filename): - msg_already_exists = 'A file with name "{filename}" already exists.'.format( + to_skip_download = self.arguments["dry_run"] + if os.path.isfile(filename): + logger.info('A file with name "{filename}" already exists.'.format( filename=filename - ) - if self.arguments["overwrite"] == "force": - force_overwrite_msg = msg_already_exists + " Forcing overwrite." - to_skip = False - logger.info(force_overwrite_msg) - elif self.arguments["overwrite"] == "prompt": - prompt_overwrite_msg = msg_already_exists + " Overwrite? (y/N): " - to_skip = not input(prompt_overwrite_msg).lower() == "y" - else: - skip_overwrite_msg = msg_already_exists + " Skipping download." - to_skip = True - logger.info(skip_overwrite_msg) + )) + to_skip_download = to_skip_download \ + or not self.should_we_overwrite_existing_file() - if to_skip: + if to_skip_download: logger.debug("Skip track download.") return - logger.info('Downloading to "{filename}".'.format(filename=filename)) + logger.info('Downloading to "{filename}"'.format(filename=filename)) if Encoder is None: track.download(stream, filename) else: @@ -297,12 +301,15 @@ class Spotdl: ) if not self.arguments["no_metadata"]: - track.metadata["lyrics"] = track.metadata["lyrics"].join() - try: - logger.info("Applying metadata") - track.apply_metadata(filename, encoding=output_extension) - except TypeError: - logger.warning("Cannot apply metadata on provided output format.") + self.apply_metadata(track, filename, output_extension) + + def apply_metadata(self, track, filename, encoding): + track.metadata["lyrics"] = track.metadata["lyrics"].join() + logger.info("Applying metadata") + try: + track.apply_metadata(filename, encoding=encoding) + except TypeError: + logger.warning("Cannot apply metadata on provided output format.") def download_tracks_from_file(self, path): logger.info( @@ -324,19 +331,26 @@ class Spotdl: with open(path, "w") as fout: fout.writelines(tracks) + print("", file=sys.stderr) + for number, track in enumerate(tracks, 1): try: - metadata = search_metadata(track, self.arguments["search_format"]) - log_track_query = str(number) + ". {artist} - {track-name}" + log_track_query = '{position}. Downloading "{track}"'.format( + position=number, + track=track + ) logger.info(log_track_query) + metadata = search_metadata(track, self.arguments["search_format"]) self.download_track_from_metadata(metadata) except (urllib.request.URLError, TypeError, IOError) as e: logger.exception(e.args[0]) - logger.warning("Failed. Will retry after other songs\n") + logger.warning( + "Failed to download current track due to possible network issue. " + "Will retry after other songs." + ) tracks.append(track) - except NoYouTubeVideoFoundError: - logger.warning("Failed. No YouTube video found.\n") - pass + except (NoYouTubeVideoFoundError, NoYouTubeVideoMatchError) as e: + logger.error(e.args[0]) else: if self.arguments["write_successful"]: with open(self.arguments["write_successful"], "a") as fout: @@ -344,12 +358,13 @@ class Spotdl: finally: with open(path, "w") as fout: fout.writelines(tracks[number-1:]) + print("", file=sys.stderr) def download_tracks_from_file_threaded(self, path): # FIXME: Can we make this function cleaner? logger.info( - "Checking and removing any duplicate tracks in {}.".format(path) + "Checking and removing any duplicate tracks in {}.\n".format(path) ) with open(path, "r") as fin: # Read tracks into a list and remove any duplicates @@ -402,6 +417,7 @@ class Spotdl: print(metadata["current_track"]["name"], file=sys.stderr) # self.download_track_from_metadata(metadata["current_track"]) except (urllib.request.URLError, TypeError, IOError) as e: + print("", file=sys.stderr) logger.exception(e.args[0]) logger.warning("Failed. Will retry after other songs\n") tracks.append(current_track) diff --git a/spotdl/helpers/spotify.py b/spotdl/helpers/spotify.py index d336524..9c6bacb 100644 --- a/spotdl/helpers/spotify.py +++ b/spotdl/helpers/spotify.py @@ -4,26 +4,47 @@ # to `spotify._get_id` in below methods. from spotdl.authorize.services import AuthorizeSpotify +import spotdl.util + +import sys import logging logger = logging.getLogger(__name__) +try: + from slugify import SLUG_OK, slugify +except ImportError: + logger.error("Oops! `unicode-slugify` was not found.") + logger.info("Please remove any other slugify library and install `unicode-slugify`.") + sys.exit(5) + + +ALBUM_BASE_URL = "https://open.spotify.com/album/" + class SpotifyHelpers: def __init__(self, spotify=None): + self._ALBUM_BASE_URL = ALBUM_BASE_URL if spotify is None: spotify = AuthorizeSpotify() self.spotify = spotify def prompt_for_user_playlist(self, username): """ Write user playlists to text_file """ - links = fetch_user_playlist_urls(username) - playlist = internals.input_link(links) - return playlist + playlists = self.fetch_user_playlist_urls(username) + for i, playlist in enumerate(playlists, 1): + playlist_details = "{0}. {1:<30} ({2} tracks)".format( + i, playlist["name"], playlist["tracks"]["total"] + ) + print(playlist_details, file=sys.stderr) + print("", file=sys.stderr) + playlist = spotdl.util.prompt_user_for_selection(playlists) + return playlist["external_urls"]["spotify"] def fetch_user_playlist_urls(self, username): """ Fetch user playlists when using the -u option. """ + logger.debug('Fetching playlists for "{username}".'.format(username=username)) playlists = self.spotify.user_playlists(username) - links = [] + collected_playlists = [] check = 1 while True: @@ -31,56 +52,51 @@ class SpotifyHelpers: # in rare cases, playlists may not be found, so playlists['next'] # is None. Skip these. Also see Issue #91. if playlist["name"] is not None: - logger.info( - # u"{0:>5}. {1:<30} ({2} tracks)".format( - # check, playlist["name"], playlist["tracks"]["total"] - # ) - # ) - playlist_url = playlist["external_urls"]["spotify"] - # log.debug(playlist_url) - links.append(playlist_url) + collected_playlists.append(playlist) check += 1 if playlists["next"]: playlists = self.spotify.next(playlists) else: break - return links + return collected_playlists def fetch_playlist(self, playlist_url): + logger.debug('Fetching playlist "{playlist}".'.format(playlist=playlist_url)) try: playlist_id = self.spotify._get_id("playlist", playlist_url) except IndexError: # Wrong format, in either case - # log.error("The provided playlist URL is not in a recognized format!") + logger.error("The provided playlist URL is not in a recognized format!") sys.exit(10) try: results = self.spotify.user_playlist( user=None, playlist_id=playlist_id, fields="tracks,next,name" ) except spotipy.client.SpotifyException: - # log.error("Unable to find playlist") - logger.info("Make sure the playlist is set to publicly visible and then try again") + logger.error("Unable to find playlist") + logger.info("Make sure the playlist is set to publicly visible and then try again.") sys.exit(11) return results - def write_playlist(self, playlist, text_file=None): + def write_playlist_tracks(self, playlist, text_file=None): tracks = playlist["tracks"] if not text_file: text_file = u"{0}.txt".format(slugify(playlist["name"], ok="-_()[]{}")) - return write_tracks(tracks, text_file) + return self.write_tracks(tracks, text_file) def fetch_album(self, album_url): + logger.debug('Fetching album "{album}".'.format(album=album_url)) album_id = self.spotify._get_id("album", album_url) album = self.spotify.album(album_id) return album - def write_album(self, album, text_file=None): + def write_album_tracks(self, album, text_file=None): tracks = self.spotify.album_tracks(album["id"]) if not text_file: text_file = u"{0}.txt".format(slugify(album["name"], ok="-_()[]{}")) - return write_tracks(tracks, text_file) + return self.write_tracks(tracks, text_file) def fetch_albums_from_artist(self, artist_url, album_type=None): """ @@ -92,9 +108,10 @@ class SpotifyHelpers: :param return - the album from the artist """ + logger.debug('Fetching all albums for "{artist}".'.format(artist=artist_url)) + artist_id = self.spotify._get_id("artist", artist_url) # fetching artist's albums limitting the results to the US to avoid duplicate # albums from multiple markets - artist_id = self.spotify._get_id("artist", artist_url) results = self.spotify.artist_albums(artist_id, album_type=album_type, country="US") albums = results["items"] @@ -106,7 +123,7 @@ class SpotifyHelpers: return albums - def write_all_albums_from_artist(self, albums, text_file=None): + def write_all_albums(self, albums, text_file=None): """ This function gets all albums from an artist and writes it to a file in the current working directory called [ARTIST].txt, where [ARTIST] is the artist @@ -115,20 +132,17 @@ class SpotifyHelpers: :param text_file - file to write albums to """ - album_base_url = "https://open.spotify.com/album/" - # if no file if given, the default save file is in the current working # directory with the name of the artist if text_file is None: text_file = albums[0]["artists"][0]["name"] + ".txt" for album in albums: - logging album name - log.info("Fetching album: " + album["name"]) - write_album(album_base_url + album["id"], text_file=text_file) + logger.info('Fetching album "{album}".'.format(album=album["name"])) + self.write_album_tracks(album, text_file=text_file) def write_tracks(self, tracks, text_file): - logger.info(u"Writing {0} tracks to {1}".format(tracks["total"], text_file)) + logger.info(u"Writing {0} tracks to {1}.".format(tracks["total"], text_file)) track_urls = [] with open(text_file, "a") as file_out: while True: @@ -139,12 +153,13 @@ class SpotifyHelpers: track = item try: track_url = track["external_urls"]["spotify"] - # log.debug(track_url) file_out.write(track_url + "\n") track_urls.append(track_url) except KeyError: - # log.warning( - u"Skipping track {0} by {1} (local only?)".format( + # FIXME: Write "{artist} - {name}" instead of Spotify URI for + # "local only" tracks. + logger.warning( + 'Skipping track "{0}" by "{1}" (local only?)'.format( track["name"], track["artists"][0]["name"] ) ) diff --git a/spotdl/util.py b/spotdl/util.py index bf7471f..647ae69 100644 --- a/spotdl/util.py +++ b/spotdl/util.py @@ -52,7 +52,7 @@ def merge(base, overrider): def prompt_user_for_selection(items): """ Let the user input a choice. """ - logger.info("Choose your number:") + logger.info("Enter a number:") while True: try: the_chosen_one = int(input("> "))