def test_date_is_ignored_if_not_parseable(self, caplog):
query = translator.sp_search_query({'date': ['abc']})
assert query == ''
assert (
'Excluded year from search query: Cannot parse date "abc"'
in caplog.text())
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_date_is_ignored_if_not_parseable(self, caplog):
query = translator.sp_search_query({"date": ["abc"]})
assert query == ""
assert (
'Excluded year from search query: Cannot parse date "abc"'
in caplog.text
)
def test_anything_can_be_combined(self):
query = translator.sp_search_query({
"any": ["ABC", "DEF"],
"artist": ["ABBA"],
"album": ["Greatest Hits"],
"track_name": ["Dancing Queen"],
"year": ["1970-01-02"],
})
assert '"ABC"' in query
assert '"DEF"' in query
assert 'artist:"ABBA"' in query
assert 'album:"Greatest Hits"' in query
assert 'track:"Dancing Queen"' in query
assert "year:1970" in query
def test_anything_can_be_combined(self):
query = translator.sp_search_query({
'any': ['ABC', 'DEF'],
'artist': ['ABBA'],
'album': ['Greatest Hits'],
'track_name': ['Dancing Queen'],
'year': ['1970-01-02'],
})
assert '"ABC"' in query
assert '"DEF"' in query
assert 'artist:"ABBA"' in query
assert 'album:"Greatest Hits"' in query
assert 'track:"Dancing Queen"' in query
assert 'year:1970' in query
def test_anything_can_be_combined(self):
query = translator.sp_search_query({
'any': ['ABC', 'DEF'],
'artist': ['ABBA'],
'album': ['Greatest Hits'],
'track_name': ['Dancing Queen'],
'year': ['1970-01-02'],
})
assert '"ABC"' in query
assert '"DEF"' in query
assert 'artist:"ABBA"' in query
assert 'album:"Greatest Hits"' in query
assert 'track:"Dancing Queen"' in query
assert 'year:1970' in query
def get_distinct(config, session, field, query=None):
# To make the returned data as interesting as possible, we limit
# ourselves to data extracted from the user's playlists when no search
# query is included.
sp_query = translator.sp_search_query(query) if query else None
if field == 'artist':
result = _get_distinct_artists(config, session, sp_query)
elif field == 'albumartist':
result = _get_distinct_albumartists(config, session, sp_query)
elif field == 'album':
result = _get_distinct_albums(config, session, sp_query)
elif field == 'date':
result = _get_distinct_dates(config, session, sp_query)
else:
result = set()
return result - {None}
def search(config, session, query=None, uris=None, exact=False):
# 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)
sp_search = session.search(
sp_query,
album_count=config['search_album_count'],
artist_count=config['search_artist_count'],
track_count=config['search_track_count'])
sp_search.load()
albums = [
translator.to_album(sp_album) for sp_album in sp_search.albums]
artists = [
translator.to_artist(sp_artist) for sp_artist in sp_search.artists]
tracks = [
translator.to_track(sp_track) for sp_track in sp_search.tracks]
return models.SearchResult(
uri=uri, albums=albums, artists=artists, tracks=tracks)
def search(config, session, query=None, uris=None, exact=False):
# 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)
sp_search = session.search(sp_query,
album_count=config['search_album_count'],
artist_count=config['search_artist_count'],
track_count=config['search_track_count'])
sp_search.load()
albums = [translator.to_album(sp_album) for sp_album in sp_search.albums]
artists = [
translator.to_artist(sp_artist) for sp_artist in sp_search.artists
]
tracks = [translator.to_track(sp_track) for sp_track in sp_search.tracks]
return models.SearchResult(uri=uri,
albums=albums,
artists=artists,
tracks=tracks)
def test_album_maps_to_album(self):
query = translator.sp_search_query({'album': ['Greatest Hits']})
assert query == 'album:"Greatest Hits"'
def test_albumartist_maps_to_artist(self):
# We don't know how to filter by albumartist in Spotify
query = translator.sp_search_query({'albumartist': ['ABBA', 'ACDC']})
assert query == 'artist:"ABBA" artist:"ACDC"'
def test_artist_maps_to_artist(self):
query = translator.sp_search_query({'artist': ['ABBA', 'ACDC']})
assert query == 'artist:"ABBA" artist:"ACDC"'
def test_any_maps_to_no_field(self):
query = translator.sp_search_query({'any': ['ABC', 'DEF']})
assert query == '"ABC" "DEF"'
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_any_maps_to_no_field(self):
query = translator.sp_search_query({"any": ["ABC", "DEF"]})
assert query == '"ABC" "DEF"'
def test_date_maps_to_year(self):
query = translator.sp_search_query({'date': ['1970']})
assert query == 'year:1970'
def test_track_name_maps_to_track(self):
query = translator.sp_search_query({"track_name": ["ABC"]})
assert query == 'track:"ABC"'
def test_date_maps_to_year(self):
query = translator.sp_search_query({"date": ["1970"]})
assert query == "year:1970"
def test_track_name_maps_to_track(self):
query = translator.sp_search_query({'track_name': ['ABC']})
assert query == 'track:"ABC"'
def test_album_maps_to_album(self):
query = translator.sp_search_query({'album': ['Greatest Hits']})
assert query == 'album:"Greatest Hits"'
def test_albumartist_maps_to_artist(self):
# We don't know how to filter by albumartist in Spotify
query = translator.sp_search_query({'albumartist': ['ABBA', 'ACDC']})
assert query == 'artist:"ABBA" artist:"ACDC"'
def test_artist_maps_to_artist(self):
query = translator.sp_search_query({'artist': ['ABBA', 'ACDC']})
assert query == 'artist:"ABBA" artist:"ACDC"'
def test_any_maps_to_no_field(self):
query = translator.sp_search_query({'any': ['ABC', 'DEF']})
assert query == '"ABC" "DEF"'
def test_track_name_maps_to_track(self):
query = translator.sp_search_query({'track_name': ['ABC']})
assert query == 'track:"ABC"'
def test_track_number_is_not_supported(self):
# We don't know how to filter by track number in Spotify
query = translator.sp_search_query({'track_number': ['10']})
assert query == ''
def test_date_is_transformed_to_just_the_year(self):
query = translator.sp_search_query({'date': ['1970-02-01']})
assert query == 'year:1970'
def test_date_is_transformed_to_just_the_year(self):
query = translator.sp_search_query({'date': ['1970-02-01']})
assert query == 'year:1970'
def test_artist_maps_to_artist(self):
query = translator.sp_search_query({"artist": ["ABBA", "ACDC"]})
assert query == 'artist:"ABBA" artist:"ACDC"'
def test_track_number_is_not_supported(self):
# We don't know how to filter by track number in Spotify
query = translator.sp_search_query({'track_number': ['10']})
assert query == ''
def test_date_is_transformed_to_just_the_year(self):
query = translator.sp_search_query({"date": ["1970-02-01"]})
assert query == "year:1970"
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_date_maps_to_year(self):
query = translator.sp_search_query({'date': ['1970']})
assert query == 'year:1970'
