def populate(self, Dir, lvl, whiteFlag, blackFlag):
node_artist = getNode(Flag.ARTIST)
node_artist.data = self.data
node_artist.label = '[ %s ]' % (node_artist.label)
if not 'albums' in self.data:
return True
for pData in self.data['albums']['items']:
node = getNode(Flag.ALBUM)
node.data = pData
self.add_child(node)
return True
del self._data['tracks']
def populate(self, Dir, lvl, whiteFlag, blackFlag):
data = api.get("/playlist/getUserPlaylists", username=self.name)
if not data:
warn(self, "No friend data")
return False
if lvl != -1:
self.add_child(getNode(Flag.FRIEND_LIST, self.parameters))
for pl in data["playlists"]["items"]:
node = getNode(Flag.PLAYLIST)
node.data = pl
if node.get_owner() == self.label:
self.nid = node.get_owner_id()
self.add_child(node)
return True
def gui_add_to_current(self):
cid = self.get_current_playlist()
qnt = int(self.get_parameter('qnt'))
qid = self.get_parameter('qid')
nodes = []
if qnt & Flag.SEARCH:
self.del_parameter('query')
if qnt & Flag.TRACK == Flag.TRACK:
node = getNode(qnt, {'nid': qid})
node.fetch(None, None, None, Flag.NONE)
nodes.append(node)
else:
render = renderer(qnt, self.parameters)
render.depth = -1
render.whiteFlag = Flag.TRACK
render.asList = True
render.run()
nodes = render.nodes
ret = xbmcgui.Dialog().select('Add to current playlist', [
node.get_label() for node in nodes
])
if ret == -1:
return False
ret = self._add_tracks(cid, nodes)
if not ret:
notifyH('Qobuz',
'Failed to add tracks')
return False
self.delete_cache(cid)
notifyH('Qobuz / Tracks added',
'%s added' % (len(nodes)))
return True
def populate(self, Dir, lvl, whiteFlag, blackFlag):
for kind in ['artists', 'albums', 'tracks']:
node = getNode(Flag.COLLECTION, params={'search-type': kind},)
node.set_parameter('search-type', kind)
node.set_label('%s collection' % kind.capitalize())
self.add_child(node)
return True
def set_root_node(self):
"""Import correct node object based on node_type parameter, setting
self.root
"""
if self.root: return self.root
self.root = getNode(self.node_type, self.parameters)
return self.root
def list_albums(self, qnt, qid):
album_ids = {}
nodes = []
if qnt & Flag.ALBUM == Flag.ALBUM:
node = getNode(Flag.ALBUM, {'nid': qid})
node.fetch(None, None, None, None)
album_ids[str(node.nid)] = 1
nodes.append(node)
elif qnt & Flag.TRACK == Flag.TRACK:
render = renderer(qnt, self.parameters)
render.depth = 1
render.whiteFlag = Flag.TRACK
render.blackFlag = Flag.NONE
render.asList = True
render.run()
if len(render.nodes) > 0:
node = getNode(Flag.ALBUM)
node.data = render.nodes[0].data['album']
album_ids[str(node.nid)] = 1
nodes.append(node)
else:
render = renderer(qnt, self.parameters)
render.depth = -1
render.whiteFlag = Flag.ALBUM
render.blackFlag = Flag.STOPBUILD & Flag.TRACK
render.asList = True
render.run()
for node in render.nodes:
if node.nt & Flag.ALBUM:
if not str(node.nid) in album_ids:
album_ids[str(node.nid)] = 1
nodes.append(node)
if node.nt & Flag.TRACK:
render = renderer(qnt, self.parameters)
render.depth = 1
render.whiteFlag = Flag.TRACK
render.blackFlag = Flag.NONE
render.asList = True
render.run()
if len(render.nodes) > 0:
newnode = getNode(Flag.ALBUM)
newnode.data = render.nodes[0].data['album']
if not str(newnode.nid) in album_ids:
nodes.append(newnode)
album_ids[str(newnode.nid)] = 1
return nodes
def _populate_tracks(self, Dir, lvl, whiteFlag, blackFlag):
ret = False
for track in self.data['tracks']['items']:
node = getNode(Flag.TRACK)
node.data = track
self.add_child(node)
ret = True
return ret
def populate(self, Dir, lvl, whiteFlag, blackFlag):
if self.search_type == 'albums':
for album in self.data['albums']['items']:
node = getNode(Flag.ALBUM)
node.data = album
self.add_child(node)
elif self.search_type == 'tracks':
for track in self.data['tracks']['items']:
node = getNode(Flag.TRACK)
node.data = track
self.add_child(node)
elif self.search_type == 'artists':
for artist in self.data['artists']['items']:
node = getNode(Flag.ARTIST)
node.data = artist
self.add_child(node)
return True
def _populate_albums(self, Dir, lvl, whiteFlag, blackFlag):
ret = False
for album in self.data['albums']['items']:
node = getNode(Flag.ALBUM)
node.data = album
self.add_child(node)
ret = True
return ret
def populate(self, Dir, lvl, whiteFlag, blackFlag):
for track in self.data['tracks']['items']:
node = getNode(Flag.TRACK)
if not 'image' in track:
track['image'] = self.get_image()
node.data = track
self.add_child(node)
return len(self.data['tracks']['items'])
def __populate_type(self, Dir, lvl, whiteFlag, blackFlag):
''' Populate type, we don't have genre_type nor genre_id
'''
for gid in RECOS_TYPE_IDS:
node = getNode(Flag.RECOMMENDATION, {'genre-type': gid})
# node.genre_type = gid
node.set_label(
self.label + ' / ' + RECOS_TYPES[gid])
self.add_child(node)
return True
def __GET_track(self, request):
api.login(api.username, api.password)
node = getNode(Flag.TRACK, {'nid': request.track_id})
streaming_url = node.get_streaming_url()
if not streaming_url:
raise RequestFailed()
self.send_response(303, "Resolved")
self.send_header('content-type', stream_mime)
self.send_header('location', streaming_url)
self.end_headers()
def populate(self, Dir, lvl, whiteFlag, blackFlag):
self.add_child(getNode(Flag.USERPLAYLISTS))
if getSetting('show_recommendations', isBool=True):
self.add_child(getNode(Flag.RECOMMENDATION))
self.add_child(getNode(Flag.PURCHASES))
self.add_child(getNode(Flag.FAVORITES))
if getSetting('search_enabled', isBool=True):
search = getNode(Flag.SEARCH)
search.search_type = 'albums'
self.add_child(search)
search = getNode(Flag.SEARCH)
search.search_type = 'tracks'
self.add_child(search)
search = getNode(Flag.SEARCH)
search.search_type = 'artists'
self.add_child(search)
self.add_child(getNode(Flag.FRIEND_LIST))
self.add_child(getNode(Flag.GENRE))
self.add_child(getNode(Flag.PUBLIC_PLAYLISTS))
return True
def _populate_artists(self, Dir, lvl, whiteFlag, blackFlag):
ret = False
if not 'artists' in self.data:
return False
for artist in self.data['artists']['items']:
node = getNode(Flag.ARTIST)
node.data = artist
node.fetch(None, None, None, Flag.NONE)
self.add_child(node)
ret = True
return ret
def populate(self, Dir, lvl, whiteFlag, blackFlag):
login = getSetting('username')
cid = self.get_current_playlist_id()
for data in self.data['playlists']['items']:
node = getNode(Flag.PLAYLIST, {'offset': 0})
node.data = data
if self.display_product_cover:
pass
if (cid and cid == node.nid):
node.set_is_current(True)
if node.get_owner() == login:
node.set_is_my_playlist(True)
self.add_child(node)
return True
def __populate_genre(self, Dir, lvl, whiteFlag, blackFlag):
'''Populate genre, we have genre_type but no genre_id
'''
for genre_id in RECOS_GENRES:
node = getNode(Flag.RECOMMENDATION, {'genre-type': self.genre_type,
'genre-id': genre_id})
# node.genre_type = self.genre_type
# node.genre_id = genre_id
label = '%s / %s / %s' % (self.label,
RECOS_TYPES[int(self.genre_type)],
RECOS_GENRES[genre_id])
node.label = label
self.add_child(node)
return True
def list_artists(self, qnt, qid):
artist_ids = {}
nodes = []
if qnt & Flag.ARTIST == Flag.ARTIST:
node = getNode(Flag.ARTIST, {'nid': qid})
node.fetch(None, None, None, Flag.NONE)
artist_ids[str(node.nid)] = 1
nodes.append(node)
else:
render = renderer(qnt, self.parameters)
render.depth = -1
render.whiteFlag = Flag.ALBUM & Flag.TRACK
render.blackFlag = Flag.TRACK & Flag.STOPBUILD
render.asList = True
render.run()
for node in render.nodes:
artist = getNode(Flag.ARTIST, {'nid': node.get_artist_id()})
if not artist.fetch(None, None, None, Flag.NONE):
continue
if not str(artist.nid) in artist_ids:
nodes.append(artist)
artist_ids[str(artist.nid)] = 1
return nodes
def __populate_type_genre(self, Dir, lvl, whiteFlag, blackFlag):
'''Populate album selected by genre_type and genre_id
'''
if self.data is None:
return False
if 'albums' not in self.data:
warn(self, "Recommendation data doesn't contain 'albums' key")
return False
if self.data['albums'] is None or 'items' not in self.data['albums']:
warn(self, "Recommendation data['albums'] doesn't contain items")
return False
for product in self.data['albums']['items']:
node = getNode(Flag.ALBUM)
node.data = product
self.add_child(node)
return True
def populate(self, Dir, lvl, whiteFlag, blackFlag):
count = 0
total = len(self.data["albums"]["items"])
for album in self.data["albums"]["items"]:
keys = ["artist", "interpreter", "composer", "performer"]
for k in keys:
try:
if k in self.data["artist"]:
album[k] = weakref.proxy(self.data["artist"][k])
except:
warn(self, "Strange thing happen")
pass
node = getNode(Flag.ALBUM)
node.data = album
count += 1
Dir.update(count, total, "Add album:" + node.get_label(), "")
self.add_child(node)
return True
def play(self, track_id):
track = getNode(Flag.TRACK, {'nid': track_id})
if not track.fetch(None, 1, Flag.TRACK, Flag.NONE):
warn(self, "Cannot get track data")
# label = "Maybe an invalid track id"
# item = xbmcgui.ListItem("No track information", label, '',
# getImage('icon-error-256'), '')
return False
if not track.is_playable():
warn(self, "Cannot get streaming URL")
return False
item = track.makeListItem()
track.item_add_playing_property(item)
'''Some tracks are not authorized for stream and a 60s sample is
returned, in that case we overwrite the song duration
'''
if track.is_sample():
item.setInfo(
'music', infoLabels={
'duration': 60,
})
'''Don't warn for free account (all songs except purchases are 60s
limited)
'''
if not isFreeAccount():
notifyH("Qobuz", "Sample returned")
xbmcgui.Window(10000).setProperty(keyTrackId, track_id)
"""
Notify
"""
if getSetting('notification_playingsong', isBool=True):
notifyH(lang(34000), track.get_label(), track.get_image())
"""
We are called from playlist...
"""
if qobuz.boot.handle == -1:
super(QobuzPlayer, self).play(track.get_streaming_url(),
item, False)
else:
setResolvedUrl(handle=qobuz.boot.handle,
succeeded=True,
listitem=item)
return True
def list_tracks(self, qnt, qid):
track_ids = {}
nodes = []
if qnt & Flag.TRACK == Flag.TRACK:
node = getNode(Flag.TRACK, {'nid': qid})
node.fetch(None, None, None, Flag.NONE)
track_ids[str(node.nid)] = 1
nodes.append(node)
else:
render = renderer(qnt, self.parameters)
render.depth = -1
render.whiteFlag = Flag.TRACK
render.asList = True
render.run()
for node in render.nodes:
if not str(node.nid) in track_ids:
nodes.append(node)
track_ids[str(node.nid)] = 1
return nodes
def populate(self, xbmc_directory, lvl, whiteFlag, blackFlag):
username = api.username
password = api.password
user_id = api.user_id
user_data = api.get('/user/login', username=username,
password=password)
if not 'user' in user_data:
return False
friend_data = user_data['user']['player_settings']['friends']
info(self, "Build-down friends list " + repr(self.name))
if self.name:
data = api.get('/playlist/getUserPlaylists',
username=self.name, limit=0)
else:
data = api.get('/playlist/getUserPlaylists',
user_id=user_id, limit=0)
if not data:
warn(self, "No friend data")
return False
# extract all owner names from the list
friend_list = []
for item in data['playlists']['items']:
if item['owner']['name'] == user_data['user']['login']:
continue
friend_list.append(item['owner']['name'])
# add previously stored
if (not self.name):
for name in friend_data:
friend_list.append(str(name))
# remove duplicates
keys = {}
for e in friend_list:
keys[e] = 1
friend_list = keys.keys()
# and add them to the directory
for name in friend_list:
node = getNode(Flag.FRIEND, {'query': str(name)})
if name == self.name:
continue
if name in friend_data:
node.label = 'Friend / %s' % (node.label)
self.add_child(node)
def gui_add_as_new(self, name=None):
nodes = []
qnt = int(self.get_parameter('qnt'))
qid = self.get_parameter('qid')
if qnt & Flag.SEARCH:
self.del_parameter('query')
if qnt & Flag.TRACK == Flag.TRACK:
node = getNode(qnt, {'nid': qid})
node.fetch(None,None,None, Flag.NONE)
nodes.append(node)
else:
render = renderer(qnt, self.parameters)
render.depth = -1
render.whiteFlag = Flag.TRACK
render.asList = True
render.run()
nodes = render.nodes
if not name and render.root.get_parameter('query', unQuote=True):
name = render.root.get_parameter('query', unQuote=True)
if not name:
name = self.get_parameter('query',
unQuote=True) or self.get_label()
ret = xbmcgui.Dialog().select('Create playlist %s' % (name), [
node.get_label() for node in nodes
])
if ret == -1:
return False
playlist = self.create(name)
if not playlist:
notifyH('Qobuz', 'Playlist creationg failed', 'icon-error-256')
warn(self, "Cannot create playlist...")
return False
if not self._add_tracks(playlist['id'], nodes):
notifyH('Qobuz / Cannot add tracks',
"%s" % (name), 'icon-error-256')
return False
self.delete_cache(playlist['id'])
notifyH('Qobuz / Playlist added',
'[%s] %s' % (len(nodes), name))
return True
def gui_remove(self):
qnt, qid = int(self.get_parameter('qnt')), self.get_parameter('qid')
node = getNode(qnt, {'nid': qid})
ret = None
if qnt & Flag.TRACK == Flag.TRACK:
ret = self.del_track(node.nid)
elif qnt & Flag.ALBUM == Flag.ALBUM:
ret = self.del_album(node.nid)
elif qnt & Flag.ARTIST == Flag.ARTIST:
ret = self.del_artist(node.nid)
else:
raise Qerror(who=self, what='invalid_node_type',
additional=self.nt)
if not ret:
notifyH(dialogHeading,
'Cannot remove item: %s' % (node.get_label()))
return False
notifyH(dialogHeading,
'Item successfully removed: %s' % (node.get_label()))
url = self.make_url(nt=self.nt, nid='', nm='')
executeBuiltin(containerUpdate(url, True))
return True
def gui_remove(self):
qnt, qid = int(self.get_parameter('qnt')), self.get_parameter('qid')
node = getNode(qnt, {'nid': qid})
ret = None
if qnt & Flag.TRACK == Flag.TRACK:
ret = self.del_track(node.nid)
elif qnt & Flag.ALBUM == Flag.ALBUM:
ret = self.del_album(node.nid)
elif qnt & Flag.ARTIST == Flag.ARTIST:
ret = self.del_artist(node.nid)
else:
raise Qerror(who=self, what='invalid_node_type',
additional=self.nt)
if not ret:
notifyH(dialogHeading,
'Cannot remove item: %s' % (node.get_label()))
return False
notifyH(dialogHeading,
'Item successfully removed: %s' % (node.get_label()))
url = self.make_url(nt=self.nt, nid='', nm='')
executeBuiltin(containerUpdate(url, True))
return True
def __add_pagination_node(self, Dir, lvl=1, whiteFlag=Flag.NODE):
"""Helper/Called by build_down to add special node when pagination is
required
"""
if self.pagination_next:
colorItem = getSetting('color_item')
params = qobuz.boot.params
params['offset'] = self.pagination_next_offset
params['nid'] = self.nid
node = getNode(self.nt, params)
node.data = self.data
label = self.get_label()
if not label and self.parent:
label = self.parent.get_label()
if self.label2: label = self.label2
nextLabel = (
'[ %s %s / %s ]') % (color(colorItem, label),
self.pagination_next_offset,
self.pagination_total)
node.label = nextLabel
node.label2 = label
self.add_child(node)
def gui_add_as_new(self, name=None):
nodes = []
qnt = int(self.get_parameter('qnt'))
qid = self.get_parameter('qid')
if qnt & Flag.SEARCH:
self.del_parameter('query')
if qnt & Flag.TRACK == Flag.TRACK:
node = getNode(qnt, {'nid': qid})
node.fetch(None, None, None, Flag.NONE)
nodes.append(node)
else:
render = renderer(qnt, self.parameters)
render.depth = -1
render.whiteFlag = Flag.TRACK
render.asList = True
render.run()
nodes = render.nodes
if not name and render.root.get_parameter('query', unQuote=True):
name = render.root.get_parameter('query', unQuote=True)
if not name:
name = self.get_parameter('query',
unQuote=True) or self.get_label()
ret = xbmcgui.Dialog().select('Create playlist %s' % (name),
[node.get_label() for node in nodes])
if ret == -1:
return False
playlist = self.create(name)
if not playlist:
notifyH('Qobuz', 'Playlist creationg failed', 'icon-error-256')
warn(self, "Cannot create playlist...")
return False
if not self._add_tracks(playlist['id'], nodes):
notifyH('Qobuz / Cannot add tracks', "%s" % (name),
'icon-error-256')
return False
self.delete_cache(playlist['id'])
notifyH('Qobuz / Playlist added', '[%s] %s' % (len(nodes), name))
return True
def populate_reco(self, Dir, lvl, whiteFlag, blackFlag, ID):
for gtype in RECOS_TYPE_IDS:
node = getNode(
Flag.RECOMMENDATION, {'parent': self, 'genre-id': ID, 'genre-type': gtype})
node.populating(Dir, 1, Flag.ALBUM, blackFlag)
return True
def populate(self, Dir, lvl, whiteFlag, blackFlag):
for article in self.data['articles']['items']:
node = getNode(Flag.ARTICLE, {'nid': article['id']})
node.data = article
self.add_child(node)
def fetch(self, Dir, lvl, whiteFlag, blackFlag):
node = getNode(Flag.FRIEND)
node.create('qobuz.com')
return True
def __populate_artists(self, Dir, lvl, whiteFlag, blackFlag):
for artist in self.data['artists']['items']:
node = getNode(Flag.ARTIST)
node.data = artist
node.fetch(None, None, None, Flag.NONE)
self.add_child(node)
def __populate_albums(self, Dir, lvl, whiteFlag, blackFlag):
for album in self.data['albums']['items']:
node = getNode(Flag.ALBUM)
node.data = album
self.add_child(node)
def populate(self, Dir, lvl, whiteFlag, blackFlag):
for track in self.data['tracks']['items']:
node = getNode(Flag.TRACK)
node.data = track
self.add_child(node)
return True
def populate(self, Dir, lvl, whiteflag, blackFlag):
for aData in self.data['artists']['items']:
artist = getNode(Flag.ARTIST, {'offset': 0, 'nid': aData['id']})
artist.data = aData
self.add_child(artist)
return True
def populate(self, Dir, lvl, whiteFlag, blackFlag):
for item in self.data['playlists']['items']:
node = getNode(Flag.PLAYLIST)
node.data = item
self.add_child(node)
return True
def populate(self, Dir, lvl, whiteFlag, blackFlag):
for item in self.data["playlists"]["items"]:
node = getNode(Flag.PLAYLIST)
node.data = item
self.add_child(node)
return True
def populate(self, Dir, lvl, whiteFlag, blackFlag):
self.add_child(getNode(Flag.USERPLAYLISTS))
if getSetting('show_recommendations', isBool=True):
self.add_child(getNode(Flag.RECOMMENDATION))
self.add_child(getNode(Flag.PURCHASES))
self.add_child(getNode(Flag.FAVORITES))
if getSetting('search_enabled', isBool=True):
search = getNode(Flag.SEARCH)
search.search_type = 'albums'
self.add_child(search)
search = getNode(Flag.SEARCH)
search.search_type = 'tracks'
self.add_child(search)
search = getNode(Flag.SEARCH)
search.search_type = 'artists'
self.add_child(search)
collections = getNode(Flag.COLLECTIONS)
self.add_child(collections)
self.add_child(getNode(Flag.FRIENDS))
self.add_child(getNode(Flag.GENRE))
self.add_child(getNode(Flag.PUBLIC_PLAYLISTS))
return True
def populate(self, Dir, lvl, whiteflag, blackFlag):
for aData in self.data['artists']['items']:
artist = getNode(Flag.ARTIST, {'offset': 0, 'nid': aData['id']})
artist.data = aData
self.add_child(artist)
return True
def populate(self, Dir, lvl, whiteFlag, blackFlag):
for kind in ['all', 'artists', 'albums', 'tracks']:
self.add_child(getNode(Flag.FAVORITE, {'search-type': kind}))
return True
