1 # An improved, structured jamendo API for the N900 with cacheing
2 # Image / cover downloads.. and more?
3 import urllib, threading, os, gzip, time, simplejson, re
5 #if util.platform == 'maemo':
6 # _CACHEDIR = os.path.expanduser('''~/MyDocs/.jamaendo''')
8 # _CACHEDIR = os.path.expanduser('''~/.cache/jamaendo''')
10 _CACHEDIR = None#'/tmp/jamaendo'
11 _COVERDIR = None#os.path.join(_CACHEDIR, 'covers')
12 _GET2 = '''http://api.jamendo.com/get2/'''
13 _MP3URL = _GET2+'stream/track/redirect/?id=%d&streamencoding=mp31'
14 _OGGURL = _GET2+'stream/track/redirect/?id=%d&streamencoding=ogg2'
17 def set_cache_dir(cachedir):
21 _COVERDIR = os.path.join(_CACHEDIR, 'covers')
24 os.makedirs(_CACHEDIR)
29 os.makedirs(_COVERDIR)
33 # These classes can be partially constructed,
34 # and if asked for a property they don't know,
35 # makes a query internally to get the full story
37 _ARTIST_FIELDS = ['id', 'name', 'image']
38 _ALBUM_FIELDS = ['id', 'name', 'image', 'artist_name', 'artist_id']
39 _TRACK_FIELDS = ['id', 'name', 'image', 'artist_name', 'album_name', 'album_id', 'numalbum', 'duration']
40 _RADIO_FIELDS = ['id', 'name', 'idstr', 'image']
42 class LazyQuery(object):
43 def set_from_json(self, json):
44 for key, value in json.iteritems():
46 assert(self.ID == int(value))
48 if key.endswith('_id'):
50 setattr(self, key, value)
53 """Not automatic for now,
54 will have to do artist.load()
56 This is filled in further down
61 def _needs_load(self):
64 def _set_from(self, other):
67 def _needs_load_impl(self, *attrs):
69 if getattr(self, attr) is None:
73 def _set_from_impl(self, other, *attrs):
75 self._set_if(other, attr)
77 def _set_if(self, other, attrname):
78 if getattr(self, attrname) is None and getattr(other, attrname) is not None:
79 setattr(self, attrname, getattr(other, attrname))
83 return u"%s(%s)"%(self.__class__.__name__,
84 u", ".join(repr(v) for k,v in self.__dict__.iteritems() if not k.startswith('_')))
85 except UnicodeEncodeError:
88 return u"%s(?)"%(self.__class__.__name__)
90 class Artist(LazyQuery):
91 def __init__(self, ID, json=None):
95 self.albums = None # None means not downloaded
97 self.set_from_json(json)
99 def _needs_load(self):
100 return self._needs_load_impl('name', 'albums')
102 def _set_from(self, other):
103 return self._set_from_impl(other, 'name', 'image', 'albums')
105 class Album(LazyQuery):
106 def __init__(self, ID, json=None):
110 self.artist_name = None
111 self.artist_id = None
112 self.tracks = None # None means not downloaded
114 self.set_from_json(json)
116 def _needs_load(self):
117 return self._needs_load_impl('name', 'image', 'artist_name', 'artist_id', 'tracks')
119 def _set_from(self, other):
120 return self._set_from_impl(other, 'name', 'image', 'artist_name', 'artist_id', 'tracks')
122 class Track(LazyQuery):
123 def __init__(self, ID, json=None):
127 self.artist_name = None
128 self.album_name = None
133 self.set_from_json(json)
136 return _MP3URL%(self.ID)
139 return _OGGURL%(self.ID)
141 def _needs_load(self):
142 return self._needs_load_impl('name', 'artist_name', 'album_name', 'album_id', 'numalbum', 'duration')
144 def _set_from(self, other):
145 return self._set_from_impl(other, 'name', 'image', 'artist_name', 'album_name', 'album_id', 'numalbum', 'duration')
147 class Radio(LazyQuery):
148 def __init__(self, ID, json=None):
154 self.set_from_json(json)
156 def _needs_load(self):
157 return self._needs_load_impl('name', 'idstr', 'image')
159 def _set_from(self, other):
160 return self._set_from_impl(other, 'name', 'idstr', 'image')
163 _artists = {} # id -> Artist()
164 _albums = {} # id -> Album()
165 _tracks = {} # id -> Track()
166 _radios = {} # id -> Radio()
169 # cache sizes per session (TODO)
170 _CACHED_ARTISTS = 100
175 # TODO: cache queries?
178 rate_limit = 1.0 # max queries per second
179 last_query = time.time() - 1.5
184 if now - cls.last_query < cls.rate_limit:
185 time.sleep(cls.rate_limit - (now - cls.last_query))
191 def _geturl(self, url):
192 print "*** %s" % (url)
194 f = urllib.urlopen(url)
195 ret = simplejson.load(f)
200 return "#%s" % (self.__class__.__name__)
205 class CoverCache(object):
207 cache and fetch covers
208 TODO: background thread that
209 fetches and returns covers,
213 self._covers = {} # (albumid, size) -> file
214 coverdir = _COVERDIR if _COVERDIR else '/tmp'
215 if os.path.isdir(coverdir):
216 covermatch = re.compile(r'(\d+)\-(\d+)\.jpg')
217 for fil in os.listdir(coverdir):
218 fl = os.path.join(coverdir, fil)
219 m = covermatch.match(fil)
220 if m and os.path.isfile(fl):
221 self._covers[(int(m.group(1)), int(m.group(2)))] = fl
223 def fetch_cover(self, albumid, size):
224 Query._ratelimit() # ratelimit cover fetching too?
225 coverdir = _COVERDIR if _COVERDIR else '/tmp'
226 to = os.path.join(coverdir, '%d-%d.jpg'%(albumid, size))
227 if not os.path.isfile(to):
228 url = _GET2+'image/album/redirect/?id=%d&imagesize=%d'%(albumid, size)
229 urllib.urlretrieve(url, to)
230 self._covers[(albumid, size)] = to
233 def get_cover(self, albumid, size):
234 cover = self._covers.get((albumid, size), None)
236 cover = self.fetch_cover(albumid, size)
239 def get_async(self, albumid, size, cb):
240 cover = self._covers.get((albumid, size), None)
245 cover = self.fetch_cover(albumid, size)
248 _cover_cache = CoverCache()
250 def get_album_cover(albumid, size=200):
251 return _cover_cache.get_cover(albumid, size)
253 def get_album_cover_async(cb, albumid, size=200):
254 _cover_cache.get_async(albumid, size, cb)
256 class CustomQuery(Query):
257 def __init__(self, url):
262 return self._geturl(self.url)
267 class GetQuery(Query):
270 'url' : _GET2+'+'.join(_ARTIST_FIELDS)+'/artist/json/?',
271 'params' : 'artist_id=%d',
272 'constructor' : Artist
275 'url' : _GET2+'+'.join(_ALBUM_FIELDS)+'/album/json/?',
276 'params' : 'album_id=%d',
277 'constructor' : Album
280 'url' : _GET2+'+'.join(_ALBUM_FIELDS)+'/album/json/?',
281 'params' : 'artist_id=%d',
282 'constructor' : [Album]
285 'url' : _GET2+'+'.join(_TRACK_FIELDS)+'/track/json/track_album+album_artist?',
287 'constructor' : Track
290 'url' : _GET2+'+'.join(_TRACK_FIELDS)+'/track/json/track_album+album_artist?',
291 'params' : 'album_id=%d',
292 'constructor' : [Track]
295 'url' : _GET2+'+'.join(_TRACK_FIELDS)+'/track/json/radio_track_inradioplaylist+track_album+album_artist/?',
296 'params' : 'order=random_asc&radio_id=%d',
297 'constructor' : [Track]
299 'favorite_albums' : {
300 'url' : _GET2+'+'.join(_ALBUM_FIELDS)+'/album/json/album_user_starred/?',
301 'params' : 'user_idstr=%s',
302 'constructor' : [Album]
304 #http://api.jamendo.com/get2/id+name+url+image+artist_name/album/jsonpretty/album_user_starred/?user_idstr=sylvinus&n=all
305 #q = SearchQuery('album', user_idstr=user)
308 #http://api.jamendo.com/get2/id+name+image+artist_name+album_name+album_id+numalbum+duration/track/json/radio_track_inradioplaylist+track_album+album_artist/?order=numradio_asc&radio_id=283
310 def __init__(self, what, ID):
313 info = GetQuery.queries[what]
314 self.url = info['url']
315 self.params = info['params']
316 self.constructor = info['constructor']
318 def construct(self, data):
319 constructor = self.constructor
320 if isinstance(constructor, list):
321 constructor = constructor[0]
322 if isinstance(data, list):
323 return [constructor(int(x['id']), json=x) for x in data]
325 return constructor(int(data['id']), json=data)
328 js = self._geturl(self.url + self.params % (self.ID))
331 return self.construct(js)
334 return self.url + self.params % (self.ID)
336 class SearchQuery(GetQuery):
337 def __init__(self, what, query=None, order=None, user=None, count=10):
338 GetQuery.__init__(self, what, None)
347 params['searchquery'] = self.query
349 params['order'] = self.order
351 params['n'] = self.count
353 params['user_idstr'] = self.user
354 js = self._geturl(self.url + urllib.urlencode(params))
357 return self.construct(js)
360 params = {'searchquery':self.query, 'order':self.order, 'n':self.count}
361 return self.url + urllib.urlencode(params)
363 class JamendoAPIException(Exception):
364 def __init__(self, url):
365 Exception.__init__(url)
367 def _update_cache(cache, new_items):
368 if not isinstance(new_items, list):
369 new_items = [new_items]
370 for item in new_items:
371 old = cache.get(item.ID)
375 cache[item.ID] = item
377 def get_artist(artist_id):
378 """Returns: Artist"""
379 a = _artists.get(artist_id, None)
381 q = GetQuery('artist', artist_id)
384 raise JamendoAPIException(str(q))
385 _update_cache(_artists, a)
386 if isinstance(a, list):
390 def get_albums(artist_id):
391 """Returns: [Album]"""
392 q = GetQuery('albums', artist_id)
395 raise JamendoAPIException(str(q))
396 _update_cache(_artists, a)
399 def get_album(album_id):
401 a = _albums.get(album_id, None)
403 q = GetQuery('album', album_id)
406 raise JamendoAPIException(str(q))
407 _update_cache(_albums, a)
408 if isinstance(a, list):
412 def get_tracks(album_id):
413 """Returns: [Track]"""
414 q = GetQuery('tracks', album_id)
417 raise JamendoAPIException(str(q))
418 _update_cache(_tracks, a)
421 def get_track(track_id):
423 a = _tracks.get(track_id, None)
425 q = GetQuery('track', track_id)
428 raise JamendoAPIException(str(q))
429 _update_cache(_tracks, a)
430 if isinstance(a, list):
434 def get_radio_tracks(radio_id):
435 """Returns: [Track]"""
436 q = GetQuery('radio', radio_id)
439 raise JamendoAPIException(str(q))
440 _update_cache(_tracks, a)
443 def search_artists(query):
444 """Returns: [Artist]"""
445 q = SearchQuery('artist', query, 'searchweight_desc')
448 raise JamendoAPIException(str(q))
449 _update_cache(_artists, a)
452 def search_albums(query):
453 """Returns: [Album]"""
454 q = SearchQuery('album', query, 'searchweight_desc')
457 raise JamendoAPIException(str(q))
458 _update_cache(_albums, a)
461 def search_tracks(query):
462 """Returns: [Track]"""
463 q = SearchQuery('track', query=query, order='searchweight_desc')
466 raise JamendoAPIException(str(q))
467 _update_cache(_tracks, a)
470 def albums_of_the_week():
471 """Returns: [Album]"""
472 q = SearchQuery('album', order='ratingweek_desc')
475 raise JamendoAPIException(str(q))
476 _update_cache(_albums, a)
480 """Returns: [Track] (playlist)"""
481 q = SearchQuery('track', order='releasedate_desc')
484 raise JamendoAPIException(str(q))
485 _update_cache(_tracks, a)
488 def tracks_of_the_week():
489 """Returns: [Track] (playlist)"""
490 q = SearchQuery('track', order='ratingweek_desc')
493 raise JamendoAPIException(str(q))
494 _update_cache(_tracks, a)
497 def get_radio(radio_id):
499 q = CustomQuery(_GET2+"id+name+idstr+image/radio/json?id=%d"%(radio_id))
502 raise JamendoAPIException(str(q))
503 if isinstance(js, list):
505 return Radio(radio_id, json=js)
507 def starred_radios():
508 """Returns: [Radio]"""
509 q = CustomQuery(_GET2+"id+name+idstr+image/radio/json?order=starred_desc")
512 raise JamendoAPIException(str(q))
513 return [Radio(int(radio['id']), json=radio) for radio in js]
515 def favorite_albums(user):
516 """Returns: [Album]"""
517 q = SearchQuery('favorite_albums', user=user, count=20)
520 raise JamendoAPIException(str(q))
521 _update_cache(_albums, a)
524 ### Set loader functions for classes
526 def _artist_loader(self):
527 if self._needs_load():
528 artist = get_artist(self.ID)
529 self._set_from(artist)
530 Artist.load = _artist_loader
532 def _album_loader(self):
533 if self._needs_load():
534 album = get_album(self.ID)
535 album.tracks = get_tracks(self.ID)
536 self._set_from(album)
537 Album.load = _album_loader
539 def _track_loader(self):
540 track = get_track(self.ID)
541 self._set_from(track)
542 Track.load = _track_loader
544 def _radio_loader(self):
545 radio = get_radio(self.ID)
546 self._set_from(radio)
547 Radio.load = _radio_loader