def get_playlist(playlist_uri):
tracks = []
if 'playlist' in playlist_uri: # playlist
try:
playlist = spotify_tools.fetch_playlist(playlist_uri)
except spotipy.client.SpotifyException as e:
log.error(e)
log.debug('Token expired, generating new one and authorizing')
new_token = spotify_tools.generate_token()
spotify_tools.spotify = spotipy.Spotify(auth=new_token)
playlist = spotify_tools.fetch_playlist(playlist_uri)
if playlist is None:
# self.error = "Could not find playlist. Please check the playlist URL and try again."
return
tracks = get_tracks(playlist['tracks'])
else: # song
try:
meta_tags = spotify_tools.generate_metadata(playlist_uri)
except spotipy.client.SpotifyException as e:
log.error(e)
# self.error = "Could not find song. Please check the song URL and try again."
return
track_name = meta_tags['name']
track_artist = meta_tags['artists'][0]['name']
track_url = playlist_uri
return tracks
def download_list(text_file):
""" Download all songs from the list. """
with open(text_file, 'r') as listed:
# read tracks into a list and remove any duplicates
lines = listed.read().splitlines()
lines = list(set(lines))
# ignore blank lines in text_file (if any)
try:
lines.remove('')
except ValueError:
pass
log.info(u'Preparing to download {} songs'.format(len(lines)))
downloaded_songs = []
for number, raw_song in enumerate(lines, 1):
print('')
try:
download_single(raw_song, number=number)
# token expires after 1 hour
except spotipy.client.SpotifyException:
# refresh token when it expires
log.debug('Token expired, generating new one and authorizing')
new_token = spotify_tools.generate_token()
spotify_tools.spotify = spotipy.Spotify(auth=new_token)
download_single(raw_song, number=number)
# detect network problems
except (urllib.request.URLError, TypeError, IOError):
lines.append(raw_song)
# remove the downloaded song from file
internals.trim_song(text_file)
# and append it at the end of file
with open(text_file, 'a') as myfile:
myfile.write(raw_song + '\n')
log.warning(
'Failed to download song. Will retry after other songs\n')
# wait 0.5 sec to avoid infinite looping
time.sleep(0.5)
continue
downloaded_songs.append(raw_song)
log.debug('Removing downloaded song from text file')
internals.trim_song(text_file)
return downloaded_songs
def convert(self, uri, convert_count, logged_in):
self.playlist_uri = uri
self.convert_count = convert_count
self.logged_in = logged_in
self.progress = 0
self.done = 1
self.out_of = 0
self.time_left = ""
self.current_song = ""
self.error = ""
self.finished = False
tracks = []
if 'playlist' in self.playlist_uri: # playlist
try:
playlist = spotify_tools.fetch_playlist(self.playlist_uri)
except spotipy.client.SpotifyException as e:
log.error(e)
log.debug('Token expired, generating new one and authorizing')
new_token = spotify_tools.generate_token()
spotify_tools.spotify = spotipy.Spotify(auth=new_token)
playlist = spotify_tools.fetch_playlist(self.playlist_uri)
if playlist is None:
self.error = "Could not find playlist. Please check the playlist URL and try again."
return
tracks = get_tracks(playlist['tracks'])
else: # song
try:
meta_tags = spotify_tools.generate_metadata(self.playlist_uri)
except spotipy.client.SpotifyException as e:
log.error(e)
self.error = "Could not find song. Please check the song URL and try again."
return
track_name = meta_tags['name']
track_artist = meta_tags['artists'][0]['name']
track_url = self.playlist_uri
tracks.append((track_name, track_artist, track_url))
self.progress = 10
length = len(tracks)
time_per_song = 9
self.out_of = length
seconds_left = length * time_per_song
self.time_left = get_time_left(seconds_left)
self.update_state(state="STARTED",
meta={'status': '200',
'error': self.error,
'finished': self.finished,
'progress': self.progress,
'current_song': self.current_song,
'done': self.done,
'out_of': self.out_of,
'time_left': self.time_left})
log.info(u'Preparing to convert {} songs'.format(length))
percentPerSong = 90 / length
converted_songs = []
for number, track in enumerate(tracks, 1):
embed_metadata = self.logged_in
high_quality = self.logged_in
if self.logged_in or self.convert_count <= max_converts:
track_name = track[0]
track_artist = track[1]
track_url = track[2]
start_time = time.time()
self.current_song = internals.sanitize_title('{} - {}'.format(track_name, track_artist))
# either not yet converted or not fully converted
try:
auxport.convert_single(track_url, folder, number, embed_metadata, high_quality)
time_per_song = (time.time() - start_time)
self.convert_count += 1
# token expires after 1 hour
except spotipy.client.SpotifyException as e:
# refresh token when it expires
log.error(e)
log.debug('Token expired, generating new one and authorizing')
new_token = spotify_tools.generate_token()
spotify_tools.spotify = spotipy.Spotify(auth=new_token)
auxport.convert_single(track_url, folder, number, embed_metadata, high_quality)
time_per_song = (time.time() - start_time)
self.convert_count += 1
# detect network problems
except (urllib.request.URLError, TypeError, IOError) as e:
log.error(e)
log.debug('Network error when converting {} by {}'.format(track_name, track_artist))
continue
except Exception as e:
log.error(e)
continue
else:
self.convert_count += 1
seconds_left = (length - self.done) * time_per_song
if self.done < self.out_of:
self.done += 1
self.progress += percentPerSong
self.time_left = get_time_left(seconds_left)
self.update_state(state="PROGRESS",
meta={'status': '200',
'error': self.error,
'finished': self.finished,
'progress': self.progress,
'current_song': self.current_song,
'done': self.done,
'out_of': self.out_of,
'time_left': self.time_left})
log.debug('Percent:' + str(self.progress) + "%")
else: # limit reached
break
def download_list(text_file, folder=None):
""" Download all songs from the list. """
log.debug('Python version: {}'.format(sys.version))
log.debug('Platform: {}'.format(platform.platform()))
with open(text_file, 'r') as listed:
lines = (listed.read()).splitlines()
# ignore blank lines in text_file (if any)
try:
lines.remove('')
except ValueError:
pass
shuffle(lines)
log.info('Preparing to download {} songs from {}\n'.format(
len(lines),
str(text_file).rsplit('/')[-1]))
downloaded_songs = []
timeout = time.time() + int(
os.getenv('MAX_DOWNLOAD_TIME_PLAYLIST_MIN', '45')) * 60
for number, raw_song in enumerate(lines, 1):
if time.time() > timeout:
log.info(
'Playlist timeout! Stopping download of playlist.\nDownloaded {} tracks.'
.format(number - 1))
return False
try:
positive_download = download_single(raw_song,
number=number,
folder=folder)
# token expires after 1 hour
except spotipy.client.SpotifyException:
# refresh token when it expires
log.debug('Token expired, generating new one and authorizing')
new_token = spotify_tools.generate_token()
spotify_tools.spotify = spotipy.Spotify(auth=new_token)
positive_download = download_single(raw_song,
number=number,
folder=folder)
# detect network problems
except (urllib.request.URLError, TypeError, IOError) as e:
lines.append(raw_song)
# remove the downloaded song from file
internals.trim_song(text_file)
# and append it at the end of file
with open(text_file, 'a') as myfile:
myfile.write(raw_song + '\n')
log.error(repr(e))
log.warning(
'Failed to download song. Will retry after other songs\n')
# wait 0.5 sec to avoid infinite looping
time.sleep(0.5)
continue
if not positive_download:
with open(os.path.join(folder, '_dead_tracks'), 'a') as f:
f.write(raw_song + '\n')
downloaded_songs.append(raw_song)
log.debug('Removing downloaded song from text file')
internals.trim_song(text_file)
log.info('Finished downloading {} songs from {}\n'.format(
len(downloaded_songs),
str(text_file).rsplit('/')[-1]))
return True
