This page describes the parts of the backend that are currently in use.

The backend gets a call from the frontend using a Spotify Artist URI or Spotify Album Uri:

# Artist call
get_artist_results('6olE6TJLqED3rqDCT0FyPh')

# Album call
get_album_content('spotify:album:6yaiubHHJy8N8QcHy3julo') # Spotify album
get_album_content('f1afec0b-26dd-3db5-9aa1-c91229a74a24') # Musicbrainz album

The following is returned for the specified parameters

Artist call

When a call for artist data is made from the frontend the following happens:

  1. The Spotify artist URI is passed down on the get_artist_results function in data_merger.py Here the following steps are taken:
  2. data is retrieved from Spotify for specified artist
    1. Spotify API calls are done using the spotify_api function in spotify.py
    2. for each album retrieved the following items are added as dictionary items to the list album_list:
      1. name
      2. release_date
      3. amount_songs
      4. spotify uri
      5. spotify url
      6. image (url)
    3. for the artist the following items are added to the dictionary artist_dict:
      1. name
      2. genres
      3. popularity
      4. image
      5. albums (retrieved from previously made list album_list)
    4. artist_dict is passed on
  3. data is retrieved from Musicbrainz for specified artist
    1. Musicbrainz API calls are done using the musicbrainz_api function in musicbrainz.py based on the Spotify artist URI
    2. At first, the Spotify artist URI is converted into the corresponding Musicbrainz artist URI (also called MBID). This is done using the get_artist_mbid function in spotify2mb.py
      1. get_artist_mbid searches for a specified Spotify artist URI using the Musicbrainz API. It returns the corresponding artist MBID or an error if none or multiple are found
    3. for each album retrieved the following items are added as dictionary items to the list album_list:
      1. name
      2. release_date
      3. musicbrainz uri
      4. image and amount_songs are set to None as Musicbrainz does not return this kind of data
    4. album_list is passed on
  4. duplicate album entries are removed from Spotify data. Data is considered duplicate when the name and release date match
  5. next an identifier list is made based on the cleaned Spotify album entries. For each entry the name and release date are added to the list as dictionary items
  6. this identifier list is checked against the Musicbrainz album entries. If an album is already in the Spotify data, only the Musicbrainz album Identier is added to the relevant Spotify album entry. If the Musicbrainz album is not in the Spotify entries, the album is added to the list musicbrainz_unique_albums_list.
  7. now the cleaned entries from Spotify and unique entries from Musicbrainz are combined
  8. next the combined data is sorted based on release date
  9. after this the albums list (= the combined data) replaces the original artist album list retrieved from Spotify. The result is saved in artist_dict
  10. a weight function is added for each album that tells something about the completeness of the data:
    1. the amount of songs is multiplied by 0,01. This makes it so that similar album releases with more songs get greater focus. For example a Deluxe version is generally set higher than the non Deluxe version because of the amount of songs.
    2. If a Spotify URI exists 1 is added
    3. If a Musicbrainz URI (also called MBID) exists 1 is added
    4. If an image link exists 2 is added
    5. If the release date consists of a year, month and date (yyyy-mm-dd) 1 is added
    6. If the release date only consists of a year (yyyy) 0,5 is added
    7. The total sum is added to the relevant album entry as relevance_score
  11. Last but not least, the release date entry of the albums is converted to unix time where if only a year is known the album release date is set to in the middle of that year