def play(self, device_id=values.UNSET, context_uri=values.UNSET, uris=values.UNSET, offset=values.UNSET):
params = values.of({
'device_id': device_id
})
data = values.of({
'context_uri': context_uri,
'uris': uris,
'offset': offset
})
response = self.version.request('PUT', '/me/player/play', params=params, data=data)
return response.status_code == 204
def list(self, limit=values.UNSET, offset=values.UNSET):
params = values.of({'limit': limit, 'offset': offset})
response = self.version.request('GET',
'/users/{}/playlists'.format(
self.user_id),
params=params)
return PlaylistPage(self.version, response.json(), 'items')
def repeat(self, state, device_id=values.UNSET):
params = values.of({
'state': state,
'device_id': device_id
})
response = self.version.request('PUT', '/me/player/repeat', params=params)
return response.status_code == 204
def transfer(self, device_ids, play=values.UNSET):
data = values.of({
'device_ids': device_ids,
'play': play
})
response = self.version.request('PUT', '/me/player', data=data)
return response.status_code == 204
def add(self, uris=values.UNSET, position=values.UNSET):
data = values.of({'uris': uris, 'position': position})
response = self.version.request('POST',
'/users/{}/playlists/{}/tracks'.format(
self.user_id, self.playlist_id),
data=data)
return Snapshot.from_json(response.json())
def volume(self, volume_percent, device_id=values.UNSET):
params = values.of({
'volume_percent': volume_percent,
'device_id': device_id
})
response = self.version.request('PUT', '/me/player/volume', params=params)
return response.status_code == 204
def contains(self, type, ids):
params = values.of({
'type': type,
'ids': ids
})
response = self.version.request('GET', '/me/following/contains', params=params)
return response.json()
def replace(self, uris=values.UNSET):
data = values.of({'uris': uris})
response = self.version.request('PUT',
'/users/{}/playlists/{}/tracks'.format(
self.user_id, self.playlist_id),
data=data)
return response.status_code == 201
def seek(self, position_ms, device_id=values.UNSET):
params = values.of({
'position_ms': position_ms,
'device_id': device_id
})
response = self.version.request('PUT', '/me/player/previous', params=params)
return response.status_code == 204
def follow(self, public=values.UNSET):
data = values.of({'public': public})
response = self.version.request(
'PUT',
'/users/{}/playlists/{}/followers'.format(self.user_id, self.id),
data=data)
return response.status_code == 200
def fetch(self, fields=values.UNSET, market=values.UNSET):
params = values.of({'fields': fields, 'market': market})
response = self.version.request('GET',
'/users/{}/playlists/{}'.format(
self.user_id, self.id),
params=params)
return PlaylistInstance(self.version, response.json())
def list(self, limit=values.UNSET, offset=values.UNSET, market=values.UNSET):
params = values.of({
'limit': limit,
'offset': offset,
'market': market
})
response = self.version.request('GET', '/me/tracks', params=params)
return TrackPage(self.version, response.json(), 'items')
def list(self, type, limit=values.UNSET, after=values.UNSET):
params = values.of({
'type': type,
'limit': limit,
'after': after
})
response = self.version.request('GET', '/me/following', params=params)
return FollowingPage(self.version, response.json(), 'items')
def list(self, country=values.UNSET, limit=values.UNSET, offset=values.UNSET):
params = values.of({
'country': country,
'limit': limit,
'offset': offset
})
response = self.version.request('GET', '/browse/categories/{}/playlists'.format(self.category_id), params=params)
return PlaylistPage(self.version, response.json()['playlists'], 'items')
def list(self, country=values.UNSET, locale=values.UNSET, limit=values.UNSET, offset=values.UNSET):
params = values.of({
'country': country,
'locale': locale,
'limit': limit,
'offset': offset
})
response = self.version.request('GET', '/browse/categories', params=params)
return CategoryPage(self.version, response.json()['categories'], 'items')
def list(self,
limit=values.UNSET,
after=values.UNSET,
before=values.UNSET):
params = values.of({'limit': limit, 'after': after, 'before': before})
response = self.version.request('GET',
'/me/player/recently-played',
params=params)
return RecentlyPlayedPage(self.version, response.json(), 'items')
def fetch(self, market=values.UNSET):
"""
Fetch the album metadata
:param str market: Market locale
:return: Fetched album instance
:rtype: AlbumInstance
"""
params = values.of({
'market': market
})
response = self.version.request('GET', '/albums/{}'.format(self.id), params=params)
return AlbumInstance(self.version, response.json())
def list(self,
limit=values.UNSET,
offset=values.UNSET,
time_range=values.UNSET):
params = values.of({
'limit': limit,
'offset': offset,
'time_range': time_range
})
response = self.version.request('GET',
'/me/top/artists',
params=params)
return ArtistPage(self.version, response.json(), 'items')
def list(self,
country=values.UNSET,
limit=values.UNSET,
offset=values.UNSET):
params = values.of({
'country': country,
'limit': limit,
'offset': offset
})
response = self.version.request('GET',
'/browse/new-releases',
params=params)
return NewReleasePage(self.version, response.json()['albums'], 'items')
def remove(self,
tracks=values.UNSET,
positions=values.UNSET,
snapshot_id=values.UNSET):
data = values.of({
'tracks': tracks,
'positions': positions,
'snapshot_id': snapshot_id
})
response = self.version.request('DELETE',
'/users/{}/playlists/{}/tracks'.format(
self.user_id, self.playlist_id),
data=data)
return Snapshot.from_json(response.json())
def list(self, ids, market=values.UNSET):
"""
List albums
:param List[str] ids: List of albums ids
:param str market: Market locale
:return: Page of Albums
:rtype: AlbumPage
"""
params = values.of({
'ids': ','.join(ids),
'market': market
})
response = self.version.request('GET', '/albums', params=params)
return AlbumPage(self.version, response.json(), 'albums')
def get(self,
q,
types,
market=values.UNSET,
limit=values.UNSET,
offset=values.UNSET):
params = values.of({
'q': q,
'type': ','.join(types),
'market': market,
'limit': limit,
'offset': offset
})
response = self.version.request('GET', '/search', params=params)
return SearchInstance(self.version, response.json())
def list(self,
album_type=values.UNSET,
market=values.UNSET,
limit=values.UNSET,
offset=values.UNSET):
params = values.of({
'album_type': album_type,
'market': market,
'limit': limit,
'offset': offset
})
response = self.version.request('GET',
'/artists/{}/albums'.format(
self.artist_id),
params=params)
return AlbumPage(self.version, response.json(), 'items')
def update(self,
name=values.UNSET,
public=values.UNSET,
collaborative=values.UNSET,
description=values.UNSET):
data = values.of({
'name': name,
'public': public,
'collaborative': collaborative,
'description': description
})
response = self.version.request('PUT',
'/users/{}/playlists/{}'.format(
self.user_id, self.id),
data=data)
return response.status_code == 200
def create(self,
name,
public=values.UNSET,
collaborative=values.UNSET,
description=values.UNSET):
data = values.of({
'name': name,
'public': public,
'collaborative': collaborative,
'description': description
})
response = self.version.request('POST',
'/users/{}/playlists'.format(
self.user_id),
data=data)
return PlaylistInstance(self.version, response.json())
def reorder(self,
range_start,
insert_before,
range_length=values.UNSET,
snapshot_id=values.UNSET):
data = values.of({
'range_start': range_start,
'insert_before': insert_before,
'range_length': range_length,
'snapshot_id': snapshot_id
})
response = self.version.request('PUT',
'/users/{}/playlists/{}/tracks'.format(
self.user_id, self.playlist_id),
data=data)
return Snapshot.from_json(response.json())
def list(self,
fields=values.UNSET,
limit=values.UNSET,
offset=values.UNSET,
market=values.UNSET):
params = values.of({
'fields': fields,
'limit': limit,
'offset': offset,
'market': market
})
response = self.version.request('GET',
'/users/{}/playlists/{}/tracks'.format(
self.user_id, self.playlist_id),
params=params)
return PlaylistTrackPage(self.version, response.json(), 'items')
def fetch(self,
locale=values.UNSET,
country=values.UNSET,
timestamp=values.UNSET,
limit=values.UNSET,
offset=values.UNSET):
params = values.of({
'locale': locale,
'country': country,
'timestamp': timestamp,
'limit': limit,
'offset': offset
})
response = self.version.request('GET',
'/browse/featured-playlists',
params=params)
return FeaturedPlaylistInstance(self.version, response.json())
def payload(self, prefix):
payload = values.of({
'acousticness': self.acousticness,
'danceability': self.danceability,
'duration_ms': self.duration_ms,
'energy': self.energy,
'instrumentalness': self.instrumentalness,
'key': self.key,
'liveness': self.liveness,
'loudness': self.loudness,
'mode': self.mode,
'popularity': self.popularity,
'speechiness': self.speechiness,
'tempo': self.tempo,
'time_signature': self.time_signature,
'valence': self.valence
})
payload = {'{}_{}'.format(prefix, k): v for k, v in payload.items()}
return payload
def fetch(self, limit=values.UNSET, market=values.UNSET, seed_artists=None, seed_genres=None, seed_tracks=None,
max_attributes=None, min_attributes=None, target_attributes=None):
params = values.of({
'limit': limit,
'market': market
})
params.update(max_attributes.payload('max'))
params.update(min_attributes.payload('min'))
params.update(target_attributes.payload('target'))
if seed_artists:
params['seed_artists'] = ','.join(seed_artists)
if seed_genres:
params['seed_genres'] = ','.join(seed_genres)
if seed_tracks:
params['seed_tracks'] = ','.join(seed_tracks)
response = self.version.request('GET', '/recommendations', params=params)
return RecommendationInstance(self.version, response.json())
