Convenience method for `get_music_library_information`
        with ``search_type='albums'``. For details of other arguments,
        see `that method
        <#soco.music_library.MusicLibrary.get_music_library_information>`_.
512787
def get_albums(self, *args, **kwargs):
        
        args = tuple(['albums'] + list(args))
        return self.get_music_library_information(*args, **kwargs)
540424
def search_json(query,types=nil,never_or=nil,extras=nil,start=nil,count=nil)
      method = 'search'
      type = TODO
      if not types
        types = 'Artist,Album,Track,Playlist,User'
      end
      args = {:query=>query}
      args[:types] = types if types
      args[:never_or] = never_or if never_or
      args[:extras] = extras if extras
      args[:start] = start if start
      args[:count] = count if count
      
      json = call method,args
      if Rdio::log_json
        Rdio::log json
      end
      return unwrap_json json
    end
393622
def get_artists(self, *args, **kwargs):
        
        args = tuple(['artists'] + list(args))
        return self.get_music_library_information(*args, **kwargs)
876688
def fetch_library_method(s)

      m = @pointer.__lib_method_cache[s]
      return m if m

      @pointer.__lib_method_cache[s] =
        loadstring_and_call("return #{s}", nil, nil, nil)
    end
632005
def download_album_by_id(self, album_id, album_name):
        

        try:
            # use old api
            songs = self.crawler.get_album_songs(album_id)
        except RequestException as exception:
            click.echo(exception)
        else:
            folder = os.path.join(self.folder, album_name)
            for song in songs:
                self.download_song_by_id(song.song_id, song.song_name, folder)
425498
def get_genres(self):
    
    page = r.get(ITUNES_GENRES_URL)
    tree = html.fromstring(page.content)
    elements = tree.xpath("//a[@class='top-level-genre']")
    return [e.attrib['href'] for e in elements]
1323362
def get_albums(self):
        
        return itunespy.lookup(id=self.artist_id, entity=itunespy.entities['album'])[1:]
1249403
def get_album(self, object_id, relation=None, **kwargs):
        
        return self.get_object("album", object_id, relation=relation, **kwargs)
426260
def search_records(self, record_type, name=None, data=None):
        
        return self.manager.search_records(self, record_type=record_type,
                name=name, data=data)
414662
def get_playlists(self, search, start=0, max_items=100):
        
        return self.get_music_service_information('playlists', search, start,
                                                  max_items)
988421
def getSearchUrl(self, album, artist):
    
    params = collections.OrderedDict()
    params["search-alias"] = "popular"
    params["field-artist"] = artist
    params["field-title"] = album
    params["sort"] = "relevancerank"
    return __class__.assembleUrl(self.base_url, params)
1041224
def query_info(self, what):
        
        if not isinstance(what, baseinteger):
            raise TypeError("what can only be an instance of type baseinteger")
        result = self._call("queryInfo",
                     in_p=[what])
        return result
293960
def search(session, query):
    
    flat_query = "".join(query.split())

    artists = session.query(Artist).filter(
            or_(Artist.name.ilike(f"%%{query}%%"),
                Artist.name.ilike(f"%%{flat_query}%%"))
               ).all()
    albums = session.query(Album).filter(
            Album.title.ilike(f"%%{query}%%")).all()
    tracks = session.query(Track).filter(
            Track.title.ilike(f"%%{query}%%")).all()

    return dict(artists=artists,
                albums=albums,
                tracks=tracks)
1270197
def searchAlbums(self, title, **kwargs):
        
        return self.search(libtype='photoalbum', title=title, **kwargs)
234038
def search(query, options={})
     api_response = @api_client.make_api_request(:GET, "artist/search", {:q => query}, options)
     @api_client.artist_digestor.nested_list_from_xml_doc(api_response.item_xml("searchResults"), :searchResult, :artist)
    end
571614
def get_files_information(self):
        
        for k in self.get_files():
            yield k, self.get_files_types()[k], self.get_files_crc32()[k]
244103
def search(type, query)
      results = []
      search = request('getResultsFromSearch', type: type, query: query)
      results = search['result'].map do |data|
        next Song.new data if type == 'Songs'
        next Playlist.new(self, data) if type == 'Playlists'
        data
      end if search.key?('result')
      results
    end