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]