def search(config, session, web_client,
query=None, uris=None, exact=False, types=_SEARCH_TYPES):
# TODO Respect `uris` argument
# TODO Support `exact` search
if query is None:
logger.debug('Ignored search without query')
return models.SearchResult(uri='spotify:search')
if 'uri' in query:
return _search_by_uri(config, session, query)
sp_query = translator.sp_search_query(query)
if not sp_query:
logger.debug('Ignored search with empty query')
return models.SearchResult(uri='spotify:search')
uri = 'spotify:search:%s' % urllib.quote(sp_query.encode('utf-8'))
logger.info('Searching Spotify for: %s', sp_query)
if session.connection.state is not spotify.ConnectionState.LOGGED_IN:
logger.info('Spotify search aborted: Spotify is offline')
return models.SearchResult(uri=uri)
search_count = max(
config['search_album_count'],
config['search_artist_count'],
config['search_track_count'])
if search_count > 50:
logger.warn(
'Spotify currently allows maximum 50 search results of each type. '
'Please set the config values spotify/search_album_count, '
'spotify/search_artist_count and spotify/search_track_count '
'to at most 50.')
search_count = 50
result = web_client.get(_API_BASE_URI, params={
'q': sp_query,
'limit': search_count,
'type': ','.join(types)})
albums = [
translator.web_to_album(web_album) for web_album in
result['albums']['items'][:config['search_album_count']]
] if 'albums' in result else []
artists = [
translator.web_to_artist(web_artist) for web_artist in
result['artists']['items'][:config['search_artist_count']]
] if 'artists' in result else []
tracks = [
translator.web_to_track(web_track) for web_track in
result['tracks']['items'][:config['search_track_count']]
] if 'tracks' in result else []
return models.SearchResult(
uri=uri, albums=albums, artists=artists, tracks=tracks)
def test_successful_translation(self, web_album_mock):
album = translator.web_to_album(web_album_mock)
artists = [models.Artist(uri='spotify:artist:abba', name='ABBA')]
assert album.uri == 'spotify:album:def'
assert album.name == 'DEF 456'
assert list(album.artists) == artists
def test_successful_translation(self, web_album_mock):
album = translator.web_to_album(web_album_mock)
artists = [models.Artist(uri='spotify:artist:abba', name='ABBA')]
assert album.uri == 'spotify:album:def'
assert album.name == 'DEF 456'
assert list(album.artists) == artists
def test_successful_translation(self, web_album_mock):
album = translator.web_to_album(web_album_mock)
artists = [models.Artist(uri="spotify:artist:abba", name="ABBA")]
assert album.uri == "spotify:album:def"
assert album.name == "DEF 456"
assert list(album.artists) == artists
def test_calls_web_to_album_ref(self, web_album_mock):
ref_mock = mock.Mock(spec=models.Ref.album)
ref_mock.uri = str(sentinel.uri)
ref_mock.name = str(sentinel.name)
with patch.object(
translator, "web_to_album_ref", return_value=ref_mock
) as ref_func_mock:
album = translator.web_to_album(web_album_mock)
ref_func_mock.assert_called_once_with(web_album_mock)
assert album.uri == str(sentinel.uri)
assert album.name == str(sentinel.name)
def test_ignores_invalid_artists(self, web_album_mock, web_artist_mock):
invalid_artist1 = {"name": "FOO", "uri": None, "type": "artist"}
invalid_artist2 = {"name": "BAR", "type": "football"}
web_album_mock["artists"] = [
invalid_artist1,
web_artist_mock,
invalid_artist2,
]
album = translator.web_to_album(web_album_mock)
artists = [models.Artist(uri="spotify:artist:abba", name="ABBA")]
assert album.uri == "spotify:album:def"
assert album.name == "DEF 456"
assert list(album.artists) == artists
def search(config,
session,
web_client,
query=None,
uris=None,
exact=False,
types=_SEARCH_TYPES):
# TODO Respect `uris` argument
# TODO Support `exact` search
if query is None:
logger.debug('Ignored search without query')
return models.SearchResult(uri='spotify:search')
if 'uri' in query:
return _search_by_uri(config, session, query, web_client)
sp_query = translator.sp_search_query(query)
if not sp_query:
logger.debug('Ignored search with empty query')
return models.SearchResult(uri='spotify:search')
uri = 'spotify:search:%s' % urllib.quote(sp_query.encode('utf-8'))
logger.info('Searching Spotify for: %s', sp_query)
if session.connection.state is not spotify.ConnectionState.LOGGED_IN:
logger.info('Spotify search aborted: Spotify is offline')
return models.SearchResult(uri=uri)
search_count = max(config['search_album_count'],
config['search_artist_count'],
config['search_track_count'])
if search_count > 50:
logger.warn(
'Spotify currently allows maximum 50 search results of each type. '
'Please set the config values spotify/search_album_count, '
'spotify/search_artist_count and spotify/search_track_count '
'to at most 50.')
search_count = 50
result = web_client.get('search',
params={
'q': sp_query,
'limit': search_count,
'market': session.user_country,
'type': ','.join(types)
})
albums = [
translator.web_to_album(web_album) for web_album in result['albums']
['items'][:config['search_album_count']]
] if 'albums' in result else []
artists = [
translator.web_to_artist(web_artist) for web_artist in
result['artists']['items'][:config['search_artist_count']]
] if 'artists' in result else []
tracks = [
translator.web_to_track(web_track) for web_track in result['tracks']
['items'][:config['search_track_count']]
] if 'tracks' in result else []
return models.SearchResult(uri=uri,
albums=albums,
artists=artists,
tracks=tracks)
def test_successful_translation(self, web_album_mock):
album = translator.web_to_album(web_album_mock)
assert album.uri == 'spotify:album:def'
assert album.name == 'DEF 456'
def search(
config,
session,
web_client,
query=None,
uris=None,
exact=False,
types=_SEARCH_TYPES,
):
# TODO Respect `uris` argument
# TODO Support `exact` search
if query is None:
logger.debug("Ignored search without query")
return models.SearchResult(uri="spotify:search")
if "uri" in query:
return _search_by_uri(config, session, web_client, query)
sp_query = translator.sp_search_query(query)
if not sp_query:
logger.debug("Ignored search with empty query")
return models.SearchResult(uri="spotify:search")
uri = f"spotify:search:{urllib.parse.quote(sp_query)}"
logger.info(f"Searching Spotify for: {sp_query}")
if session.connection.state is not spotify.ConnectionState.LOGGED_IN:
logger.info("Spotify search aborted: Spotify is offline")
return models.SearchResult(uri=uri)
search_count = max(
config["search_album_count"],
config["search_artist_count"],
config["search_track_count"],
)
if search_count > 50:
logger.warn(
"Spotify currently allows maximum 50 search results of each type. "
"Please set the config values spotify/search_album_count, "
"spotify/search_artist_count and spotify/search_track_count "
"to at most 50.")
search_count = 50
result = web_client.get(
"search",
params={
"q": sp_query,
"limit": search_count,
"market": "from_token",
"type": ",".join(types),
},
)
albums = ([
translator.web_to_album(web_album) for web_album in result["albums"]
["items"][:config["search_album_count"]]
] if "albums" in result else [])
artists = ([
translator.web_to_artist(web_artist) for web_artist in
result["artists"]["items"][:config["search_artist_count"]]
] if "artists" in result else [])
tracks = ([
translator.web_to_track(web_track) for web_track in result["tracks"]
["items"][:config["search_track_count"]]
] if "tracks" in result else [])
return models.SearchResult(uri=uri,
albums=albums,
artists=artists,
tracks=tracks)
def test_release_date_formats_truncating(self, web_album_mock):
web_album_mock["release_date"] = "2001-12-01"
album = translator.web_to_album(web_album_mock)
assert album.date == "2001"
def test_returns_none_if_invalid_ref(self, web_album_mock):
with patch.object(translator, "web_to_album_ref", return_value=None):
assert translator.web_to_album(web_album_mock) is None
