def find_playlist(seed_artist_ids, playable=False):
if playable:
logger.info("finding playlist with audio...")
p = playlist.static(type='artist-radio', artist_id=seed_artist_ids, variety=1, buckets=['id:7digital-US', 'tracks'], limit=True)
else:
logger.info("finding playlist without audio...")
p = playlist.static(type='artist-radio', artist_id=seed_artist_ids, variety=1)
return p
def get_lyricfind_ids(artist=None, title=None, genre=None, num_songs=1):
if genre:
res = playlist.static(results=num_songs,type='genre-radio',genres=genre,buckets=['id:lyricfind-US'], limit=True)
elif not title:
res = playlist.static(results=num_songs,type='artist',artist=artist,buckets=['id:lyricfind-US'], limit=True)
else:
res = song.search(sort='song_hotttnesss-desc', buckets=['id:lyricfind-US'], limit=True, artist=artist, title=title, results=num_songs)
lids = [x.get_foreign_id('lyricfind-US').split(":")[-1] for x in res]
print [x for x in lids]
def main(radio_type, paramaterList):
collect = []
if radio_type == "artist-radio":
p = playlist.static(type=radio_type, artist=paramaterList)
elif radio_type == "song-radio":
p = playlist.static(type=radio_type, song_id=paramaterList)
elif radio_type == "genre-radio":
p = playlist.static(type=radio_type, genres=paramaterList)
else:
p = playlist.static(type="artist", artist=paramaterList)
for song in p:
print song.title
def find_playlist(seed_artist_ids, playable=False):
if playable:
logger.info("finding playlist with audio...")
p = playlist.static(type='artist-radio',
artist_id=seed_artist_ids,
variety=1,
buckets=['id:7digital-US', 'tracks'],
limit=True)
else:
logger.info("finding playlist without audio...")
p = playlist.static(type='artist-radio',
artist_id=seed_artist_ids,
variety=1)
return p
def _similar_tracks(self, callback, artist, title, threshold):
timestamp = now()
diff = timestamp - self.get_track_timestamp(artist, title)
if diff < threshold:
self._logger.debug(u"similar_tracks[%s-%s]: looked up %d seconds ago" %
(artist, title, diff))
return
self.set_track_timestamp(artist, title, timestamp)
try:
self._logger.debug(u"similar_tracks[%s-%s]: lookup" % (artist, title))
self._delay()
a = en_song.search(title=title, artist=artist)
try:
p = en_playlist.static(type='song-radio', song_id=a[0].id, results=100)
i = 100.0
self._logger.info(u"similar_tracks[%s-%s]: %d result(s)" % (artist,
title, len(p)))
for song in p:
callback(artist, title, song.artist_name.lower(), song.title.lower(),
i / 100.0, self._title)
i -= 1.0
except IndexError:
self._logger.info(u"similar_tracks[%s-%s]: no result" % (artist, title))
return
except Exception, e:
self._logger.error(e)
self._logger.info(u"similar_tracks[%s-%s]: no result" % (artist, title))
return
def get_suggestions(artists):
asSuggestions = []
#print(artists)
asSeed_artist_ids = lookup_seeds(artists)
if len(asSeed_artist_ids) >5:
asSeed_artist_ids = asSeed_artist_ids[:4]
acPlaylist = playlist.static(type='artist-radio', artist_id=asSeed_artist_ids, variety=1)
dJoined = {}
dJoined['tempo'] = 0
dJoined['loudness'] = 0
dJoined['key'] = 0
dJoined['danceability'] = 0
dJoined['valence'] = 0
dJoined['time_signature'] = 0
dJoined['liveness'] = 0
for cSong in acPlaylist:
print(str(cSong))
sName = cSong.artist_name
sTitle = cSong.title
#{u'time_signature': 4, u'analysis_url': u'http://echonest-analysis.s3.amazonaws.com/TR/OqovGwdNlmWtC8VzwJogN4Opv5rBOGHWijcEaB/3/full.json?AWSAccessKeyId=AKIAJRDFEY23UEVW42BQ&Expires=1379809796&Signature=v6ip9VeZolRYdPLQb6ZCHLjty5Q%3D',
#u'energy': 0.6618792929537817, u'liveness': 0.20491740560245644,
#u'tempo': 101.236, u'speechiness': 0.04450662602495192, u'acousticness': 0.041829643112355895, u'mode': 1, u'key': 6, u'duration': 303.64,
#u'loudness': -8.239, u'audio_md5': u'6aea199d3def4f58dca07819772586cb',
#u'valence': 0.6757293197830115, u'danceability': 0.29761525479382267}
dChars = get_song_characteristics(cSong.id)
for key, val in dChars.items():
if (dJoined.get(key) != None):
dJoined[key] += val
asSuggestions.append(sName + sTitle)
print(dJoined, len(asSuggestions))
return [asSuggestions, dJoined]
def get_songs(g):
time.sleep(60)
print(g, "GENRE")
i = 0
while (i <= 60):
try:
p = playlist.static(genres=g, type="genre-radio", results=15)
for s in p:
print(s, "SONG")
dictionary = s.get_audio_summary()
track = []
track.append(s.artist_name.encode('ascii', 'ignore'))
track.append(dictionary['danceability'])
track.append(dictionary['duration'])
track.append(dictionary['energy'])
track.append(dictionary['key'])
track.append(dictionary['liveness'])
track.append(dictionary['loudness'])
track.append(dictionary['mode'])
track.append(dictionary['speechiness'])
track.append(dictionary['tempo'])
track.append(dictionary['time_signature'])
track.append(g)
songs.append(track)
i += 1
time.sleep(60)
except:
print("Connection lost!, reconnecting...")
time.sleep(60)
pass
def get_songs(g):
time.sleep(60)
print (g,"GENRE")
i = 0
while (i <= 60 ):
try:
p = playlist.static(genres=g,type="genre-radio", results=15)
for s in p:
print (s,"SONG")
dictionary = s.get_audio_summary()
track = []
track.append(s.artist_name.encode('ascii','ignore'))
track.append(dictionary['danceability'])
track.append(dictionary['duration'])
track.append(dictionary['energy'])
track.append(dictionary['key'])
track.append(dictionary['liveness'])
track.append(dictionary['loudness'])
track.append(dictionary['mode'])
track.append(dictionary['speechiness'])
track.append(dictionary['tempo'])
track.append(dictionary['time_signature'])
track.append(g)
songs.append(track)
i +=1
time.sleep(60)
except:
print ("Connection lost!, reconnecting...")
time.sleep(60)
pass
def test_get_tracks_with_audio():
seed_ids = [artist.Artist(a).id for a in ARTISTS]
assert len(seed_ids) == len(ARTISTS)
raw_plist = playlist.static(type='artist-radio', artist_id=seed_ids, variety=1, buckets = ['id:7digital-US', 'tracks'], limit=True)
assert len(raw_plist) >= len(seed_ids)
tuple_plist = [s.get_tracks('7digital-US', [{}])[0].get('preview_url') for s in raw_plist]
assert len(tuple_plist) == len(raw_plist)
def get_catalog_tracks(variety=0.8):
print "getting catalog tracks"
p = playlist.static(type='catalog-radio', seed_catalog=settings.seed_catalog, variety=variety, results=100) # lol
print "done getting catalog tracks"
tracks = []
while len(tracks) < settings.songs_per_keystream:
try:
#s = p.get_next_song()
s = p.pop()
t = track.track_from_id(s.get_tracks('7digital')[0]['id'])
tracks.append(t)
print t
except IndexError:
pass
if len(p) == 0:
p = playlist.static(type='catalog-radio', seed_catalog=settings.seed_catalog, variety=variety, results=100)
return tracks
def make_playlist(s,y):
mc = memcache.Client(['127.0.0.1:11219'], debug=0)
mpl = mc.get(str(s))
if not mpl:
pl = [x.get_tracks('spotify-WW')[0]['foreign_id'].split(":")[-1] for x in playlist.static(artist_start_year_before=int(y)+1,song_id=s,type='song-radio',results=9,buckets=['id:spotify-WW'],limit=True,sort='energy-desc')]
mc.set(str(s),pl,time=43200)
else:
pl = mpl
return pl
def chill(catalog):
"""gets lower energy songs"""
# results = 20
energy = 0.3
songs = playlist.static(
type='catalog',
seed_catalog=catalog,
results=results,
buckets = ['id:spotify', 'tracks'],
max_energy = energy
)
return songs
def adventure(catalog):
"""gets songs that are rated as not well known"""
# results = 20
adventurousness = 1
songs = playlist.static(
type='catalog',
seed_catalog=catalog,
results=results,
buckets = ['id:spotify', 'tracks'],
adventurousness = adventurousness
)
return songs
def under_the_radar(catalog):
"""gets songs for artists with a low familiartiy rating"""
# results = 20
familiarity = 0.45
songs = playlist.static(
type='catalog',
seed_catalog=catalog,
results=results,
buckets = ['id:spotify', 'tracks'],
artist_max_familiarity = familiarity
)
return songs
def dance(catalog):
"""gets songs that have a high danceability rating """
# results = 20
danceability = 0.80
songs = playlist.static(
type='catalog',
seed_catalog=catalog,
results=results,
buckets = ['id:spotify', 'tracks'],
min_danceability = danceability,
)
return songs
def seed_playlist(catalog, danceability=0.5, hotttnesss=0.5,
energy=0.5, variety=0.5, adventurousness=0.5,
results=50):
'''
Seed playlist and return playlist parameterized by args.
'''
pl = playlist.static(type='catalog-radio', seed_catalog=catalog,
min_danceability=danceability, artist_min_hotttnesss=hotttnesss,
min_energy=energy, variety=variety, adventurousness=adventurousness,
distribution='focused', artist_pick='song_hotttnesss-desc',
sort='artist_familiarity-desc', results=results)
print 'songs in playslist', len(pl)
return pl
def post(self):
search_value= str(self.request.get('searchValue'))
#query.vq = search_value
#query.max_results = 1
#query.start_index = 1
#query.racy = "exclude"
#query.format = "5"
#query.orderby = "relevance"
#feed = client.YouTubeQuery(query)
#for entry in feed.entry:
# logging.warning(entry.GetSwfUrl())
#logging.warning(search_value)
#p = playlist.Playlist(type='artist-radio', artist=search_value)
#if p is None:
# logging.warning("Cannot create playlist")
#sid = p.session_id
#song = p.get_next_songs()
#youtube_search_string = str(song.artist_name)+" - "+str(song.title)
#youtube_search_string = search_value
yt_service = gdata.youtube.service.YouTubeService()
yt_service.ssl = False
#query = gdata.youtube.service.YouTubeVideoQuery()
#query.vq = youtube_search_string
#query.orderby = 'relevance' # might want to change this
#query.racy = 'include' # feelin' racy
#feed = yt_service.YouTubeQuery(query)
#result = feed.entry[0]
#embed_url = result.split("&")[0].replace("watch?v=","v/")
#embed_url = result.GetSwfUrl()
p = playlist.static(type="artist-radio", artist=search_value)
songs = []
for song in p:
#query = gdata.youtube.service.YouTubeVideoQuery()
#query.vq = song.artist_name+" - "+song.title
#query.orderby = 'relevance'
#query.racy = 'include'
#feed = yt_service.YouTubeQuery(query)
#result = feed.entry[0]
#embed_url = result.GetSwfUrl()
songs.append({"artist":song.artist_name,"title":song.title})
ajaxresult = []
ajaxresult.append({
'songs' : songs
});
json_string = json.dumps(ajaxresult)
self.response.write(json_string)
def popular_artists(catalog):
"""gets songs using artist's mininmal hotttnesss rating on scale of 0-1.0 """
# results = 20
hotttnesss = 0.7
songs = playlist.static(
type='catalog',
seed_catalog=catalog, #id or string
results=results,
buckets = ['id:spotify', 'tracks'],
artist_min_hotttnesss=hotttnesss
)
return songs
def hottest_songs(catalog):
"""gets popular songs"""
# results = 20
songs = playlist.static(
type='catalog',
seed_catalog=catalog,
results=results,
buckets = ['id:spotify', 'tracks'],
# song_type = 'live'
artist_pick='song_hotttnesss'
)
return songs
def get_spotify_url(self, artist_id):
try:
results = playlist.static(artist_id=artist_id, results=10, buckets=["id:spotify-WW", "tracks"], limit=True)
for song in results:
tracks = song.get_tracks('spotify-WW')
if len(tracks) > 0:
# pprint.pprint(tracks[0])
tid = tracks[0]['foreign_id']
fields = tid.split(':')
tid = 'http://open.spotify.com/track/' + fields[2]
avail = self.is_track_available(tid)
print avail, song.title
if avail:
return tid
else:
return None
except util.EchoNestAPIError:
return None
def seed_playlist(catalog,
danceability=0.5,
hotttnesss=0.5,
energy=0.5,
variety=0.5,
adventurousness=0.5,
results=50):
'''
Seed playlist and return playlist parameterized by args.
'''
pl = playlist.static(type='catalog-radio',
seed_catalog=catalog,
min_danceability=danceability,
artist_min_hotttnesss=hotttnesss,
min_energy=energy,
variety=variety,
adventurousness=adventurousness,
distribution='focused',
artist_pick='song_hotttnesss-desc',
sort='artist_familiarity-desc',
results=results)
print 'songs in playslist', len(pl)
return pl
# Uncomment to set the API key explicitly. Otherwise Pyechonest will
# look in the ECHO_NEST_API_KEY environment variable for the key.
# from pyechonest import config
# config.ECHO_NEST_API_KEY='YOUR API KEY'
from pyechonest import playlist, artist
tsquare = artist.Artist("Thompson Square")
jaldean = artist.Artist("Jason Aldean")
afire = artist.Artist("Arcade Fire")
a_playlist = playlist.static(type="artist-radio", artist_id=[tsquare.id, jaldean.id, afire.id], results=5)
other_playlist = playlist.static(type="artist-radio", artist_id=[tsquare.id, jaldean.id, afire.id], results=5)
print "Songs in one playlist for seed artists %s:" % (
", ".join(an_artist.name for an_artist in [tsquare, jaldean, afire]),
)
for a_song in a_playlist:
print '"%s" by %s' % (a_song.title, a_song.artist_name)
print ""
print "Songs in another playlist for seed artists %s:" % (
", ".join(an_artist.name for an_artist in [tsquare, jaldean, afire]),
)
for a_song in other_playlist:
print '"%s" by %s' % (a_song.title, a_song.artist_name)
def test_get_tracks_without_audio():
seed_ids = [artist.Artist(a).id for a in ARTISTS]
assert len(seed_ids) == len(ARTISTS)
raw_plist = playlist.static(type='artist-radio', artist_id=seed_ids, variety=1)
assert len(raw_plist) >= len(seed_ids)
def get(self):
pl = playlist.static(type="artist-radio", artist="Madonna", buckets=["id:rdio-us-streaming"], limit=True)
self.write(json.dumps([s.get_foreign_id("rdio-us-streaming") for s in pl]))
# Uncomment to set the API key explicitly. Otherwise Pyechonest will
# look in the ECHO_NEST_API_KEY environment variable for the key.
#from pyechonest import config
#config.ECHO_NEST_API_KEY='YOUR API KEY'
from pyechonest import playlist, song
kwstr = song.Song('SOSGSJB12A8C13B2D4')
dptec = song.Song('SOOSADY12A6701F119')
jwcb = song.Song('SOCEGKM12A58A7F30D')
a_playlist = playlist.static(type='song-radio', song_id=[kwstr.id, dptec.id, jwcb.id], results=5)
other_playlist = playlist.static(type='song-radio', song_id=[kwstr.id, dptec.id, jwcb.id], results=5)
print 'Songs in one playlist for seed songs "%s":' % ('," "'.join(a_song.title for a_song in [kwstr, dptec, jwcb]),)
for a_song in a_playlist:
print '"%s" by %s' % (a_song.title, a_song.artist_name)
print ''
print 'Songs in another playlist for seed songs "%s":' % ('," "'.join(a_song.title for a_song in [kwstr, dptec, jwcb]),)
for a_song in other_playlist:
print '"%s" by %s' % (a_song.title, a_song.artist_name)
# Uncomment to set the API key explicitly. Otherwise Pyechonest will
# look in the ECHO_NEST_API_KEY environment variable for the key.
#from pyechonest import config
#config.ECHO_NEST_API_KEY='YOUR API KEY'
from pyechonest import playlist, song
kwstr = song.Song('SOSGSJB12A8C13B2D4')
dptec = song.Song('SOOSADY12A6701F119')
jwcb = song.Song('SOCEGKM12A58A7F30D')
a_playlist = playlist.static(type='song-radio',
song_id=[kwstr.id, dptec.id, jwcb.id],
results=5)
other_playlist = playlist.static(type='song-radio',
song_id=[kwstr.id, dptec.id, jwcb.id],
results=5)
print 'Songs in one playlist for seed songs "%s":' % ('," "'.join(
a_song.title for a_song in [kwstr, dptec, jwcb]), )
for a_song in a_playlist:
print '"%s" by %s' % (a_song.title, a_song.artist_name)
print ''
print 'Songs in another playlist for seed songs "%s":' % ('," "'.join(
a_song.title for a_song in [kwstr, dptec, jwcb]), )
for a_song in other_playlist:
print '"%s" by %s' % (a_song.title, a_song.artist_name)
# Uncomment to set the API key explicitly. Otherwise Pyechonest will
# look in the ECHO_NEST_API_KEY environment variable for the key.
#from pyechonest import config
#config.ECHO_NEST_API_KEY='YOUR API KEY'
from pyechonest import playlist, artist
tsquare = artist.Artist('Thompson Square')
jaldean = artist.Artist('Jason Aldean')
afire = artist.Artist('Arcade Fire')
a_playlist = playlist.static(type='artist-radio', artist_id=[tsquare.id, jaldean.id, afire.id], results=5)
other_playlist = playlist.static(type='artist-radio', artist_id=[tsquare.id, jaldean.id, afire.id], results=5)
print 'Songs in one playlist for seed artists %s:' % (', '.join(an_artist.name for an_artist in [tsquare, jaldean, afire]),)
for a_song in a_playlist:
print '"%s" by %s' % (a_song.title, a_song.artist_name)
print ''
print 'Songs in another playlist for seed artists %s:' % (', '.join(an_artist.name for an_artist in [tsquare, jaldean, afire]),)
for a_song in other_playlist:
print '"%s" by %s' % (a_song.title, a_song.artist_name)
def create_playlist(raw_input):
if not raw_input:
return create_rickroll_playlist()
# sanitize our input
entities = clean_and_parse_input(raw_input)
artist_names, song_names = classify_input(entities)
if song_names:
song_ids = resolve_songs(song_names)
else:
song_ids = []
if not (artist_names or song_names):
return create_rickroll_playlist()
# figure out playlist type based on input
playlist_type = "song-radio" if len(song_names) > 0 else "artist-radio"
# generate the Echo Nest playlist
try:
en_playlist = pyechonest_playlist.static(
type=playlist_type,
artist=artist_names,
song_id=song_ids,
buckets=["id:7digital", "tracks"],
limit=True,
results=20,
)
except pyechonest_util.EchoNestAPIError:
artist_ids = resolve_artists(artist_names)
if artist_ids:
en_playlist = pyechonest_playlist.static(
type=playlist_type,
artist_id=artist_ids,
song_id=song_ids,
buckets=["id:7digital", "tracks"],
limit=True,
results=20,
)
else:
return create_rickroll_playlist()
# tack on spotify IDs (and filter out songs we can't find in spotify)
spotified_playlist = expand_song_results_for_spotify(en_playlist)
# trim to MAX_PLAYLIST_LENGTH
spotified_playlist = spotified_playlist[:MAX_PLAYLIST_LENGTH]
# assemble the response and cache it
playlist_id = uuid.uuid4().hex
playlist_urn = get_spotify_playlist_urn(playlist_id, artist_names + song_names, spotified_playlist)
song_dicts = []
for song in spotified_playlist:
sd = {
"href": song.urn,
"image": convert_link_to_smaller_image(song.cache["tracks"][0]["release_image"]),
"name": song.title,
"artist": song.artist_name,
"artist_href": song.artist_urn,
}
song_dicts.append(sd)
response = {"query": raw_input, "playlist_urn": playlist_urn, "playlist": song_dicts, "playlist_id": playlist_id}
cacher.set_values({playlist_id: response})
return response
