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 = JukeboxUI(self)
self.ctr = None
self.playing = False
self._queue = []
print "Logging in, please wait..."
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
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)
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]])
