def load_album_info(self, index, album):
#Directly discard unavailable albums
if not album.is_available():
self.__album_data[index] = {
'available_tracks': 0,
'type': self._get_album_type(album),
}
#Otherwise load it's data
else:
#A checker for a single condition? Overkill!
checker = BulkConditionChecker()
cb = AlbumCallbacks(checker)
album_info = albumbrowse.Albumbrowse(self.__session, album, cb)
#Now wait until it's loaded
self._wait_for_album_info(album_info, checker)
#Populate it's data
self.__album_data[index] = {
'available_tracks': self._num_available_tracks(album_info),
'type': self._get_album_type(album),
}
#Tell that we've done
self.__checker.check_conditions()
def do_list(self, line):
container = self._session.playlistcontainer()
if not container.is_loaded():
checker = BulkConditionChecker()
#Wait until the container is loaded
checker.add_condition(container.is_loaded)
callbacks = JukeboxPlaylistContainerCallbacks(checker)
container.add_callbacks(callbacks)
checker.complete_wait()
for item in container.playlists():
item.set_in_ram(self._session, True)
if not line:
#Print all playlists
print "%d playlists:" % container.num_playlists()
for k, item in enumerate(container.playlists()):
if item.is_loaded():
print "playlist #%d: %s" % (k, item.name())
else:
print "playlist #%d: loading..." % k
else:
pos = int(line)
pl = container.playlist(pos)
print "playlist #%d, %d tracks:" % (pos, pl.num_tracks())
for index,item in enumerate(pl.tracks()):
if item.is_loaded():
print "track #%d: %s" % (index, item.name())
#print item.album().cover()
else:
print "track #%d: loading..." % index
def _load_toplist(self, type, region, user):
checker = BulkConditionChecker()
callbacks = ToplistbrowseLoadCallbacks(checker)
toplistbrowse_obj = toplistbrowse.Toplistbrowse(
self._session, type, region, user, callbacks)
checker.add_condition(toplistbrowse_obj.is_loaded)
checker.complete_wait(10)
return toplistbrowse_obj
def get_album_info(self, index):
album = self.__artistbrowse.album(index)
checker = BulkConditionChecker()
cb = AlbumCallbacks(checker)
album_info = albumbrowse.Albumbrowse(self.__session, album, cb)
#Wait until it's loaded
self._wait_for_album_info(album_info, checker)
return album_info
def _load_radio(self, from_year, to_year, genres):
checker = BulkConditionChecker()
callbacks = SearchLoadCallbacks(checker)
radio_obj = radio.RadioSearch(
self._session, from_year, to_year, genres, callbacks
)
checker.add_condition(radio_obj.is_loaded)
checker.complete_wait(10)
return radio_obj
def __init__(self, session, artist):
self.__checker = BulkConditionChecker()
self.__session = session
self.__artist = artist
self.__album_data = {}
cb = ArtistCallbacks(self)
self.__artistbrowse = artistbrowse.Artistbrowse(
session, artist, BrowseType.NoTracks, cb)
self.__is_loaded = False
#Avoid locking this thread and continue in another one
self.continue_in_background()
def __init__(self, session, container, playlist_manager):
self.__session = session
self.__container = container
self.__playlist_manager = playlist_manager
self.__playlists = []
self.__checker = BulkConditionChecker()
self.__loading_lock = threading.RLock()
self.__list_lock = threading.RLock()
self.__is_loaded = False
#Load the rest in the background
self._start_load()
def _load_search(self, query):
checker = BulkConditionChecker()
callbacks = SearchLoadCallbacks(checker)
search_obj = search.Search(
self._session, query,
track_count=100, album_count=100, artist_count=100,
callbacks=callbacks
)
checker.add_condition(search_obj.is_loaded)
checker.complete_wait(10)
return search_obj
def _load_artist(self, id):
full_id = "spotify:artist:%s" % id
checker = BulkConditionChecker()
#Get the artist object
link_obj = link.create_from_string(full_id)
artist_obj = link_obj.as_artist()
#Now initialize the artistbrowse load stuff
callbacks = ArtistbrowseLoadCallbacks(checker)
artistbrowse_obj = artistbrowse.Artistbrowse(self._session, artist_obj,
callbacks)
checker.add_condition(artistbrowse_obj.is_loaded)
checker.complete_wait(10)
return artist_obj, artistbrowse_obj
def _load_album(self, id):
import time
full_id = "spotify:album:%s" % id
checker = BulkConditionChecker()
#All the album loading stuff
link_obj = link.create_from_string(full_id)
album_obj = link_obj.as_album()
#Now the albumbrowse object
callbacks = AlbumbrowseLoadCallbacks(checker)
albumbrowse_obj = albumbrowse.Albumbrowse(self._session, album_obj,
callbacks)
checker.add_condition(albumbrowse_obj.is_loaded)
checker.complete_wait(10)
return album_obj, albumbrowse_obj
def __init__(self, session, playlist, playlist_manager):
#Initialize all instance vars
self.__playlist = playlist
self.__playlist_manager = playlist_manager
self.__checker = BulkConditionChecker()
self.__is_loaded = False
self.__has_errors = False
self.__thumbnails = []
#Add the callbacks we are interested in
playlist.add_callbacks(PlaylistCallbacks(self))
#Fire playlist loading if neccesary
if not playlist.is_in_ram(session):
playlist.set_in_ram(session, True)
#Finish the rest in the background
self.load_in_background()