Create a gist now

Instantly share code, notes, and snippets.

A wrapper to tag spotify album covers from a given artist using the Clarifai Deep-learning API.
from clarifai.client import ClarifaiApi
import spotipy
class SpotiTags(ClarifaiApi):
A wrapper to tag spotify album covers from a given artist
using the Clarifai Deep-learning API.
Requires to set-up the Clarifai API first.
sp = SpotiTags()
print sp.tag('3jOstUTkEu2JkjvRdBA5Gu')
# A blacklist of terms that are (generally) not relevant to artists,
# but generic to the "album cover" artistic concept
'graphic design',
def __init__(self):
super(SpotiTags, self).__init__()
self._spotipy = spotipy.Spotify()
def _cleanup(self):
self._image_tags = {}
self._tags = {}
def _get_covers(self, artist, limit=10):
Get artist images from the Spotify API.
Removes duplicate and epty results.
- query: the query string (e.g. 'motorhead')
- limit: the number of images (optional)
- list: a list of distinct image URLs
albums = self._spotipy.artist_albums(artist).get('items')
covers = [self._get_largest_image(album['images']) for album in albums]
covers = list(set(filter(None, covers)))
return limit < len(covers) and covers[:limit] or covers
def _get_largest_image(self, images):
Returns the largest Spotify images among the images list.
- images: a list of images (as Spotify API dicts)
- image: A single image, None if no images available
sorted_images = sorted(images, key=lambda x: x.get('height'), reverse=True)
return sorted_images and sorted_images[0].get('url') or None
def _tag(self, images):
Tag images via the Clarifai API.
Group results as a dict using the image URL as a key, and a dict of
class => value as the dict value, e.g.
"" : {
"bar": 0.65
- images: a list of images URLs to tag
- tags: a dictionary of images URLs and tags (as desribed above)
tags = {}
for result in self.tag_image_urls(images)['results']:
classes = result['result']['tag']['classes']
prob = result['result']['tag']['probs']
tags[result['url']] = dict([class_, prob[i]] for (i, class_) in enumerate(classes))
return tags
def tag(self, artist):
Run the whole tagging process.
Aggregates the value of each tag, and return sorted results (most popular first).
Uses a blacklist of not relevant terms.
- query: the query string, i.e. artist name (e.g. 'motorhead')
- tags: a list of (tag, value) items, ordered by most popular tags first
covers = self._get_covers(artist)
for cover, tags in self._tag(covers).items():
for tag, value in tags.items():
if tag in self.BLACKLIST:
self._tags.setdefault(tag, 0)
self._tags[tag] += value
return sorted(self._tags.items(), key=lambda x: x[1], reverse=True)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment