Python node.getNode函数代码示例

 def populate(self, options=None):
     if self.method is not None:
         return True
     if self.search_type is None:
         for kind in all_kinds:
             self.add_child(
                 getNode(
                     Flag.FAVORITE, parameters={'search-type': kind}))
         self.add_child(
             getNode(
                 Flag.FAVORITE, parameters={'search-type': 'all'}))
         return True
     result = False
     search_for = (self.search_type, )
     if self.search_type == 'all':
         search_for = all_kinds
     for kind in search_for:
         if kind not in self.data:
             continue
         method = '_populate_%s' % kind
         if not hasattr(self, method):
             logger.warn('No method named %s', method)
             continue
         if getattr(self, method)(options):
             result = True
     return result

 def populate(self, options=None):
     options = helper.get_tree_traverse_opts(options)
     result = False
     if options.lvl != -1:
         self.add_child(getNode(Flag.FRIENDS, parameters=self.parameters))
     for playlist in self.data['playlists']['items']:
         node = getNode(Flag.PLAYLIST, data=playlist)
         if node.get_owner() == self.label:
             self.nid = node.get_owner_id()
         self.add_child(node)
         result = True
     return result

def is_purchased(track):
    purchases = getNode(Flag.PURCHASE, parameters={'search-type': 'all'})
    purchases.data = purchases.fetch()
    if search(purchases, track):
        return True
    album = getNode(
        Flag.ALBUM, parameters={'nid': track.get_property('album/id')})
    album.data = album.fetch()
    if album.data is None:
        return False
    if search(purchases, album, kind='albums'):
        return True
    return False

 def _populate_artists(self, options):
     self.content_type = 'artists'
     for artist in self.data['artists']['items']:
         node = getNode(Flag.ARTIST, data=artist)
         node.data = node.fetch(helper.TreeTraverseOpts(noRemote=True))
         self.add_child(node)
     return True if len(self.data['artists']['items']) > 0 else False

def make_subscription_node():
    return getNode(
        Flag.TEXT,
        parameters={
            'label': '(Free Account / Subscribe on qobuz.com)',
            'image': 'http://static-www.qobuz.com/img/sprite/sprite-plans-option-2015.png'
        })

 def list_albums(self, qnt, qid):
     ''' List albums givent a node type and a node id
     '''
     album_ids = {}
     nodes = []
     if qnt & Flag.ALBUM == Flag.ALBUM:
         node = getNode(Flag.ALBUM, {'nid': qid})
         node.data = node.fetch()
         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 not render.nodes:
             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 and str(node.nid) not 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 not render.nodes:
                     newnode = getNode(
                         Flag.ALBUM, 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_artists(self, *a, **ka):
     for artist in self.data[self.search_type]['items']:
         self.add_child(
             getNode(
                 Flag.ARTIST,
                 parameters=self._get_parameters(),
                 data=artist))
     return True if len(self.data[self.search_type]['items']) > 0 else False

 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 route_disc_image(album_id=None, track_id=None):
    node = getNode(Flag.ALBUM, parameters={'nid': album_id})
    node.data = node.fetch()
    image = None
    if node.data is not None:
        image = node.get_image()
    if image is None:
        return http_error(404)
    return redirect(image, code=302)

 def __populate_type(self, options=None):
     '''Populate type, we don't have genre_type nor genre_id
     '''
     for genre_type_id in RECOS_TYPE_IDS:
         node = getNode(Flag.RECOMMENDATION, {'genre-type': genre_type_id})
         node.label2 = self.label
         node.label = RECOS_TYPES[genre_type_id]
         self.add_child(node)
     return True

 def populate(self, options=None):
     if self.search_type is None:
         for search_type in data_search_type.keys():
             self.add_child(
                 getNode(
                     Flag.SEARCH, parameters={'search-type': search_type}))
         return True
     self.content_type = data_search_type[self.search_type]['content_type']
     return getattr(self, '_populate_%s' % self.search_type)(options)

def route_track(album_id=None, track_id=None):
    if request.method == 'HEAD':
        return 'ok', 200
    track = getNode(Flag.TRACK, parameters={'nid': track_id})
    track.data = track.fetch()
    url = track.get_streaming_url()
    if url is None:
        return http_error(404)
    
    req = requests.get(url, stream=True)
    return Response(stream_with_context(req.iter_content(chunk_size=2048)), content_type=req.headers["content-type"])

 def populate(self, options=None):
     cid = self.get_current_playlist_id()
     for data in self.data['playlists']['items']:
         node = getNode(
             Flag.PLAYLIST, data=data, parameters={'nt': self.nt})
         if cid and cid == node.nid:
             node.set_is_current(True)
         if node.get_owner() == user.username:
             node.set_is_my_playlist(True)
         self.add_child(node)
     return True if self.data['playlists']['items'] else False

def _list_track_helper_populate_album(xdir, album_id):
    album = getNode(Flag.ALBUM,
                    parameters={
                        'nid': album_id,
                        'mode': Mode.SCAN
                    })
    album.populating(helper.TreeTraverseOpts(
        xdir=xdir,
        lvl=1,
        whiteFlag=Flag.TRACK,
        blackFlag=Flag.STOPBUILD))

 def add_name(name):
     if name in friend_list:
         return None
     if name == user_data['user']['login']:
         return None
     if name == self.name:
         return None
     friend_list[name] = 1
     node = getNode(Flag.FRIEND, {'query': str(name)})
     node.label = 'Friend / %s' % node.label
     self.add_child(node)
     return node