def run(self):
container_loaded.wait()
container_loaded.clear()
link = Link.from_string(sys.argv[3])
if link.type() == Link.LINK_TRACK:
track = link.as_track()
itrack = iter([track])
elif link.type() == Link.LINK_PLAYLIST:
playlist = link.as_playlist()
print('loading playlist...')
while not playlist.is_loaded():
time.sleep(0.1)
print('done')
itrack = iter(playlist)
session = self.ripper.session
for track in itrack:
self.ripper.load_track(track)
rip_init(session, track)
self.ripper.play()
end_of_track.wait()
end_of_track.clear()
rip_terminate(session, track)
rip_id3(session, track)
self.ripper.disconnect()
def _lookup_playlist(self, uri):
playlist = Link.from_string(uri).as_playlist()
self._wait_for_object_to_load(playlist)
return [
SpotifyTrack(track=t) for t in playlist
if t.availability() == TRACK_AVAILABLE
]
def track_playback_started(self, track):
try:
if track.name == u'[loading...]':
spotify_track = Link.from_string(track.uri).as_track()
# TODO Block until metadata_updated callback is called. Before that
# the track will be unloaded, unless it's already in the stored
# playlists.
if not spotify_track.is_loaded():
logger.debug(u'Looking up "%s" from metadata API', track.uri)
spotify_track = utils.lookup_spotify_track(track.uri)
track = Track(
uri=track.uri,
name=spotify_track["track"]["name"],
artists=[Artist(name=artist["name"], uri=artist["href"]) for artist in spotify_track["track"]["artists"]],
album=Album(name=spotify_track["track"]["album"]["name"], uri=spotify_track["track"]["album"]["href"]),
track_no=spotify_track["track"]["track-number"],
length=spotify_track["track"]["length"],
bitrate=settings.SPOTIFY_BITRATE,
)
else:
track = SpotifyTranslator.to_mopidy_track(spotify_track)
# Tweet #Nowplaying ... / ... requested by @...
artists = ', '.join([a.name for a in track.artists])
uri = track.uri
screen_name = self.requests.pop(uri)
# Send tweet!
tweet = u'#Nowplaying %s / %s, requested by @%s %s' % (artists, track.name, screen_name, utils.spotify_uri_to_url(uri))
self.api.update_status(status=tweet, lat="50.82519295639108", long="-0.14594435691833496", display_coordinates="1")
logger.info(u'Tweeted: %s' % tweet)
except SpotifyError, e:
logger.debug(u'Failed to lookup "%s": %s', track.uri, e)
def load(self, tid):
log.msg("load %r" % tid, system="squeal.spot.service.SpotifyManager")
if self.playing:
self.session.play(0)
link = Link.from_string(tid)
track = link.as_track()
self.session.load(track)
def _lookup_track(self, uri):
track = Link.from_string(uri).as_track()
utils.wait_for_object_to_load(track, self._timeout)
if track.is_loaded():
return [SpotifyTrack(track=track)]
else:
return [SpotifyTrack(uri=uri)]
def do_play(self, line):
if not line:
self.jukebox.play()
return
try:
if line.startswith("spotify:"):
# spotify url
l = Link.from_string(line)
if not l.type() == Link.LINK_TRACK:
print "You can only play tracks!"
return
self.jukebox.load_track(l.as_track())
else:
try:
playlist, track = map(int, line.split(' ', 1))
self.jukebox.load(playlist, track)
except ValueError:
try:
playlist = int(line)
self.jukebox.load_playlist(playlist)
except ValueError:
print("Usage: play [track_link] | "
"[playlist] [track] | [playlist]")
return
except SpotifyError as e:
print "Unable to load track:", e
return
self.jukebox.play()
def _lookup_track(self, uri):
track = Link.from_string(uri).as_track()
utils.wait_for_object_to_load(track, self._timeout)
if track.is_loaded():
return [SpotifyTrack(track=track)]
else:
return [SpotifyTrack(uri=uri)]
def play(self, track):
if track.uri is None:
return False
spotify_backend = self.backend.actor_ref.proxy()
need_data_callback_bound = functools.partial(need_data_callback,
spotify_backend)
enough_data_callback_bound = functools.partial(enough_data_callback,
spotify_backend)
seek_data_callback_bound = functools.partial(seek_data_callback,
spotify_backend)
self._first_seek = True
try:
self.backend.spotify.session.load(
Link.from_string(track.uri).as_track())
self.backend.spotify.session.play(1)
self.backend.spotify.buffer_timestamp = 0
self.audio.prepare_change()
self.audio.set_appsrc(self._caps,
need_data=need_data_callback_bound,
enough_data=enough_data_callback_bound,
seek_data=seek_data_callback_bound)
self.audio.start_playback()
self.audio.set_metadata(track)
return True
except SpotifyError as e:
logger.info('Playback of %s failed: %s', track.uri, e)
return False
def play(self, track):
if track.uri is None:
return False
spotify_backend = self.backend.actor_ref.proxy()
need_data_callback_bound = functools.partial(
need_data_callback, spotify_backend)
enough_data_callback_bound = functools.partial(
enough_data_callback, spotify_backend)
seek_data_callback_bound = functools.partial(
seek_data_callback, spotify_backend)
self._first_seek = True
try:
spotify_track = Link.from_string(track.uri).as_track()
utils.wait_for_object_to_load(spotify_track, self._timeout)
self.backend.spotify.session.load(spotify_track)
self.backend.spotify.session.play(1)
self.backend.spotify.buffer_timestamp = 0
self.audio.prepare_change()
self.audio.set_appsrc(
self._caps,
need_data=need_data_callback_bound,
enough_data=enough_data_callback_bound,
seek_data=seek_data_callback_bound)
self.audio.start_playback()
self.audio.set_metadata(track)
return True
except SpotifyError as e:
logger.info('Playback of %s failed: %s', track.uri, e)
return False
def _lookup_album(self, uri):
album = Link.from_string(uri).as_album()
album_browser = self.backend.spotify.session.browse_album(album)
self._wait_for_object_to_load(album_browser)
return [
SpotifyTrack(track=t)
for t in album_browser if t.availability() == TRACK_AVAILABLE]
def do_play(self, line):
if not line:
self.jukebox.play()
return
try:
if line.startswith("spotify:"):
# spotify url
l = Link.from_string(line)
if not l.type() == Link.LINK_TRACK:
print "You can only play tracks!"
return
self.jukebox.load_track(l.as_track())
else:
try:
playlist, track = map(int, line.split(' ', 1))
self.jukebox.load(playlist, track)
except ValueError:
try:
playlist = int(line)
self.jukebox.load_playlist(playlist)
except ValueError:
print(
"Usage: play [track_link] | "
"[playlist] [track] | [playlist]")
return
except SpotifyError as e:
print "Unable to load track:", e
return
self.jukebox.play()
def run(self):
# wait for container
container_loaded.wait()
container_loaded.clear()
# create track iterator
link = Link.from_string(sys.argv[3])
if link.type() == Link.LINK_TRACK:
track = link.as_track()
itrack = iter([track])
elif link.type() == Link.LINK_PLAYLIST:
playlist = link.as_playlist()
print('loading playlist ...')
while not playlist.is_loaded():
time.sleep(0.1)
print('done')
itrack = iter(playlist)
# ripping loop
session = self.ripper.session
for track in itrack:
self.ripper.load_track(track)
rip_init(session, track)
self.ripper.play()
end_of_track.wait()
end_of_track.clear() # TODO check if necessary
rip_terminate(session, track)
rip_id3(session, track)
self.ripper.disconnect()
def do_quit(self, line):
link = Link.from_string("spotify:track:5sCCUyrCF2u9LerPMUsmlY")
track = link.as_track()
while(track.is_loaded() != 1):
pass
self.jukebox.load_track(track)
self.jukebox.play()
def _lookup_album(self, uri):
album = Link.from_string(uri).as_album()
album_browser = self.backend.spotify.session.browse_album(album)
self._wait_for_object_to_load(album_browser)
return [
SpotifyTrack(track=t) for t in album_browser
if t.availability() == TRACK_AVAILABLE
]
def queue_song(self, uri):
l = Link.from_string(uri)
track = l.as_track()
print track
for pl in self.ctr:
if(pl.name() != 'playing'):
continue
pl.add_tracks(len(pl), [track])
def __init__(self, uri=None, track=None):
super(SpotifyTrack, self).__init__()
if (uri and track) or (not uri and not track):
raise AttributeError('uri or track must be provided')
elif uri:
self._spotify_track = Link.from_string(uri).as_track()
elif track:
self._spotify_track = track
self._track = None
def __init__(self, uri=None, track=None):
super(SpotifyTrack, self).__init__()
if (uri and track) or (not uri and not track):
raise AttributeError('uri or track must be provided')
elif uri:
self._spotify_track = Link.from_string(uri).as_track()
elif track:
self._spotify_track = track
self._track = None
def do_add_to_playlist(index, track_string): try: l=Link.from_string(track_string) except SpotifyError as e: print "error", e playlist=j.ctr[index] print playlist.name() playlist.add_tracks(len(playlist), [l.as_track()])
def load_cover(self, link, callback, userdata):
track = Link.from_string(link).as_track()
covid = track.album().cover()
if covid:
img = self.session.image_create(covid)
if img.is_loaded():
callback(img, userdata)
else:
img.add_load_callback(callback, userdata)
def load_track(self, uri):
''' Load a track from a spotify URI
Note: this currently polls as there is no API for browsing
individual tracks
:param uri: The spotify URI of the track to load.
'''
track = Link.from_string(uri).as_track()
return self.wait_until_loaded(track, POLL_TIMEOUT)
def _lookup_track(self, uri):
track = Link.from_string(uri).as_track()
self._wait_for_object_to_load(track)
if track.is_loaded():
if track.availability() == TRACK_AVAILABLE:
return [SpotifyTrack(track=track)]
else:
return []
else:
return [SpotifyTrack(uri=uri)]
def _lookup_track(self, uri):
track = Link.from_string(uri).as_track()
self._wait_for_object_to_load(track)
if track.is_loaded():
if track.availability() == TRACK_AVAILABLE:
return [SpotifyTrack(track=track)]
else:
return []
else:
return [SpotifyTrack(uri=uri)]
def lookup(self, uri):
try:
spotify_track = Link.from_string(uri).as_track()
# TODO Block until metadata_updated callback is called. Before that
# the track will be unloaded, unless it's already in the stored
# playlists.
return SpotifyTranslator.to_mopidy_track(spotify_track)
except SpotifyError as e:
logger.debug(u'Failed to lookup "%s": %s', uri, e)
return None
def lookup(self, uri):
try:
spotify_track = Link.from_string(uri).as_track()
# TODO Block until metadata_updated callback is called. Before that
# the track will be unloaded, unless it's already in the stored
# playlists.
return SpotifyTranslator.to_mopidy_track(spotify_track)
except SpotifyError as e:
logger.debug(u'Failed to lookup "%s": %s', uri, e)
return None
def load_track(self, uri):
''' Load a track from a spotify URI
Note: this currently polls as there is no API for browsing
individual tracks
:param uri: The spotify URI of the track to load.
'''
track = Link.from_string(uri).as_track()
return self.wait_until_loaded(track, POLL_TIMEOUT)
def star(self, track_uri, session):
link = Link.from_string(track_uri)
if not link.type() == Link.LINK_TRACK:
return
print "Starring", track_uri
track = link.as_track()
track.starred(session, True)
return track.starred(session)
def __init__(self, uri=None, track=None):
super(SpotifyTrack, self).__init__()
if (uri and track) or (not uri and not track):
raise AttributeError("uri or track must be provided")
elif uri:
self._spotify_track = Link.from_string(uri).as_track()
elif track:
self._spotify_track = track
self._unloaded_track = Track(uri=uri, name="[loading...]")
self._track = None
def browse(self, uri):
if uri == self.root_directory.uri:
return self._root
variant, identifier = translator.parse_uri(uri.lower())
if variant == 'album':
album = Link.from_string(uri).as_album()
album_browser = self.backend.spotify.session.browse_album(album)
utils.wait_for_object_to_load(album_browser, self._timeout)
return [translator.to_mopidy_track_ref(t) for t in album_browser]
if variant == 'user':
playlist = Link.from_string(uri).as_playlist()
utils.wait_for_object_to_load(playlist, self._timeout)
return [translator.to_mopidy_track_ref(t) for t in playlist]
if variant != 'toplist':
return []
if identifier == 'countries':
return self._countries
if identifier not in ('all', 'current'):
identifier = identifier.upper()
if identifier not in SPOTIFY_COUNTRIES:
return []
result = []
done = threading.Event()
def callback(browser, userdata):
for track in browser:
result.append(translator.to_mopidy_track_ref(track))
done.set()
logger.debug('Performing toplist browse for %s', identifier)
ToplistBrowser(b'tracks', bytes(identifier), callback, None)
if not done.wait(self._timeout):
logger.warning('%s toplist browse timed out.', identifier)
return result
def browse(self, uri):
if uri == self.root_directory.uri:
return self._root
variant, identifier = translator.parse_uri(uri.lower())
if variant == 'album':
album = Link.from_string(uri).as_album()
album_browser = self.backend.spotify.session.browse_album(album)
utils.wait_for_object_to_load(album_browser, self._timeout)
return [translator.to_mopidy_track_ref(t) for t in album_browser]
if variant == 'user':
playlist = Link.from_string(uri).as_playlist()
utils.wait_for_object_to_load(playlist, self._timeout)
return [translator.to_mopidy_track_ref(t) for t in playlist]
if variant != 'toplist':
return []
if identifier == 'countries':
return self._countries
if identifier not in ('all', 'current'):
identifier = identifier.upper()
if identifier not in SPOTIFY_COUNTRIES:
return []
result = []
done = threading.Event()
def callback(browser, userdata):
for track in browser:
result.append(translator.to_mopidy_track_ref(track))
done.set()
logger.debug('Performing toplist browse for %s', identifier)
ToplistBrowser(b'tracks', bytes(identifier), callback, None)
if not done.wait(self._timeout):
logger.warning('%s toplist browse timed out.', identifier)
return result
def do_browse(self, line):
if not line or not line.startswith("spotify:"):
print "Invalid id provided"
return
l = Link.from_string(line)
if not l.type() in [Link.LINK_ALBUM, Link.LINK_ARTIST]:
print "You can only browse albums and artists"
return
def browse_finished(browser):
print "Browse finished"
self.jukebox.browse(l, browse_finished)
def play_track(self, track_str):
l = Link.from_string(track_str)
if not l.type() == Link.LINK_TRACK:
print "You can only play tracks!"
return
try:
self.jukebox.load_track(l.as_track())
self.jukebox.play()
return True
except Exception as e:
return False
def play_track(self,track_str):
l = Link.from_string(track_str)
if not l.type() == Link.LINK_TRACK:
print "You can only play tracks!"
return
try:
self.jukebox.load_track(l.as_track())
self.jukebox.play()
return True
except Exception as e:
return False
def do_browse(self, line):
if not line or not line.startswith("spotify:"):
print "Invalid id provided"
return
l = Link.from_string(line)
if not l.type() in [Link.LINK_ALBUM, Link.LINK_ARTIST]:
print "You can only browse albums and artists"
return
def browse_finished(browser, userdata):
print "Browse finished, %s" % (userdata)
self.jukebox.browse(l, browse_finished)
def play_callback(data):
track = data.strip('\"')
print "Playing: %s" % track
try:
if track.startswith("spotify:"):
l = Link.from_string(track)
if not l.type() == Link.LINK_TRACK:
print "Can only play tracks!"
return
session.load_track(l.as_track())
except SpotifyError as e:
print "Unable to load track:", e
return
session.play()
def play(self, track):
self.backend.output.set_state('READY')
if self.backend.playback.state == self.backend.playback.PLAYING:
self.backend.spotify.session.play(0)
if track.uri is None:
return False
try:
self.backend.spotify.session.load(
Link.from_string(track.uri).as_track())
self.backend.spotify.session.play(1)
self.backend.output.set_state('PLAYING')
return True
except SpotifyError as e:
logger.warning('Play %s failed: %s', track.uri, e)
return False
def next(self): if self.playing: self.stop() if self.manager.trackQueue: if len(self.manager.trackQueue) > self.currentIndex: l = Link.from_string(self.manager.trackQueue[self.currentIndex]) self.currentIndex += 1 print self.currentIndex if l.type() == Link.LINK_TRACK: threading.Timer(0,self.load_track,[l.as_track()]).start() else: self.stop() else: print "Reached end of queue" self.stop()
def play(self, track):
if self.backend.playback.state == PlaybackState.PLAYING:
self.backend.spotify.session.play(0)
if track.uri is None:
return False
try:
self.backend.spotify.session.load(Link.from_string(track.uri).as_track())
self.backend.spotify.session.play(1)
self.backend.audio.prepare_change()
self.backend.audio.set_uri("appsrc://")
self.backend.audio.start_playback()
self.backend.audio.set_metadata(track)
return True
except SpotifyError as e:
logger.info("Playback of %s failed: %s", track.uri, e)
return False
def action_load_track(self, track, playlist=None):
extra = {}
if track.startswith("spotify:"):
# spotify url
l = Link.from_string(track)
if not l.type() == Link.LINK_TRACK:
print "You can only play tracks!"
return False
self.load_track(l.as_track())
extra.update({'type':'link', 'playlist':'link'})
elif playlist != None:
#print "Usage: play [track_link] | [playlist] [track]"
self.load(playlist, track)
extra.update({'type':'playlistmember', 'playlist':playlist})
self.play()
self.onEvent('playing',track,extra)
def lookup(self, uri):
try:
link = Link.from_string(uri)
if link.type() == Link.LINK_TRACK:
return self._lookup_track(uri)
if link.type() == Link.LINK_ALBUM:
return self._lookup_album(uri)
elif link.type() == Link.LINK_ARTIST:
return self._lookup_artist(uri)
elif link.type() == Link.LINK_PLAYLIST:
return self._lookup_playlist(uri)
else:
return []
except SpotifyError as error:
logger.debug(u'Failed to lookup "%s": %s', uri, error)
return []
def action_load_track(self, track, playlist=None):
extra = {}
if track.startswith("spotify:"):
# spotify url
l = Link.from_string(track)
if not l.type() == Link.LINK_TRACK:
print "You can only play tracks!"
return False
self.load_track(l.as_track())
extra.update({'type': 'link', 'playlist': 'link'})
elif playlist != None:
#print "Usage: play [track_link] | [playlist] [track]"
self.load(playlist, track)
extra.update({'type': 'playlistmember', 'playlist': playlist})
self.play()
self.onEvent('playing', track, extra)
def lookup(self, uri):
try:
link = Link.from_string(uri)
if link.type() == Link.LINK_TRACK:
return self._lookup_track(uri)
if link.type() == Link.LINK_ALBUM:
return self._lookup_album(uri)
elif link.type() == Link.LINK_ARTIST:
return self._lookup_artist(uri)
elif link.type() == Link.LINK_PLAYLIST:
return self._lookup_playlist(uri)
else:
return []
except SpotifyError as error:
logger.debug(u'Failed to lookup "%s": %s', uri, error)
return []
def cmd_load_track(self, track, playlist=None):
extra = {}
if track.startswith("spotify:"):
# spotify url
l = Link.from_string(track)
if not l.type() == Link.LINK_TRACK:
print "You can only play tracks!"
return False
self.load_track(l.as_track())
extra.update({"type": "link", "playlist": "link"})
elif playlist != None:
# print "Usage: play [track_link] | [playlist] [track]"
self.load(playlist, track)
extra.update({"type": "playlistmember", "playlist": playlist})
self.play()
self.onEvent("playing", track, extra)
def get_art(self, uri, callback):
''' Fetch and return album artwork.
note:: Currently only album artowk can be retrieved.
:param uri: The spotify URI of the album to load art for.
:param callback: The callback to invoke when artwork is loaded.
Should take image data as a single parameter.
'''
self.log("Get artwork: %s" % uri)
link = Link.from_string(uri)
if link.type() != Link.LINK_ALBUM:
raise RuntimeError("Non album artwork not supported")
album = link.as_album()
def browse_finished(browser):
self.load_image(uri, album.cover(), callback)
return self.browse_album(album, browse_finished)
def get_artist_albums(self, uri, completion):
''' Browse an artist invoking the completion callback when done.
:param uri: The Spotify URI of the artist to browse.
:param completion: A callback to invoke with results when done.
'''
artist = Link.from_string(uri).as_artist()
def browse_finished(browser):
del self.browsers[uri]
albums = browser.albums()
directory = ObjectContainer(
title2 = artist.name().decode("utf-8"),
view_group = ViewMode.Tracks)
for album in albums:
self.add_album_to_directory(album, directory)
completion(directory)
self.browsers[uri] = self.client.browse_artist(artist, browse_finished)
def get_album_tracks(self, uri, completion):
''' Browse an album invoking the completion callback when done.
:param uri: The Spotify URI of the album to browse.
:param completion: A callback to invoke with results when done.
'''
album = Link.from_string(uri).as_album()
def browse_finished(browser):
del self.browsers[uri]
tracks = list(browser)
directory = ObjectContainer(
title2 = album.name().decode("utf-8"),
view_group = ViewMode.Tracks)
for track in tracks:
self.add_track_to_directory(track, directory)
completion(directory)
self.browsers[uri] = self.client.browse_album(album, browse_finished)
def play(self, track):
if self.backend.playback.state == PlaybackState.PLAYING:
self.backend.spotify.session.play(0)
if track.uri is None:
return False
try:
self.backend.spotify.session.load(
Link.from_string(track.uri).as_track())
self.backend.spotify.session.play(1)
self.backend.audio.prepare_change()
self.backend.audio.set_uri('appsrc://')
self.backend.audio.start_playback()
self.backend.audio.set_metadata(track)
return True
except SpotifyError as e:
logger.info('Playback of %s failed: %s', track.uri, e)
return False
def track_playback_started(self, track):
try:
if track.name == u'[loading...]':
spotify_track = Link.from_string(track.uri).as_track()
# TODO Block until metadata_updated callback is called. Before that
# the track will be unloaded, unless it's already in the stored
# playlists.
if not spotify_track.is_loaded():
logger.debug(u'Looking up "%s" from metadata API',
track.uri)
spotify_track = utils.lookup_spotify_track(track.uri)
track = Track(
uri=track.uri,
name=spotify_track["track"]["name"],
artists=[
Artist(name=artist["name"], uri=artist["href"])
for artist in spotify_track["track"]["artists"]
],
album=Album(
name=spotify_track["track"]["album"]["name"],
uri=spotify_track["track"]["album"]["href"]),
track_no=spotify_track["track"]["track-number"],
length=spotify_track["track"]["length"],
bitrate=settings.SPOTIFY_BITRATE,
)
else:
track = SpotifyTranslator.to_mopidy_track(spotify_track)
# Tweet #Nowplaying ... / ... requested by @...
artists = ', '.join([a.name for a in track.artists])
uri = track.uri
screen_name = self.requests.pop(uri)
# Send tweet!
tweet = u'#Nowplaying %s / %s, requested by @%s %s' % (
artists, track.name, screen_name,
utils.spotify_uri_to_url(uri))
self.api.update_status(status=tweet,
lat="50.82519295639108",
long="-0.14594435691833496",
display_coordinates="1")
logger.info(u'Tweeted: %s' % tweet)
except SpotifyError, e:
logger.debug(u'Failed to lookup "%s": %s', track.uri, e)
def get_artist_albums(self, uri, completion):
''' Browse an artist invoking the completion callback when done.
:param uri: The Spotify URI of the artist to browse.
:param completion: A callback to invoke with results when done.
'''
artist = Link.from_string(uri).as_artist()
def browse_finished(browser):
del self.browsers[uri]
albums = browser.albums()
directory = ObjectContainer(title2=artist.name().decode("utf-8"),
view_group=ViewMode.Tracks)
for album in albums:
self.add_album_to_directory(album, directory)
completion(directory)
self.browsers[uri] = self.client.browse_artist(artist, browse_finished)
def get_art(self, uri, callback):
''' Fetch and return album artwork.
note:: Currently only album artowk can be retrieved.
:param uri: The spotify URI of the album to load art for.
:param callback: The callback to invoke when artwork is loaded.
Should take image data as a single parameter.
'''
self.log("Get artwork: %s" % uri)
link = Link.from_string(uri)
if link.type() != Link.LINK_ALBUM:
raise RuntimeError("Non album artwork not supported")
album = link.as_album()
def browse_finished(browser):
self.load_image(uri, album.cover(), callback)
return self.browse_album(album, browse_finished)
def run(self):
# wait for container
container_loaded.wait()
container_loaded.clear()
# create track iterator
link = Link.from_string(sys.argv[3])
if link.type() == Link.LINK_PLAYLIST:
playlist = link.as_playlist()
print('Loading the playlist: ' + str(playlist))
while not playlist.is_loaded():
time.sleep(0.1)
print('done')
session = self.ripper.session
name = str(playlist)
print("name: " + name)
for track in iter(playlist):
self.ripper.load_track(track)
rip_init(session, track, name)
rip_id3(session, track, name)
self.ripper.disconnect()
def __init__(self, uri):
self._spotify_track = Link.from_string(uri).as_track()
self._unloaded_track = Track(uri=uri, name=u'[loading...]')
self._track = None
def _lookup_artist(self, uri):
artist = Link.from_string(uri).as_artist()
artist_browser = self.backend.spotify.session.browse_artist(artist)
utils.wait_for_object_to_load(artist_browser, self._timeout)
return [SpotifyTrack(track=t) for t in artist_browser]
def _lookup_playlist(self, uri):
playlist = Link.from_string(uri).as_playlist()
utils.wait_for_object_to_load(playlist, self._timeout)
return [SpotifyTrack(track=t) for t in playlist]
