def release_date(self): """ The date the album was **first** released. Returns: A tuple with up to 3 ints. The tuple will be one of the following - (year,) - (year, month) - (year, month, day) Note: If the album was first released in March 2010 in Europe, and then 2 months later (May) was released to the rest of the world, this function will return the March 2010 date. We considered instead returning a Python datetime.date object. However since Spotify may not return a month or day, we cannot use a datetime.date object. Calls endpoints: - GET /v1/albums/{id} """ # Spotify returns date in format Y-M-D date = utils.get_field(self, 'release_date').split('-') # Convert to ints date = [int(elem) for elem in date] return tuple(date)
def uri(self): """ Returns: str: The album's Spotify uri. Calls endpoints: - GET /v1/albums/{id} """ return utils.get_field(self, 'uri')
def explicit(self): """ Returns: bool: True if the track has explicit lyrics, and False otherwise. Calls endpoints: - GET /v1/tracks/{id} """ return utils.get_field(self, 'explicit')
def name(self): """ Returns: str: The name of the album as it appears on Spotify. Calls endpoints: - GET /v1/albums/{id} """ return utils.get_field(self, 'name')
def name(self): """ Returns: str: The user's display name as it appears on Spotify Calls endpoints: - GET /v1/users/{id} """ return utils.get_field(self, 'display_name')
def label(self): """ Returns: str: The name of the label for this album. Calls endpoints: - GET /v1/albums/{id} """ return utils.get_field(self, 'label')
def __len__(self): """ Returns: int: The length of the track in milliseconds Calls endpoints: - GET /v1/tracks/{id} """ return utils.get_field(self, 'duration_ms')
def uri(self): """ Returns: str: the user's Spotify uri. Calls endpoints: - GET /v1/users/{id} """ return utils.get_field(self, 'uri')
def href(self): """ Get the user's href. Returns: str: a link to the Web API endpoint containing the user's profile. Calls endpoints: - GET /v1/users/{id} """ return utils.get_field(self, 'href')
def href(self): """ Get the album's href. Returns: str: A link to the Web API endpoint providing full album details. Calls endpoints: - GET /v1/albums/{id} """ return utils.get_field(self, 'href')
def copyrights(self): """ Returns: List[Copyright]: The copyright statement(s) for this album. Calls endpoints: - GET /v1/albums/{id} """ result = utils.get_field(self, 'copyrights') return [Copyright(elem) for elem in result]
def available_markets(self): """ Returns: List[str]: A list of the :term:`markets <Market>` this track is available in. Calls endpoints: - GET /v1/tracks/{id} """ return utils.get_field(self, 'available_markets')
def images(self): """ Returns: List[Image]: The album's cover art in various sizes, widest first. Calls endpoints: - GET /v1/albums/{id} """ result = utils.get_field(self, 'images') return [Image(elem) for elem in result]
def genres(self): """ Get the genres for this album as categorized by Spotify. Returns: List[str]: A list of genre names. Could be empty if the album is not yet classified. Calls endpoints: - GET /v1/albums/{id} """ return utils.get_field(self, 'genres')
def popularity(self): """ Get the popularity of the track as calculated by Spotify. Returns: int: The popularity is between 0 and 100 (inclusive), with 100 being the most popular. This number is calculated in Spotify's backend. Calls endpoints: - GET /v1/tracks/{id} """ return utils.get_field(self, 'popularity')
def popularity(self): """ Get the popularity of the album as calculated by Spotify. Returns: int: The popularity between 0 and 100 (inclusive), with 100 being the most popular. This number is calculated using the popularity of each track. Calls endpoints: - GET /v1/albums/{id} """ return utils.get_field(self, 'popularity')
def artists(self): """ Returns: List[Artist]: a list of the artist(s) on this track. Calls endpoints: - GET /v1/tracks/{id} """ if self._artists is None: artists = utils.get_field(self, 'artists') self._artists = [Artist(self._session, art) for art in artists] return self._artists
def album(self): """ Returns: Album: The album this track is on: Calls endpoints: - GET /v1/tracks/{id} """ if self._album is None: album = utils.get_field(self, 'album') self._album = Album(self._session, album) return self._album
def available_markets(self): """ Get the country codes of the :term:`markets <Market>` this album is available in. The album is considered available in a market when at least one of its tracks is available in that market. Returns: List[str]: A list of the available country codes. Calls endpoints: - GET /v1/albums/{id} """ return utils.get_field(self, 'available_markets')
def artists(self): """ Returns: List[Artist]: The artist(s) who wrote this album. Calls endpoints: - GET /v1/albums/{id} """ if self._artists is not None: return self._artists artists = utils.get_field(self, 'artists') self._artists = [Artist(self._session, artist) for artist in artists] return self._artists
def image(self): """ Get the User's profile picture. Returns: Union[Image, None]: An image object if the User has a profile picture, else None. Calls endpoints: - GET /v1/users/{id} """ result = utils.get_field(self, 'images') if len(result) > 1: raise utils.SpotifyError('User has more than one profile picture!') return None if len(result) == 0 else Image(result[0])
def disc_number(self): """ Get the track's disc number (0 indexed). Note: On Spotify (and in most music software) disc number is 1-indexed. This method intentionally makes it 0 indexed for consistency with the rest of the library. Returns: int: The number of the disc on which this track appears. This is usually 0, unless an album has multiple discs. Calls endpoints: - GET /v1/tracks/{id} """ result = utils.get_field(self, 'disc_number') return result - 1
def type(self): """ Get the type of this album. Returns: One of - sp.SINGLE - sp.COMPILATION - sp.ALBUMS Calls endpoints: - GET /v1/albums/{id} """ types = { 'single': const.SINGLE, 'compilation': const.COMPILATION, 'album': const.ALBUMS } return types[utils.get_field(self, 'album_type')]
def track_number(self): """ Get the track's number (0 indexed). Note: On Spotify (and in most music software) track number is 1-indexed. This method intentionally makes it 0 indexed for consistency with the rest of the library. This decision was made so that Track.track_number() is consistent with Album.__get_item__(). Ex: for some 0 <= num < len(Album), Album[num].track_number() == num Returns: int: The track's number in the album. If an album has several discs, the track number is the number of this track on the disc it appears. Calls endpoints: - GET /v1/tracks/{id} """ result = utils.get_field(self, 'track_number') return result - 1
def spotify_id(self): """ Returns: str: The Spotify id of this artist. """ return utils.get_field(self, 'id')