Convenience method for `get_music_library_information`
        with ``search_type='album_artists'``. For details of other arguments,
        see `that method
        <#soco.music_library.MusicLibrary.get_music_library_information>`_.
763494
def get_album_artists(self, *args, **kwargs):
        
        args = tuple(['album_artists'] + list(args))
        return self.get_music_library_information(*args, **kwargs)
1306255
def get_tracks(self, search, start=0, max_items=100):
        
        return self.get_music_service_information('tracks', search, start,
                                                  max_items)
1263546
def get_artists(self, search, start=0, max_items=100):
        
        return self.get_music_service_information('artists', search, start,
                                                  max_items)
505877
def get_genres(self, *args, **kwargs):
        
        args = tuple(['genres'] + list(args))
        return self.get_music_library_information(*args, **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
318277
def get_artist(self):
        
        # pylint: disable=E1101
        assert isinstance(self, (Album, Track))
        return self.client.get_artist(self.artist.id)
1100107
@Get("/musics/search")
	public void search(Music music) {
		String title = MoreObjects.firstNonNull(music.getTitle(), "");
        result.include("musics", this.musicDao.searchSimilarTitle(title));
    }
78887
function retrieveRecords(rType, source) {
  return function(options, callback) {
    var q = {
      _source : source,
      size : hitSize,
      "query": {
        "filtered": {
          "query": {
            "bool": {
              "must": [
                {
                  query_string: {
                    query: 'member:' + (options.member ? '"' + options.member + '"' : '*')
                  }
                }
              ]
            }
          }
        }
      }
    };

    getEs().search({ _index : GLOBAL.config.ESEARCH._index, _type : rType}, q, function(err, res) {
      callback(err, res);
    });
  };
}
425224
def get_song(self, id_):
        """"""
        endpoint = "songs/{id}".format(id=id_)
        return self._make_request(endpoint)
884525
def search_album(self, album_name, quiet=False, limit=9):
        

        result = self.search(album_name, search_type=10, limit=limit)

        if result['result']['albumCount'] <= 0:
            LOG.warning('Album %s not existed!', album_name)
            raise SearchNotFound('Album {} not existed'.format(album_name))
        else:
            albums = result['result']['albums']
            if quiet:
                album_id, album_name = albums[0]['id'], albums[0]['name']
                album = Album(album_id, album_name)
                return album
            else:
                return self.display.select_one_album(albums)
271694
def _parse_album(self, album):
        '''
        
        '''
        if album['CoverArtFilename']:
            cover_url = '%sm%s' % (grooveshark.const.ALBUM_COVER_URL,
                                   album['CoverArtFilename'])
        else:
            cover_url = None
        return Album(
            album['AlbumID'],
            album['Name'],
            album['ArtistID'],
            album['ArtistName'],
            cover_url,
            self.connection)
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)
679133
def artist_infos(self, artist_id):
        
        action = uri + '/artist/' + str(artist_id)
        data = self.request('GET', action)
        return data
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)
278246
def search(self, search_string):
        
        query = """
        SELECT ?s ?label ?type
        WHERE {
            ?s a ?type .
            ?s rdfs:label ?label .
            ?label bif:contains "'%s'" .
        }
        """ % search_string
        response = self._session.default_store.execute_sparql(query)
        results = [(result['s']['value'], result['label']['value'], result['type']['value'])
                                                            for result in response["results"]["bindings"]]
        resources = [(label, self._session.get_resource(subject, self._session.get_class(type)))
                                                            for subject, label, type in results]

        Name = self._session.get_class(surf.ns.EFRBROO['F12_Name'])
        Title = self._session.get_class(surf.ns.EFRBROO['E35_Title'])
        Work = self._session.get_class(surf.ns.EFRBROO['F1_Work'])
        Person = self._session.get_class(surf.ns.EFRBROO['F10_Person'])

        result = []
        for label, resource in resources:
            if resource.uri == surf.ns.EFRBROO['E35_Title']:
                work = Work.get_by(efrbroo_P102_has_title = resource).first()
                result.append((label, work))
            elif resource.uri == surf.ns.EFRBROO['F12_Name']:
                author = Person.get_by(ecrm_P1_is_identified_by = resource).first()
                result.append((label, author))
            elif resource.uri == surf.ns.ECRM['E41_Appellation']:
                try:
                    name = Name.get_by(ecrm_P139_has_alternative_form = resource).first()
                    assert name is not None
                    author = Person.get_by(ecrm_P1_is_identified_by = name).first()
                    result.append((label, author))
                except Exception as e:
                    title = Title.get_by(ecrm_P139_has_alternative_form=resource).first()
                    assert title is not None
                    work = Work.get_by(efrbroo_P102_has_title = title).first()
                    result.append((label, work))
        return result
1323362
def get_albums(self):
        
        return itunespy.lookup(id=self.artist_id, entity=itunespy.entities['album'])[1:]
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)