def _checksong(self, song): # it is ok if the song is contained in a local song database, so we first # check whether this is the case. # XXX make this behaviour configurable? stats = hub.request(requests.getdatabasestats(song.songdbid)) if isinstance(song, item.song): if stats.type == "local": return song return song # XXX do we really need this # currently it does not work anymore if os.path.isfile(song.path): # first we try to access the song via its filesystem path return hub.request( requests.queryregistersong(self.songdbid, song.path)) if song.artist != dbitem.UNKNOWN and song.album != dbitem.UNKNOWN: # otherwise we use the artist and album tags and try to obtain the song via # the database songs = hub.request( requests.getsongs(self.songdbid, artist=song.artist, album=song.album)) for asong in songs: if asong.title == song.title: return asong # song not found # XXX start transmitting song return
def _checksong(self, song): # it is ok if the song is contained in a local song database, so we first # check whether this is the case. # XXX make this behaviour configurable? stats = hub.request(requests.getdatabasestats(song.songdbid)) if isinstance(song, item.song): if stats.type == "local": return song return song # XXX do we really need this # currently it does not work anymore if os.path.isfile(song.path): # first we try to access the song via its filesystem path return hub.request(requests.queryregistersong(self.songdbid, song.path)) if song.artist != dbitem.UNKNOWN and song.album != dbitem.UNKNOWN: # otherwise we use the artist and album tags and try to obtain the song via # the database songs = hub.request(requests.getsongs(self.songdbid, artist=song.artist, album=song.album)) for asong in songs: if asong.title == song.title: return asong # song not found # XXX start transmitting song return
def __init__(self, songdbids, afilters=None, rootdir=False): # XXX: as a really dirty hack, we cache the result of getdatabasestats for # all databases because we cannot call this request safely later on # (we might be handling another request which calls the basedir constructor) global _dbstats if _dbstats is None: _dbstats = {} for songdbid in songdbids: _dbstats[songdbid] = hub.request(requests.getdatabasestats(songdbid)) self.name = _("Song Database") self.songdbids = songdbids if len(songdbids) == 1: self.songdbid = songdbids[0] self.type = _dbstats[self.songdbid].type self.basedir = _dbstats[self.songdbid].basedir else: self.songdbid = None self.type = "virtual" self.basedir = None self.id = "basedir" if afilters is None: # add default filters self.filters = filters((podcastfilter(inverted=True), deletedfilter(inverted=True))) else: self.filters = afilters self.rootdir = rootdir self.maxnr = 100 self.nrartists = None self.nrsongs = None self._initvirtdirs()
def rescanplaylists(self): # we rescan by deleting all playlist first and then reading them in again for playlist in hub.request(requests.getplaylists(self.songdbid)): log.debug("deleting playlist: %s" % playlist.name) self._notify(events.delete_playlist(self.songdbid, playlist)) self.rescanplaylists_dirtree(configmodule.general.playlistdir or ".")
def saveplaylisthandler(self, name, key): name = name.strip() if key == ord("\n") and name != "" and self.items: songs = [ item.song for item in self.items if item.song.songdbid == self.songdbid ] hub.notify(events.add_playlist(self.songdbid, name, songs)) # also write playlist to filesystem if name[-4:] != ".m3u": name = name + ".m3u" try: name = os.path.join(config.general.playlistdir, name) file = open(name, "w", encoding="utf-8") for item in self.items: if item.song.url.startswith("file://"): dbstats = hub.request( requests.getdatabasestats(item.song.songdbid)) path = os.path.join(dbstats.basedir, item.song.url[7:]) else: path = item.song.url file.write("%s\n" % path) file.close() except (IOError, OSError): pass
def getname(self): if self.nrsongs is None: self.nrsongs = hub.request(requests.getnumberofsongs(self.songdbid, filters=self.filters)) if self.basedir: return _("[Database: %s (%d)]") % (self.basedir, self.nrsongs) else: return _("%d databases (%d)") % (len(self.songdbids), self.nrsongs)
def run(self): # process events, request and subscription requests coming from # the client while not self.done: type, obj = self._receiveobject() if type == _EVENT: log.debug("server: client sends event '%s'" % obj) hub.notify(obj, priority=-50) elif type == _REQUEST: log.debug("server: requesting %s for client" % `obj`) # extract id rid, obj = obj result = hub.request(obj, priority=-50) log.debug("server: got answer %s" % `result`) # be careful, handler may not exist anymore? try: self.handler._sendobject(_RESULT, (rid, result)) except: pass elif type == _SUBSCRIBE: log.debug("server: client requests subscription for '%s'" % `obj`) # be careful, maybe handler does not exists anymore? try: self.handler.subscribe(obj) except: pass else: log.debug("server: servernetworkreceiver exits: type=%s" % type) self.done = True self.handler.done = True
def autoregistersongs(self, event): if self.songdbid == event.songdbid: oldsongs = set(hub.request(requests.getsongs(self.songdbid))) log.info(_("database %r: scanning for songs in %r (currently %d songs registered)") % (self.songdbid, self.basedir, len(oldsongs))) # scan for all songs in the filesystem log.debug("database %r: searching for new songs" % self.songdbid) self.registerdirtree(self.basedir, oldsongs, event.force) # remove songs which have not yet been scanned and thus are not accesible anymore log.info(_("database %r: removing %d stale songs") % (self.songdbid, len(oldsongs))) for song in oldsongs: self._notify(events.delete_song(self.songdbid, song)) nrsongs = hub.request(requests.getnumberofsongs(self.songdbid)) log.info(_("database %r: rescan finished (%d songs registered)") % (self.songdbid, nrsongs))
def getcontentsrecursivesorted(self): albums = hub.request( requests.getalbums(self.songdbid, filters=self.filters)) result = [] for aalbum in albums: result.extend(aalbum.getcontentsrecursivesorted()) return result
def __init__(self, songdbids, afilters=None, rootdir=False): # XXX: as a really dirty hack, we cache the result of getdatabasestats for # all databases because we cannot call this request safely later on # (we might be handling another request which calls the basedir constructor) global _dbstats if _dbstats is None: _dbstats = {} for songdbid in songdbids: _dbstats[songdbid] = hub.request( requests.getdatabasestats(songdbid)) self.name = _("Song Database") self.songdbids = songdbids if len(songdbids) == 1: self.songdbid = songdbids[0] self.type = _dbstats[self.songdbid].type self.basedir = _dbstats[self.songdbid].basedir else: self.songdbid = None self.type = "virtual" self.basedir = None self.id = "basedir" if afilters is None: # add default filters self.filters = filters( (podcastfilter(inverted=True), deletedfilter(inverted=True))) else: self.filters = afilters self.rootdir = rootdir self.maxnr = 100 self.nrartists = None self.nrsongs = None self._initvirtdirs()
def getcontents(self): songs = hub.request( requests.getsongs(self.songdbid, filters=self.filters, sort=self.order)) self.nrsongs = len(songs) return songs
def getname(self): if self.nrsongs is None: self.nrsongs = hub.request( requests.getnumberofsongs(self.songdbid, filters=self.filters)) if self.basedir: return _("[Database: %s (%d)]") % (self.basedir, self.nrsongs) else: return _("%d databases (%d)") % (len(self.songdbids), self.nrsongs)
def getname(self): # XXX make this configurable (note that showing the numbers by default is rather costly) if 1: return "%s/" % self.description else: if self.nrsongs is None: self.nrsongs = hub.request(requests.getnumberofsongs(self.songdbid, filters=self.filters)) return "%s (%d)/" % (self.description, self.nrsongs)
def getcontentsrecursivesorted(self): # we cannot rely on the default implementation since we don't want # to have the albums and songs included trice artists = hub.request(requests.getartists(self.songdbid, filters=self.filters)) result = [] for aartist in artists: result.extend(aartist.getcontentsrecursivesorted()) return result
def getcontentsrecursivesorted(self): # we cannot rely on the default implementation since we don't want # to have the albums and songs included trice artists = hub.request( requests.getartists(self.songdbid, filters=self.filters)) result = [] for aartist in artists: result.extend(aartist.getcontentsrecursivesorted()) return result
def getcontents(self): songs = [] while len(songs)<self.maxnr: newsongs = hub.request(requests.getsongs(self.songdbid, filters=self.filters, random=True)) if len(newsongs) > 0: songs.extend(newsongs) else: break return songs[:self.maxnr]
def getname(self): # XXX make this configurable (note that showing the numbers by default is rather costly) if 1: return "%s/" % self.description else: if self.nrsongs is None: self.nrsongs = hub.request( requests.getnumberofsongs(self.songdbid, filters=self.filters)) return "%s (%d)/" % (self.description, self.nrsongs)
def __init__(self, win, playerid): slist.slist.__init__(self, win, config.playlistwindow.scrollmode=="page") self.playerid = playerid self.songdbid = "main" items, self.ptime, self.ttime, self.autoplaymode, self.playingitem = \ hub.request(requests.playlistgetcontents()) self.set(items) self._recenter() self.win.channel.subscribe(events.playlistchanged, self.playlistchanged)
def getcontents(self): # do not show artists which only appear in compilations filters = self.filters.added(compilationfilter(False)) aartists = hub.request(requests.getartists(self.songdbid, filters=filters)) self.nrartists = len(aartists) # reset cached value self.nrsongs = None if config.filelistwindow.virtualdirectoriesattop: return self.virtdirs + aartists else: return aartists + self.virtdirs
def showitems(self): lines = [] stats = hub.request(requests.getsongdbmanagerstats()) indent = " " * 3 for songdbstats in stats.songdbsstats: dbidstring = _("Database %s") % songdbstats.id + ":" dbstatstring = _("%d songs, %d albums, %d artists, %d tags") % ( songdbstats.numberofsongs, songdbstats.numberofalbums, songdbstats.numberofartists, songdbstats.numberoftags) lines.append((dbidstring, dbstatstring)) if songdbstats.type == "local": dbtypestring = _("local database (db file: %s)") % ( songdbstats.dbfile) else: dbtypestring = _("remote database (server: %s)") % ( songdbstats.location) lines.append((indent + _("type") + ":", dbtypestring)) lines.append( (indent + _("base directory") + ":", songdbstats.basedir)) dbcachesizestring = "%dkB" % songdbstats.cachesize lines.append((indent + _("cache size") + ":", dbcachesizestring)) lines.append(("", "")) cachestatsstring = _("%d requests, %d / %d objects") % ( stats.requestcacherequests, stats.requestcachesize, stats.requestcachemaxsize) if stats.requestcachemaxsize != 0: cachestatsstring = cachestatsstring + " (%d%%)" % ( 100 * stats.requestcachesize // stats.requestcachemaxsize) lines.append((_("Request cache size") + ":", cachestatsstring)) totalrequests = stats.requestcachehits + stats.requestcachemisses if totalrequests != 0: percentstring = " (%d%%)" % (100 * stats.requestcachehits // totalrequests) else: percentstring = "" lines.append( (_("Request cache stats") + ":", (_("%d hits / %d requests") % (stats.requestcachehits, totalrequests)) + percentstring)) wc1 = max([len(lc) for lc, rc in lines]) + 1 if wc1 > 0.6 * self.iw: wc1 = int(0.6 * self.iw) wc2 = self.iw - wc1 y = self.iy for lc, rc in lines: self.move(y, self.ix) self.addstr( encoding.encode(lc).ljust(wc1)[:wc1], self.colors.description) self.addstr( encoding.encode(rc).ljust(wc2)[:wc2], self.colors.content) y += 1
def __getattr__(self, attr): # we refuse to fetch the song metadata if an "internal" method name is queried. # Thus, we do not interfere with pickling of song instances, etc. if attr.startswith("__"): raise AttributeError if not self.song_metadata: self.song_metadata = hub.request(requests.getsong_metadata(self.songdbid, self.id)) # return metadata if we have been able to fetch it, otherwise return None if self.song_metadata: return getattr(self.song_metadata, attr) else: return None
def getcontents(self): songs = [] while len(songs) < self.maxnr: newsongs = hub.request( requests.getsongs(self.songdbid, filters=self.filters, random=True)) if len(newsongs) > 0: songs.extend(newsongs) else: break return songs[:self.maxnr]
def getcontents(self): # do not show artists which only appear in compilations filters = self.filters.added(compilationfilter(False)) aartists = hub.request( requests.getartists(self.songdbid, filters=filters)) self.nrartists = len(aartists) # reset cached value self.nrsongs = None if config.filelistwindow.virtualdirectoriesattop: return self.virtdirs + aartists else: return aartists + self.virtdirs
def __getattr__(self, attr): # we refuse to fetch the song metadata if an "internal" method name is queried. # Thus, we do not interfere with pickling of song instances, etc. if attr.startswith("__"): raise AttributeError if not self.song_metadata: self.song_metadata = hub.request( requests.getsong_metadata(self.songdbid, self.id)) # return metadata if we have been able to fetch it, otherwise return None if self.song_metadata: return getattr(self.song_metadata, attr) else: return None
def _playsong(self, playlistitemorsong, manual): """play event.song next""" path = None if isinstance( playlistitemorsong, services.playlist.playlistitem ): url = playlistitemorsong.song.url if url.startswith("file://"): dbstats = hub.request(requests.getdatabasestats(playlistitemorsong.song.songdbid)) path = os.path.join(dbstats.basedir, url[7:]) else: path = url else: log.warning("mpg123 player: song %s not a playlistitem. Not added!" % repr( playlistitemorsong) ) return self.sendmpg123("L %s" % path) self.framespersecond = None self.playbackinfo.updatesong(song)
def getcontents(self): items = [] try: for name in os.listdir(self.dir): try: path = os.path.join(self.dir, name) extension = os.path.splitext(path)[1] if os.path.isdir(path) and os.access( path, os.R_OK | os.X_OK): newitem = filesystemdir(self.songdbid, self.basedir, path) items.append(newitem) elif extension in metadata.getextensions() and os.access( path, os.R_OK): song = hub.request( requests.autoregisterer_queryregistersong( self.songdbid, path)) if song: items.append(song) except (IOError, OSError): pass except OSError: return None def cmpitem(x, y): if isinstance(x, filesystemdir): if isinstance(y, filesystemdir): # sort directories alphabetically return cmp(x.getname(), y.getname()) else: # sort directories first return -1 else: if isinstance(y, filesystemdir): # sort directories first return 1 else: # sort songs as usual in db return (x.disknumber and y.disknumber and cmp(x.disknumber, y.disknumber) or x.tracknumber and y.tracknumber and cmp(x.tracknumber, y.tracknumber) or cmp(x.title, y.title)) items.sort(key=cmp_to_key(cmpitem)) return items
def showitems(self): lines = [] stats = hub.request(requests.getsongdbmanagerstats()) indent = " "*3 for songdbstats in stats.songdbsstats: dbidstring = _("Database %s") % songdbstats.id + ":" dbstatstring = _("%d songs, %d albums, %d artists, %d tags") % (songdbstats.numberofsongs, songdbstats.numberofalbums, songdbstats.numberofartists, songdbstats.numberoftags) lines.append((dbidstring, dbstatstring)) if songdbstats.type == "local": dbtypestring = _("local database (db file: %s)") % (songdbstats.dbfile) else: dbtypestring = _("remote database (server: %s)") % (songdbstats.location) lines.append((indent + _("type") + ":", dbtypestring)) lines.append((indent + _("base directory") + ":", songdbstats.basedir)) dbcachesizestring = "%dkB" % songdbstats.cachesize lines.append((indent + _("cache size") + ":", dbcachesizestring)) lines.append(("", "")) cachestatsstring = _("%d requests, %d / %d objects") % (stats.requestcacherequests, stats.requestcachesize, stats.requestcachemaxsize) if stats.requestcachemaxsize != 0: cachestatsstring = cachestatsstring + " (%d%%)" % (100*stats.requestcachesize//stats.requestcachemaxsize) lines.append((_("Request cache size") + ":", cachestatsstring)) totalrequests = stats.requestcachehits + stats.requestcachemisses if totalrequests != 0: percentstring = " (%d%%)" % (100*stats.requestcachehits//totalrequests) else: percentstring = "" lines.append((_("Request cache stats") + ":", (_("%d hits / %d requests") % (stats.requestcachehits, totalrequests)) + percentstring)) wc1 = max([len(lc) for lc, rc in lines]) + 1 if wc1 > 0.6*self.iw: wc1 = int(0.6*self.iw) wc2 = self.iw - wc1 y = self.iy for lc, rc in lines: self.move(y, self.ix) self.addstr(encoding.encode(lc).ljust(wc1)[:wc1], self.colors.description) self.addstr(encoding.encode(rc).ljust(wc2)[:wc2], self.colors.content) y += 1
def __init__(self, song, outrate): self.outrate = outrate self.default_rate = outrate try: decoder = getdecoder(song.type) except: log.error("No decoder for song type '%r' registered " % song.type) raise RuntimeError("No decoder for song type '%r' registered " % song.type) url = encoding.encode_path(song.url) if url.startswith("file://"): dbstats = hub.request(requests.getdatabasestats(song.songdbid)) if not dbstats.basedir: log.error( "Currently only support for locally stored songs available" ) raise RuntimeError( "Currently only support for locally stored songs available" ) path = os.path.join(dbstats.basedir, url[7:]) self.decodedfile = decoder(path) else: log.error( "Currently only support for locally stored songs available") raise RuntimeError( "Currently only support for locally stored songs available") # Use the total time given by the decoder library and not the one # stored in the database. The former one turns out to be more precise # for some VBR songs. self.ttime = max(self.decodedfile.ttime(), song.length) # sometimes the mad library seems to report a wrong sample rate, # so use the one stored in the database if song.samplerate: self.samplerate = song.samplerate else: self.samplerate = self.decodedfile.samplerate() self.buff = self.last_l = self.last_r = None self.buffpos = 0 self.ptime = 0
def loadplaylisthandler(self, name, key): if key == ord("\n"): if name[-4:] != ".m3u": name = name + ".m3u" try: path = os.path.join(config.general.playlistdir, name) file = open(path, "r", encoding="utf-8") self._clear() for line in file: if not line.startswith("#"): song = hub.request(requests.autoregisterer_queryregistersong(self.songdbid, line.strip())) if song: self.append(playlistitem(song)) file.close() except (IOError, OSError): pass self._updateplaystarttimes() self.notifyplaylistchanged()
def playlist_requestnextsong(self, request): if request.playlistid != self.id: raise hub.DenyRequest if not request.previous: nextitem = self._playnext() if not nextitem: if self.autoplaymode == "random": # add some randomly selected song to the end of the playlist randomsongs = hub.request(requests.getsongs("main", random=True)) if randomsongs: self._addsongs(randomsongs[0:1]) nextitem = self._playnext() elif self.autoplaymode == "repeat": self._markallunplayed() nextitem = self._playnext() else: nextitem = self._playprevious() self.notifyplaylistchanged() return nextitem
def playlist_requestnextsong(self, request): if request.playlistid != self.id: raise hub.DenyRequest if not request.previous: nextitem = self._playnext() if not nextitem: if self.autoplaymode == "random": # add some randomly selected song to the end of the playlist randomsongs = hub.request( requests.getsongs("main", random=True)) if randomsongs: self._addsongs(randomsongs[0:1]) nextitem = self._playnext() elif self.autoplaymode == "repeat": self._markallunplayed() nextitem = self._playnext() else: nextitem = self._playprevious() self.notifyplaylistchanged() return nextitem
def loadplaylisthandler(self, name, key): if key == ord("\n"): if name[-4:] != ".m3u": name = name + ".m3u" try: path = os.path.join(config.general.playlistdir, name) file = open(path, "r", encoding="utf-8") self._clear() for line in file: if not line.startswith("#"): song = hub.request( requests.autoregisterer_queryregistersong( self.songdbid, line.strip())) if song: self.append(playlistitem(song)) file.close() except (IOError, OSError): pass self._updateplaystarttimes() self.notifyplaylistchanged()
def saveplaylisthandler(self, name, key): name = name.strip() if key == ord("\n") and name != "" and self.items: songs = [item.song for item in self.items if item.song.songdbid == self.songdbid ] hub.notify(events.add_playlist(self.songdbid, name, songs)) # also write playlist to filesystem if name[-4:] != ".m3u": name = name + ".m3u" try: name = os.path.join(config.general.playlistdir, name) file = open(name, "w", encoding="utf-8") for item in self.items: if item.song.url.startswith("file://"): dbstats = hub.request(requests.getdatabasestats(item.song.songdbid)) path = os.path.join(dbstats.basedir, item.song.url[7:]) else: path = item.song.url file.write("%s\n" % path) file.close() except (IOError, OSError): pass
def __init__(self, song, outrate): self.outrate = outrate self.default_rate = outrate try: decoder = getdecoder(song.type) except: log.error("No decoder for song type '%r' registered "% song.type) raise RuntimeError("No decoder for song type '%r' registered "% song.type) url = encoding.encode_path(song.url) if url.startswith("file://"): dbstats = hub.request(requests.getdatabasestats(song.songdbid)) if not dbstats.basedir: log.error("Currently only support for locally stored songs available") raise RuntimeError("Currently only support for locally stored songs available") path = os.path.join(dbstats.basedir, url[7:]) self.decodedfile = decoder(path) else: log.error("Currently only support for locally stored songs available") raise RuntimeError("Currently only support for locally stored songs available") # Use the total time given by the decoder library and not the one # stored in the database. The former one turns out to be more precise # for some VBR songs. self.ttime = max(self.decodedfile.ttime(), song.length) # sometimes the mad library seems to report a wrong sample rate, # so use the one stored in the database if song.samplerate: self.samplerate = song.samplerate else: self.samplerate = self.decodedfile.samplerate() self.buff = self.last_l = self.last_r = None self.buffpos = 0 self.ptime = 0
def getcontents(self): items = [] try: for name in os.listdir(self.dir): try: path = os.path.join(self.dir, name) extension = os.path.splitext(path)[1] if os.path.isdir(path) and os.access(path, os.R_OK|os.X_OK): newitem = filesystemdir(self.songdbid, self.basedir, path) items.append(newitem) elif extension in metadata.getextensions() and os.access(path, os.R_OK): song = hub.request(requests.autoregisterer_queryregistersong(self.songdbid, path)) if song: items.append(song) except (IOError, OSError): pass except OSError: return None def cmpitem(x, y): if isinstance(x, filesystemdir): if isinstance(y, filesystemdir): # sort directories alphabetically return cmp(x.getname(), y.getname()) else: # sort directories first return -1 else: if isinstance(y, filesystemdir): # sort directories first return 1 else: # sort songs as usual in db return ( x.disknumber and y.disknumber and cmp(x.disknumber, y.disknumber) or x.tracknumber and y.tracknumber and cmp(x.tracknumber, y.tracknumber) or cmp(x.title, y.title) ) items.sort(cmp=cmpitem) return items
def getname(self): if self.nrsongs is None: self.nrsongs = hub.request( requests.getnumberofsongs(self.songdbid, filters=self.filters)) return "[%s (%d)]/" % (self.name, self.nrsongs)
def getcontents(self): albums = hub.request(requests.getalbums(self.songdbid, filters=self.filters)) self.nralbums = len(albums) return albums
def getname(self): if self.nralbums is None: self.nralbums = hub.request(requests.getnumberofalbums(self.songdbid, filters=self.filters)) return "[%s (%d)]/" % (self.name, self.nralbums)
def getcontents(self): playlists = hub.request(requests.getplaylists(self.songdbid, filters=self.filters)) self.nrplaylists = len(playlists) return playlists
def getcontentsrecursiverandom(self): return hub.request( requests.getsongs(self.songdbid, sort=self.order, filters=self.filters, random=True))
def getcontents(self): tags = hub.request( requests.gettags(self.songdbid, filters=self.filters)) tags = [tag for tag in tags if tag.id not in self.exclude_tag_ids] self.nrtags = len(tags) return tags
def getcontents(self): albums = hub.request( requests.getalbums(self.songdbid, filters=self.filters)) return albums + [songs(self.songdbid, self.name, self.filters)]
def getcontents(self): songs = hub.request(requests.getsongs(self.songdbid, filters=self.filters, sort=self.order)) self.nrsongs = len(songs) return songs
def getcontentsrecursive(self): return hub.request(requests.getsongs(self.songdbid, filters=self.filters))
def getcontentsrecursivesorted(self): albums = hub.request(requests.getalbums(self.songdbid, filters=self.filters)) result = [] for aalbum in albums: result.extend(aalbum.getcontentsrecursivesorted()) return result
def getcontents(self): albums = hub.request(requests.getalbums(self.songdbid, filters=self.filters)) return albums + [songs(self.songdbid, self.name, self.filters)]
def getcontentsrecursiverandom(self): return hub.request( requests.getlastplayedsongs(self.songdbid, filters=self.filters, random=True))
def getcontents(self): tags = hub.request(requests.gettags(self.songdbid, filters=self.filters)) tags = [tag for tag in tags if tag.id not in self.exclude_tag_ids] self.nrtags = len(tags) return tags
def getcontentsrecursive(self): return hub.request( requests.getsongs(self.songdbid, filters=self.filters))
def getcontents(self): return hub.request( requests.getsongs(self.songdbid, filters=self.filters, sort=self.order))
def getcontents(self): return hub.request( requests.getlastplayedsongs(self.songdbid, sort=self.order, filters=self.filters))
def getcontents(self): playlists = hub.request( requests.getplaylists(self.songdbid, filters=self.filters)) self.nrplaylists = len(playlists) return playlists
def getcontentsrecursiverandom(self): return hub.request(requests.getlastplayedsongs(self.songdbid, filters=self.filters, random=True))
def getcontents(self): albums = hub.request( requests.getalbums(self.songdbid, filters=self.filters)) self.nralbums = len(albums) return albums
def getcontents(self): return hub.request(requests.getsongs(self.songdbid, sort=self.order, filters=self.filters))
def getcontents(self): songs = hub.request( requests.getsongs(self.songdbid, sort=self.order, filters=self.filters)) return songs
def getcontentsrecursiverandom(self): return hub.request(requests.getsongs(self.songdbid, sort=self.order, filters=self.filters, random=True))