git.maemo.org Git - jamaendo/blob - jamaendo/api.py

   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
   4 #import util
   5 #if util.platform == 'maemo':
   6 #    _CACHEDIR = os.path.expanduser('''~/MyDocs/.jamaendo''')
   7 #else:
   8 #    _CACHEDIR = os.path.expanduser('''~/.cache/jamaendo''')
   9
  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'
  15
  16
  17 def set_cache_dir(cachedir):
  18     global _CACHEDIR
  19     global _COVERDIR
  20     _CACHEDIR = cachedir
  21     _COVERDIR = os.path.join(_CACHEDIR, 'covers')
  22
  23     try:
  24         os.makedirs(_CACHEDIR)
  25     except OSError:
  26         pass
  27
  28     try:
  29         os.makedirs(_COVERDIR)
  30     except OSError:
  31         pass
  32
  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
  36
  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']
  41
  42 class LazyQuery(object):
  43     def set_from_json(self, json):
  44         for key, value in json.iteritems():
  45             if key == 'id':
  46                 assert(self.ID == int(value))
  47             else:
  48                 if key.endswith('_id'):
  49                     value = int(value)
  50                 setattr(self, key, value)
  51
  52     def load(self):
  53         """Not automatic for now,
  54         will have to do artist.load()
  55
  56         This is filled in further down
  57         in the file
  58         """
  59         raise NotImplemented
  60
  61     def _needs_load(self):
  62         return True
  63
  64     def _set_from(self, other):
  65         raise NotImplemented
  66
  67     def _needs_load_impl(self, *attrs):
  68         for attr in attrs:
  69             if getattr(self, attr) is None:
  70                 return True
  71         return False
  72
  73     def _set_from_impl(self, other, *attrs):
  74         for attr in attrs:
  75             self._set_if(other, attr)
  76
  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))
  80
  81     def __repr__(self):
  82         try:
  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:
  86             import traceback
  87             traceback.print_exc()
  88             return u"%s(?)"%(self.__class__.__name__)
  89
  90 class Artist(LazyQuery):
  91     def __init__(self, ID, json=None):
  92         self.ID = int(ID)
  93         self.name = None
  94         self.image = None
  95         self.albums = None # None means not downloaded
  96         if json:
  97             self.set_from_json(json)
  98
  99     def _needs_load(self):
 100         return self._needs_load_impl('name', 'albums')
 101
 102     def _set_from(self, other):
 103         return self._set_from_impl(other, 'name', 'image', 'albums')
 104
 105 class Album(LazyQuery):
 106     def __init__(self, ID, json=None):
 107         self.ID = int(ID)
 108         self.name = None
 109         self.image = None
 110         self.artist_name = None
 111         self.artist_id = None
 112         self.tracks = None # None means not downloaded
 113         if json:
 114             self.set_from_json(json)
 115
 116     def _needs_load(self):
 117         return self._needs_load_impl('name', 'image', 'artist_name', 'artist_id', 'tracks')
 118
 119     def _set_from(self, other):
 120         return self._set_from_impl(other, 'name', 'image', 'artist_name', 'artist_id', 'tracks')
 121
 122 class Track(LazyQuery):
 123     def __init__(self, ID, json=None):
 124         self.ID = int(ID)
 125         self.name = None
 126         self.image = None
 127         self.artist_name = None
 128         self.album_name = None
 129         self.album_id = None
 130         self.numalbum = None
 131         self.duration = None
 132         if json:
 133             self.set_from_json(json)
 134
 135     def mp3_url(self):
 136        return _MP3URL%(self.ID)
 137
 138     def ogg_url(self):
 139        return _OGGURL%(self.ID)
 140
 141     def _needs_load(self):
 142         return self._needs_load_impl('name', 'artist_name', 'album_name', 'album_id', 'numalbum', 'duration')
 143
 144     def _set_from(self, other):
 145         return self._set_from_impl(other, 'name', 'image', 'artist_name', 'album_name', 'album_id', 'numalbum', 'duration')
 146
 147 class Radio(LazyQuery):
 148     def __init__(self, ID, json=None):
 149         self.ID = int(ID)
 150         self.name = None
 151         self.idstr = None
 152         self.image = None
 153         if json:
 154             self.set_from_json(json)
 155
 156     def _needs_load(self):
 157         return self._needs_load_impl('name', 'idstr', 'image')
 158
 159     def _set_from(self, other):
 160         return self._set_from_impl(other, 'name', 'idstr', 'image')
 161
 162
 163 _artists = {} # id -> Artist()
 164 _albums = {} # id -> Album()
 165 _tracks = {} # id -> Track()
 166 _radios = {} # id -> Radio()
 167
 168
 169 # cache sizes per session (TODO)
 170 _CACHED_ARTISTS = 100
 171 _CACHED_ALBUMS = 200
 172 _CACHED_TRACKS = 500
 173 _CACHED_RADIOS = 10
 174
 175 # TODO: cache queries?
 176
 177 class Query(object):
 178     rate_limit = 1.0 # max queries per second
 179     last_query = time.time() - 1.5
 180
 181     @classmethod
 182     def _ratelimit(cls):
 183         now = time.time()
 184         if now - cls.last_query < cls.rate_limit:
 185             time.sleep(cls.rate_limit - (now - cls.last_query))
 186         cls.last_query = now
 187
 188     def __init__(self):
 189         pass
 190
 191     def _geturl(self, url):
 192         print "*** %s" % (url)
 193         Query._ratelimit()
 194         f = urllib.urlopen(url)
 195         ret = simplejson.load(f)
 196         f.close()
 197         return ret
 198
 199     def __str__(self):
 200         return "#%s" % (self.__class__.__name__)
 201
 202     def execute(self):
 203         raise NotImplemented
 204
 205 class CoverCache(object):
 206     """
 207     cache and fetch covers
 208     TODO: background thread that
 209     fetches and returns covers,
 210     asynchronously, LIFO
 211     """
 212     def __init__(self):
 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
 222
 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
 231         return to
 232
 233     def get_cover(self, albumid, size):
 234         cover = self._covers.get((albumid, size), None)
 235         if not cover:
 236             cover = self.fetch_cover(albumid, size)
 237         return cover
 238
 239     def get_async(self, albumid, size, cb):
 240         cover = self._covers.get((albumid, size), None)
 241         if cover:
 242             cb(cover)
 243         else:
 244             # TODO
 245             cover = self.fetch_cover(albumid, size)
 246             cb(cover)
 247
 248 _cover_cache = CoverCache()
 249
 250 def get_album_cover(albumid, size=200):
 251     return _cover_cache.get_cover(albumid, size)
 252
 253 def get_album_cover_async(cb, albumid, size=200):
 254     _cover_cache.get_async(albumid, size, cb)
 255
 256 class CustomQuery(Query):
 257     def __init__(self, url):
 258         Query.__init__(self)
 259         self.url = url
 260
 261     def execute(self):
 262         return self._geturl(self.url)
 263
 264     def __str__(self):
 265         return self.url
 266
 267 class GetQuery(Query):
 268     queries = {
 269         'artist' : {
 270             'url' : _GET2+'+'.join(_ARTIST_FIELDS)+'/artist/json/?',
 271             'params' : 'artist_id=%d',
 272             'constructor' : Artist
 273             },
 274         'album' : {
 275             'url' : _GET2+'+'.join(_ALBUM_FIELDS)+'/album/json/?',
 276             'params' : 'album_id=%d',
 277             'constructor' : Album
 278             },
 279         'albums' : {
 280             'url' : _GET2+'+'.join(_ALBUM_FIELDS)+'/album/json/?',
 281             'params' : 'artist_id=%d',
 282             'constructor' : [Album]
 283             },
 284         'track' : {
 285             'url' : _GET2+'+'.join(_TRACK_FIELDS)+'/track/json/track_album+album_artist?',
 286             'params' : 'id=%d',
 287             'constructor' : Track
 288             },
 289         'tracks' : {
 290             'url' : _GET2+'+'.join(_TRACK_FIELDS)+'/track/json/track_album+album_artist?',
 291             'params' : 'order=numalbum_asc&album_id=%d',
 292             'constructor' : [Track]
 293             },
 294         'radio' : {
 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]
 298             },
 299         'favorite_albums' : {
 300             'url' : _GET2+'+'.join(_ALBUM_FIELDS)+'/album/json/album_user_starred/?',
 301             'params' : 'user_idstr=%s',
 302             'constructor' : [Album]
 303             },
 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)
 306
 307         }
 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
 309
 310     def __init__(self, what, ID):
 311         Query.__init__(self)
 312         self.ID = ID
 313         info = GetQuery.queries[what]
 314         self.url = info['url']
 315         self.params = info['params']
 316         self.constructor = info['constructor']
 317
 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]
 324         else:
 325             return constructor(int(data['id']), json=data)
 326
 327     def execute(self):
 328         js = self._geturl(self.url + self.params % (self.ID))
 329         if not js:
 330             return None
 331         return self.construct(js)
 332
 333     def __str__(self):
 334         return self.url + self.params % (self.ID)
 335
 336 class SearchQuery(GetQuery):
 337     def __init__(self, what, query=None, order=None, user=None, count=10):
 338         GetQuery.__init__(self, what, None)
 339         self.query = query
 340         self.order = order
 341         self.count = count
 342         self.user = user
 343
 344     def execute(self):
 345         params = {}
 346         if self.query:
 347             params['searchquery'] = self.query
 348         if self.order:
 349             params['order'] = self.order
 350         if self.count:
 351             params['n'] = self.count
 352         if self.user:
 353             params['user_idstr'] = self.user
 354         js = self._geturl(self.url +  urllib.urlencode(params))
 355         if not js:
 356             return None
 357         return self.construct(js)
 358
 359     def __str__(self):
 360         params = {'searchquery':self.query, 'order':self.order, 'n':self.count}
 361         return self.url +  urllib.urlencode(params)
 362
 363 class JamendoAPIException(Exception):
 364     def __init__(self, url):
 365         Exception.__init__(url)
 366
 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)
 372         if old:
 373             old._set_from(item)
 374         else:
 375             cache[item.ID] = item
 376
 377 def get_artist(artist_id):
 378     """Returns: Artist"""
 379     a = _artists.get(artist_id, None)
 380     if not a:
 381         q = GetQuery('artist', artist_id)
 382         a = q.execute()
 383         if not a:
 384             raise JamendoAPIException(str(q))
 385         _update_cache(_artists, a)
 386         if isinstance(a, list):
 387             a = a[0]
 388     return a
 389
 390 def get_albums(artist_id):
 391     """Returns: [Album]"""
 392     q = GetQuery('albums', artist_id)
 393     a = q.execute()
 394     if not a:
 395         raise JamendoAPIException(str(q))
 396     _update_cache(_artists, a)
 397     return a
 398
 399 def get_album(album_id):
 400     """Returns: Album"""
 401     a = _albums.get(album_id, None)
 402     if not a:
 403         q = GetQuery('album', album_id)
 404         a = q.execute()
 405         if not a:
 406             raise JamendoAPIException(str(q))
 407         _update_cache(_albums, a)
 408         if isinstance(a, list):
 409             a = a[0]
 410     return a
 411
 412 def get_tracks(album_id):
 413     """Returns: [Track]"""
 414     q = GetQuery('tracks', album_id)
 415     a = q.execute()
 416     if not a:
 417         raise JamendoAPIException(str(q))
 418     _update_cache(_tracks, a)
 419     return a
 420
 421 def get_track(track_id):
 422     """Returns: Track"""
 423     a = _tracks.get(track_id, None)
 424     if not a:
 425         q = GetQuery('track', track_id)
 426         a = q.execute()
 427         if not a:
 428             raise JamendoAPIException(str(q))
 429         _update_cache(_tracks, a)
 430         if isinstance(a, list):
 431             a = a[0]
 432     return a
 433
 434 def get_radio_tracks(radio_id):
 435     """Returns: [Track]"""
 436     q = GetQuery('radio', radio_id)
 437     a = q.execute()
 438     if not a:
 439         raise JamendoAPIException(str(q))
 440     _update_cache(_tracks, a)
 441     return a
 442
 443 def search_artists(query):
 444     """Returns: [Artist]"""
 445     q = SearchQuery('artist', query, 'searchweight_desc')
 446     a = q.execute()
 447     if not a:
 448         raise JamendoAPIException(str(q))
 449     _update_cache(_artists, a)
 450     return a
 451
 452 def search_albums(query):
 453     """Returns: [Album]"""
 454     q = SearchQuery('album', query, 'searchweight_desc')
 455     a = q.execute()
 456     if not a:
 457         raise JamendoAPIException(str(q))
 458     _update_cache(_albums, a)
 459     return a
 460
 461 def search_tracks(query):
 462     """Returns: [Track]"""
 463     q = SearchQuery('track', query=query, order='searchweight_desc')
 464     a = q.execute()
 465     if not a:
 466         raise JamendoAPIException(str(q))
 467     _update_cache(_tracks, a)
 468     return a
 469
 470 def albums_of_the_week():
 471     """Returns: [Album]"""
 472     q = SearchQuery('album', order='ratingweek_desc')
 473     a = q.execute()
 474     if not a:
 475         raise JamendoAPIException(str(q))
 476     _update_cache(_albums, a)
 477     return a
 478
 479 def new_releases():
 480     """Returns: [Track] (playlist)"""
 481     q = SearchQuery('track', order='releasedate_desc')
 482     a = q.execute()
 483     if not a:
 484         raise JamendoAPIException(str(q))
 485     _update_cache(_tracks, a)
 486     return a
 487
 488 def tracks_of_the_week():
 489     """Returns: [Track] (playlist)"""
 490     q = SearchQuery('track', order='ratingweek_desc')
 491     a = q.execute()
 492     if not a:
 493         raise JamendoAPIException(str(q))
 494     _update_cache(_tracks, a)
 495     return a
 496
 497 def get_radio(radio_id):
 498     """Returns: Radio"""
 499     q = CustomQuery(_GET2+"id+name+idstr+image/radio/json?id=%d"%(radio_id))
 500     js = q.execute()
 501     if not js:
 502         raise JamendoAPIException(str(q))
 503     if isinstance(js, list):
 504         ks = js[0]
 505     return Radio(radio_id, json=js)
 506
 507 def starred_radios():
 508     """Returns: [Radio]"""
 509     q = CustomQuery(_GET2+"id+name+idstr+image/radio/json?order=starred_desc")
 510     js = q.execute()
 511     if not js:
 512         raise JamendoAPIException(str(q))
 513     return [Radio(int(radio['id']), json=radio) for radio in js]
 514
 515 def favorite_albums(user):
 516     """Returns: [Album]"""
 517     q = SearchQuery('favorite_albums', user=user, count=20)
 518     a = q.execute()
 519     if not a:
 520         raise JamendoAPIException(str(q))
 521     _update_cache(_albums, a)
 522     return a
 523
 524 ### Set loader functions for classes
 525
 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
 531
 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
 538
 539 def _track_loader(self):
 540     track = get_track(self.ID)
 541     self._set_from(track)
 542 Track.load = _track_loader
 543
 544 def _radio_loader(self):
 545     radio = get_radio(self.ID)
 546     self._set_from(radio)
 547 Radio.load = _radio_loader