3 # This file is part of Jamaendo.
4 # Copyright (c) 2010, Kristoffer Gronlund
7 # Redistribution and use in source and binary forms, with or without
8 # modification, are permitted provided that the following conditions are met:
9 # * Redistributions of source code must retain the above copyright
10 # notice, this list of conditions and the following disclaimer.
12 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
13 # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
14 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
15 # DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
16 # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
17 # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
18 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
19 # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
20 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
21 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 # An improved, structured jamendo API wrapper for the N900 with cacheing
24 # Image / cover downloads.. and more?
25 import urllib, threading, os, time, simplejson, re
26 import logging, hashlib
30 _GET2 = '''http://api.jamendo.com/get2/'''
31 _MP3URL = _GET2+'stream/track/redirect/?id=%d&streamencoding=mp31'
32 _OGGURL = _GET2+'stream/track/redirect/?id=%d&streamencoding=ogg2'
33 _TORRENTURL = _GET2+'bittorrent/file/redirect/?album_id=%d&type=archive&class=mp32'
36 log = logging.getLogger(__name__)
38 class StdoutLogger(object):
39 def info(self, s, *args):
41 def debug(self, s, *args):
45 # These classes can be partially constructed,
46 # and if asked for a property they don't know,
47 # makes a query internally to get the full story
49 _ARTIST_FIELDS = ['id', 'name', 'image']
50 _ALBUM_FIELDS = ['id', 'name', 'image', 'artist_name', 'artist_id', 'license_url']
51 _TRACK_FIELDS = ['id', 'name', 'album_image', 'artist_id', 'artist_name', 'album_name', 'album_id', 'numalbum', 'duration']
52 _RADIO_FIELDS = ['id', 'name', 'idstr', 'image']
53 _TAG_FIELDS = ['id', 'name']
55 class LazyQuery(object):
56 def set_from_json(self, json):
57 for key, value in json.iteritems():
59 assert(self.ID == int(value))
61 if key.endswith('_id'):
63 setattr(self, key, value)
66 """Not automatic for now,
67 will have to do artist.load()
69 This is filled in further down
74 def _needs_load(self):
77 def _set_from(self, other):
80 def _needs_load_impl(self, *attrs):
82 if getattr(self, attr) is None:
86 def _set_from_impl(self, other, *attrs):
88 self._set_if(other, attr)
90 def _set_if(self, other, attrname):
91 if getattr(self, attrname) is None and getattr(other, attrname) is not None:
92 setattr(self, attrname, getattr(other, attrname))
96 return u"%s(%s)"%(self.__class__.__name__,
97 u", ".join(("%s:%s"%(k,repr(v))) for k,v in self.__dict__.iteritems() if not k.startswith('_')))
98 except UnicodeEncodeError:
100 #traceback.print_exc()
101 return u"%s(?)"%(self.__class__.__name__)
103 class Artist(LazyQuery):
104 def __init__(self, ID, json=None):
108 self.albums = None # None means not downloaded
110 self.set_from_json(json)
112 def _needs_load(self):
113 return self._needs_load_impl('name', 'albums')
115 def _set_from(self, other):
116 return self._set_from_impl(other, 'name', 'image', 'albums')
118 class Album(LazyQuery):
119 def __init__(self, ID, json=None):
123 self.artist_name = None
124 self.artist_id = None
125 self.license_url = None
126 self.tracks = None # None means not downloaded
128 self.set_from_json(json)
130 def torrent_url(self):
131 return _TORRENTURL%(self.ID)
134 def _needs_load(self):
135 return self._needs_load_impl('name', 'image', 'artist_name', 'artist_id', 'license_url', 'tracks')
137 def _set_from(self, other):
138 return self._set_from_impl(other, 'name', 'image', 'artist_name', 'artist_id', 'license_url', 'tracks')
140 class Track(LazyQuery):
141 def __init__(self, ID, json=None):
144 self.artist_id = None
145 self.artist_name = None
146 self.album_image = None
147 self.album_name = None
152 self.set_from_json(json)
155 return _MP3URL%(self.ID)
158 return _OGGURL%(self.ID)
160 def _needs_load(self):
161 return self._needs_load_impl('name', 'artist_name', 'artist_id', 'album_name', 'album_id', 'numalbum', 'duration')
163 def _set_from(self, other):
164 return self._set_from_impl(other, 'name', 'album_image', 'artist_name', 'artist_id', 'album_name', 'album_id', 'numalbum', 'duration')
166 class Radio(LazyQuery):
167 def __init__(self, ID, json=None):
173 self.set_from_json(json)
175 def _needs_load(self):
176 return self._needs_load_impl('name', 'idstr', 'image')
178 def _set_from(self, other):
179 return self._set_from_impl(other, 'name', 'idstr', 'image')
181 class Tag(LazyQuery):
182 def __init__(self, ID, json=None):
186 self.set_from_json(json)
188 def _needs_load(self):
189 return self._needs_load_impl('name')
191 def _set_from(self, other):
192 return self._set_from_impl(other, 'name')
194 _artists = {} # id -> Artist()
195 _albums = {} # id -> Album()
196 _tracks = {} # id -> Track()
197 _radios = {} # id -> Radio()
200 # cache sizes per session (TODO)
201 _CACHED_ARTISTS = 100
205 # cache sizes, persistant
206 _CACHED_COVERS = 2048
208 # TODO: cache queries?
211 rate_limit = 1.1 # seconds between queries
212 last_query = time.time() - 1.5
217 if now - cls.last_query < cls.rate_limit:
218 time.sleep(cls.rate_limit - (now - cls.last_query))
224 def _geturl(self, url):
228 f = urllib.urlopen(url)
229 ret = simplejson.load(f)
236 return "#%s" % (self.__class__.__name__)
241 class CoverFetcher(threading.Thread):
243 threading.Thread.__init__(self)
245 self.cond = threading.Condition()
248 def _fetch_cover(self, albumid, size):
250 coverdir = _COVERDIR if _COVERDIR else '/tmp'
251 to = os.path.join(coverdir, '%d-%d.jpg'%(albumid, size))
252 if not os.path.isfile(to):
253 url = _GET2+'image/album/redirect/?id=%d&imagesize=%d'%(albumid, size)
254 urllib.urlretrieve(url, to)
259 def _fetch_image(self, url):
261 h = hashlib.md5(url).hexdigest()
262 coverdir = _COVERDIR if _COVERDIR else '/tmp'
263 to = os.path.join(coverdir, h+'.jpg')
264 if not os.path.isfile(to):
265 urllib.urlretrieve(url, to)
270 def request_cover(self, albumid, size, cb):
272 self.work.insert(0, (albumid, size, cb))
276 def request_images(self, urls, cb):
277 """cb([(url, image)])"""
279 self.work.insert(0, ('images', urls, cb))
295 multi = len(work) > 1
297 if job[0] == 'images':
298 self.process_images(job[1], job[2])
300 self.process_cover(*job)
304 def process_cover(self, albumid, size, cb):
305 cover = self._fetch_cover(albumid, size)
307 cb(albumid, size, cover)
309 def process_images(self, urls, cb):
310 results = [(url, image) for url, image in ((url, self._fetch_image(url)) for url in urls) if image is not None]
314 class CoverCache(object):
316 cache and fetch covers
317 TODO: background thread that
318 fetches and returns covers,
322 self._covers = {} # (albumid, size) -> file
324 self._fetcher = CoverFetcher()
325 self._fetcher.start()
326 if _COVERDIR and os.path.isdir(_COVERDIR):
329 def prime_cache(self):
331 covermatch = re.compile(r'(\d+)\-(\d+)\.jpg')
333 prev_covers = os.listdir(coverdir)
335 if len(prev_covers) > _CACHED_COVERS:
337 dropn = len(prev_covers) - _CACHED_COVERS
338 todrop = random.sample(prev_covers, dropn)
339 log.warning("Deleting from cache: %s", todrop)
341 m = covermatch.match(d)
344 os.unlink(os.path.join(coverdir, d))
346 log.exception('unlinking failed')
348 for fil in os.listdir(coverdir):
349 fl = os.path.join(coverdir, fil)
350 m = covermatch.match(fil)
351 if m and os.path.isfile(fl):
352 self._covers[(int(m.group(1)), int(m.group(2)))] = fl
354 def fetch_cover(self, albumid, size):
357 to = os.path.join(coverdir, '%d-%d.jpg'%(albumid, size))
358 if not os.path.isfile(to):
359 url = _GET2+'image/album/redirect/?id=%d&imagesize=%d'%(albumid, size)
360 urllib.urlretrieve(url, to)
361 self._covers[(albumid, size)] = to
365 def get_cover(self, albumid, size):
366 cover = self._covers.get((albumid, size), None)
368 cover = self.fetch_cover(albumid, size)
371 def get_async(self, albumid, size, cb):
372 cover = self._covers.get((albumid, size), None)
374 cb(albumid, size, cover)
376 def cb2(albumid, size, cover):
377 self._covers[(albumid, size)] = cover
378 cb(albumid, size, cover)
379 self._fetcher.request_cover(albumid, size, cb2)
381 def get_images_async(self, url_list, cb):
385 image = self._images.get(url, None)
387 found.append((url, image))
395 for url, image in results:
396 self._images[url] = image
398 self._fetcher.request_images(lookup, cb2)
400 _cover_cache = CoverCache()
402 def set_cache_dir(cachedir):
406 _COVERDIR = os.path.join(_CACHEDIR, 'covers')
409 os.makedirs(_CACHEDIR)
414 os.makedirs(_COVERDIR)
418 _cover_cache.prime_cache()
420 def get_album_cover(albumid, size=100):
421 return _cover_cache.get_cover(albumid, size)
423 def get_album_cover_async(cb, albumid, size=100):
424 _cover_cache.get_async(albumid, size, cb)
426 def get_images_async(cb, url_list):
427 _cover_cache.get_images_async(url_list, cb)
429 class CustomQuery(Query):
430 def __init__(self, url):
435 return self._geturl(self.url)
440 class GetQuery(Query):
443 'url' : _GET2+'+'.join(_ARTIST_FIELDS)+'/artist/json/?',
444 'params' : 'artist_id=%d',
445 'constructor' : Artist
448 'url' : _GET2+'+'.join(_ALBUM_FIELDS)+'/artist/json/?',
449 'params' : 'artist_id=%s',
450 'constructor' : Album
453 'url' : _GET2+'+'.join(_ALBUM_FIELDS)+'/album/json/?',
454 'params' : 'album_id=%d',
455 'constructor' : Album
458 'url' : _GET2+'+'.join(_ALBUM_FIELDS)+'/album/json/?',
459 'params' : 'album_id=%s',
460 'constructor' : Album
463 'url' : _GET2+'+'.join(_ALBUM_FIELDS)+'/album/json/?',
464 'params' : 'artist_id=%d',
465 'constructor' : [Album]
468 'url' : _GET2+'+'.join(_TRACK_FIELDS)+'/track/json/track_album+album_artist?',
470 'constructor' : Track
473 'url' : _GET2+'+'.join(_TRACK_FIELDS)+'/track/json/track_album+album_artist?',
475 'constructor' : Track
478 'url' : _GET2+'+'.join(_TRACK_FIELDS)+'/track/json/track_album+album_artist?',
479 'params' : 'order=numalbum_asc&album_id=%d',
480 'constructor' : [Track]
483 'url' : _GET2+'+'.join(_TRACK_FIELDS)+'/track/json/radio_track_inradioplaylist+track_album+album_artist/?',
484 'params' : 'order=random_asc&radio_id=%d&n=16',
485 'constructor' : [Track]
487 'favorite_albums' : {
488 'url' : _GET2+'+'.join(_ALBUM_FIELDS)+'/album/json/album_user_starred/?',
489 'params' : 'user_idstr=%s',
490 'constructor' : [Album]
493 'url' : _GET2+'+'.join(_TRACK_FIELDS)+'/track/json/track_album+album_artist?',
494 'params' : 'tag_id=%d&n=50&order=rating_desc',
495 'constructor' : [Track]
499 def __init__(self, what, ID):
502 info = GetQuery.queries[what]
503 self.url = info['url']
504 self.params = info['params']
505 self.constructor = info['constructor']
507 def construct(self, data):
508 constructor = self.constructor
509 if isinstance(constructor, list):
510 constructor = constructor[0]
511 if isinstance(data, list):
512 return [constructor(int(x['id']), json=x) for x in data]
514 return constructor(int(data['id']), json=data)
517 js = self._geturl(self.url + self.params % (self.ID))
520 return self.construct(js)
523 return self.url + self.params % (self.ID)
525 class SearchQuery(GetQuery):
526 def __init__(self, what, query=None, order=None, user=None, count=20):
527 GetQuery.__init__(self, what, None)
536 params['searchquery'] = self.query
538 params['order'] = self.order
540 params['n'] = self.count
542 params['user_idstr'] = self.user
543 js = self._geturl(self.url + urllib.urlencode(params))
546 return self.construct(js)
549 params = {'searchquery':self.query, 'order':self.order, 'n':self.count}
550 return self.url + urllib.urlencode(params)
552 class JamendoAPIException(Exception):
553 def __init__(self, url):
554 Exception.__init__(self, url)
556 def _update_cache(cache, new_items):
557 if not isinstance(new_items, list):
558 new_items = [new_items]
559 for item in new_items:
560 old = cache.get(item.ID)
564 cache[item.ID] = item
565 if isinstance(item, Artist) and item.albums:
566 for album in item.albums:
567 _update_cache(_albums, album)
568 elif isinstance(item, Album) and item.tracks:
569 for track in item.tracks:
570 _update_cache(_tracks, track)
571 # enforce cache limits here!
572 # also, TODO: save/load cache between sessions
573 # that will require storing a timestamp with
574 # each item, though..
576 # artists: 1 day - changes often
577 # albums: 2-5 days - changes less often (?)
578 # tracks: 1 week - changes rarely, queried often
580 def get_artist(artist_id):
581 """Returns: Artist"""
582 a = _artists.get(artist_id, None)
584 q = GetQuery('artist', artist_id)
587 raise JamendoAPIException(str(q))
588 _update_cache(_artists, a)
589 if isinstance(a, list):
593 def get_artists(artist_ids):
594 """Returns: [Artist]"""
595 assert(isinstance(artist_ids, list))
598 for artist_id in artist_ids:
599 a = _artists.get(artist_id, None)
601 lookup.append(artist_id)
605 q = GetQuery('artist_list', '+'.join(str(x) for x in lookup))
608 raise JamendoAPIException(str(q))
609 _update_cache(_artists, a)
611 return found + lookup
613 def get_album_list(album_ids):
614 """Returns: [Album]"""
615 assert(isinstance(album_ids, list))
618 for album_id in album_ids:
619 a = _albums.get(album_id, None)
621 lookup.append(album_id)
625 q = GetQuery('album_list', '+'.join(str(x) for x in lookup))
628 raise JamendoAPIException(str(q))
629 _update_cache(_albums, a)
631 return found + lookup
633 def get_albums(artist_id):
635 Parameter can either be an artist_id or a list of album ids.
637 if isinstance(artist_id, list):
638 return get_album_list(artist_id)
639 a = _artists.get(artist_id, None)
643 q = GetQuery('albums', artist_id)
646 raise JamendoAPIException(str(q))
647 _update_cache(_artists, a)
650 def get_album(album_id):
652 a = _albums.get(album_id, None)
654 q = GetQuery('album', album_id)
657 raise JamendoAPIException(str(q))
658 _update_cache(_albums, a)
659 if isinstance(a, list):
663 def get_track_list(track_ids):
664 """Returns: [Track]"""
665 assert(isinstance(track_ids, list))
668 for track_id in track_ids:
669 a = _tracks.get(track_id, None)
671 lookup.append(track_id)
675 q = GetQuery('track_list', '+'.join(str(x) for x in lookup))
678 raise JamendoAPIException(str(q))
679 _update_cache(_tracks, a)
681 return found + lookup
683 def get_tracks(album_id):
685 Parameter can either be an album_id or a list of track ids.
687 if isinstance(album_id, list):
688 return get_track_list(album_id)
689 a = _albums.get(album_id, None)
693 q = GetQuery('tracks', album_id)
696 raise JamendoAPIException(str(q))
697 _update_cache(_tracks, a)
700 def get_track(track_id):
702 a = _tracks.get(track_id, None)
704 q = GetQuery('track', track_id)
707 raise JamendoAPIException(str(q))
708 _update_cache(_tracks, a)
709 if isinstance(a, list):
713 def get_radio_tracks(radio_id):
714 """Returns: [Track]"""
715 q = GetQuery('radio', radio_id)
718 raise JamendoAPIException(str(q))
719 _update_cache(_tracks, a)
722 #http://api.jamendo.com/get2/id+name/track/plain/?tag_id=327&n=50&order=rating_desc
723 def get_tag_tracks(tag_id):
724 """Returns: [Track]"""
725 q = GetQuery('tag', tag_id)
728 raise JamendoAPIException(str(q))
729 _update_cache(_tracks, a)
732 def search_artists(query):
733 """Returns: [Artist]"""
734 q = SearchQuery('artist', query, 'searchweight_desc')
737 raise JamendoAPIException(str(q))
738 _update_cache(_artists, a)
741 def search_albums(query):
742 """Returns: [Album]"""
743 q = SearchQuery('album', query, 'searchweight_desc')
746 raise JamendoAPIException(str(q))
747 _update_cache(_albums, a)
750 def search_tracks(query):
751 """Returns: [Track]"""
752 q = SearchQuery('track', query=query, order='searchweight_desc')
755 raise JamendoAPIException(str(q))
756 _update_cache(_tracks, a)
759 def albums_of_the_week():
760 """Returns: [Album]"""
761 q = SearchQuery('album', order='ratingweek_desc')
764 raise JamendoAPIException(str(q))
765 _update_cache(_albums, a)
769 """Returns: [Track] (playlist)"""
770 q = SearchQuery('track', order='releasedate_desc')
773 raise JamendoAPIException(str(q))
774 _update_cache(_tracks, a)
777 def tracks_of_the_week():
778 """Returns: [Track] (playlist)"""
779 q = SearchQuery('track', order='ratingweek_desc')
782 raise JamendoAPIException(str(q))
783 _update_cache(_tracks, a)
786 def top_artists(order='rating_desc', count=20):
787 """Returns: [Artist]"""
788 q = SearchQuery('artist', order=order, count=count)
791 raise JamendoAPIException(str(q))
792 _update_cache(_artists, a)
795 def top_albums(order='rating_desc', count=20):
796 """Returns: [Album]"""
797 q = SearchQuery('album', order=order, count=count)
800 raise JamendoAPIException(str(q))
801 _update_cache(_albums, a)
804 def top_tracks(order='rating_desc', count=20):
805 """Returns: [Track]"""
806 q = SearchQuery('track', order=order, count=count)
809 raise JamendoAPIException(str(q))
810 _update_cache(_tracks, a)
813 def get_radio(radio_id):
815 q = CustomQuery(_GET2+"id+name+idstr+image/radio/json?id=%d"%(radio_id))
818 raise JamendoAPIException(str(q))
819 if isinstance(js, list):
821 return Radio(radio_id, json=js)
823 def starred_radios():
824 """Returns: [Radio]"""
825 q = CustomQuery(_GET2+"id+name+idstr+image/radio/json?order=starred_desc")
828 raise JamendoAPIException(str(q))
829 return [Radio(int(radio['id']), json=radio) for radio in js]
831 def top_tags(count=50, order='rating_desc'):
833 q = CustomQuery(_GET2+"id+name/tag/json?n=%d&order=%s"%(count, order))
836 raise JamendoAPIException(str(q))
837 return [Tag(int(tag['id']), json=tag) for tag in js]
839 def favorite_albums(user):
840 """Returns: [Album]"""
841 q = SearchQuery('favorite_albums', user=user, count=20)
844 raise JamendoAPIException(str(q))
845 _update_cache(_albums, a)
848 ### Set loader functions for classes
850 def _artist_loader(self):
851 if self._needs_load():
852 artist = get_artist(self.ID)
853 artist.albums = get_albums(self.ID)
854 self._set_from(artist)
855 Artist.load = _artist_loader
857 def _album_loader(self):
858 if self._needs_load():
859 album = get_album(self.ID)
860 album.tracks = get_tracks(self.ID)
861 self._set_from(album)
862 Album.load = _album_loader
864 def _track_loader(self):
865 track = get_track(self.ID)
866 self._set_from(track)
867 Track.load = _track_loader
869 def _radio_loader(self):
870 radio = get_radio(self.ID)
871 self._set_from(radio)
872 Radio.load = _radio_loader