def dampp(alpha):
'dampp functon'
a = np.array([[-.267, -.110, .308, 1.34, 2.08, 2.91, 2.76, 2.05, 1.50, 1.49, 1.83, 1.21], \
[.882, .852, .876, .958, .962, .974, .819, .483, .590, 1.21, -.493, -1.04], \
[-.108, -.108, -.188, .110, .258, .226, .344, .362, .611, .529, .298, -2.27], \
[-8.80, -25.8, -28.9, -31.4, -31.2, -30.7, -27.7, -28.2, -29.0, -29.8, -38.3, -35.3], \
[-.126, -.026, .063, .113, .208, .230, .319, .437, .680, .100, .447, -.330], \
[-.360, -.359, -.443, -.420, -.383, -.375, -.329, -.294, -.230, -.210, -.120, -.100], \
[-7.21, -.540, -5.23, -5.26, -6.11, -6.64, -5.69, -6.00, -6.20, -6.40, -6.60, -6.00], \
[-.380, -.363, -.378, -.386, -.370, -.453, -.550, -.582, -.595, -.637, -1.02, -.840], \
[.061, .052, .052, -.012, -.013, -.024, .050, .150, .130, .158, .240, .150]], dtype=float).T
s = .2 * alpha
k = fix(s)
if k <= -2:
k = -1
if k >= 9:
k = 8
da = s - k
l = k + fix(1.1 * sign(da))
k = k + 3
l = l + 3
d = np.zeros((9, ))
for i in range(9):
d[i] = a[k - 1, i] + abs(da) * (a[l - 1, i] - a[k - 1, i])
return d
def get_similar(self, results=15, start=0, buckets=None, limit=False, cache=True, max_familiarity=None, min_familiarity=None, \
max_hotttnesss=None, min_hotttnesss=None, min_results=None, reverse=False):
"""Return similar artists to this one
Args:
Kwargs:
cache (bool): A boolean indicating whether or not the cached value should be used (if available). Defaults to True.
results (int): An integer number of results to return
start (int): An integer starting value for the result set
max_familiarity (float): A float specifying the max familiarity of artists to search for
min_familiarity (float): A float specifying the min familiarity of artists to search for
max_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
min_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
reverse (bool): A boolean indicating whether or not to return dissimilar artists (wrecommender). Defaults to False.
Returns:
A list of similar Artist objects
Example:
>>> a = artist.Artist('Sleater Kinney')
>>> similars = a.similar[:5]
>>> similars
[<artist - Bikini Kill>, <artist - Pretty Girls Make Graves>, <artist - Huggy Bear>, <artist - Bratmobile>, <artist - Team Dresch>]
>>>
"""
buckets = buckets or []
kwargs = {}
if max_familiarity:
kwargs['max_familiarity'] = max_familiarity
if min_familiarity:
kwargs['min_familiarity'] = min_familiarity
if max_hotttnesss:
kwargs['max_hotttnesss'] = max_hotttnesss
if min_hotttnesss:
kwargs['min_hotttnesss'] = min_hotttnesss
if min_results:
kwargs['min_results'] = min_results
if buckets:
kwargs['bucket'] = buckets
if limit:
kwargs['limit'] = 'true'
if reverse:
kwargs['reverse'] = 'true'
if cache and ('similar' in self.cache) and results==15 and start==0 and (not kwargs):
return [Artist(**util.fix(a)) for a in self.cache['similar']]
else:
response = self.get_attribute('similar', results=results, start=start, **kwargs)
if results==15 and start==0 and (not kwargs):
self.cache['similar'] = response['artists']
return [Artist(**util.fix(a)) for a in response['artists']]
def read_items(self, buckets=None, results=15, start=0, item_ids=None):
"""
Returns data from the catalog; also expanded for the requested buckets
Args:
Kwargs:
buckets (list): A list of strings specifying which buckets to retrieve
results (int): An integer number of results to return
start (int): An integer starting value for the result set
Returns:
A list of objects in the catalog; list contains additional attributes 'start' and 'total'
Example:
>>> c
<catalog - my_songs>
>>> c.read_items(results=1)
[<song - Harmonice Mundi II>]
>>>
"""
kwargs = {}
kwargs['bucket'] = buckets or []
kwargs['item_id'] = item_ids or []
response = self.get_attribute("read",
results=results,
start=start,
**kwargs)
rval = ResultList([])
if item_ids:
rval.start = 0
rval.total = len(response['catalog']['items'])
else:
rval.start = response['catalog']['start']
rval.total = response['catalog']['total']
for item in response['catalog']['items']:
new_item = None
# song items
if 'song_id' in item:
item['id'] = item.pop('song_id')
item['title'] = item.pop('song_name')
request = item['request']
new_item = song.Song(**util.fix(item))
new_item.request = request
# artist item
elif 'artist_id' in item:
item['id'] = item.pop('artist_id')
item['name'] = item.pop('artist_name')
request = item['request']
new_item = artist.Artist(**util.fix(item))
new_item.request = request
# unresolved item
else:
new_item = item
rval.append(new_item)
return rval
def read_items(self, buckets=None, results=15, start=0,item_ids=None):
"""
Returns data from the catalog; also expanded for the requested buckets.
This method is provided for backwards-compatibility
Args:
Kwargs:
buckets (list): A list of strings specifying which buckets to retrieve
results (int): An integer number of results to return
start (int): An integer starting value for the result set
Returns:
A list of objects in the catalog; list contains additional attributes 'start' and 'total'
Example:
>>> c
<catalog - my_songs>
>>> c.read_items(results=1)
[<song - Harmonice Mundi II>]
>>>
"""
warnings.warn("catalog.read_items() is depreciated. Please use catalog.get_item_dicts() instead.")
kwargs = {}
kwargs['bucket'] = buckets or []
kwargs['item_id'] = item_ids or []
response = self.get_attribute("read", results=results, start=start, **kwargs)
rval = ResultList([])
if item_ids:
rval.start=0;
rval.total=len(response['catalog']['items'])
else:
rval.start = response['catalog']['start']
rval.total = response['catalog']['total']
for item in response['catalog']['items']:
new_item = None
# song items
if 'song_id' in item:
item['id'] = item.pop('song_id')
item['title'] = item.pop('song_name')
request = item['request']
new_item = song.Song(**util.fix(item))
new_item.request = request
# artist item
elif 'artist_id' in item:
item['id'] = item.pop('artist_id')
item['name'] = item.pop('artist_name')
request = item['request']
new_item = artist.Artist(**util.fix(item))
new_item.request = request
# unresolved item
else:
new_item = item
rval.append(new_item)
return rval
def get_songs(self, cache=True, results=15, start=0):
"""Get the songs associated with an artist
Args:
Kwargs:
cache (bool): A boolean indicating whether or not the cached value should be used (if available). Defaults to True.
results (int): An integer number of results to return
start (int): An integer starting value for the result set
Results:
A list of Song objects; list contains additional attributes 'start' and 'total'
Example:
>>> a = artist.Artist('Strokes')
>>> a.get_songs(results=5)
[<song - Fear Of Sleep>, <song - Red Light>, <song - Ize Of The World>, <song - Evening Sun>, <song - Juicebox>]
>>>
"""
if cache and ('songs' in self.cache) and results == 15 and start == 0:
return self.cache['songs']
else:
response = self.get_attribute('songs',
results=results,
start=start)
for s in response['songs']:
s.update({'artist_id': self.id, 'artist_name': self.name})
songs = [Song(**util.fix(s)) for s in response['songs']]
if results == 15 and start == 0:
self.cache['songs'] = ResultList(songs, 0, response['total'])
return ResultList(songs, start, response['total'])
def get_songs(self, cache=True, results=15, start=0):
"""Get the songs associated with an artist
Args:
Kwargs:
cache (bool): A boolean indicating whether or not the cached value should be used (if available). Defaults to True.
results (int): An integer number of results to return
start (int): An integer starting value for the result set
Results:
A list of Song objects; list contains additional attributes 'start' and 'total'
Example:
>>> a = artist.Artist('Strokes')
>>> a.get_songs(results=5)
[<song - Fear Of Sleep>, <song - Red Light>, <song - Ize Of The World>, <song - Evening Sun>, <song - Juicebox>]
>>>
"""
if cache and ('songs' in self.cache) and results==15 and start==0:
return self.cache['songs']
else:
response = self.get_attribute('songs', results=results, start=start)
for s in response['songs']:
s.update({'artist_id':self.id, 'artist_name':self.name})
songs = [Song(**util.fix(s)) for s in response['songs']]
if results==15 and start==0:
self.cache['songs'] = ResultList(songs, 0, response['total'])
return ResultList(songs, start, response['total'])
def list_catalogs(results=30, start=0):
"""
Returns list of all catalogs created on this API key
Args:
Kwargs:
results (int): An integer number of results to return
start (int): An integer starting value for the result set
Returns:
A list of catalog objects
Example:
>>> catalog.list()
[<catalog - test_artist_catalog>, <catalog - test_song_catalog>, <catalog - my_songs>]
>>>
"""
result = util.callm("%s/%s" % ('catalog', 'list'), {
'results': results,
'start': start
})
cats = [Catalog(**util.fix(d)) for d in result['response']['catalogs']]
start = result['response']['start']
total = result['response']['total']
return ResultList(cats, start, total)
def get_current_song(self):
"""Get the current song in the playlist
Args:
Kwargs:
Returns:
A song object
Example:
>>> p = playlist.Playlist(type='artist-radio', artist=['ida maria', 'florence + the machine'])
>>> p.song
<song - Later On>
>>> p.get_current_song()
<song - Later On>
>>>
"""
# we need this to fix up all the dict keys to be strings, not unicode objects
if not 'songs' in self.cache:
self.get_next_song()
if len(self.cache['songs']):
return Song(**util.fix(self.cache['songs'][0]))
else:
return None
def get_current_song(self):
"""Get the current song in the playlist
Args:
Kwargs:
Returns:
A song object
Example:
>>> p = playlist.DeprecatedPlaylist(type='artist-radio', artist=['ida maria', 'florence + the machine'])
>>> p.song
<song - Later On>
>>> p.get_current_song()
<song - Later On>
>>>
"""
# we need this to fix up all the dict keys to be strings, not unicode objects
if not 'songs' in self.cache:
self.get_next_song()
if len(self.cache['songs']):
return Song(**util.fix(self.cache['songs'][0]))
else:
return None
def list_catalogs(results=30, start=0):
"""
Returns list of all catalogs created on this API key
Args:
Kwargs:
results (int): An integer number of results to return
start (int): An integer starting value for the result set
Returns:
A list of catalog objects
Example:
>>> catalog.list_catalogs()
[<catalog - test_artist_catalog>, <catalog - test_song_catalog>, <catalog - my_songs>]
>>>
"""
result = util.callm("%s/%s" % ('catalog', 'list'), {'results': results, 'start': start})
cats = [Catalog(**util.fix(d)) for d in result['response']['catalogs']]
start = result['response']['start']
total = result['response']['total']
return ResultList(cats, start, total)
def _get_friends_and_idols(self, person_type, results, sort=None):
assert person_type in ('followers', 'following')
paramd = {}
if sort:
assert sort in ('when', 'affinity', 'alpha')
paramd['order'] = sort
friends_and_idols = self._get_listed_things(person_type, 'people', results, **paramd)
return [TIMJUser(**util.fix(raw_person)) for raw_person in friends_and_idols]
def suggest(q='', results=15, buckets=None, limit=False, max_familiarity=None, min_familiarity=None,
max_hotttnesss=None, min_hotttnesss=None):
"""Suggest artists based upon partial names.
Args:
Kwargs:
q (str): The text to suggest artists from
results (int): An integer number of results to return
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
max_familiarity (float): A float specifying the max familiarity of artists to search for
min_familiarity (float): A float specifying the min familiarity of artists to search for
max_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
min_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
Returns:
A list of Artist objects
Example:
>>> results = artist.suggest(text='rad')
>>> results
>>>
"""
buckets = buckets or []
kwargs = {}
kwargs['q'] = q
if max_familiarity is not None:
kwargs['max_familiarity'] = max_familiarity
if min_familiarity is not None:
kwargs['min_familiarity'] = min_familiarity
if max_hotttnesss is not None:
kwargs['max_hotttnesss'] = max_hotttnesss
if min_hotttnesss is not None:
kwargs['min_hotttnesss'] = min_hotttnesss
if results:
kwargs['results'] = results
if buckets:
kwargs['bucket'] = buckets
if limit:
kwargs['limit'] = 'true'
result = util.callm("%s/%s" % ('artist', 'suggest'), kwargs)
return [Artist(**util.fix(a_dict)) for a_dict in result['response']['artists']]
def profile(ids=None, track_ids=None, buckets=None, limit=False):
"""get the profiles for multiple songs at once
Args:
ids (str or list): a song ID or list of song IDs
Kwargs:
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
Returns:
A list of term document dicts
Example:
>>> song_ids = ['SOBSLVH12A8C131F38', 'SOXMSGY1338A5D5873', 'SOJPHZO1376210AFE5', 'SOBHNKR12AB0186218', 'SOSJAHD13770F4D40C']
>>> songs = song.profile(song_ids, buckets=['audio_summary'])
[<song - Say It Ain't So>,
<song - Island In The Sun>,
<song - My Name Is Jonas>,
<song - Buddy Holly>]
>>> songs[0].audio_summary
{u'analysis_url': u'https://echonest-analysis.s3.amazonaws.com/TR/7VRBNguufpHAQQ4ZjJ0eWsIQWl2S2_lrK-7Bp2azHOvPN4VFV-YnU7uO0dXgYtOKT-MTEa/3/full.json?Signature=hmNghHwfEsA4JKWFXnRi7mVP6T8%3D&Expires=1349809918&AWSAccessKeyId=AKIAJRDFEY23UEVW42BQ',
u'audio_md5': u'b6079b2b88f8265be8bdd5fe9702e05c',
u'danceability': 0.64540643050283253,
u'duration': 255.92117999999999,
u'energy': 0.30711665772260549,
u'key': 8,
u'liveness': 0.088994423525370583,
u'loudness': -9.7799999999999994,
u'mode': 1,
u'speechiness': 0.031970700260699259,
u'tempo': 76.049999999999997,
u'time_signature': 4}
>>>
"""
kwargs = {}
if ids:
if not isinstance(ids, list):
ids = [ids]
kwargs['id'] = ids
if track_ids:
if not isinstance(track_ids, list):
track_ids = [track_ids]
kwargs['track_id'] = track_ids
buckets = buckets or []
if buckets:
kwargs['bucket'] = buckets
if limit:
kwargs['limit'] = 'true'
result = util.callm("%s/%s" % ('song', 'profile'), kwargs)
return [Song(**util.fix(s_dict)) for s_dict in result['response']['songs']]
def suggest(q='', results=15, buckets=None, limit=False, max_familiarity=None, min_familiarity=None,
max_hotttnesss=None, min_hotttnesss=None):
"""Suggest artists based upon partial names.
Args:
Kwargs:
q (str): The text to suggest artists from
results (int): An integer number of results to return
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
max_familiarity (float): A float specifying the max familiarity of artists to search for
min_familiarity (float): A float specifying the min familiarity of artists to search for
max_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
min_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
Returns:
A list of Artist objects
Example:
>>> results = artist.suggest(text='rad')
>>> results
>>>
"""
buckets = buckets or []
kwargs = {}
kwargs['q'] = q
if max_familiarity is not None:
kwargs['max_familiarity'] = max_familiarity
if min_familiarity is not None:
kwargs['min_familiarity'] = min_familiarity
if max_hotttnesss is not None:
kwargs['max_hotttnesss'] = max_hotttnesss
if min_hotttnesss is not None:
kwargs['min_hotttnesss'] = min_hotttnesss
if results:
kwargs['results'] = results
if buckets:
kwargs['bucket'] = buckets
if limit:
kwargs['limit'] = 'true'
result = util.callm("%s/%s" % ('artist', 'suggest'), kwargs)
return [Artist(**util.fix(a_dict)) for a_dict in result['response']['artists']]
def profile(ids=None, track_ids=None, buckets=None, limit=False):
"""get the profiles for multiple songs at once
Args:
ids (str or list): a song ID or list of song IDs
Kwargs:
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
Returns:
A list of term document dicts
Example:
>>> song_ids = ['SOBSLVH12A8C131F38', 'SOXMSGY1338A5D5873', 'SOJPHZO1376210AFE5', 'SOBHNKR12AB0186218', 'SOSJAHD13770F4D40C']
>>> songs = song.profile(song_ids, buckets=['audio_summary'])
[<song - Say It Ain't So>,
<song - Island In The Sun>,
<song - My Name Is Jonas>,
<song - Buddy Holly>]
>>> songs[0].audio_summary
{u'analysis_url': u'https://echonest-analysis.s3.amazonaws.com/TR/7VRBNguufpHAQQ4ZjJ0eWsIQWl2S2_lrK-7Bp2azHOvPN4VFV-YnU7uO0dXgYtOKT-MTEa/3/full.json?Signature=hmNghHwfEsA4JKWFXnRi7mVP6T8%3D&Expires=1349809918&AWSAccessKeyId=AKIAJRDFEY23UEVW42BQ',
u'audio_md5': u'b6079b2b88f8265be8bdd5fe9702e05c',
u'danceability': 0.64540643050283253,
u'duration': 255.92117999999999,
u'energy': 0.30711665772260549,
u'key': 8,
u'liveness': 0.088994423525370583,
u'loudness': -9.7799999999999994,
u'mode': 1,
u'speechiness': 0.031970700260699259,
u'tempo': 76.049999999999997,
u'time_signature': 4}
>>>
"""
kwargs = {}
if ids:
if not isinstance(ids, list):
ids = [ids]
kwargs['id'] = ids
if track_ids:
if not isinstance(track_ids, list):
track_ids = [track_ids]
kwargs['track_id'] = track_ids
buckets = buckets or []
if buckets:
kwargs['bucket'] = buckets
if limit:
kwargs['limit'] = 'true'
result = util.callm("%s/%s" % ('song', 'profile'), kwargs)
return [Song(**util.fix(s_dict)) for s_dict in result['response']['songs']]
def cn(alpha, beta):
'cn function'
a = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], \
[.018, .019, .018, .019, .019, .018, .013, .007, .004, -.014, -.017, -.033], \
[.038, .042, .042, .042, .043, .039, .030, .017, .004, -.035, -.047, -.057], \
[.056, .057, .059, .058, .058, .053, .032, .012, .002, -.046, -.071, -.073], \
[.064, .077, .076, .074, .073, .057, .029, .007, .012, -.034, -.065, -.041], \
[.074, .086, .093, .089, .080, .062, .049, .022, .028, -.012, -.002, -.013], \
[.079, .090, .106, .106, .096, .080, .068, .030, .064, .015, .011, -.001]], dtype=float).T
s = .2 * alpha
k = fix(s)
if k <= -2:
k = -1
if k >= 9:
k = 8
da = s - k
l = k + fix(1.1 * sign(da))
s = .2 * abs(beta)
m = fix(s)
if m == 0:
m = 1
if m >= 6:
m = 5
db = s - m
n = m + fix(1.1 * sign(db))
l = l + 3
k = k + 3
m = m + 1
n = n + 1
t = a[k - 1, m - 1]
u = a[k - 1, n - 1]
v = t + abs(da) * (a[l - 1, m - 1] - t)
w = u + abs(da) * (a[l - 1, n - 1] - u)
dum = v + (w - v) * abs(db)
return dum * sign(beta)
def _search_users_by(by, q, results):
get_function = proxies.get_json_resource
raw = proxies.get_listed_things(get_function,
"search/person",
'people',
results,
by=by,
q=q)
return [TIMJUser(**util.fix(raw_person)) for raw_person in raw]
def profile(ids=None, track_ids=None, buckets=None, limit=False):
"""get the profiles for multiple songs at once
Args:
ids (str or list): a song ID or list of song IDs
Kwargs:
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
Returns:
A list of term document dicts
Example:
>>> song_ids = [u'SOGNMKX12B0B806320', u'SOLUHKP129F0698D49', u'SOOLGAZ127F3E1B87C', u'SOQKVPH12A58A7AF4D', u'SOHKEEM1288D3ED9F5']
>>> songs = song.profile(song_ids, buckets=['audio_summary'])
[<song - chickfactor>,
<song - One Step Closer>,
<song - And I Am Telling You I'm Not Going (Glee Cast Version)>,
<song - In This Temple As In The Hearts Of Man For Whom He Saved The Earth>,
<song - Octet>]
>>> songs[0].audio_summary
{u'analysis_url': u'https://echonest-analysis.s3.amazonaws.com:443/TR/TRKHTDL123E858AC4B/3/full.json?Signature=sE6OwAzg6UvrtiX6nJJW1t7E6YI%3D&Expires=1287585351&AWSAccessKeyId=AKIAIAFEHLM3KJ2XMHRA',
u'danceability': None,
u'duration': 211.90485000000001,
u'energy': None,
u'key': 7,
u'loudness': -16.736999999999998,
u'mode': 1,
u'tempo': 94.957999999999998,
u'time_signature': 4}
>>>
"""
kwargs = {}
if ids:
if not isinstance(ids, list):
ids = [ids]
kwargs['id'] = ids
if track_ids:
if not isinstance(track_ids, list):
track_ids = [track_ids]
kwargs['track_id'] = track_ids
buckets = buckets or []
if buckets:
kwargs['bucket'] = buckets
if limit:
kwargs['limit'] = 'true'
result = util.callm("%s/%s" % ('song', 'profile'), kwargs)
return [Song(**util.fix(s_dict)) for s_dict in result['response']['songs']]
def dldr(alpha, beta):
'dldr function'
a = np.array([[.005, .017, .014, .010, -.005, .009, .019, .005, -.000, -.005, -.011, .008], \
[.007, .016, .014, .014, .013, .009, .012, .005, .000, .004, .009, .007], \
[.013, .013, .011, .012, .011, .009, .008, .005, .000, .005, .003, .005], \
[.018, .015, .015, .014, .014, .014, .014, .015, .013, .011, .006, .001], \
[.015, .014, .013, .013, .012, .011, .011, .010, .008, .008, .007, .003], \
[.021, .011, .010, .011, .010, .009, .008, .010, .006, .005, .000, .001], \
[.023, .010, .011, .011, .011, .010, .008, .010, .006, .014, .020, .000]], dtype=float).T
s = .2 * alpha
k = fix(s)
if k <= -2:
k = -1
if k >= 9:
k = 8
da = s - k
l = k + fix(1.1 * sign(da))
s = .1 * beta
m = fix(s)
if m <= -3:
m = -2
if m >= 3:
m = 2
db = s - m
n = m + fix(1.1 * sign(db))
l = l + 3
k = k + 3
m = m + 4
n = n + 4
t = a[k - 1, m - 1]
u = a[k - 1, n - 1]
v = t + abs(da) * (a[l - 1, m - 1] - t)
w = u + abs(da) * (a[l - 1, n - 1] - u)
return v + (w - v) * abs(db)
def cl(alpha, beta):
'cl function'
a = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], \
[-.001, -.004, -.008, -.012, -.016, -.022, -.022, -.021, -.015, -.008, -.013, -.015], \
[-.003, -.009, -.017, -.024, -.030, -.041, -.045, -.040, -.016, -.002, -.010, -.019], \
[-.001, -.010, -.020, -.030, -.039, -.054, -.057, -.054, -.023, -.006, -.014, -.027], \
[.000, -.010, -.022, -.034, -.047, -.060, -.069, -.067, -.033, -.036, -.035, -.035], \
[.007, -.010, -.023, -.034, -.049, -.063, -.081, -.079, -.060, -.058, -.062, -.059], \
[.009, -.011, -.023, -.037, -.050, -.068, -.089, -.088, -.091, -.076, -.077, -.076]], dtype=float).T
s = .2 * alpha
k = fix(s)
if k <= -2:
k = -1
if k >= 9:
k = 8
da = s - k
l = k + fix(1.1 * sign(da))
s = .2 * abs(beta)
m = fix(s)
if m == 0:
m = 1
if m >= 6:
m = 5
db = s - m
n = m + fix(1.1 * sign(db))
l = l + 3
k = k + 3
m = m + 1
n = n + 1
t = a[k - 1, m - 1]
u = a[k - 1, n - 1]
v = t + abs(da) * (a[l - 1, m - 1] - t)
w = u + abs(da) * (a[l - 1, n - 1] - u)
dum = v + (w - v) * abs(db)
return dum * sign(beta)
def get_lookahead_songs(self):
if not 'lookahead' in self.cache:
return None
if len(self.cache['lookahead']):
lookahead = self.cache['lookahead'][:]
lookahead = [Song(**util.fix(song)) for song in lookahead]
return lookahead
else:
return None
def get_catalog_by_name(name):
"""
Grabs a catalog by name, if its there on the api key.
Otherwise, an error is thrown (mirroring the API)
"""
kwargs = {
'name': name,
}
result = util.callm("%s/%s" % ('catalog', 'profile'), kwargs)
return Catalog(**util.fix(result['response']['catalog']))
def get_lookahead_songs(self):
if not 'lookahead' in self.cache:
return None
if len(self.cache['lookahead']):
lookahead = self.cache['lookahead'][:]
lookahead = [Song(**util.fix(song)) for song in lookahead]
return lookahead
else:
return None
def get_catalog_by_name(name):
"""
Grabs a catalog by name, if its there on the api key.
Otherwise, an error is thrown (mirroring the API)
"""
kwargs = {
'name' : name,
}
result = util.callm("%s/%s" % ('catalog', 'profile'), kwargs)
return Catalog(**util.fix(result['response']['catalog']))
def get_current_songs(self):
if not 'songs' in self.cache:
self.get_next_songs(results=1)
if len(self.cache['songs']):
songs = self.cache['songs'][:]
songs = [Song(**util.fix(song)) for song in songs]
return songs
else:
return None
def get_next_songs(self, results=None, lookahead=None):
response = self.get_attribute(method="next", session_id=self.session_id, results=results, lookahead=lookahead)
self.cache["songs"] = response["songs"]
self.cache["lookahead"] = response["lookahead"]
if len(self.cache["songs"]):
songs = self.cache["songs"][:]
songs = [Song(**util.fix(song)) for song in songs]
return songs
else:
return None
def get_current_songs(self):
if not 'songs' in self.cache:
self.get_next_songs(results=1)
if len(self.cache['songs']):
songs = self.cache['songs'][:]
songs = [Song(**util.fix(song)) for song in songs]
return songs
else:
return None
def __init__(self, id, **kwargs):
super(JamProxy, self).__init__()
self.id = id
kwargs = util.fix(kwargs)
core_attrs = [] # things you want/need initted at object creation time
if not all(core_attr in kwargs for core_attr in core_attrs):
profile = get_json_resource("jams/%s" % self.id)['jam']
kwargs.update(profile)
self.cache.update(kwargs)
def __init__(self, name, **kwargs):
super(UserProxy, self).__init__()
self.id = name
kwargs = util.fix(kwargs)
core_attrs = [] # things you want/need initted at object creation time
if not all(core_attr in kwargs for core_attr in core_attrs):
profile = get_json_resource(self.id)['person']
kwargs.update(profile)
self.cache.update(kwargs)
def cm(alpha, el):
'cm function'
a = np.array([[.205, .168, .186, .196, .213, .251, .245, .238, .252, .231, .198, .192], \
[.081, .077, .107, .110, .110, .141, .127, .119, .133, .108, .081, .093], \
[-.046, -.020, -.009, -.005, -.006, .010, .006, -.001, .014, .000, -.013, .032], \
[-.174, -.145, -.121, -.127, -.129, -.102, -.097, -.113, -.087, -.084, -.069, -.006], \
[-.259, -.202, -.184, -.193, -.199, -.150, -.160, -.167, -.104, -.076, -.041, -.005]], dtype=float).T
s = .2 * alpha
k = fix(s)
if k <= -2:
k = -1
if k >= 9:
k = 8
da = s - k
l = k + fix(1.1 * sign(da))
s = el / 12
m = fix(s)
if m <= -2:
m = -1
if m >= 2:
m = 1
de = s - m
n = m + fix(1.1 * sign(de))
k = k + 3
l = l + 3
m = m + 3
n = n + 3
t = a[k - 1, m - 1]
u = a[k - 1, n - 1]
v = t + abs(da) * (a[l - 1, m - 1] - t)
w = u + abs(da) * (a[l - 1, n - 1] - u)
return v + (w - v) * abs(de)
def _get_friends_and_idols(self, person_type, results, sort=None):
assert person_type in ('followers', 'following')
paramd = {}
if sort:
assert sort in ('when', 'affinity', 'alpha')
paramd['order'] = sort
friends_and_idols = self._get_listed_things(person_type, 'people',
results, **paramd)
return [
TIMJUser(**util.fix(raw_person))
for raw_person in friends_and_idols
]
def cx(alpha, el):
'cx definition'
a = np.array([[-.099, -.081, -.081, -.063, -.025, .044, .097, .113, .145, .167, .174, .166], \
[-.048, -.038, -.040, -.021, .016, .083, .127, .137, .162, .177, .179, .167], \
[-.022, -.020, -.021, -.004, .032, .094, .128, .130, .154, .161, .155, .138], \
[-.040, -.038, -.039, -.025, .006, .062, .087, .085, .100, .110, .104, .091], \
[-.083, -.073, -.076, -.072, -.046, .012, .024, .025, .043, .053, .047, .040]], dtype=float).T
s = .2 * alpha
k = fix(s)
if k <= -2:
k = -1
if k >= 9:
k = 8
da = s - k
l = k + fix(1.1 * sign(da))
s = el / 12
m = fix(s)
if m <= -2:
m = -1
if m >= 2:
m = 1
de = s - m
n = m + fix(1.1 * sign(de))
k = k + 3
l = l + 3
m = m + 3
n = n + 3
t = a[k-1, m-1]
u = a[k-1, n-1]
v = t + abs(da) * (a[l-1, m-1] - t)
w = u + abs(da) * (a[l-1, n-1] - u)
cxx = v + (w - v) * abs(de)
return cxx
def dndr(alpha, beta):
'dndr function'
a = np.array([[-.018, -.052, -.052, -.052, -.054, -.049, -.059, -.051, -.030, -.037, -.026, -.013], \
[-.028, -.051, -.043, -.046, -.045, -.049, -.057, -.052, -.030, -.033, -.030, -.008], \
[-.037, -.041, -.038, -.040, -.040, -.038, -.037, -.030, -.027, -.024, -.019, -.013], \
[-.048, -.045, -.045, -.045, -.044, -.045, -.047, -.048, -.049, -.045, -.033, -.016], \
[-.043, -.044, -.041, -.041, -.040, -.038, -.034, -.035, -.035, -.029, -.022, -.009], \
[-.052, -.034, -.036, -.036, -.035, -.028, -.024, -.023, -.020, -.016, -.010, -.014], \
[-.062, -.034, -.027, -.028, -.027, -.027, -.023, -.023, -.019, -.009, -.025, -.010]], dtype=float).T
s = .2 * alpha
k = fix(s)
if k <= -2:
k = -1
if k >= 9:
k = 8
da = s - k
l = k + fix(1.1 * sign(da))
s = .1 * beta
m = fix(s)
if m <= -3:
m = -2
if m >= 3:
m = 2
db = s - m
n = m + fix(1.1 * sign(db))
l = l + 3
k = k + 3
m = m + 4
n = n + 4
t = a[k - 1, m - 1]
u = a[k - 1, n - 1]
v = t + abs(da) * (a[l - 1, m - 1] - t)
w = u + abs(da) * (a[l - 1, n - 1] - u)
return v + (w - v) * abs(db)
def get_next_songs(self, results=None, lookahead=None):
response = self.get_attribute(method='next',
session_id=self.session_id,
results=results,
lookahead=lookahead)
self.cache['songs'] = response['songs']
self.cache['lookahead'] = response['lookahead']
if len(self.cache['songs']):
songs = self.cache['songs'][:]
songs = [Song(**util.fix(song)) for song in songs]
return songs
else:
return None
def cz(alpha, beta, el):
'cz function'
a = np.array([.770, .241, -.100, -.415, -.731, -1.053, -1.355, -1.646, -1.917, -2.120, -2.248, -2.229], \
dtype=float).T
s = .2 * alpha
k = fix(s)
if k <= -2:
k = -1
if k >= 9:
k = 8
da = s - k
l = k + fix(1.1 * sign(da))
l = l + 3
k = k + 3
s = a[k-1] + abs(da) * (a[l-1] - a[k-1])
return s * (1 - (beta / 57.3)**2) - .19 * (el / 25)
def basic(
type='artist-radio',
artist_id=None,
artist=None,
song_id=None,
song=None,
track_id=None,
dmca=False,
results=15,
buckets=None,
limit=False,
genres=None,
):
"""Get a basic playlist
Args:
Kwargs:
type (str): a string representing the playlist type ('artist-radio' or 'song-radio')
artist_id (str): the artist_id to seed the playlist
artist (str): the name of an artist to seed the playlist
song_id (str): a song_id to seed the playlist
song (str): the name of a song to seed the playlist
track_id (str): the name of a track to seed the playlist
dmca (bool): make the playlist dmca-compliant
results (int): desired length of the playlist
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): Whether results should be restricted to any idspaces given in the buckets parameter
"""
limit = str(limit).lower()
dmca = str(dmca).lower()
kwargs = locals()
kwargs['bucket'] = kwargs['buckets']
del kwargs['buckets']
kwargs['genre'] = kwargs['genres']
del kwargs['genres']
result = util.callm("%s/%s" % ('playlist', 'basic'), kwargs)
return [Song(**util.fix(s_dict)) for s_dict in result['response']['songs']]
def basic(
type="artist-radio",
artist_id=None,
artist=None,
song_id=None,
song=None,
track_id=None,
dmca=False,
results=15,
buckets=None,
limit=False,
):
"""Get a basic playlist
Args:
Kwargs:
type (str): a string representing the playlist type ('artist-radio' or 'song-radio')
artist_id (str): the artist_id to seed the playlist
artist (str): the name of an artist to seed the playlist
song_id (str): a song_id to seed the playlist
song (str): the name of a song to seed the playlist
track_id (str): the name of a track to seed the playlist
dmca (bool): make the playlist dmca-compliant
results (int): desired length of the playlist
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): Whether results should be restricted to any idspaces given in the buckets parameter
"""
limit = str(limit).lower()
dmca = str(dmca).lower()
kwargs = locals()
kwargs["bucket"] = kwargs["buckets"]
del kwargs["buckets"]
result = util.callm("%s/%s" % ("playlist", "basic"), kwargs)
return [Song(**util.fix(s_dict)) for s_dict in result["response"]["songs"]]
def top_hottt(start=0, results=15, buckets=None, limit=False):
"""Get the top hotttest artists, according to The Echo Nest
Args:
Kwargs:
results (int): An integer number of results to return
start (int): An integer starting value for the result set
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
Returns:
A list of hottt Artist objects
Example:
>>> hot_stuff = artist.top_hottt()
>>> hot_stuff
[<artist - Deerhunter>, <artist - Sufjan Stevens>, <artist - Belle and Sebastian>, <artist - Glee Cast>, <artist - Linkin Park>, <artist - Neil Young>, <artist - Jimmy Eat World>, <artist - Kanye West>, <artist - Katy Perry>, <artist - Bruno Mars>, <artist - Lady Gaga>, <artist - Rihanna>, <artist - Lil Wayne>, <artist - Jason Mraz>, <artist - Green Day>]
>>>
"""
buckets = buckets or []
kwargs = {}
if start:
kwargs['start'] = start
if results:
kwargs['results'] = results
if buckets:
kwargs['bucket'] = buckets
if limit:
kwargs['limit'] = 'true'
"""Get top hottt artists"""
result = util.callm("%s/%s" % ('artist', 'top_hottt'), kwargs)
return [
Artist(**util.fix(a_dict)) for a_dict in result['response']['artists']
]
def top_hottt(start=0, results=15, buckets = None, limit=False):
"""Get the top hotttest artists, according to The Echo Nest
Args:
Kwargs:
results (int): An integer number of results to return
start (int): An integer starting value for the result set
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
Returns:
A list of hottt Artist objects
Example:
>>> hot_stuff = artist.top_hottt()
>>> hot_stuff
[<artist - Deerhunter>, <artist - Sufjan Stevens>, <artist - Belle and Sebastian>, <artist - Glee Cast>, <artist - Linkin Park>, <artist - Neil Young>, <artist - Jimmy Eat World>, <artist - Kanye West>, <artist - Katy Perry>, <artist - Bruno Mars>, <artist - Lady Gaga>, <artist - Rihanna>, <artist - Lil Wayne>, <artist - Jason Mraz>, <artist - Green Day>]
>>>
"""
buckets = buckets or []
kwargs = {}
if start:
kwargs['start'] = start
if results:
kwargs['results'] = results
if buckets:
kwargs['bucket'] = buckets
if limit:
kwargs['limit'] = 'true'
"""Get top hottt artists"""
result = util.callm("%s/%s" % ('artist', 'top_hottt'), kwargs)
return [Artist(**util.fix(a_dict)) for a_dict in result['response']['artists']]
def search(name=None, description=None, style=None, mood=None, start=0, \
results=15, buckets=None, limit=False, \
fuzzy_match=False, sort=None, max_familiarity=None, min_familiarity=None, \
max_hotttnesss=None, min_hotttnesss=None, test_new_things=None, rank_type=None, \
artist_start_year_after=None, artist_start_year_before=None,artist_end_year_after=None,artist_end_year_before=None):
"""Search for artists by name, description, or constraint.
Args:
Kwargs:
name (str): the name of an artist
description (str): A string describing the artist
style (str): A string describing the style/genre of the artist
mood (str): A string describing the mood of the artist
start (int): An integer starting value for the result set
results (int): An integer number of results to return
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
fuzzy_match (bool): A boolean indicating whether or not to search for similar sounding matches (only works with name)
max_familiarity (float): A float specifying the max familiarity of artists to search for
min_familiarity (float): A float specifying the min familiarity of artists to search for
max_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
min_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
artist_start_year_before (int): Returned artists will have started recording music before this year.
artist_start_year_after (int): Returned artists will have started recording music after this year.
artist_end_year_before (int): Returned artists will have stopped recording music before this year.
artist_end_year_after (int): Returned artists will have stopped recording music after this year.
rank_type (str): A string denoting the desired ranking for description searches, either 'relevance' or 'familiarity'
Returns:
A list of Artist objects
Example:
>>> results = artist.search(name='t-pain')
>>> results
[<artist - T-Pain>, <artist - T-Pain & Lil Wayne>, <artist - T Pain & 2 Pistols>, <artist - Roscoe Dash & T-Pain>, <artist - Tony Moxberg & T-Pain>, <artist - Flo-Rida (feat. T-Pain)>, <artist - Shortyo/Too Short/T-Pain>]
>>>
"""
limit = str(limit).lower()
fuzzy_match = str(fuzzy_match).lower()
kwargs = locals()
kwargs['bucket'] = buckets or []
del kwargs['buckets']
"""Search for artists"""
result = util.callm("%s/%s" % ('artist', 'search'), kwargs)
return [Artist(**util.fix(a_dict)) for a_dict in result['response']['artists']]
def get_liked_jams(self, results=10):
liked_jams = self._get_listed_things('likes', 'jams', results)
return [Jam(**util.fix(raw_jam)) for raw_jam in liked_jams]
def search(title=None, artist=None, artist_id=None, combined=None, description=None, style=None, mood=None, \
results=None, start=None, max_tempo=None, min_tempo=None, \
max_duration=None, min_duration=None, max_loudness=None, min_loudness=None, \
artist_max_familiarity=None, artist_min_familiarity=None, artist_max_hotttnesss=None, \
artist_min_hotttnesss=None, song_max_hotttnesss=None, song_min_hotttnesss=None, mode=None, \
min_energy=None, max_energy=None, min_danceability=None, max_danceability=None, \
key=None, max_latitude=None, min_latitude=None, max_longitude=None, min_longitude=None, \
sort=None, buckets = None, limit=False, test_new_things=None, rank_type=None,
artist_start_year_after=None, artist_start_year_before=None, artist_end_year_after=None, artist_end_year_before=None):
"""Search for songs by name, description, or constraint.
Args:
Kwargs:
title (str): the name of a song
artist (str): the name of an artist
artist_id (str): the artist_id
combined (str): the artist name and song title
description (str): A string describing the artist and song
style (str): A string describing the style/genre of the artist and song
mood (str): A string describing the mood of the artist and song
results (int): An integer number of results to return
max_tempo (float): The max tempo of song results
min_tempo (float): The min tempo of song results
max_duration (float): The max duration of song results
min_duration (float): The min duration of song results
max_loudness (float): The max loudness of song results
min_loudness (float): The min loudness of song results
artist_max_familiarity (float): A float specifying the max familiarity of artists to search for
artist_min_familiarity (float): A float specifying the min familiarity of artists to search for
artist_max_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
artist_min_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
song_max_hotttnesss (float): A float specifying the max hotttnesss of songs to search for
song_min_hotttnesss (float): A float specifying the max hotttnesss of songs to search for
max_energy (float): The max energy of song results
min_energy (float): The min energy of song results
max_dancibility (float): The max dancibility of song results
min_dancibility (float): The min dancibility of song results
mode (int): 0 or 1 (minor or major)
key (int): 0-11 (c, c-sharp, d, e-flat, e, f, f-sharp, g, a-flat, a, b-flat, b)
max_latitude (float): A float specifying the max latitude of artists to search for
min_latitude (float): A float specifying the min latitude of artists to search for
max_longitude (float): A float specifying the max longitude of artists to search for
min_longitude (float): A float specifying the min longitude of artists to search for
sort (str): A string indicating an attribute and order for sorting the results
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
rank_type (str): A string denoting the desired ranking for description searches, either 'relevance' or 'familiarity
artist_start_year_before (int): Returned songs's artists will have started recording music before this year.
artist_start_year_after (int): Returned songs's artists will have started recording music after this year.
artist_end_year_before (int): Returned songs's artists will have stopped recording music before this year.
artist_end_year_after (int): Returned songs's artists will have stopped recording music after this year.
Returns:
A list of Song objects
Example:
>>> results = song.search(artist='shakira', title='she wolf', buckets=['id:7digital', 'tracks'], limit=True, results=1)
>>> results
[<song - She Wolf>]
>>> results[0].get_tracks('7digital')[0]
{u'catalog': u'7digital',
u'foreign_id': u'7digital:track:7854109',
u'id': u'TRTOBSE12903CACEC4',
u'preview_url': u'http://previews.7digital.com/clips/34/7854109.clip.mp3',
u'release_image': u'http://cdn.7static.com/static/img/sleeveart/00/007/081/0000708184_200.jpg'}
>>>
"""
limit = str(limit).lower()
kwargs = locals()
kwargs['bucket'] = buckets
del kwargs['buckets']
result = util.callm("%s/%s" % ('song', 'search'), kwargs)
return [Song(**util.fix(s_dict)) for s_dict in result['response']['songs']]
def identify(filename=None, query_obj=None, code=None, artist=None, title=None, release=None, duration=None, genre=None, buckets=None, version=None, codegen_start=0, codegen_duration=30):
"""Identify a song.
Args:
Kwargs:
filename (str): The path of the file you want to analyze (requires codegen binary!)
query_obj (dict or list): A dict or list of dicts containing a 'code' element with an fp code
code (str): A fingerprinter code
artist (str): An artist name
title (str): A song title
release (str): A release name
duration (int): A song duration
genre (str): A string representing the genre
buckets (list): A list of strings specifying which buckets to retrieve
version (str): The version of the code generator used to generate the code
codegen_start (int): The point (in seconds) where the codegen should start
codegen_duration (int): The duration (in seconds) the codegen should analyze
Example:
>>> qo
{'code': 'eJxlldehHSEMRFsChAjlAIL-S_CZvfaXXxAglEaBTen300Qu__lAyoJYhVQdXTvXrmvXdTsKZOqoU1q63QNydBGfOd1cGX3scpb1jEiWRLaPcJureC6RVkXE69jL8pGHjpP48pLI1m7r9oiEyBXvoVv45Q-5IhylYLkIRxGO4rp18ZpEOmpFPopwfJjL0u3WceO3HB1DIvJRnkQeO1PCLIsIjBWEzYaShq4pV9Z0KzDiQ8SbSNuSyBZPOOxIJKR7dauEmXwotxDCqllEAVZlrX6F8Y-IJ0e169i_HQaqslaVtTq1W-1vKeupImzrxWWVI5cPlw-XDxckN-3kyeXDm3jKmqv6PtB1gfH1Eey5qu8qvAuMC4zLfPv1l3aqviylJhytFhF0mzqs6aYpYU04mlqgKWtNjppwNKWubR2FowlHUws0gWmPi668dSHq6rOuPuhqgRcVKKM8s-fZS937nBe23iz3Uctx9607z-kLph1i8YZ8f_TfzLXseBh7nXy9nn1YBAg4Nwjp4AzTL23M_U3Rh0-sdDFtyspNOb1bYeZZqz2Y6TaHmXeuNmfFdTueLuvdsbOU9luvtIkl4vI5F_92PVprM1-sdJ_o9_Guc0b_WimpD_Rt1DFg0sY3wyw08e6jlqhjH3o76naYvzWqhX9rOv15Y7Ww_MIF8dXzw30s_uHO5PPDfUonnzq_NJ8J93mngAkIz5jA29SqxGwwvxQsih-sozX0zVk__RFaf_qyG9hb8dktZZXd4a8-1ljB-c5bllXOe1HqHplzeiN4E7q9ZRdmJuI73gBEJ_HcAxUm74PAVDNL47D6OAfzTHI0mHpXAmY60QNmlqjDfIPzwUDYhVnoXqtvZGrBdMi3ClQUQ8D8rX_1JE_In94CBXER4lrrw0H867ei8x-OVz8c-Osh5plzTOySpKIROmFkbn5xVuK784vTyPpS3OlcSjHpL16saZnm4Bk66hte9sd80Dcj02f7xDVrExjk32cssKXjmflU_SxXmn4Y9Ttued10YM552h5Wtt_WeVR4U6LPWfbIdW31J4JOXnpn4qhH7yE_pdBH9E_sMwbNFr0z0IW5NA8aOZhLmOh3zSVNRZwxiZc5pb8fikGzIf-ampJnCSb3r-ZPfjPuvLm7CY_Vfa_k7SCzdwHNg5mICTSHDxyBWmaOSyLQpPmCSXyF-eL7MHo7zNd668JMb_N-AJJRuMwrX0jNx7a8-Rj5oN6nyWoL-jRv4pu7Ue821TzU3MhvpD9Fo-XI',
'code_count': 151,
'low_rank': 0,
'metadata': {'artist': 'Harmonic 313',
'bitrate': 198,
'codegen_time': 0.57198400000000005,
'decode_time': 0.37954599999999999,
'duration': 226,
'filename': 'koln.mp3',
'genre': 'Electronic',
'given_duration': 30,
'release': 'When Machines Exceed Human Intelligence',
'sample_rate': 44100,
'samples_decoded': 661816,
'start_offset': 0,
'title': 'kln',
'version': 3.1499999999999999},
'tag': 0}
>>> song.identify(query_obj=qo)
[<song - Köln>]
>>>
"""
post, has_data, data = False, False, False
if filename:
if os.path.exists(filename):
query_obj = util.codegen(filename, start=codegen_start, duration=codegen_duration)
if query_obj is None:
raise Exception("The filename specified: %s could not be decoded." % filename)
else:
raise Exception("The filename specified: %s does not exist." % filename)
if query_obj and not isinstance(query_obj, list):
query_obj = [query_obj]
if filename:
# check codegen results from file in case we had a bad result
for q in query_obj:
if 'error' in q:
raise Exception(q['error'] + ": " + q.get('metadata', {}).get('filename', ''))
if not (filename or query_obj or code):
raise Exception("Not enough information to identify song.")
kwargs = {}
if code:
has_data = True
kwargs['code'] = code
if title:
kwargs['title'] = title
if release:
kwargs['release'] = release
if duration:
kwargs['duration'] = duration
if genre:
kwargs['genre'] = genre
if buckets:
kwargs['bucket'] = buckets
if version:
kwargs['version'] = version
if query_obj and any(query_obj):
has_data = True
data = {'query':json.dumps(query_obj)}
post = True
if has_data:
result = util.callm("%s/%s" % ('song', 'identify'), kwargs, POST=post, data=data)
return [Song(**util.fix(s_dict)) for s_dict in result['response'].get('songs',[])]
def get_current_jam(self):
jam = self.get_json_resource(self.id).get('jam')
if jam:
return Jam(**util.fix(jam))
else:
return None
def similar(names=None, ids=None, start=0, results=15, buckets=None, limit=False, max_familiarity=None, min_familiarity=None,
max_hotttnesss=None, min_hotttnesss=None, seed_catalog=None,artist_start_year_before=None, \
artist_start_year_after=None,artist_end_year_before=None,artist_end_year_after=None):
"""Return similar artists to this one
Args:
Kwargs:
ids (str/list): An artist id or list of ids
names (str/list): An artist name or list of names
results (int): An integer number of results to return
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
start (int): An integer starting value for the result set
max_familiarity (float): A float specifying the max familiarity of artists to search for
min_familiarity (float): A float specifying the min familiarity of artists to search for
max_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
min_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
seed_catalog (str): A string specifying the catalog similar artists are restricted to
Returns:
A list of similar Artist objects
Example:
>>> some_dudes = [artist.Artist('weezer'), artist.Artist('radiohead')]
>>> some_dudes
[<artist - Weezer>, <artist - Radiohead>]
>>> sims = artist.similar(ids=[art.id for art in some_dudes], results=5)
>>> sims
[<artist - The Smashing Pumpkins>, <artist - Biffy Clyro>, <artist - Death Cab for Cutie>, <artist - Jimmy Eat World>, <artist - Nerf Herder>]
>>>
"""
buckets = buckets or []
kwargs = {}
if ids:
if not isinstance(ids, list):
ids = [ids]
kwargs['id'] = ids
if names:
if not isinstance(names, list):
names = [names]
kwargs['name'] = names
if max_familiarity is not None:
kwargs['max_familiarity'] = max_familiarity
if min_familiarity is not None:
kwargs['min_familiarity'] = min_familiarity
if max_hotttnesss is not None:
kwargs['max_hotttnesss'] = max_hotttnesss
if min_hotttnesss is not None:
kwargs['min_hotttnesss'] = min_hotttnesss
if seed_catalog is not None:
kwargs['seed_catalog'] = seed_catalog
if start:
kwargs['start'] = start
if results:
kwargs['results'] = results
if buckets:
kwargs['bucket'] = buckets
if limit:
kwargs['limit'] = 'true'
if artist_start_year_before:
kwargs['artist_start_year_before'] = artist_start_year_before
if artist_start_year_after:
kwargs['artist_start_year_after'] = artist_start_year_after
if artist_end_year_before:
kwargs['artist_end_year_before'] = artist_end_year_before
if artist_end_year_after:
kwargs['artist_end_year_after'] = artist_end_year_after
result = util.callm("%s/%s" % ('artist', 'similar'), kwargs)
return [Artist(**util.fix(a_dict)) for a_dict in result['response']['artists']]
def get_suggested_users(results=10):
get_function = proxies.get_json_resource
raw = proxies.get_listed_things(get_function, "suggestedPeople", 'people', results)
return [TIMJUser(**util.fix(raw_person)) for raw_person in raw]
def from_user(cls, username):
raw_jam = proxies.get_json_resource(username).get('jam')
if raw_jam:
return cls(**util.fix(raw_jam))
else:
return None
def static(type='artist',
artist_pick='song_hotttnesss-desc',
variety=.5,
artist_id=None,
artist=None,
song_id=None,
track_id=None,
description=None,
style=None,
mood=None,
results=15,
max_tempo=None,
min_tempo=None,
max_duration=None,
min_duration=None,
max_loudness=None,
min_loudness=None,
max_danceability=None,
min_danceability=None,
max_energy=None,
min_energy=None,
artist_max_familiarity=None,
artist_min_familiarity=None,
artist_max_hotttnesss=None,
artist_min_hotttnesss=None,
song_max_hotttnesss=None,
song_min_hotttnesss=None,
min_longitude=None,
max_longitude=None,
min_latitude=None,
max_latitude=None,
adventurousness=0.2,
mode=None,
key=None,
buckets=None,
sort=None,
limit=False,
seed_catalog=None,
source_catalog=None,
rank_type=None,
test_new_things=None,
artist_start_year_after=None,
artist_start_year_before=None,
artist_end_year_after=None,
artist_end_year_before=None,
dmca=False,
distribution=None,
song_type=None,
genres=None):
"""Get a static playlist
Args:
Kwargs:
type (str): a string representing the playlist type ('artist', 'artist-radio', ...)
artist_pick (str): How songs should be chosen for each artist
variety (float): A number between 0 and 1 specifying the variety of the playlist
artist_id (str): the artist_id
artist (str): the name of an artist
song_id (str): the song_id
track_id (str): the track id
description (str): A string describing the artist and song
style (str): A string describing the style/genre of the artist and song
mood (str): A string describing the mood of the artist and song
results (int): An integer number of results to return
max_tempo (float): The max tempo of song results
min_tempo (float): The min tempo of song results
max_duration (float): The max duration of song results
min_duration (float): The min duration of song results
max_loudness (float): The max loudness of song results
min_loudness (float): The min loudness of song results
artist_max_familiarity (float): A float specifying the max familiarity of artists to search for
artist_min_familiarity (float): A float specifying the min familiarity of artists to search for
artist_max_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
artist_min_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
song_max_hotttnesss (float): A float specifying the max hotttnesss of songs to search for
song_min_hotttnesss (float): A float specifying the max hotttnesss of songs to search for
max_energy (float): The max energy of song results
min_energy (float): The min energy of song results
max_danceability (float): The max danceability of song results
min_danceability (float): The min danceability of song results
mode (int): 0 or 1 (minor or major)
key (int): 0-11 (c, c-sharp, d, e-flat, e, f, f-sharp, g, a-flat, a, b-flat, b)
max_latitude (float): A float specifying the max latitude of artists to search for
min_latitude (float): A float specifying the min latitude of artists to search for
max_longitude (float): A float specifying the max longitude of artists to search for
min_longitude (float): A float specifying the min longitude of artists to search for
adventurousness (float): A float ranging from 0 for old favorites to 1.0 for unheard music according to a seed_catalog
sort (str): A string indicating an attribute and order for sorting the results
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
seed_catalog (str or Catalog): An Artist Catalog object or Artist Catalog id to use as a seed
source_catalog (str or Catalog): A Catalog object or catalog id
rank_type (str): A string denoting the desired ranking for description searches, either 'relevance' or 'familiarity'
artist_start_year_before (int): Returned song's artists will have started recording music before this year.
artist_start_year_after (int): Returned song's artists will have started recording music after this year.
artist_end_year_before (int): Returned song's artists will have stopped recording music before this year.
artist_end_year_after (int): Returned song's artists will have stopped recording music after this year.
distribution (str): Affects the range of artists returned and how many songs each artist will have in the playlist relative to how similar they are to the seed. (wandering, focused)
song_type (str): A string or list of strings of the type of songs allowed. The only valid song type at the moment is 'christmas'.
Valid formats are 'song_type', 'song_type:true', 'song_type:false', or 'song_type:any'.
Returns:
A list of Song objects
Example:
>>> p = playlist.static(type='artist-radio', artist=['ida maria', 'florence + the machine'])
>>> p
[<song - Pickpocket>,
<song - Self-Taught Learner>,
<song - Maps>,
<song - Window Blues>,
<song - That's Not My Name>,
<song - My Lover Will Go>,
<song - Home Sweet Home>,
<song - Stella & God>,
<song - Don't You Want To Share The Guilt?>,
<song - Forget About It>,
<song - Dull Life>,
<song - This Trumpet In My Head>,
<song - Keep Your Head>,
<song - One More Time>,
<song - Knights in Mountain Fox Jackets>]
>>>
"""
limit = str(limit).lower()
if seed_catalog and isinstance(seed_catalog, catalog.Catalog):
seed_catalog = seed_catalog.id
if source_catalog and isinstance(source_catalog, catalog.Catalog):
source_catalog = source_catalog.id
dmca = str(dmca).lower()
kwargs = locals()
kwargs['bucket'] = kwargs['buckets'] or []
del kwargs['buckets']
kwargs['genre'] = kwargs['genres']
del kwargs['genres']
result = util.callm("%s/%s" % ('playlist', 'static'), kwargs)
return [Song(**util.fix(s_dict)) for s_dict in result['response']['songs']]
def _search_users_by(by, q, results):
get_function = proxies.get_json_resource
raw = proxies.get_listed_things(get_function, "search/person", 'people', results, by=by, q=q)
return [TIMJUser(**util.fix(raw_person)) for raw_person in raw]
def extract(text='', start=0, results=15, buckets=None, limit=False, max_familiarity=None, min_familiarity=None,
max_hotttnesss=None, min_hotttnesss=None, sort=None):
"""Extract artist names from a block of text.
Args:
Kwargs:
text (str): The text to extract artists from
start (int): An integer starting value for the result set
results (int): An integer number of results to return
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
max_familiarity (float): A float specifying the max familiarity of artists to search for
min_familiarity (float): A float specifying the min familiarity of artists to search for
max_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
min_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
Returns:
A list of Artist objects
Example:
>>> results = artist.extract(text='i saw beyonce at burger king, she was eatin, she was eatin')
>>> results
>>>
"""
buckets = buckets or []
kwargs = {}
kwargs['text'] = text
if max_familiarity is not None:
kwargs['max_familiarity'] = max_familiarity
if min_familiarity is not None:
kwargs['min_familiarity'] = min_familiarity
if max_hotttnesss is not None:
kwargs['max_hotttnesss'] = max_hotttnesss
if min_hotttnesss is not None:
kwargs['min_hotttnesss'] = min_hotttnesss
if start:
kwargs['start'] = start
if results:
kwargs['results'] = results
if buckets:
kwargs['bucket'] = buckets
if limit:
kwargs['limit'] = 'true'
if sort:
kwargs['sort'] = sort
result = util.callm("%s/%s" % ('artist', 'extract'), kwargs)
return [Artist(**util.fix(a_dict)) for a_dict in result['response']['artists']]
def thrust(power, alt, rmach):
'thrust lookup-table version'
a = np.array([[1060, 670, 880, 1140, 1500, 1860], \
[635, 425, 690, 1010, 1330, 1700], \
[60, 25, 345, 755, 1130, 1525], \
[-1020, -170, -300, 350, 910, 1360], \
[-2700, -1900, -1300, -247, 600, 1100], \
[-3600, -1400, -595, -342, -200, 700]], dtype=float).T
b = np.array([[12680, 9150, 6200, 3950, 2450, 1400], \
[12680, 9150, 6313, 4040, 2470, 1400], \
[12610, 9312, 6610, 4290, 2600, 1560], \
[12640, 9839, 7090, 4660, 2840, 1660], \
[12390, 10176, 7750, 5320, 3250, 1930], \
[11680, 9848, 8050, 6100, 3800, 2310]], dtype=float).T
c = np.array([[20000, 15000, 10800, 7000, 4000, 2500], \
[21420, 15700, 11225, 7323, 4435, 2600], \
[22700, 16860, 12250, 8154, 5000, 2835], \
[24240, 18910, 13760, 9285, 5700, 3215], \
[26070, 21075, 15975, 11115, 6860, 3950], \
[28886, 23319, 18300, 13484, 8642, 5057]], dtype=float).T
if alt < 0:
alt = 0.01 # uh, why not 0?
h = .0001 * alt
i = fix(h)
if i >= 5:
i = 4
dh = h - i
rm = 5 * rmach
m = fix(rm)
if m >= 5:
m = 4
elif m <= 0:
m = 0
dm = rm - m
cdh = 1 - dh
# do not increment these, since python is 0-indexed while matlab is 1-indexed
#i = i + 1
#m = m + 1
s = b[i, m] * cdh + b[i + 1, m] * dh
t = b[i, m + 1] * cdh + b[i + 1, m + 1] * dh
tmil = s + (t - s) * dm
if power < 50:
s = a[i, m] * cdh + a[i + 1, m] * dh
t = a[i, m + 1] * cdh + a[i + 1, m + 1] * dh
tidl = s + (t - s) * dm
thrst = tidl + (tmil - tidl) * power * .02
else:
s = c[i, m] * cdh + c[i + 1, m] * dh
t = c[i, m + 1] * cdh + c[i + 1, m + 1] * dh
tmax = s + (t - s) * dm
thrst = tmil + (tmax - tmil) * (power - 50) * .02
return thrst
def get_likes(self, results=10):
users_who_liked = self._get_listed_things('likes', 'people', results)
return [TIMJUser(**util.fix(raw_person)) for raw_person in users_who_liked]
def search(title=None, artist=None, artist_id=None, combined=None, description=None, results=None, start=None, max_tempo=None, \
min_tempo=None, max_duration=None, min_duration=None, max_loudness=None, min_loudness=None, \
artist_max_familiarity=None, artist_min_familiarity=None, artist_max_hotttnesss=None, \
artist_min_hotttnesss=None, song_max_hotttnesss=None, song_min_hotttnesss=None, mode=None, \
min_energy=None, max_energy=None, min_danceability=None, max_danceability=None, \
key=None, max_latitude=None, min_latitude=None, max_longitude=None, min_longitude=None, \
sort=None, buckets = None, limit=False):
"""Search for songs by name, description, or constraint.
Args:
Kwargs:
title (str): the name of a song
artist (str): the name of an artist
artist_id (str): the artist_id
combined (str): the artist name and song title
description (str): A string describing the artist and song
results (int): An integer number of results to return
max_tempo (float): The max tempo of song results
min_tempo (float): The min tempo of song results
max_duration (float): The max duration of song results
min_duration (float): The min duration of song results
max_loudness (float): The max loudness of song results
min_loudness (float): The min loudness of song results
artist_max_familiarity (float): A float specifying the max familiarity of artists to search for
artist_min_familiarity (float): A float specifying the min familiarity of artists to search for
artist_max_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
artist_min_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
song_max_hotttnesss (float): A float specifying the max hotttnesss of songs to search for
song_min_hotttnesss (float): A float specifying the max hotttnesss of songs to search for
max_energy (float): The max energy of song results
min_energy (float): The min energy of song results
max_dancibility (float): The max dancibility of song results
min_dancibility (float): The min dancibility of song results
mode (int): 0 or 1 (minor or major)
key (int): 0-11 (c, c-sharp, d, e-flat, e, f, f-sharp, g, a-flat, a, b-flat, b)
max_latitude (float): A float specifying the max latitude of artists to search for
min_latitude (float): A float specifying the min latitude of artists to search for
max_longitude (float): A float specifying the max longitude of artists to search for
min_longitude (float): A float specifying the min longitude of artists to search for
sort (str): A string indicating an attribute and order for sorting the results
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
Returns:
A list of Song objects
Example:
>>> results = song.search(artist='shakira', title='she wolf', buckets=['id:7digital', 'tracks'], limit=True, results=1)
>>> results
[<song - She Wolf>]
>>> results[0].get_tracks('7digital')[0]
{u'catalog': u'7digital',
u'foreign_id': u'7digital:track:7854109',
u'id': u'TRTOBSE12903CACEC4',
u'preview_url': u'http://previews.7digital.com/clips/34/7854109.clip.mp3',
u'release_image': u'http://cdn.7static.com/static/img/sleeveart/00/007/081/0000708184_200.jpg'}
>>>
"""
kwargs = {}
if title:
kwargs['title'] = title
if artist:
kwargs['artist'] = artist
if artist_id:
kwargs['artist_id'] = artist_id
if combined:
kwargs['combined'] = combined
if description:
kwargs['description'] = description
if results is not None:
kwargs['results'] = results
if start is not None:
kwargs['start'] = start
if max_tempo is not None:
kwargs['max_tempo'] = max_tempo
if min_tempo is not None:
kwargs['min_tempo'] = min_tempo
if max_duration is not None:
kwargs['max_duration'] = max_duration
if min_duration is not None:
kwargs['min_duration'] = min_duration
if max_loudness is not None:
kwargs['max_loudness'] = max_loudness
if min_loudness is not None:
kwargs['min_loudness'] = min_loudness
if artist_max_familiarity is not None:
kwargs['artist_max_familiarity'] = artist_max_familiarity
if artist_min_familiarity is not None:
kwargs['artist_min_familiarity'] = artist_min_familiarity
if artist_max_hotttnesss is not None:
kwargs['artist_max_hotttnesss'] = artist_max_hotttnesss
if artist_min_hotttnesss is not None:
kwargs['artist_min_hotttnesss'] = artist_min_hotttnesss
if song_max_hotttnesss is not None:
kwargs['song_max_hotttnesss'] = song_max_hotttnesss
if song_min_hotttnesss is not None:
kwargs['song_min_hotttnesss'] = song_min_hotttnesss
if min_danceability is not None:
kwargs['min_danceability'] = min_danceability
if max_danceability is not None:
kwargs['max_danceability'] = max_danceability
if max_energy is not None:
kwargs['max_energy'] = max_energy
if max_energy is not None:
kwargs['max_energy'] = max_energy
if mode is not None:
kwargs['mode'] = mode
if key is not None:
kwargs['key'] = key
if max_latitude is not None:
kwargs['max_latitude'] = max_latitude
if min_latitude is not None:
kwargs['min_latitude'] = min_latitude
if max_longitude is not None:
kwargs['max_longitude'] = max_longitude
if min_longitude is not None:
kwargs['min_longitude'] = min_longitude
if sort:
kwargs['sort'] = sort
if buckets:
kwargs['bucket'] = buckets
if limit:
kwargs['limit'] = 'true'
result = util.callm("%s/%s" % ('song', 'search'), kwargs)
return [Song(**util.fix(s_dict)) for s_dict in result['response']['songs']]
def static(type='artist', artist_pick='song_hotttnesss-desc', variety=.5, artist_id=None, artist=None, \
song_id=None, track_id=None, description=None, style=None, mood=None, \
results=15, max_tempo=None, min_tempo=None, max_duration=None, \
min_duration=None, max_loudness=None, min_loudness=None, max_danceability=None, min_danceability=None, \
max_energy=None, min_energy=None, artist_max_familiarity=None, artist_min_familiarity=None, \
artist_max_hotttnesss=None, artist_min_hotttnesss=None, song_max_hotttnesss=None, song_min_hotttnesss=None, \
min_longitude=None, max_longitude=None, min_latitude=None, max_latitude=None, adventurousness=0.2, \
mode=None, key=None, buckets=[], sort=None, limit=False, seed_catalog=None, source_catalog=None, rank_type=None, test_new_things=None,
artist_start_year_after=None, artist_start_year_before=None, artist_end_year_after=None, artist_end_year_before=None,dmca=False, distribution=None):
"""Get a static playlist
Args:
Kwargs:
type (str): a string representing the playlist type ('artist', 'artist-radio', ...)
artist_pick (str): How songs should be chosen for each artist
variety (float): A number between 0 and 1 specifying the variety of the playlist
artist_id (str): the artist_id
artist (str): the name of an artist
song_id (str): the song_id
track_id (str): the track id
description (str): A string describing the artist and song
style (str): A string describing the style/genre of the artist and song
mood (str): A string describing the mood of the artist and song
results (int): An integer number of results to return
max_tempo (float): The max tempo of song results
min_tempo (float): The min tempo of song results
max_duration (float): The max duration of song results
min_duration (float): The min duration of song results
max_loudness (float): The max loudness of song results
min_loudness (float): The min loudness of song results
artist_max_familiarity (float): A float specifying the max familiarity of artists to search for
artist_min_familiarity (float): A float specifying the min familiarity of artists to search for
artist_max_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
artist_min_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
song_max_hotttnesss (float): A float specifying the max hotttnesss of songs to search for
song_min_hotttnesss (float): A float specifying the max hotttnesss of songs to search for
max_energy (float): The max energy of song results
min_energy (float): The min energy of song results
max_dancibility (float): The max dancibility of song results
min_dancibility (float): The min dancibility of song results
mode (int): 0 or 1 (minor or major)
key (int): 0-11 (c, c-sharp, d, e-flat, e, f, f-sharp, g, a-flat, a, b-flat, b)
max_latitude (float): A float specifying the max latitude of artists to search for
min_latitude (float): A float specifying the min latitude of artists to search for
max_longitude (float): A float specifying the max longitude of artists to search for
min_longitude (float): A float specifying the min longitude of artists to search for
adventurousness (float): A float ranging from 0 for old favorites to 1.0 for unheard music according to a seed_catalog
sort (str): A string indicating an attribute and order for sorting the results
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
seed_catalog (str or Catalog): An Artist Catalog object or Artist Catalog id to use as a seed
source_catalog (str or Catalog): A Catalog object or catalog id
rank_type (str): A string denoting the desired ranking for description searches, either 'relevance' or 'familiarity'
artist_start_year_before (int): Returned songs's artists will have started recording music before this year.
artist_start_year_after (int): Returned songs's artists will have started recording music after this year.
artist_end_year_before (int): Returned songs's artists will have stopped recording music before this year.
artist_end_year_after (int): Returned songs's artists will have stopped recording music after this year.
distribution (str): Affects the range of artists returned and how many songs each artsits will have in the playlist realative to how similar they are to the seed. (wandering, focused)
Returns:
A list of Song objects
Example:
>>> p = playlist.static(type='artist-radio', artist=['ida maria', 'florence + the machine'])
>>> p
[<song - Pickpocket>,
<song - Self-Taught Learner>,
<song - Maps>,
<song - Window Blues>,
<song - That's Not My Name>,
<song - My Lover Will Go>,
<song - Home Sweet Home>,
<song - Stella & God>,
<song - Don't You Want To Share The Guilt?>,
<song - Forget About It>,
<song - Dull Life>,
<song - This Trumpet In My Head>,
<song - Keep Your Head>,
<song - One More Time>,
<song - Knights in Mountain Fox Jackets>]
>>>
"""
limit = str(limit).lower()
if seed_catalog and isinstance(seed_catalog, catalog.Catalog):
seed_catalog = seed_catalog.id
if source_catalog and isinstance(source_catalog, catalog.Catalog):
source_catalog = source_catalog.id
dmca = str(dmca).lower()
kwargs = locals()
kwargs['bucket'] = kwargs['buckets']
del kwargs['buckets']
result = util.callm("%s/%s" % ('playlist', 'static'), kwargs)
return [Song(**util.fix(s_dict)) for s_dict in result['response']['songs']]
def search(name=None, description=None, results=15, buckets=None, limit=False, \
fuzzy_match=False, sort=None, max_familiarity=None, min_familiarity=None, \
max_hotttnesss=None, min_hotttnesss=None):
"""Search for artists by name, description, or constraint.
Args:
Kwargs:
name (str): the name of an artist
description (str): A string describing the artist
results (int): An integer number of results to return
buckets (list): A list of strings specifying which buckets to retrieve
limit (bool): A boolean indicating whether or not to limit the results to one of the id spaces specified in buckets
fuzzy_match (bool): A boolean indicating whether or not to search for similar sounding matches (only works with name)
max_familiarity (float): A float specifying the max familiarity of artists to search for
min_familiarity (float): A float specifying the min familiarity of artists to search for
max_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
min_hotttnesss (float): A float specifying the max hotttnesss of artists to search for
Returns:
A list of Artist objects
Example:
>>> results = artist.search(name='t-pain')
>>> results
[<artist - T-Pain>, <artist - T-Pain & Lil Wayne>, <artist - T Pain & 2 Pistols>, <artist - Roscoe Dash & T-Pain>, <artist - Tony Moxberg & T-Pain>, <artist - Flo-Rida (feat. T-Pain)>, <artist - Shortyo/Too Short/T-Pain>]
>>>
"""
buckets = buckets or []
kwargs = {}
if name:
kwargs['name'] = name
if description:
kwargs['description'] = description
if results:
kwargs['results'] = results
if buckets:
kwargs['bucket'] = buckets
if limit:
kwargs['limit'] = 'true'
if fuzzy_match:
kwargs['fuzzy_match'] = 'true'
if max_familiarity is not None:
kwargs['max_familiarity'] = max_familiarity
if min_familiarity is not None:
kwargs['min_familiarity'] = min_familiarity
if max_hotttnesss is not None:
kwargs['max_hotttnesss'] = max_hotttnesss
if min_hotttnesss is not None:
kwargs['min_hotttnesss'] = min_hotttnesss
if sort:
kwargs['sort'] = sort
"""Search for artists"""
result = util.callm("%s/%s" % ('artist', 'search'), kwargs)
return [Artist(**util.fix(a_dict)) for a_dict in result['response']['artists']]