def top_songs_ids(self, sp: spotipy.Spotify) -> List[str]:
"""
Return the most played songs of the artist.
:param sp: Spotify session object.
:return: Spotify ids of the most played songs of the artist.
"""
return [t["id"] for t in sp.artist_top_tracks(self.id)["tracks"]]
def get_artists_top_tracks(sp: spotipy.Spotify,
artists_uri: list,
amount: int = 50) -> list:
# compiles list of top tracks made by artists in artists_uri of length amount
print('...getting top tracks for each artist')
tracks = []
for artist in artists_uri:
all_top_tracks_data = sp.artist_top_tracks(artist)
top_tracks_data = all_top_tracks_data['tracks']
for track_data in top_tracks_data:
tracks.append(
dict(id=track_data['id'],
artist=track_data['artists'][0]['name'],
name=track_data['name']))
return tracks
def get_top_tracks(artist_id: str, sp: Spotify):
"""
Get an artist's top tracks.
:param artist_id: id of artist
:param sp: Spotify object to be used with the API query
:return: a dictionary with the top tracks.
"""
try:
top_tracks = sp.artist_top_tracks(artist_id)
except SpotifyException as e:
print(e)
return None
if len(top_tracks['tracks']) == 0:
# Handle the case of no top tracks.
print(top_tracks)
print("No top tracks found")
return None
return top_tracks
def generate_track_ids_spotify(artist: dict, sp: Spotify):
"""
Generates a list of recommended songs through the Spotify related artists API query.
@param artist: An artist object received from the Spotify API.
@param sp: Spotify object authenticated by a user to be used with the API queries.
@return: A list of track ids
"""
track_ids = []
artist_id = artist['uri']
similar_artists = sp.artist_related_artists(artist_id)
for artist in similar_artists['artists']:
top_tracks = sp.artist_top_tracks(artist['uri'])
if len(top_tracks['tracks']) == 0:
# Handle the case of no top tracks.
print(top_tracks)
print("No top tracks found")
continue
track = top_tracks['tracks'][0]['uri']
track_ids.append(track)
return track_ids
class TestSpotipy(unittest.TestCase):
"""
These tests require user authentication - provide client credentials using the
following environment variables
::
'SPOTIPY_CLIENT_USERNAME'
'SPOTIPY_CLIENT_ID'
'SPOTIPY_CLIENT_SECRET'
'SPOTIPY_REDIRECT_URI'
"""
creep_urn = 'spotify:track:3HfB5hBU0dmBt8T0iCmH42'
creep_id = '3HfB5hBU0dmBt8T0iCmH42'
creep_url = 'http://open.spotify.com/track/3HfB5hBU0dmBt8T0iCmH42'
el_scorcho_urn = 'spotify:track:0Svkvt5I79wficMFgaqEQJ'
el_scorcho_bad_urn = 'spotify:track:0Svkvt5I79wficMFgaqEQK'
pinkerton_urn = 'spotify:album:04xe676vyiTeYNXw15o9jT'
weezer_urn = 'spotify:artist:3jOstUTkEu2JkjvRdBA5Gu'
pablo_honey_urn = 'spotify:album:6AZv3m27uyRxi8KyJSfUxL'
radiohead_urn = 'spotify:artist:4Z8W4fKeB5YxbusRsdQVPb'
angeles_haydn_urn = 'spotify:album:1vAbqAeuJVWNAe7UR00bdM'
bad_id = 'BAD_ID'
@classmethod
def setUpClass(self):
missing = list(filter(lambda var: not os.getenv(CCEV[var]), CCEV))
if missing:
raise Exception(
'Please set the client credentials for the test application using the following environment variables: {}'
.format(CCEV.values()))
self.username = os.getenv(CCEV['client_username'])
self.scope = 'user-library-read'
self.token = prompt_for_user_token(self.username, scope=self.scope)
self.spotify = Spotify(auth=self.token)
def test_artist_urn(self):
artist = self.spotify.artist(self.radiohead_urn)
self.assertTrue(artist['name'] == 'Radiohead')
def test_artists(self):
results = self.spotify.artists([self.weezer_urn, self.radiohead_urn])
self.assertTrue('artists' in results)
self.assertTrue(len(results['artists']) == 2)
def test_album_urn(self):
album = self.spotify.album(self.pinkerton_urn)
self.assertTrue(album['name'] == 'Pinkerton')
def test_album_tracks(self):
results = self.spotify.album_tracks(self.pinkerton_urn)
self.assertTrue(len(results['items']) == 10)
def test_album_tracks_many(self):
results = self.spotify.album_tracks(self.angeles_haydn_urn)
tracks = results['items']
total, received = results['total'], len(tracks)
while received < total:
results = self.spotify.album_tracks(self.angeles_haydn_urn,
offset=received)
tracks.extend(results['items'])
received = len(tracks)
self.assertEqual(received, total)
def test_albums(self):
results = self.spotify.albums(
[self.pinkerton_urn, self.pablo_honey_urn])
self.assertTrue('albums' in results)
self.assertTrue(len(results['albums']) == 2)
def test_track_urn(self):
track = self.spotify.track(self.creep_urn)
self.assertTrue(track['name'] == 'Creep')
def test_track_id(self):
track = self.spotify.track(self.creep_id)
self.assertTrue(track['name'] == 'Creep')
def test_track_url(self):
track = self.spotify.track(self.creep_url)
self.assertTrue(track['name'] == 'Creep')
def test_track_bad_urn(self):
try:
track = self.spotify.track(self.el_scorcho_bad_urn)
self.assertTrue(False)
except SpotifyException:
self.assertTrue(True)
def test_tracks(self):
results = self.spotify.tracks([self.creep_url, self.el_scorcho_urn])
self.assertTrue('tracks' in results)
self.assertTrue(len(results['tracks']) == 2)
def test_artist_top_tracks(self):
results = self.spotify.artist_top_tracks(self.weezer_urn)
self.assertTrue('tracks' in results)
self.assertTrue(len(results['tracks']) == 10)
def test_artist_related_artists(self):
results = self.spotify.artist_related_artists(self.weezer_urn)
self.assertTrue('artists' in results)
self.assertTrue(len(results['artists']) == 20)
for artist in results['artists']:
if artist['name'] == 'Jimmy Eat World':
found = True
self.assertTrue(found)
def test_artist_search(self):
results = self.spotify.search(q='weezer', type='artist')
self.assertTrue('artists' in results)
self.assertTrue(len(results['artists']['items']) > 0)
self.assertTrue(results['artists']['items'][0]['name'] == 'Weezer')
def test_artist_search_with_market(self):
results = self.spotify.search(q='weezer', type='artist', market='GB')
self.assertTrue('artists' in results)
self.assertTrue(len(results['artists']['items']) > 0)
self.assertTrue(results['artists']['items'][0]['name'] == 'Weezer')
def test_artist_albums(self):
results = self.spotify.artist_albums(self.weezer_urn)
self.assertTrue('items' in results)
self.assertTrue(len(results['items']) > 0)
found = False
for album in results['items']:
if album['name'] == 'Hurley':
found = True
self.assertTrue(found)
def test_search_timeout(self):
sp = Spotify(auth=self.token, requests_timeout=.01)
try:
results = sp.search(q='my*', type='track')
self.assertTrue(False, 'unexpected search timeout')
except requests.Timeout:
self.assertTrue(True, 'expected search timeout')
def test_album_search(self):
results = self.spotify.search(q='weezer pinkerton', type='album')
self.assertTrue('albums' in results)
self.assertTrue(len(results['albums']['items']) > 0)
self.assertTrue(
results['albums']['items'][0]['name'].find('Pinkerton') >= 0)
def test_track_search(self):
results = self.spotify.search(q='el scorcho weezer', type='track')
self.assertTrue('tracks' in results)
self.assertTrue(len(results['tracks']['items']) > 0)
self.assertTrue(results['tracks']['items'][0]['name'] == 'El Scorcho')
def test_user(self):
user = self.spotify.user(user='******')
self.assertTrue(user['uri'] == 'spotify:user:plamere')
def test_track_bad_id(self):
try:
track = self.spotify.track(self.bad_id)
self.assertTrue(False)
except SpotifyException:
self.assertTrue(True)
def test_track_bad_id(self):
try:
track = self.spotify.track(self.bad_id)
self.assertTrue(False)
except SpotifyException:
self.assertTrue(True)
def test_unauthenticated_post_fails(self):
with self.assertRaises(SpotifyException) as cm:
self.spotify.user_playlist_create("spotify",
"Best hits of the 90s")
self.assertTrue(cm.exception.http_status == 401
or cm.exception.http_status == 403)
def test_custom_requests_session(self):
sess = requests.Session()
sess.headers["user-agent"] = "spotipy-test"
with_custom_session = Spotify(auth=self.token, requests_session=sess)
self.assertTrue(
with_custom_session.user(user="******")["uri"] == "spotify:user:akx")
def test_force_no_requests_session(self):
with_no_session = Spotify(auth=self.token, requests_session=False)
self.assertFalse(isinstance(with_no_session._session,
requests.Session))
self.assertTrue(
with_no_session.user(user="******")["uri"] == "spotify:user:akx")
class AuthTestSpotipy(unittest.TestCase):
"""
These tests require client authentication - provide client credentials
using the following environment variables
::
'SPOTIPY_CLIENT_ID'
'SPOTIPY_CLIENT_SECRET'
"""
playlist = "spotify:user:plamere:playlist:2oCEWyyAPbZp9xhVSxZavx"
four_tracks = [
"spotify:track:6RtPijgfPKROxEzTHNRiDp",
"spotify:track:7IHOIqZUUInxjVkko181PB", "4VrWlk8IQxevMvERoX08iC",
"http://open.spotify.com/track/3cySlItpiPiIAzU3NyHCJf"
]
two_tracks = [
"spotify:track:6RtPijgfPKROxEzTHNRiDp",
"spotify:track:7IHOIqZUUInxjVkko181PB"
]
other_tracks = [
"spotify:track:2wySlB6vMzCbQrRnNGOYKa",
"spotify:track:29xKs5BAHlmlX1u4gzQAbJ",
"spotify:track:1PB7gRWcvefzu7t3LJLUlf"
]
bad_id = 'BAD_ID'
creep_urn = 'spotify:track:6b2oQwSGFkzsMtQruIWm2p'
creep_id = '6b2oQwSGFkzsMtQruIWm2p'
creep_url = 'http://open.spotify.com/track/6b2oQwSGFkzsMtQruIWm2p'
el_scorcho_urn = 'spotify:track:0Svkvt5I79wficMFgaqEQJ'
el_scorcho_bad_urn = 'spotify:track:0Svkvt5I79wficMFgaqEQK'
pinkerton_urn = 'spotify:album:04xe676vyiTeYNXw15o9jT'
weezer_urn = 'spotify:artist:3jOstUTkEu2JkjvRdBA5Gu'
pablo_honey_urn = 'spotify:album:6AZv3m27uyRxi8KyJSfUxL'
radiohead_urn = 'spotify:artist:4Z8W4fKeB5YxbusRsdQVPb'
angeles_haydn_urn = 'spotify:album:1vAbqAeuJVWNAe7UR00bdM'
heavyweight_urn = 'spotify:show:5c26B28vZMN8PG0Nppmn5G'
heavyweight_id = '5c26B28vZMN8PG0Nppmn5G'
heavyweight_url = 'https://open.spotify.com/show/5c26B28vZMN8PG0Nppmn5G'
reply_all_urn = 'spotify:show:7gozmLqbcbr6PScMjc0Zl4'
heavyweight_ep1_urn = 'spotify:episode:68kq3bNz6hEuq8NtdfwERG'
heavyweight_ep1_id = '68kq3bNz6hEuq8NtdfwERG'
heavyweight_ep1_url = 'https://open.spotify.com/episode/68kq3bNz6hEuq8NtdfwERG'
reply_all_ep1_urn = 'spotify:episode:1KHjbpnmNpFmNTczQmTZlR'
@classmethod
def setUpClass(self):
self.spotify = Spotify(
client_credentials_manager=SpotifyClientCredentials())
self.spotify.trace = False
def test_audio_analysis(self):
result = self.spotify.audio_analysis(self.four_tracks[0])
assert ('beats' in result)
def test_audio_features(self):
results = self.spotify.audio_features(self.four_tracks)
self.assertTrue(len(results) == len(self.four_tracks))
for track in results:
assert ('speechiness' in track)
def test_audio_features_with_bad_track(self):
bad_tracks = ['spotify:track:bad']
input = self.four_tracks + bad_tracks
results = self.spotify.audio_features(input)
self.assertTrue(len(results) == len(input))
for track in results[:-1]:
if track is not None:
assert ('speechiness' in track)
self.assertTrue(results[-1] is None)
def test_recommendations(self):
results = self.spotify.recommendations(seed_tracks=self.four_tracks,
min_danceability=0,
max_loudness=0,
target_popularity=50)
self.assertTrue(len(results['tracks']) == 20)
def test_artist_urn(self):
artist = self.spotify.artist(self.radiohead_urn)
self.assertTrue(artist['name'] == 'Radiohead')
def test_artists(self):
results = self.spotify.artists([self.weezer_urn, self.radiohead_urn])
self.assertTrue('artists' in results)
self.assertTrue(len(results['artists']) == 2)
def test_album_urn(self):
album = self.spotify.album(self.pinkerton_urn)
self.assertTrue(album['name'] == 'Pinkerton')
def test_album_tracks(self):
results = self.spotify.album_tracks(self.pinkerton_urn)
self.assertTrue(len(results['items']) == 10)
def test_album_tracks_many(self):
results = self.spotify.album_tracks(self.angeles_haydn_urn)
tracks = results['items']
total, received = results['total'], len(tracks)
while received < total:
results = self.spotify.album_tracks(self.angeles_haydn_urn,
offset=received)
tracks.extend(results['items'])
received = len(tracks)
self.assertEqual(received, total)
def test_albums(self):
results = self.spotify.albums(
[self.pinkerton_urn, self.pablo_honey_urn])
self.assertTrue('albums' in results)
self.assertTrue(len(results['albums']) == 2)
def test_track_urn(self):
track = self.spotify.track(self.creep_urn)
self.assertTrue(track['name'] == 'Creep')
def test_track_id(self):
track = self.spotify.track(self.creep_id)
self.assertTrue(track['name'] == 'Creep')
self.assertTrue(track['popularity'] > 0)
def test_track_url(self):
track = self.spotify.track(self.creep_url)
self.assertTrue(track['name'] == 'Creep')
def test_track_bad_urn(self):
try:
self.spotify.track(self.el_scorcho_bad_urn)
self.assertTrue(False)
except SpotifyException:
self.assertTrue(True)
def test_tracks(self):
results = self.spotify.tracks([self.creep_url, self.el_scorcho_urn])
self.assertTrue('tracks' in results)
self.assertTrue(len(results['tracks']) == 2)
def test_artist_top_tracks(self):
results = self.spotify.artist_top_tracks(self.weezer_urn)
self.assertTrue('tracks' in results)
self.assertTrue(len(results['tracks']) == 10)
def test_artist_related_artists(self):
results = self.spotify.artist_related_artists(self.weezer_urn)
self.assertTrue('artists' in results)
self.assertTrue(len(results['artists']) == 20)
for artist in results['artists']:
if artist['name'] == 'Jimmy Eat World':
found = True
self.assertTrue(found)
def test_artist_search(self):
results = self.spotify.search(q='weezer', type='artist')
self.assertTrue('artists' in results)
self.assertTrue(len(results['artists']['items']) > 0)
self.assertTrue(results['artists']['items'][0]['name'] == 'Weezer')
def test_artist_search_with_market(self):
results = self.spotify.search(q='weezer', type='artist', market='GB')
self.assertTrue('artists' in results)
self.assertTrue(len(results['artists']['items']) > 0)
self.assertTrue(results['artists']['items'][0]['name'] == 'Weezer')
def test_artist_search_with_multiple_markets(self):
total = 5
countries_list = ['GB', 'US', 'AU']
countries_tuple = ('GB', 'US', 'AU')
results_multiple = self.spotify.search_markets(q='weezer',
type='artist',
markets=countries_list)
results_all = self.spotify.search_markets(q='weezer', type='artist')
results_tuple = self.spotify.search_markets(q='weezer',
type='artist',
markets=countries_tuple)
results_limited = self.spotify.search_markets(q='weezer',
limit=3,
type='artist',
markets=countries_list,
total=total)
self.assertTrue(
all('artists' in results_multiple[country]
for country in results_multiple))
self.assertTrue(
all('artists' in results_all[country] for country in results_all))
self.assertTrue(
all('artists' in results_tuple[country]
for country in results_tuple))
self.assertTrue(
all('artists' in results_limited[country]
for country in results_limited))
self.assertTrue(
all(
len(results_multiple[country]['artists']['items']) > 0
for country in results_multiple))
self.assertTrue(
all(
len(results_all[country]['artists']['items']) > 0
for country in results_all))
self.assertTrue(
all(
len(results_tuple[country]['artists']['items']) > 0
for country in results_tuple))
self.assertTrue(
all(
len(results_limited[country]['artists']['items']) > 0
for country in results_limited))
self.assertTrue(
all(results_multiple[country]['artists']['items'][0]['name'] ==
'Weezer' for country in results_multiple))
self.assertTrue(
all(results_all[country]['artists']['items'][0]['name'] == 'Weezer'
for country in results_all))
self.assertTrue(
all(results_tuple[country]['artists']['items'][0]['name'] ==
'Weezer' for country in results_tuple))
self.assertTrue(
all(results_limited[country]['artists']['items'][0]['name'] ==
'Weezer' for country in results_limited))
total_limited_results = 0
for country in results_limited:
total_limited_results += len(
results_limited[country]['artists']['items'])
self.assertTrue(total_limited_results <= total)
def test_artist_albums(self):
results = self.spotify.artist_albums(self.weezer_urn)
self.assertTrue('items' in results)
self.assertTrue(len(results['items']) > 0)
found = False
for album in results['items']:
if album['name'] == 'Hurley':
found = True
self.assertTrue(found)
def test_search_timeout(self):
client_credentials_manager = SpotifyClientCredentials()
sp = spotipy.Spotify(
requests_timeout=0.01,
client_credentials_manager=client_credentials_manager)
# depending on the timing or bandwidth, this raises a timeout or connection error"
self.assertRaises(
(requests.exceptions.Timeout, requests.exceptions.ConnectionError),
lambda: sp.search(q='my*', type='track'))
def test_album_search(self):
results = self.spotify.search(q='weezer pinkerton', type='album')
self.assertTrue('albums' in results)
self.assertTrue(len(results['albums']['items']) > 0)
self.assertTrue(
results['albums']['items'][0]['name'].find('Pinkerton') >= 0)
def test_track_search(self):
results = self.spotify.search(q='el scorcho weezer', type='track')
self.assertTrue('tracks' in results)
self.assertTrue(len(results['tracks']['items']) > 0)
self.assertTrue(results['tracks']['items'][0]['name'] == 'El Scorcho')
def test_user(self):
user = self.spotify.user(user='******')
self.assertTrue(user['uri'] == 'spotify:user:plamere')
def test_track_bad_id(self):
try:
self.spotify.track(self.bad_id)
self.assertTrue(False)
except SpotifyException:
self.assertTrue(True)
def test_show_urn(self):
show = self.spotify.show(self.heavyweight_urn, market="US")
self.assertTrue(show['name'] == 'Heavyweight')
def test_show_id(self):
show = self.spotify.show(self.heavyweight_id, market="US")
self.assertTrue(show['name'] == 'Heavyweight')
def test_show_url(self):
show = self.spotify.show(self.heavyweight_url, market="US")
self.assertTrue(show['name'] == 'Heavyweight')
def test_show_bad_urn(self):
with self.assertRaises(SpotifyException):
self.spotify.show("bogus_urn", market="US")
def test_shows(self):
results = self.spotify.shows(
[self.heavyweight_urn, self.reply_all_urn], market="US")
self.assertTrue('shows' in results)
self.assertTrue(len(results['shows']) == 2)
def test_show_episodes(self):
results = self.spotify.show_episodes(self.heavyweight_urn, market="US")
self.assertTrue(len(results['items']) > 1)
def test_show_episodes_many(self):
results = self.spotify.show_episodes(self.reply_all_urn, market="US")
episodes = results['items']
total, received = results['total'], len(episodes)
while received < total:
results = self.spotify.show_episodes(self.reply_all_urn,
offset=received,
market="US")
episodes.extend(results['items'])
received = len(episodes)
self.assertEqual(received, total)
def test_episode_urn(self):
episode = self.spotify.episode(self.heavyweight_ep1_urn, market="US")
self.assertTrue(episode['name'] == '#1 Buzz')
def test_episode_id(self):
episode = self.spotify.episode(self.heavyweight_ep1_id, market="US")
self.assertTrue(episode['name'] == '#1 Buzz')
def test_episode_url(self):
episode = self.spotify.episode(self.heavyweight_ep1_url, market="US")
self.assertTrue(episode['name'] == '#1 Buzz')
def test_episode_bad_urn(self):
with self.assertRaises(SpotifyException):
self.spotify.episode("bogus_urn", market="US")
def test_episodes(self):
results = self.spotify.episodes(
[self.heavyweight_ep1_urn, self.reply_all_ep1_urn], market="US")
self.assertTrue('episodes' in results)
self.assertTrue(len(results['episodes']) == 2)
def test_unauthenticated_post_fails(self):
with self.assertRaises(SpotifyException) as cm:
self.spotify.user_playlist_create("spotify",
"Best hits of the 90s")
self.assertTrue(cm.exception.http_status == 401
or cm.exception.http_status == 403)
def test_custom_requests_session(self):
sess = requests.Session()
sess.headers["user-agent"] = "spotipy-test"
with_custom_session = spotipy.Spotify(
client_credentials_manager=SpotifyClientCredentials(),
requests_session=sess)
self.assertTrue(
with_custom_session.user(user="******")["uri"] == "spotify:user:akx")
sess.close()
def test_force_no_requests_session(self):
with_no_session = spotipy.Spotify(
client_credentials_manager=SpotifyClientCredentials(),
requests_session=False)
self.assertNotIsInstance(with_no_session._session, requests.Session)
user = with_no_session.user(user="******")
self.assertEqual(user["uri"], "spotify:user:akx")
class SpotifyGateway:
"""Class implementing a gateway to the spotify web api.
Available functions:
- fetch_playlist: Fetch a Playlist namedtuple given a playlist_uri.
- fetch_related_tracks: Fetch a track's related tracks by artist or album.
- fetch_related_tracks_by_track: Concurrently fetch a mapping of tracks to their related tracks.
- create_playlist: Create a playlist for a user[]
"""
@raise_spotipy_error_as_souffle_error
def __init__(self, access_token: str):
"""C'tor"""
self._access_token = access_token
self._spotify = Spotify(access_token, requests_session=False)
@raise_spotipy_error_as_souffle_error
def fetch_playlist(self, playlist_uri: str):
"""Fetch a Playlist namedtuple representation of a spotify playlist given a playlist_uri."""
playlist_id = playlist_uri.split(':')[-1]
name, description = fetch_playlist_metadata(playlist_id, self._access_token)
track_data = fetch_playlist_track_data(playlist_id, self._access_token)
tracks = [pluck_track(track_record) for track_record in track_data]
return Playlist(
name=name,
tracks=tracks,
description=description
)
@raise_spotipy_error_as_souffle_error
def fetch_related_tracks(self, track, related_by):
"""Fetch a set of Track namedtuples that are related to TRACK by RELATED_BY."""
if related_by == 'artist':
related_track_data = self._spotify.artist_top_tracks(track.artist)['tracks']
related_tracks = {pluck_track(track_record, artist=track.artist)
for track_record in related_track_data}
elif related_by == 'album':
related_track_data = self._spotify.album_tracks(track.album)['items']
related_tracks = {pluck_track(track_record, album=track.album)
for track_record in related_track_data}
else:
raise SouffleParameterError('Invalid souffle type "{}".'.format(related_by))
return related_tracks
@raise_spotipy_error_as_souffle_error
def fetch_related_tracks_by_track(self, tracks, related_by):
"""Fetch a related_tracks_by_track mapping, where each related_tracks set is the set of
tracks related to a track in TRACKS by RELATED_BY.
"""
with futures.ThreadPoolExecutor(max_workers=10) as executor:
related_tracks_by_track = dict(executor.map(
lambda track: (track, self.fetch_related_tracks(track, related_by)),
tracks
))
return related_tracks_by_track
@raise_spotipy_error_as_souffle_error
def create_playlist(self, playlist: Playlist, is_public: bool = True) -> str:
"""Create a new playlist for the given Playlist namedtuple. Return the uri of the new
playlist.
"""
user_id = self.fetch_current_user_id()
response = requests.post(
f'{BASE}/users/{user_id}/playlists',
json={
'name': playlist.name,
'description': playlist.description,
'public': is_public
},
headers={'Authorization': f'Bearer {self._access_token}'}
)
response_json = response.json()
playlist_id = response_json['id']
playlist_track_uris = [f'spotify:track:{track.id}' for track in playlist.tracks]
response = requests.post(
f'{BASE}/playlists/{playlist_id}/tracks',
params={
'uris': ','.join(playlist_track_uris)
},
headers={'Authorization': f'Bearer {self._access_token}'}
)
return playlist_id
@raise_spotipy_error_as_souffle_error
def fetch_current_user_id(self):
"""Fetch the current user id based on the access token provided to the SpotifyGateway
constructor.
Note: This should eventually return a plucked User namedtuple.
"""
response = self._spotify.current_user()
return response['id']
class AuthTestSpotipy(unittest.TestCase):
"""
These tests require client authentication - provide client credentials
using the following environment variables
::
'SPOTIPY_CLIENT_ID'
'SPOTIPY_CLIENT_SECRET'
"""
playlist = "spotify:user:plamere:playlist:2oCEWyyAPbZp9xhVSxZavx"
four_tracks = [
"spotify:track:6RtPijgfPKROxEzTHNRiDp",
"spotify:track:7IHOIqZUUInxjVkko181PB", "4VrWlk8IQxevMvERoX08iC",
"http://open.spotify.com/track/3cySlItpiPiIAzU3NyHCJf"
]
two_tracks = [
"spotify:track:6RtPijgfPKROxEzTHNRiDp",
"spotify:track:7IHOIqZUUInxjVkko181PB"
]
other_tracks = [
"spotify:track:2wySlB6vMzCbQrRnNGOYKa",
"spotify:track:29xKs5BAHlmlX1u4gzQAbJ",
"spotify:track:1PB7gRWcvefzu7t3LJLUlf"
]
bad_id = 'BAD_ID'
creep_urn = 'spotify:track:3HfB5hBU0dmBt8T0iCmH42'
creep_id = '3HfB5hBU0dmBt8T0iCmH42'
creep_url = 'http://open.spotify.com/track/3HfB5hBU0dmBt8T0iCmH42'
el_scorcho_urn = 'spotify:track:0Svkvt5I79wficMFgaqEQJ'
el_scorcho_bad_urn = 'spotify:track:0Svkvt5I79wficMFgaqEQK'
pinkerton_urn = 'spotify:album:04xe676vyiTeYNXw15o9jT'
weezer_urn = 'spotify:artist:3jOstUTkEu2JkjvRdBA5Gu'
pablo_honey_urn = 'spotify:album:6AZv3m27uyRxi8KyJSfUxL'
radiohead_urn = 'spotify:artist:4Z8W4fKeB5YxbusRsdQVPb'
angeles_haydn_urn = 'spotify:album:1vAbqAeuJVWNAe7UR00bdM'
@classmethod
def setUpClass(self):
self.spotify = Spotify(
client_credentials_manager=SpotifyClientCredentials())
self.spotify.trace = False
def test_audio_analysis(self):
result = self.spotify.audio_analysis(self.four_tracks[0])
assert ('beats' in result)
def test_audio_features(self):
results = self.spotify.audio_features(self.four_tracks)
self.assertTrue(len(results) == len(self.four_tracks))
for track in results:
assert ('speechiness' in track)
def test_audio_features_with_bad_track(self):
bad_tracks = ['spotify:track:bad']
input = self.four_tracks + bad_tracks
results = self.spotify.audio_features(input)
self.assertTrue(len(results) == len(input))
for track in results[:-1]:
if track is not None:
assert ('speechiness' in track)
self.assertTrue(results[-1] is None)
def test_recommendations(self):
results = self.spotify.recommendations(seed_tracks=self.four_tracks,
min_danceability=0,
max_loudness=0,
target_popularity=50)
self.assertTrue(len(results['tracks']) == 20)
def test_artist_urn(self):
artist = self.spotify.artist(self.radiohead_urn)
self.assertTrue(artist['name'] == 'Radiohead')
def test_artists(self):
results = self.spotify.artists([self.weezer_urn, self.radiohead_urn])
self.assertTrue('artists' in results)
self.assertTrue(len(results['artists']) == 2)
def test_album_urn(self):
album = self.spotify.album(self.pinkerton_urn)
self.assertTrue(album['name'] == 'Pinkerton')
def test_album_tracks(self):
results = self.spotify.album_tracks(self.pinkerton_urn)
self.assertTrue(len(results['items']) == 10)
def test_album_tracks_many(self):
results = self.spotify.album_tracks(self.angeles_haydn_urn)
tracks = results['items']
total, received = results['total'], len(tracks)
while received < total:
results = self.spotify.album_tracks(self.angeles_haydn_urn,
offset=received)
tracks.extend(results['items'])
received = len(tracks)
self.assertEqual(received, total)
def test_albums(self):
results = self.spotify.albums(
[self.pinkerton_urn, self.pablo_honey_urn])
self.assertTrue('albums' in results)
self.assertTrue(len(results['albums']) == 2)
def test_track_urn(self):
track = self.spotify.track(self.creep_urn)
self.assertTrue(track['name'] == 'Creep')
def test_track_id(self):
track = self.spotify.track(self.creep_id)
self.assertTrue(track['name'] == 'Creep')
self.assertTrue(track['popularity'] > 0)
def test_track_url(self):
track = self.spotify.track(self.creep_url)
self.assertTrue(track['name'] == 'Creep')
def test_track_bad_urn(self):
try:
self.spotify.track(self.el_scorcho_bad_urn)
self.assertTrue(False)
except SpotifyException:
self.assertTrue(True)
def test_tracks(self):
results = self.spotify.tracks([self.creep_url, self.el_scorcho_urn])
self.assertTrue('tracks' in results)
self.assertTrue(len(results['tracks']) == 2)
def test_artist_top_tracks(self):
results = self.spotify.artist_top_tracks(self.weezer_urn)
self.assertTrue('tracks' in results)
self.assertTrue(len(results['tracks']) == 10)
def test_artist_related_artists(self):
results = self.spotify.artist_related_artists(self.weezer_urn)
self.assertTrue('artists' in results)
self.assertTrue(len(results['artists']) == 20)
for artist in results['artists']:
if artist['name'] == 'Jimmy Eat World':
found = True
self.assertTrue(found)
def test_artist_search(self):
results = self.spotify.search(q='weezer', type='artist')
self.assertTrue('artists' in results)
self.assertTrue(len(results['artists']['items']) > 0)
self.assertTrue(results['artists']['items'][0]['name'] == 'Weezer')
def test_artist_search_with_market(self):
results = self.spotify.search(q='weezer', type='artist', market='GB')
self.assertTrue('artists' in results)
self.assertTrue(len(results['artists']['items']) > 0)
self.assertTrue(results['artists']['items'][0]['name'] == 'Weezer')
def test_artist_albums(self):
results = self.spotify.artist_albums(self.weezer_urn)
self.assertTrue('items' in results)
self.assertTrue(len(results['items']) > 0)
found = False
for album in results['items']:
if album['name'] == 'Hurley':
found = True
self.assertTrue(found)
def test_search_timeout(self):
client_credentials_manager = SpotifyClientCredentials()
sp = spotipy.Spotify(
client_credentials_manager=client_credentials_manager,
requests_timeout=.01)
try:
sp.search(q='my*', type='track')
self.assertTrue(False, 'unexpected search timeout')
except requests.exceptions.Timeout:
self.assertTrue(True, 'expected search timeout')
def test_album_search(self):
results = self.spotify.search(q='weezer pinkerton', type='album')
self.assertTrue('albums' in results)
self.assertTrue(len(results['albums']['items']) > 0)
self.assertTrue(
results['albums']['items'][0]['name'].find('Pinkerton') >= 0)
def test_track_search(self):
results = self.spotify.search(q='el scorcho weezer', type='track')
self.assertTrue('tracks' in results)
self.assertTrue(len(results['tracks']['items']) > 0)
self.assertTrue(results['tracks']['items'][0]['name'] == 'El Scorcho')
def test_user(self):
user = self.spotify.user(user='******')
self.assertTrue(user['uri'] == 'spotify:user:plamere')
def test_track_bad_id(self):
try:
self.spotify.track(self.bad_id)
self.assertTrue(False)
except SpotifyException:
self.assertTrue(True)
def test_unauthenticated_post_fails(self):
with self.assertRaises(SpotifyException) as cm:
self.spotify.user_playlist_create("spotify",
"Best hits of the 90s")
self.assertTrue(cm.exception.http_status == 401
or cm.exception.http_status == 403)
def test_custom_requests_session(self):
sess = requests.Session()
sess.headers["user-agent"] = "spotipy-test"
with_custom_session = spotipy.Spotify(
client_credentials_manager=SpotifyClientCredentials(),
requests_session=sess)
self.assertTrue(
with_custom_session.user(user="******")["uri"] == "spotify:user:akx")
sess.close()
def test_force_no_requests_session(self):
from requests import Session
with_no_session = spotipy.Spotify(
client_credentials_manager=SpotifyClientCredentials(),
requests_session=False)
self.assertFalse(isinstance(with_no_session._session, Session))
self.assertTrue(
with_no_session.user(user="******")["uri"] == "spotify:user:akx")
