def open(self): print "def open(self):" self.api_version = spotify.api_version self.cache_location = '/tmp' self.settings_location = '/tmp' self.application_key = None self.appkey_file = 'spotify_appkey.key' self.user_agent = 'chains' if self.application_key is None: self.classdata = config.getServiceSharePath( self.config['main']['class']) + '/' self.application_key = open(self.classdata + self.appkey_file).read() self.awoken = threading.Event() # used to block until awoken self.timer = None self.finished = False self.session = None self.username = self.config.get('username') self.password = self.config.get('password') if not self.username or not self.password: sys.exit('Need username and password') self.audio = AlsaController() self.ctr = None self.playing = False self._queue = [] print "Logging in, please wait..." self.connect() print "Finished connecting?"
def __init__(self, list, *a, **kw): SpotifySessionManager.__init__(self, *a, **kw) self.audio = AlsaController() self.ctr = None self.playing = False self._queue = [] self.to_random = list print "Logging in, please wait..."
def __init__(self, *a, **kw): SpotifySessionManager.__init__(self, *a, **kw) self.audio = AlsaController() self.ui = JukeboxUI(self) self.ctr = None self.playing = False self._queue = [] print "Logging in, please wait..."
def open(self): print "def open(self):" self.api_version = spotify.api_version self.cache_location = "/tmp" self.settings_location = "/tmp" self.application_key = None self.appkey_file = "spotify_appkey.key" self.user_agent = "chains" if self.application_key is None: self.classdata = config.getServiceSharePath(self.config["main"]["class"]) + "/" self.application_key = open(self.classdata + self.appkey_file).read() self.awoken = threading.Event() # used to block until awoken self.timer = None self.finished = False self.session = None self.username = "******" try: self.username = self.config["main"]["username"] except KeyError: log.warn('No "username" in %s service config, using %s' % (self.config["id"], self.username)) self.password = "******" try: self.password = self.config["main"]["password"] except KeyError: log.warn('No "password" in %s service config, using %s' % (self.config["id"], self.password)) self.audio = AlsaController() self.ctr = None self.playing = False self._queue = [] print "Logging in, please wait..." self.connect() print "Finished connecting?"
def open(self): print "def open(self):" self.api_version = spotify.api_version self.cache_location = '/tmp' self.settings_location = '/tmp' self.application_key = None self.appkey_file = 'spotify_appkey.key' self.user_agent = 'chains' if self.application_key is None: self.classdata= config.getServiceSharePath(self.config['main']['class']) + '/' self.application_key = open(self.classdata + self.appkey_file).read() self.awoken = threading.Event() # used to block until awoken self.timer = None self.finished = False self.session = None self.username = self.config.get('username') self.password = self.config.get('password') if not self.username or not self.password: sys.exit('Need username and password') self.audio = AlsaController() self.ctr = None self.playing = False self._queue = [] print "Logging in, please wait..." self.connect() print "Finished connecting?"
def __init__(self, condition, *a, **kw): SpotifySessionManager.__init__(self, *a, **kw) self.audio = AlsaController() self.ctr = None self.playing = False self._queue = [] self.playlist_manager = JukeboxPlaylistManager() self.container_manager = JukeboxContainerManager(condition)
def __init__(self, *args, **kwargs): threading.Thread.__init__(self) SpotifySessionManager.__init__(self, *args, **kwargs) self.audio = AlsaController() self.playing = False self.loaded_tracks = [] self.start()
def __init__(self, *a, **kw): SpotifySessionManager.__init__(self, *a, **kw) self.audio = AlsaController() self.ui = HTTPRequests(self) self.ctr = None self.playing = False self.username = a[0] self._queue = [] print "Trying to log in as " + a[0] + ", please wait..."
class Example1(SpotifySessionManager): queued = False playlist = 2 track = 0 def __init__(self, *a, **kw): SpotifySessionManager.__init__(self, *a, **kw) self.audio = AlsaController() def logged_in(self, session, error): print "logged_in" try: self.ctr = session.playlist_container() print "Got playlist container", repr(self.ctr) except: traceback.print_exc() def metadata_updated(self, session): print "metadata_updated called" try: if not self.queued: playlist = self.ctr[self.playlist] if playlist.is_loaded(): if playlist[self.track].is_loaded(): session.load(playlist[self.track]) session.play(1) self.queued = True print "Playing", playlist[self.track].name() except: traceback.print_exc() def end_of_track(self, session): self.terminate() def music_delivery(self, *a, **kw): return self.audio.music_delivery(*a, **kw)
class SpotCtrlService(Service): ### chains stuff def open(self): print "def open(self):" self.api_version = spotify.api_version self.cache_location = '/tmp' self.settings_location = '/tmp' self.application_key = None self.appkey_file = 'spotify_appkey.key' self.user_agent = 'chains' if self.application_key is None: self.classdata= config.getServiceSharePath(self.config['main']['class']) + '/' self.application_key = open(self.classdata + self.appkey_file).read() self.awoken = threading.Event() # used to block until awoken self.timer = None self.finished = False self.session = None self.username = self.config.get('username') self.password = self.config.get('password') if not self.username or not self.password: sys.exit('Need username and password') self.audio = AlsaController() self.ctr = None self.playing = False self._queue = [] print "Logging in, please wait..." self.connect() print "Finished connecting?" def onDescribe(self): return { 'info': '', 'commands': [ ('quit', [], 'Quit spotify'), ('lists', [], 'List playlists'), ('list', [('listnr','int',None,'Playlist number')], 'List contents of playlist'), ('play', [], 'Play'), ('stop', [], 'Stop'), ('next', [], 'Next track'), ('load', [('listnr','int',None,'Playlist number'),('track','int',None,'Track number')], 'Load track from playlist'), ('load_track', [('track','str',None,'spotify url or playlist id')], 'Load spotify url or playlist id'), ('queue', [], 'List queue'), ('queue_track', [('listnr','int',None,'Playlist number'),('tracknr','int',None,'Track number')], 'Add track to queue'), ('set_bitrate', [('bitrate','str',['normal','high'])], 'Set bitrate to normal or high'), # Simple: ('mycommand', [('arg1','str'), ('arg2','int')]) # Advanced: ('mycommand', [('arg1','str',None,'Arg1 - a string'), ('arg2','int',[3,4],'Arg2 - an int, either 3 or 4')], 'My command description') ], 'events': [ # ('myevent', ('key','str',['mykey1','mykey2'],'event.key = mykey1 or mykey2'), ('value','bool') ), ], } def onEvent(self, key, value, extra): evt = { 'service': self.config['id'], 'key': key, 'value': value, 'extra': extra } self.devDaemon.onEvent(evt) def action_quit(self, line): print "Goodbye!" self.terminate() return True def action_lists(self): """ List the playlists """ extra = {} for i, p in enumerate(self.ctr): if p.is_loaded(): print "%3d %s" % (i, p.name()) extra.update({i: p.name()}) else: print "%3d %s" % (i, "loading...") extra.update({i: "loading..."}) self.onEvent('playlists',len(extra),extra) # return extra def action_list(self, listid): """ List the contents of a playlist """ extra = {} try: p = int(listid) except ValueError: print "that's not a number!" return False if p < 0 or p > len(self.ctr): print "That's out of range!" return False print "Listing playlist #%d" % p for i, t in enumerate(self.ctr[p]): if t.is_loaded(): print "%3d %s" % (i, t.name()) extra.update({i: t.name()}) else: print "%3d %s" % (i, "loading...") extra.update({i: 'loading...'}) self.onEvent('playlist',listid,extra) # return extra def action_play(self): self.play() self.onEvent('status','playing',{}) return True 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 action_search(self, line): if not line: if self.results is False: print "No search is in progress" return False elif self.results is None: print "Searching is in progress" else: print "Artists:" for a in self.results.artists(): print " ", Link.from_artist(a), a.name() print "Albums:" for a in self.results.albums(): print " ", Link.from_album(a), a.name() print "Tracks:" for a in self.results.tracks(): print " ", Link.from_track(a, 0), a.name() print self.results.total_tracks() - len(self.results.tracks()), "Tracks not shown" self.results = False else: self.results = None def _(results, userdata): print "\nSearch results received" self.results = results self.search(line, _) def action_queue(self): extra = {} for playlist, track in self._queue: print playlist, track extra.update({'playlist':playlist, 'trackid':track}) self.onEvent('list','queue',extra) return def action_queue_track(self, playlist, track): try: playlist, track = map(int, line.split(' ', 1)) except ValueError: print "Usage: play playlist track" return self.queue(int(playlist), int(track)) def action_stop(self): self.stop() def action_next(self): self.next() def action_set_bitrate(self, bitrate): self.bitrate(bitrate) def action_load(self,playlist,track): self.load(int(playlist),int(track)) def action_load_tack(self,track): self.load(int(track)) ## spotify main loop etc ############ def connect(self): print "def connect(self)" sess = spotify.connect(self) print str(sess) self.sesson = sess self.loop(sess) # returns on disconnect def loop(self, sess): """ The main loop. This processes events and then either waits for an event. The event is either triggered by a timer expiring, or by a notification from within the spotify subsystem (it calls the wake method below). """ print "def loop(self, sess)" while not self.finished: print "Main loop" self.awoken.clear() timeout = sess.process_events() print "timeout: %s" % str(timeout) self.timer = threading.Timer(timeout/1000.0, self.awoken.set) self.timer.start() self.awoken.wait() def terminate(self): self.finished = True self.wake() disconnect = terminate def wake(self, sess=None): """ This is called by the spotify subsystem to wake up the main loop. """ print "def wake(self, sess=None):" if self.timer is not None: self.timer.cancel() self.awoken.set() # spotify callbacks def logged_in(self, session, error): print "CALLBACK: logged_in(self, session, error): (%s,%s)" % (str(session), str(error)) self.session = session """ try: print "session.username:"******"FAILED: session.username(): " + str(e) try: print "session.user_is_loaded:" + str(self.session.user_is_loaded()) except Exception, e: print "FAILED: session.user_is_loaded(): " + str(e) try: print "session.display_name:" + str(self.session.display_name()) except Exception, e: print "FAILED: session.display_name(): " + str(e) """ if error > 1: return try: self.ctr = self.session.playlist_container() except: print "FAIL: self.ctr = session.playlist_container()" traceback.print_exc() # def logged_in(self, session, error): # """ Called when the user has successfully logged in. You almost # certainly want to do something with session.playlist_container() at # this point. """ # pass def logged_out(self, sess): print "CALLBACK: def logged_out(self, sess):" pass def metadata_updated(self, sess): print "CALLBACK: def metadata_updated(self, sess): CallBack" pass def connection_error(self, sess, error): print "CALLBACK: def connection_error(self, sess, error): %s" % str(error) pass def message_to_user(self, sess, message): print "CALLBACK: def message_to_user(self, sess, message): %s" % str(message) pass def notify_main_thread(self, sess): print "CALLBACK: def notify_main_thread(self, sess):" pass def music_delivery(self, sess, frames, frame_size, num_frames, sample_type, sample_rate, channels): print "CALLBACK: def music_delivery(self, sess, frames, frame_size, num_frames, sample_type, sample_rate, channels):" pass def play_token_lost(self, sess): print "CALLBACK: def play_token_lost(self, sess):" pass def log_message(self, sess, data): print "CALLBACK: def log_message(self, sess, data): %s" % str(data) pass def end_of_track(self, sess): print "CALLBACK: def end_of_track(self, sess):" pass # spotify functions def load(self, playlist, track): if self.playing: self.stop() self.session.load(self.ctr[playlist][track]) print "Loading %s from %s" % (self.ctr[playlist][track].name(), self.ctr[playlist].name()) def load_track(self, track): if self.playing: self.stop() self.session.load(track) print "Loading %s" % track.name() def queue(self, playlist, track): if self.playing: self._queue.append((playlist, track)) else: self.load(playlist, track) self.play() def play(self): self.session.play(1) print "Playing" self.playing = True def stop(self): self.session.play(0) print "Stopping" self.playing = False def music_delivery(self, *a, **kw): return self.audio.music_delivery(*a, **kw) def next(self): self.stop() if self._queue: t = self._queue.pop() self.load(*t) self.play() else: self.stop() def end_of_track(self, sess): print "track ends." self.next() def search(self, query, callback): self.session.search(query, callback) def bitrate(self, bitrate): if bitrate == 'normal': self.session.set_preferred_bitrate(0) elif bitrate == 'high': self.session.set_preferred_bitrate(1)
class SessionManager(SpotifySessionManager): queued = False playlist = 2 track = 0 username = "" def __init__(self, *a, **kw): SpotifySessionManager.__init__(self, *a, **kw) self.audio = AlsaController() self.ui = HTTPRequests(self) self.ctr = None self.playing = False self.username = a[0] self._queue = [] print "Trying to log in as " + a[0] + ", please wait..." def logged_in(self, session, error): self.session = session try: self.ctr = session.playlist_container() print "Successfully logged in as " + self.username self.ui.start() except: traceback.print_exc() def load_track(self, track): if self.playing: self.stop() while(track.is_loaded() != 1): pass self.session.load(track) print "Loading track '%s'" % track.name() def load(self, playlist, track): if self.playing: self.stop() print type(self.ctr[playlist][track]) self.session.load(self.ctr[playlist][track]) print "Loading %s from %s" % (self.ctr[playlist][track].name(), self.ctr[playlist].name()) def queue(self, playlist, track): if self.playing: self._queue.append((playlist, track)) else: self.load(playlist, track) self.play() def play(self): self.session.play(1) self.playing = True print "Playing" def stop(self): self.session.play(0) self.playing = False print "Stopping" def music_delivery(self, *a, **kw): return self.audio.music_delivery(*a, **kw) def next(self): self.stop() if self._queue: t = self._queue.pop() self.load(*t) self.play() else: self.stop() def end_of_track(self, sess): #self.next() self.playing = False print "Track ends" def search(self, query, callback): self.session.search(query, callback)
class SpotifySession(SpotifySessionManager, threading.Thread): def __init__(self, *args, **kwargs): threading.Thread.__init__(self) SpotifySessionManager.__init__(self, *args, **kwargs) self.audio = AlsaController() self.playing = False self.loaded_tracks = [] self.start() def run(self): self.connect() def logged_in(self, session, error): if error: # TODO: Halt the client print "sp_error: ", error self.session = session def is_loaded(self): return getattr(self, "session", False) def metadata_updated(self, session): """ Store all loaded tracks in self.loaded_tracks so we can supply them to the server. Called when libspotify has new metadata. """ self.playlist_container = session.playlist_container() self.metadata_updated_callback(self) def load_track(self, track): if self.playing: self.stop() # If spotify has not yet been initialized, wait a second and try again if not self.is_loaded(): return False link = Link.from_string(track) assert link.type() == Link.LINK_TRACK try: self.session.load(link.as_track()) except SpotifyError: return False return True 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 play(self): self.session.play(1) self.playing = True def stop(self): self.session.play(0) self.playing = False def music_delivery(self, *args, **kwargs): return self.audio.music_delivery(*args, **kwargs)
class Jukebox(SpotifySessionManager): queued = False playlist = 2 track = 0 def __init__(self, *a, **kw): SpotifySessionManager.__init__(self, *a, **kw) self.audio = AlsaController() self.ui = JukeboxUI(self) self.ctr = None self.playing = False self._queue = [] print "Logging in, please wait..." def logged_in(self, session, error): self.session = session try: self.ctr = session.playlist_container() self.ui.start() except: traceback.print_exc() def load_track(self, track): if self.playing: self.stop() self.session.load(track) print "Loading %s" % track.name() def load(self, playlist, track): if self.playing: self.stop() self.session.load(self.ctr[playlist][track]) print "Loading %s from %s" % (self.ctr[playlist][track].name(), self.ctr[playlist].name()) def queue(self, playlist, track): if self.playing: self._queue.append((playlist, track)) else: self.load(playlist, track) self.play() def play(self): self.session.play(1) print "Playing" self.playing = True def stop(self): self.session.play(0) print "Stopping" self.playing = False def music_delivery(self, *a, **kw): return self.audio.music_delivery(*a, **kw) def next(self): self.stop() if self._queue: t = self._queue.pop() self.load(*t) self.play() else: self.stop() def end_of_track(self, sess): print "track ends." self.next() def search(self, query, callback): self.session.search(query, callback)
def __init__(self, *a, **kw): SpotifySessionManager.__init__(self, *a, **kw) self.audio = AlsaController()
class SpotCtrlService(Service): ### chains stuff def open(self): print "def open(self):" self.api_version = spotify.api_version self.cache_location = '/tmp' self.settings_location = '/tmp' self.application_key = None self.appkey_file = 'spotify_appkey.key' self.user_agent = 'chains' if self.application_key is None: self.classdata = config.getServiceSharePath( self.config['main']['class']) + '/' self.application_key = open(self.classdata + self.appkey_file).read() self.awoken = threading.Event() # used to block until awoken self.timer = None self.finished = False self.session = None self.username = self.config.get('username') self.password = self.config.get('password') if not self.username or not self.password: sys.exit('Need username and password') self.audio = AlsaController() self.ctr = None self.playing = False self._queue = [] print "Logging in, please wait..." self.connect() print "Finished connecting?" def onDescribe(self): return { 'info': '', 'commands': [ ('quit', [], 'Quit spotify'), ('lists', [], 'List playlists'), ('list', [('listnr', 'int', None, 'Playlist number')], 'List contents of playlist'), ('play', [], 'Play'), ('stop', [], 'Stop'), ('next', [], 'Next track'), ('load', [('listnr', 'int', None, 'Playlist number'), ('track', 'int', None, 'Track number')], 'Load track from playlist'), ('load_track', [ ('track', 'str', None, 'spotify url or playlist id') ], 'Load spotify url or playlist id'), ('queue', [], 'List queue'), ('queue_track', [('listnr', 'int', None, 'Playlist number'), ('tracknr', 'int', None, 'Track number')], 'Add track to queue'), ('set_bitrate', [('bitrate', 'str', ['normal', 'high'])], 'Set bitrate to normal or high'), # Simple: ('mycommand', [('arg1','str'), ('arg2','int')]) # Advanced: ('mycommand', [('arg1','str',None,'Arg1 - a string'), ('arg2','int',[3,4],'Arg2 - an int, either 3 or 4')], 'My command description') ], 'events': [ # ('myevent', ('key','str',['mykey1','mykey2'],'event.key = mykey1 or mykey2'), ('value','bool') ), ], } def onEvent(self, key, value, extra): evt = { 'service': self.config['id'], 'key': key, 'value': value, 'extra': extra } self.devDaemon.onEvent(evt) def action_quit(self, line): print "Goodbye!" self.terminate() return True def action_lists(self): """ List the playlists """ extra = {} for i, p in enumerate(self.ctr): if p.is_loaded(): print "%3d %s" % (i, p.name()) extra.update({i: p.name()}) else: print "%3d %s" % (i, "loading...") extra.update({i: "loading..."}) self.onEvent('playlists', len(extra), extra) # return extra def action_list(self, listid): """ List the contents of a playlist """ extra = {} try: p = int(listid) except ValueError: print "that's not a number!" return False if p < 0 or p > len(self.ctr): print "That's out of range!" return False print "Listing playlist #%d" % p for i, t in enumerate(self.ctr[p]): if t.is_loaded(): print "%3d %s" % (i, t.name()) extra.update({i: t.name()}) else: print "%3d %s" % (i, "loading...") extra.update({i: 'loading...'}) self.onEvent('playlist', listid, extra) # return extra def action_play(self): self.play() self.onEvent('status', 'playing', {}) return True 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 action_search(self, line): if not line: if self.results is False: print "No search is in progress" return False elif self.results is None: print "Searching is in progress" else: print "Artists:" for a in self.results.artists(): print " ", Link.from_artist(a), a.name() print "Albums:" for a in self.results.albums(): print " ", Link.from_album(a), a.name() print "Tracks:" for a in self.results.tracks(): print " ", Link.from_track(a, 0), a.name() print self.results.total_tracks() - len( self.results.tracks()), "Tracks not shown" self.results = False else: self.results = None def _(results, userdata): print "\nSearch results received" self.results = results self.search(line, _) def action_queue(self): extra = {} for playlist, track in self._queue: print playlist, track extra.update({'playlist': playlist, 'trackid': track}) self.onEvent('list', 'queue', extra) return def action_queue_track(self, playlist, track): try: playlist, track = map(int, line.split(' ', 1)) except ValueError: print "Usage: play playlist track" return self.queue(int(playlist), int(track)) def action_stop(self): self.stop() def action_next(self): self.next() def action_set_bitrate(self, bitrate): self.bitrate(bitrate) def action_load(self, playlist, track): self.load(int(playlist), int(track)) def action_load_tack(self, track): self.load(int(track)) ## spotify main loop etc ############ def connect(self): print "def connect(self)" sess = spotify.connect(self) print str(sess) self.sesson = sess self.loop(sess) # returns on disconnect def loop(self, sess): """ The main loop. This processes events and then either waits for an event. The event is either triggered by a timer expiring, or by a notification from within the spotify subsystem (it calls the wake method below). """ print "def loop(self, sess)" while not self.finished: print "Main loop" self.awoken.clear() timeout = sess.process_events() print "timeout: %s" % str(timeout) self.timer = threading.Timer(timeout / 1000.0, self.awoken.set) self.timer.start() self.awoken.wait() def terminate(self): self.finished = True self.wake() disconnect = terminate def wake(self, sess=None): """ This is called by the spotify subsystem to wake up the main loop. """ print "def wake(self, sess=None):" if self.timer is not None: self.timer.cancel() self.awoken.set() # spotify callbacks def logged_in(self, session, error): print "CALLBACK: logged_in(self, session, error): (%s,%s)" % ( str(session), str(error)) self.session = session """ try: print "session.username:"******"FAILED: session.username(): " + str(e) try: print "session.user_is_loaded:" + str(self.session.user_is_loaded()) except Exception, e: print "FAILED: session.user_is_loaded(): " + str(e) try: print "session.display_name:" + str(self.session.display_name()) except Exception, e: print "FAILED: session.display_name(): " + str(e) """ if error > 1: return try: self.ctr = self.session.playlist_container() except: print "FAIL: self.ctr = session.playlist_container()" traceback.print_exc() # def logged_in(self, session, error): # """ Called when the user has successfully logged in. You almost # certainly want to do something with session.playlist_container() at # this point. """ # pass def logged_out(self, sess): print "CALLBACK: def logged_out(self, sess):" pass def metadata_updated(self, sess): print "CALLBACK: def metadata_updated(self, sess): CallBack" pass def connection_error(self, sess, error): print "CALLBACK: def connection_error(self, sess, error): %s" % str( error) pass def message_to_user(self, sess, message): print "CALLBACK: def message_to_user(self, sess, message): %s" % str( message) pass def notify_main_thread(self, sess): print "CALLBACK: def notify_main_thread(self, sess):" pass def music_delivery(self, sess, frames, frame_size, num_frames, sample_type, sample_rate, channels): print "CALLBACK: def music_delivery(self, sess, frames, frame_size, num_frames, sample_type, sample_rate, channels):" pass def play_token_lost(self, sess): print "CALLBACK: def play_token_lost(self, sess):" pass def log_message(self, sess, data): print "CALLBACK: def log_message(self, sess, data): %s" % str(data) pass def end_of_track(self, sess): print "CALLBACK: def end_of_track(self, sess):" pass # spotify functions def load(self, playlist, track): if self.playing: self.stop() self.session.load(self.ctr[playlist][track]) print "Loading %s from %s" % (self.ctr[playlist][track].name(), self.ctr[playlist].name()) def load_track(self, track): if self.playing: self.stop() self.session.load(track) print "Loading %s" % track.name() def queue(self, playlist, track): if self.playing: self._queue.append((playlist, track)) else: self.load(playlist, track) self.play() def play(self): self.session.play(1) print "Playing" self.playing = True def stop(self): self.session.play(0) print "Stopping" self.playing = False def music_delivery(self, *a, **kw): return self.audio.music_delivery(*a, **kw) def next(self): self.stop() if self._queue: t = self._queue.pop() self.load(*t) self.play() else: self.stop() def end_of_track(self, sess): print "track ends." self.next() def search(self, query, callback): self.session.search(query, callback) def bitrate(self, bitrate): if bitrate == 'normal': self.session.set_preferred_bitrate(0) elif bitrate == 'high': self.session.set_preferred_bitrate(1)
class Jukebox(SpotifySessionManager): queued = False playlist = 2 track = 0 appkey_file = os.path.join(os.path.dirname(__file__), 'spotify_appkey.key') def __init__(self, *a, **kw): SpotifySessionManager.__init__(self, *a, **kw) self.audio = AlsaController() self.ui = JukeboxUI(self) self.ctr = None self.playing = False self._queue = [] self.playlist_manager = JukeboxPlaylistManager() self.container_manager = JukeboxContainerManager() print "Logging in, please wait..." def logged_in(self, session, error): if error: print error return self.session = session try: self.ctr = session.playlist_container() self.container_manager.watch(self.ctr) self.starred = session.starred() self.ui.start() except: traceback.print_exc() def logged_out(self, session): self.ui.cmdqueue.append("quit") def load_track(self, track): if self.playing: self.stop() self.session.load(track) print "Loading %s" % track.name() def load(self, playlist, track): if self.playing: self.stop() if 0 <= playlist < len(self.ctr): pl = self.ctr[playlist] elif playlist == len(self.ctr): pl = self.starred self.session.load(pl[track]) print "Loading %s from %s" % (pl[track].name(), pl.name()) def queue(self, playlist, track): if self.playing: self._queue.append((playlist, track)) else: self.load(playlist, track) self.play() def play(self): self.session.play(1) print "Playing" self.playing = True def stop(self): self.session.play(0) print "Stopping" self.playing = False def music_delivery(self, *a, **kw): return self.audio.music_delivery(*a, **kw) def next(self): self.stop() if self._queue: t = self._queue.pop() self.load(*t) self.play() else: self.stop() def end_of_track(self, sess): print "track ends." self.next() def search(self, *args, **kwargs): self.session.search(*args, **kwargs) def browse(self, link, callback): if link.type() == link.LINK_ALBUM: browser = self.session.browse_album(link.as_album(), callback) while not browser.is_loaded(): time.sleep(0.1) for track in browser: print track if link.type() == link.LINK_ARTIST: browser = self.session.browse_artist(link.as_artist(), callback) while not browser.is_loaded(): time.sleep(0.1) for album in browser: print album.name() callback(browser) def watch(self, p, unwatch=False): if not unwatch: print "Watching playlist: %s" % p.name() self.playlist_manager.watch(p); else: print "Unatching playlist: %s" % p.name() self.playlist_manager.unwatch(p) def toplist(self, tl_type, tl_region): print repr(tl_type) print repr(tl_region) def callback(tb, ud): for i in xrange(len(tb)): print '%3d: %s' % (i+1, tb[i].name()) tb = ToplistBrowser(tl_type, tl_region, callback) def shell(self): import code shell = code.InteractiveConsole(globals()) shell.interact()
class Jukebox(SpotifySessionManager): queued = False playlist = 2 track = 0 appkey_file = os.path.join(os.path.dirname(__file__), 'spotify_appkey.key') def __init__(self, *a, **kw): SpotifySessionManager.__init__(self, *a, **kw) self.audio = AlsaController() self.ui = JukeboxUI(self) self.ctr = None self.playing = False self._queue = [] self.playlist_manager = JukeboxPlaylistManager() self.container_manager = JukeboxContainerManager() print "Logging in, please wait..." def logged_in(self, session, error): if error: print error return self.session = session try: self.ctr = session.playlist_container() self.container_manager.watch(self.ctr) self.starred = session.starred() self.ui.start() except: traceback.print_exc() def logged_out(self, session): self.ui.cmdqueue.append("quit") def load_track(self, track): if self.playing: self.stop() self.session.load(track) print "Loading %s" % track.name() def load(self, playlist, track): if self.playing: self.stop() if 0 <= playlist < len(self.ctr): pl = self.ctr[playlist] elif playlist == len(self.ctr): pl = self.starred self.session.load(pl[track]) print "Loading %s from %s" % (pl[track].name(), pl.name()) def queue(self, playlist, track): if self.playing: self._queue.append((playlist, track)) else: self.load(playlist, track) self.play() def play(self): self.session.play(1) print "Playing" self.playing = True def stop(self): self.session.play(0) print "Stopping" self.playing = False def music_delivery(self, *a, **kw): return self.audio.music_delivery(*a, **kw) def next(self): self.stop() if self._queue: t = self._queue.pop() self.load(*t) self.play() else: self.stop() def end_of_track(self, sess): print "track ends." self.next() def search(self, *args, **kwargs): self.session.search(*args, **kwargs) def browse(self, link, callback): if link.type() == link.LINK_ALBUM: browser = self.session.browse_album(link.as_album(), callback) while not browser.is_loaded(): time.sleep(0.1) for track in browser: print track if link.type() == link.LINK_ARTIST: browser = self.session.browse_artist(link.as_artist(), callback) while not browser.is_loaded(): time.sleep(0.1) for album in browser: print album.name() callback(browser) def watch(self, p, unwatch=False): if not unwatch: print "Watching playlist: %s" % p.name() self.playlist_manager.watch(p) else: print "Unatching playlist: %s" % p.name() self.playlist_manager.unwatch(p) def toplist(self, tl_type, tl_region): print repr(tl_type) print repr(tl_region) def callback(tb, ud): for i in xrange(len(tb)): print '%3d: %s' % (i + 1, tb[i].name()) tb = ToplistBrowser(tl_type, tl_region, callback) def shell(self): import code shell = code.InteractiveConsole(globals()) shell.interact()
class Jukebox(SpotifySessionManager): queued = False playlist = 2 track = 0 appkey_file = os.path.join(os.path.dirname(__file__), 'spotify_appkey.key') def __init__(self, list, *a, **kw): SpotifySessionManager.__init__(self, *a, **kw) self.audio = AlsaController() self.ctr = None self.playing = False self._queue = [] self.to_random = list print "Logging in, please wait..." def logged_in(self, session, error): if error: print error return self.session = session try: self.ctr = session.playlist_container() self.starred = session.starred() self.randomize(self.to_random) except: traceback.print_exc() def logged_out(self, session): self.ui.cmdqueue.append("quit") def load_track(self, track): if self.playing: self.stop() self.session.load(track) print "Loading %s" % track.name() def load(self, playlist, track): if self.playing: self.stop() if 0 <= playlist < len(self.ctr): pl = self.ctr[playlist] elif playlist == len(self.ctr): pl = self.starred self.session.load(pl[track]) print "Loading %s from %s" % (pl[track].name(), pl.name()) def queue(self, playlist, track): if self.playing: self._queue.append((playlist, track)) else: self.load(playlist, track) self.play() def play(self): self.session.play(1) print "Playing" self.playing = True def stop(self): self.session.play(0) print "Stopping" self.playing = False def music_delivery(self, *a, **kw): return self.audio.music_delivery(*a, **kw) def next(self): self.stop() if self._queue: t = self._queue.pop() self.load(*t) self.play() else: self.stop() def end_of_track(self, sess): print "track ends." self.next() def search(self, *args, **kwargs): self.session.search(*args, **kwargs) def browse(self, link, callback): if link.type() == link.LINK_ALBUM: browser = self.session.browse_album(link.as_album(), callback) while not browser.is_loaded(): time.sleep(0.1) for track in browser: print track if link.type() == link.LINK_ARTIST: browser = self.session.browse_artist(link.as_artist(), callback) while not browser.is_loaded(): time.sleep(0.1) for album in browser: print album.name() callback(browser) def toplist(self, tl_type, tl_region): print repr(tl_type) print repr(tl_region) def callback(tb, ud): for i in xrange(len(tb)): print '%3d: %s' % (i+1, tb[i].name()) tb = ToplistBrowser(tl_type, tl_region, callback) def shell(self): import code shell = code.InteractiveConsole(globals()) shell.interact() def randomize(self, name): playlist = None dup_playlist = None for play in self.ctr: print play.name() if name == play.name(): playlist = play #elif name + " - Random" == play.name(): # print "dup_playlist" # dup_playlist = play if not playlist: print "Playlist not found" return if not dup_playlist: self.ctr.add_new_playlist(name + " - Random") for play in self.ctr: if name + " - Random" == play.name(): dup_playlist = play else: to_remove = [] for i, track in enumerate(dup_playlist): to_remove.append(i) dup_playlist.remove_tracks(to_remove) copied = [] while len(copied) < len(playlist): i = random.randint(0, len(playlist) - 1) if not i in copied: copied.append(i) dup_playlist.add_tracks(0, [playlist[i]])