resources/lib/GrooveAPI.py

   1 import urllib2, md5, unicodedata, re, os, traceback, sys, pickle, socket, xbmc
   2 from operator import itemgetter, attrgetter
   3
   4 class LoginTokensExceededError(Exception):
   5         def __init__(self):
   6                 self.value = 'You have created to many tokens. Only 12 are allowed'
   7         def __str__(self):
   8                 return repr(self.value)
   9
  10 class LoginUnknownError(Exception):
  11         def __init__(self):
  12                 self.value = 'Unable to get a new session ID. Wait a few minutes and try again'
  13         def __str__(self):
  14                 return repr(self.value)
  15
  16 class SessionIDTryAgainError(Exception):
  17         def __init__(self):
  18                 self.value = 'Unable to get a new session ID. Wait a few minutes and try again'
  19         def __str__(self):
  20                 return repr(self.value)
  21
  22 class GrooveAPI:
  23         def __init__(self, enableDebug = False, isXbox = False):
  24                 import simplejson
  25                 self.simplejson = simplejson
  26                 timeout = 40
  27                 socket.setdefaulttimeout(timeout)
  28                 self.enableDebug = enableDebug
  29                 self.loggedIn = 0
  30                 self.userId = 0
  31                 self.removeDuplicates = False
  32
  33                 self.radioRecentSongs = []
  34                 self.radioRecentArtists = []
  35                 self.radioEnabled = False
  36
  37                 self.dataDir = 'addon_data'
  38                 self.confDir = xbmc.translatePath(os.path.join('special://masterprofile/' + self.dataDir, os.path.basename(os.getcwd())))
  39                 self.sessionID = self.getSavedSession()
  40                 self.debug('Saved sessionID: ' + self.sessionID)
  41                 #self.sessionID = self.getSessionFromAPI()
  42                 #self.debug('API sessionID: ' + self.sessionID)
  43                 if self.sessionID == '':
  44                         self.sessionID = self.startSession()
  45                         self.debug('Start() sessionID: ' + self.sessionID)
  46                         if self.sessionID == '':
  47                                 self.debug('Could not get a sessionID. Try again in a few minutes')
  48                                 raise SessionIDTryAgainError()
  49                         else:
  50                                 self.saveSession()
  51
  52                 self.debug('sessionID: ' + self.sessionID)
  53
  54         def __del__(self):
  55                 try:
  56                         if self.loggedIn == 1:
  57                                 self.logout()
  58                 except:
  59                         pass
  60
  61         def debug(self, msg):
  62                 if self.enableDebug == True:
  63                         print msg
  64
  65         def setRemoveDuplicates(self, enable):
  66                 if enable == True or enable == 'true' or enable == 'True':
  67                         self.removeDuplicates = True
  68                 else:
  69                         self.removeDuplicates = False
  70
  71         def getSavedSession(self):
  72                 sessionID = ''
  73                 path = os.path.join(self.confDir, 'session', 'session.txt')
  74
  75                 try:
  76                         f = open(path, 'rb')
  77                         sessionID = pickle.load(f)
  78                         f.close()
  79                 except:
  80                         sessionID = ''
  81                         pass
  82
  83                 return sessionID
  84
  85         def saveSession(self):
  86                 try:
  87                         dir = os.path.join(self.confDir, 'session')
  88                         # Create the 'data' directory if it doesn't exist.
  89                         if not os.path.exists(dir):
  90                                 os.makedirs(dir)
  91                         path = os.path.join(dir, 'session.txt')
  92                         f = open(path, 'wb')
  93                         pickle.dump(self.sessionID, f, protocol=pickle.HIGHEST_PROTOCOL)
  94                         f.close()
  95                 except IOError, e:
  96                         print 'There was an error while saving the session pickle (%s)' % e
  97                         pass
  98                 except:
  99                         print "An unknown error occured during save session: " + str(sys.exc_info()[0])
 100                         pass
 101
 102         def saveSettings(self):
 103                 try:
 104                         dir = os.path.join(self.confDir, 'data')
 105                         # Create the 'data' directory if it doesn't exist.
 106                         if not os.path.exists(dir):
 107                                 os.makedirs(dir)
 108                         path = os.path.join(dir, 'settings1.txt')
 109                         f = open(path, 'wb')
 110                         pickle.dump(self.settings, f, protocol=pickle.HIGHEST_PROTOCOL)
 111                         f.close()
 112                 except IOError, e:
 113                         print 'There was an error while saving the settings pickle (%s)' % e
 114                         pass
 115                 except:
 116                         print "An unknown error occured during save settings\n"
 117                         pass
 118
 119         def callRemote(self, method, params={}):
 120                 data = {'header': {'sessionID': self.sessionID}, 'method': method, 'parameters': params}
 121                 data = self.simplejson.dumps(data)
 122                 req = urllib2.Request("http://api.grooveshark.com/ws/1.0/?json")
 123                 req.add_header('Host', 'api.grooveshark.com')
 124                 req.add_header('Content-type', 'text/json')
 125                 req.add_header('Content-length', str(len(data)))
 126                 req.add_data(data)
 127                 response = urllib2.urlopen(req)
 128                 result = response.read()
 129                 response.close()
 130                 try:
 131                         result = self.simplejson.loads(result)
 132                         if 'fault' in result:
 133                                 self.debug(result)
 134                                 if result['fault']['code'] == 8: #Session ID has expired. Get a new and try again if possible.
 135                                         self.debug(result['fault']['message'])
 136                                         self.sessionID = self.startSession()
 137                                         if self.sessionID != '':
 138                                                 self.saveSession()
 139                                                 return self.callRemote(method, params)
 140                                         else:
 141                                                 self.debug('GrooveShark: SessionID expired, but unable to get new')
 142                                                 return []
 143                         return result
 144                 except:
 145                         return []
 146
 147         def startSession(self):
 148                 response = urllib2.urlopen("http://www.moovida.com/services/grooveshark/session_start")
 149                 result = response.read()
 150                 result = self.simplejson.loads(result)
 151                 response.close()
 152                 if 'fault' in result:
 153                         return ''
 154                 else:
 155                         return result['result']['sessionID']
 156
 157         def sessionDestroy(self):
 158                 return self.callRemote("session.destroy")
 159
 160         def getSessionFromAPI(self):
 161                 result = self.callRemote("session.get")
 162                 if 'fault' in result:
 163                         return ''
 164                 else:
 165                         return result['header']['sessionID']
 166
 167         def getStreamURL(self, songID):
 168                 result = self.callRemote("song.getStreamUrlEx", {"songID": songID})
 169                 if 'result' in result:
 170                         return result['result']['url']
 171                 else:
 172                         return ''
 173
 174         def createUserAuthToken(self, username, password):
 175                 hashpass = md5.new(password).hexdigest()
 176                 hashpass = username + hashpass
 177                 hashpass = md5.new(hashpass).hexdigest()
 178                 result = self.callRemote("session.createUserAuthToken", {"username": username, "hashpass": hashpass})
 179                 if 'result' in result:
 180                         return result['result']['token'], result['result']['userID']
 181                 elif 'fault' in result:
 182                         if result['fault']['code'] == 256:
 183                                 return -1 # Exceeded the number of allowed tokens. Should not happen
 184                         else:
 185                                 return -2 # Unknown error
 186                 else:
 187                         return -2 # Unknown error
 188
 189         def destroyUserAuthToken(self, token):
 190                 self.callRemote("session.destroyAuthToken", {"token": token})
 191
 192         def loginViaAuthToken(self, token):
 193                 result = self.callRemote("session.loginViaAuthToken", {"token": token})
 194                 self.destroyUserAuthToken(token)
 195                 if 'result' in result:
 196                         self.userID = result['result']['userID']
 197                         return result['result']['userID']
 198                 else:
 199                         return 0
 200
 201         def login(self, username, password):
 202                 if self.loggedIn == 1:
 203                         return self.userId
 204                 result = self.createUserAuthToken(username, password)
 205                 if result == -1:
 206                         raise LoginTokensExceededError()
 207                 elif result == -2:
 208                         raise LoginUnknownError()
 209                 else:
 210                         self.token = result[0]
 211                         self.debug('Token:' + self.token)
 212                         self.userId = self.loginViaAuthToken(self.token)
 213                         if self.userId == 0:
 214                                 raise LoginUnknownError()
 215                         else:
 216                                 self.loggedIn = 1
 217                                 return self.userId
 218
 219
 220         def loginExt(self, username, password):
 221                 if self.loggedIn == 1:
 222                         return self.userId
 223                 token = md5.new(username.lower() + md5.new(password).hexdigest()).hexdigest()
 224                 result = self.callRemote("session.loginExt", {"username": username, "token": token})
 225                 if 'result' in result:
 226                         if 'userID' in result['result']:
 227                                 self.loggedIn = 1
 228                                 self.userId = result['result']['userID']
 229                                 return result['result']['userID']
 230                 else:
 231                         return 0
 232
 233
 234         def loginBasic(self, username, password):
 235                 if self.loggedIn == 1:
 236                         return self.userId
 237                 result = self.callRemote("session.login", {"username": username, "password": password})
 238                 if 'result' in result:
 239                         if 'userID' in result['result']:
 240                                 self.loggedIn = 1
 241                                 self.userId = result['result']['userID']
 242                                 return result['result']['userID']
 243                 else:
 244                         return 0
 245
 246         def loggedInStatus(self):
 247                 return self.loggedIn
 248
 249         def logout(self):
 250                 self.callRemote("session.logout", {})
 251                 self.loggedIn = 0
 252
 253         def getSongInfo(self, songID):
 254                 return self.callRemote("song.about", {"songID": songID})['result']['song']
 255
 256         def userGetFavoriteSongs(self, userID):
 257                 result = self.callRemote("user.getFavoriteSongs", {"userID": userID})
 258                 list = self.parseSongs(result)
 259                 return list
 260
 261         def userGetPlaylists(self, limit=25):
 262                 if self.loggedIn == 1:
 263                         result = self.callRemote("user.getPlaylists", {"userID": self.userId, "limit": limit})
 264                         if 'result' in result:
 265                                 playlists = result['result']['playlists']
 266                         else:
 267                                 return []
 268                         i = 0
 269                         list = []
 270                         while(i < len(playlists)):
 271                                 p = playlists[i]
 272                                 list.append([p['playlistName'].encode('ascii', 'ignore'), p['playlistID']])
 273                                 i = i + 1
 274                         return sorted(list, key=itemgetter(0))
 275                 else:
 276                         return []
 277
 278         def playlistCreate(self, name, about):
 279                 if self.loggedIn == 1:
 280                         result = self.callRemote("playlist.create", {"name": name, "about": about})
 281                         if 'result' in result:
 282                                 return result['result']['playlistID']
 283                         else:
 284                                 return 0
 285                 else:
 286                         return 0
 287
 288         def playlistGetSongs(self, playlistId, limit=25):
 289                 result = self.callRemote("playlist.getSongs", {"playlistID": playlistId})
 290                 list = self.parseSongs(result)
 291                 return list
 292
 293         def playlistDelete(self, playlistId):
 294                 if self.loggedIn == 1:
 295                         return self.callRemote("playlist.delete", {"playlistID": playlistId})
 296
 297         def playlistRename(self, playlistId, name):
 298                 if self.loggedIn == 1:
 299                         result = self.callRemote("playlist.rename", {"playlistID": playlistId, "name": name})
 300                         if 'fault' in result:
 301                                 return 0
 302                         else:
 303                                 return 1
 304                 else:
 305                         return 0
 306
 307         def playlistClearSongs(self, playlistId):
 308                 if self.loggedIn == 1:
 309                         return self.callRemote("playlist.clearSongs", {"playlistID": playlistId})
 310
 311         def playlistAddSong(self, playlistId, songId, position):
 312                 if self.loggedIn == 1:
 313                         result = self.callRemote("playlist.addSong", {"playlistID": playlistId, "songID": songId, "position": position})
 314                         if 'fault' in result:
 315                                 return 0
 316                         else:
 317                                 return 1
 318                 else:
 319                         return 0
 320
 321         def playlistReplace(self, playlistId, songIds):
 322                 if self.loggedIn == 1:
 323                         result = self.callRemote("playlist.replace", {"playlistID": playlistId, "songIDs": songIds})
 324                         if 'fault' in result:
 325                                 return 0
 326                         else:
 327                                 return 1
 328                 else:
 329                         return 0
 330
 331         def radioStartArtists(self):
 332                 radio = self.getSavedRadio()
 333                 if radio == None:
 334                         return False
 335                 result = self.callRemote("autoplay.startWithArtistIDs", {"artistIDs": radio['seedArtists']})
 336                 if 'fault' in result:
 337                         print "Cannot autoplay artists"
 338                         self.radioEnabled = False
 339                 else:
 340                         self.radioEnabled = True
 341                 return self.radioEnabled
 342
 343         def radioStartSongs(self):
 344                 radio = self.getSavedRadio()
 345                 if radio == None:
 346                         return False
 347                 result = self.callRemote("autoplay.start", {"songIDs": radio['seedSongs']})
 348                 if 'fault' in result:
 349                         print "Cannot autoplay songs"
 350                         self.radioEnabled = False
 351                 else:
 352                         self.radioEnabled = True
 353                 return self.radioEnabled
 354
 355         def radioNextSong(self):
 356                 radio = self.getSavedRadio()
 357                 if radio == None:
 358                         return None
 359                 else:
 360                         result = self.callRemote("autoplay.getNextSongEx", {"seedArtists": radio['seedArtists'], "frowns": radio['frowns'], "songIDsAlreadySeen": self.radioRecentSongs, "recentArtists": self.radioRecentArtists})
 361                         if 'fault' in result:
 362                                 return []
 363                         else:
 364                                 song = self.parseSongs(result)
 365                                 self.radioRecentSongs.append(song[0][1])
 366                                 self.radioRecentArtists.append(song[0][7])
 367                                 return song
 368
 369         def radioFrown(self, songId = None):
 370                 radio = self.getSavedRadio()
 371                 if radio != None and songId != None:
 372                         try:
 373                                 radio['frowns'].remove(songId)
 374                         except: pass
 375                         radio['frowns'].append(songId)
 376                         return self.saveRadio(radio = radio)
 377                 else:
 378                         return False
 379
 380         def radioArtist(self, artistId = None):
 381                 radio = self.getSavedRadio()
 382                 if radio != None and artistId != None:
 383                         try:
 384                                 radio['seedArtists'].remove(artistId)
 385                         except: pass
 386                         radio['seedArtists'].append(artistId)
 387                         print "Saved radio"
 388                         return self.saveRadio(radio = radio)
 389                 else:
 390                         print "Failed to get radio"
 391                         return False
 392
 393         def radioSong(self, songId = None):
 394                 radio = self.getSavedRadio()
 395                 if radio != None and songId != None:
 396                         try:
 397                                 radio['seedSongs'].remove(songId)
 398                         except: pass
 399                         radio['seedSongs'].append(songId)
 400                         print "Saved radio"
 401                         return self.saveRadio(radio = radio)
 402                 else:
 403                         print "Failed to get radio"
 404                         return False
 405
 406         def radioTurnedOn(self):
 407                 return self.radioEnabled
 408
 409         def getSavedRadio(self):
 410                 path = os.path.join(self.confDir, 'radio', 'radio.dmp')
 411                 try:
 412                         f = open(path, 'rb')
 413                         radio = pickle.load(f)
 414                         f.close()
 415                         print radio
 416                 except:
 417                         print "Failed to open " + path
 418                         radio = {}
 419                         radio['seedSongs'] = []
 420                         radio['seedArtists'] = []
 421                         radio['frowns'] = []
 422                         if self.saveRadio(radio) == False:
 423                                 return None
 424                 return radio
 425
 426         def saveRadio(self, radio): #blaher
 427                 if radio == {}:
 428                         print 'Invalid radio'
 429                         return False
 430                 try:
 431                         dir = os.path.join(self.confDir, 'radio')
 432                         # Create the 'data' directory if it doesn't exist.
 433                         if not os.path.exists(dir):
 434                                 os.mkdir(dir)
 435                         path = os.path.join(dir, 'radio.dmp')
 436                         f = open(path, 'wb')
 437                         pickle.dump(radio, f, protocol=pickle.HIGHEST_PROTOCOL)
 438                         f.close()
 439                         return True
 440                 except IOError, e:
 441                         print 'There was an error while saving the radio pickle (%s)' % e
 442                         return False
 443                 except:
 444                         print "An unknown error occurred during save radio: " + str(sys.exc_info()[0])
 445                         return False
 446
 447         def favoriteSong(self, songID):
 448                 return self.callRemote("song.favorite", {"songID": songID})
 449
 450         def unfavoriteSong(self, songID):
 451                 return self.callRemote("song.unfavorite", {"songID": songID})
 452
 453         def getMethods(self):
 454                 return self.callRemote("service.getMethods")
 455
 456         def searchSongsExactMatch(self, songName, artistName, albumName):
 457                 result = self.callRemote("search.songExactMatch", {"songName": songName, "artistName": artistName, "albumName": albumName})
 458                 list = self.parseSongs(result)
 459                 return list
 460
 461         def searchSongs(self, query, limit, page=0, sortKey=6):
 462                 result = self.callRemote("search.songs", {"query": query, "limit": limit, "page:": page, "streamableOnly": 1})
 463                 list = self.parseSongs(result)
 464                 return list
 465                 #return sorted(list, key=itemgetter(sortKey))
 466
 467         def searchArtists(self, query, limit, sortKey=0):
 468                 result = self.callRemote("search.artists", {"query": query, "limit": limit, "streamableOnly": 1})
 469                 list = self.parseArtists(result)
 470                 return list
 471                 #return sorted(list, key=itemgetter(sortKey))
 472
 473         def searchAlbums(self, query, limit, sortKey=2):
 474                 result = self.callRemote("search.albums", {"query": query, "limit": limit, "streamableOnly": 1})
 475                 list = self.parseAlbums(result)
 476                 return list
 477                 #return sorted(list, key=itemgetter(sortKey))
 478
 479         def searchPlaylists(self, query, limit):
 480                 result = self.callRemote("search.playlists", {"query": query, "limit": limit, "streamableOnly": 1})
 481                 list = self.parsePlaylists(result)
 482                 return list
 483
 484         def popularGetSongs(self, limit):
 485                 result = self.callRemote("popular.getSongs", {"limit": limit})
 486                 list = self.parseSongs(result)
 487                 return list
 488
 489         def popularGetArtists(self, limit):
 490                 result = self.callRemote("popular.getArtists", {"limit": limit})
 491                 list = self.parseArtists(result)
 492                 return list
 493
 494         def popularGetAlbums(self, limit):
 495                 result = self.callRemote("popular.getAlbums", {"limit": limit})
 496                 list = self.parseAlbums(result)
 497                 return list
 498
 499         def artistAbout(self, artistId):
 500                 result = self.callRemote("artist.about", {"artistID": artistId})
 501                 return result
 502
 503         def artistGetAlbums(self, artistId, limit, sortKey=2):
 504                 result = self.callRemote("artist.getAlbums", {"artistID": artistId, "limit": limit})
 505                 list = self.parseAlbums(result)
 506                 return list
 507                 #return sorted(list, key=itemgetter(sortKey))
 508
 509         def artistGetVerifiedAlbums(self, artistId, limit):
 510                 result = self.callRemote("artist.getVerifiedAlbums", {"artistID": artistId, "limit": limit})
 511                 list = self.parseSongs(result)
 512                 return list
 513
 514         def albumGetSongs(self, albumId, limit):
 515                 result = self.callRemote("album.getSongs", {"albumID": albumId, "limit": limit})
 516                 list = self.parseSongs(result)
 517                 return list
 518
 519         def songGetSimilar(self, songId, limit):
 520                 result = self.callRemote("song.getSimilar", {"songID": songId, "limit": limit})
 521                 list = self.parseSongs(result)
 522                 return list
 523
 524         def artistGetSimilar(self, artistId, limit):
 525                 result = self.callRemote("artist.getSimilar", {"artistID": artistId, "limit": limit})
 526                 list = self.parseArtists(result)
 527                 return list
 528
 529         def songAbout(self, songId):
 530                 result = self.callRemote("song.about", {"songID": songId})
 531                 return result['result']['song']
 532
 533         def getVersion(self):
 534                 result = self.callRemote("service.getVersion", {})
 535                 return result
 536
 537         def parseSongs(self, items):
 538                 try:
 539                         if 'result' in items:
 540                                 i = 0
 541                                 list = []
 542                                 if 'songs' in items['result']:
 543                                         l = len(items['result']['songs'])
 544                                         index = 'songs'
 545                                 elif 'song' in items['result']:
 546                                         l = 1
 547                                         index = 'song'
 548                                 else:
 549                                         l = 0
 550                                         index = ''
 551                                 while(i < l):
 552                                         if index == 'songs':
 553                                                 s = items['result'][index][i]
 554                                         else:
 555                                                 s = items['result'][index]
 556                                         if 'estDurationSecs' in s:
 557                                                 dur = s['estDurationSecs']
 558                                         else:
 559                                                 dur = 0
 560                                         try:
 561                                                 notIn = True
 562                                                 for entry in list:
 563                                                         songName = s['songName'].encode('ascii', 'ignore')
 564                                                         albumName = s['albumName'].encode('ascii', 'ignore')
 565                                                         artistName = s['artistName'].encode('ascii', 'ignore')
 566                                                         if self.removeDuplicates == True:
 567                                                                 if (entry[0].lower() == songName.lower()) and (entry[3].lower() == albumName.lower()) and (entry[6].lower() == artistName.lower()):
 568                                                                         notIn = False
 569                                                 if notIn == True:
 570                                                         list.append([s['songName'].encode('ascii', 'ignore'),\
 571                                                         s['songID'],\
 572                                                         dur,\
 573                                                         s['albumName'].encode('ascii', 'ignore'),\
 574                                                         s['albumID'],\
 575                                                         s['image']['tiny'].encode('ascii', 'ignore'),\
 576                                                         s['artistName'].encode('ascii', 'ignore'),\
 577                                                         s['artistID'],\
 578                                                         s['image']['small'].encode('ascii', 'ignore'),\
 579                                                         s['image']['medium'].encode('ascii', 'ignore')])
 580                                         except:
 581                                                 print 'GrooveShark: Could not parse song number: ' + str(i)
 582                                                 traceback.print_exc()
 583                                         i = i + 1
 584                                 return list
 585                         else:
 586                                 return []
 587                                 pass
 588                 except:
 589                         print 'GrooveShark: Could not parse songs. Got this:'
 590                         traceback.print_exc()
 591                         return []
 592
 593         def parseArtists(self, items):
 594                 try:
 595                         if 'result' in items:
 596                                 i = 0
 597                                 list = []
 598                                 artists = items['result']['artists']
 599                                 while(i < len(artists)):
 600                                         s = artists[i]
 601                                         try:
 602                                                 list.append([s['artistName'].encode('ascii', 'ignore'),\
 603                                                 s['artistID']])
 604                                         except:
 605                                                 print 'GrooveShark: Could not parse album number: ' + str(i)
 606                                                 traceback.print_exc()
 607                                         i = i + 1
 608                                 return list
 609                         else:
 610                                 return []
 611                 except:
 612                         print 'GrooveShark: Could not parse artists. Got this:'
 613                         traceback.print_exc()
 614                         return []
 615
 616         def parseAlbums(self, items):
 617                 try:
 618                         if 'result' in items:
 619                                 i = 0
 620                                 list = []
 621                                 albums = items['result']['albums']
 622                                 while(i < len(albums)):
 623                                         s = albums[i]
 624                                         try: # Avoid ascii ancoding errors
 625                                                 list.append([s['artistName'].encode('ascii', 'ignore'),\
 626                                                 s['artistID'],\
 627                                                 s['albumName'].encode('ascii', 'ignore'),\
 628                                                 s['albumID'],\
 629                                                 s['image']['medium'].encode('ascii', 'ignore')])
 630                                         except:
 631                                                 print 'GrooveShark: Could not parse album number: ' + str(i)
 632                                                 traceback.print_exc()
 633                                         i = i + 1
 634                                 return list
 635                         else:
 636                                 return []
 637                 except:
 638                         print 'GrooveShark: Could not parse albums. Got this'
 639                         traceback.print_exc()
 640                         return []
 641
 642         def parsePlaylists(self, items):
 643                 try:
 644                         if 'result' in items:
 645                                 i = 0
 646                                 list = []
 647                                 playlists = items['result']['playlists']
 648                                 while(i < len(playlists)):
 649                                         s = playlists[i]
 650                                         try: # Avoid ascii ancoding errors
 651                                                 list.append([s['playlistID'],\
 652                                                 s['playlistName'].encode('ascii', 'ignore'),\
 653                                                 s['username'].encode('ascii', 'ignore')])
 654                                         except:
 655                                                 print 'GrooveShark: Could not parse playlist number: ' + str(i)
 656                                                 traceback.print_exc()
 657                                         i = i + 1
 658                                 return list
 659                         else:
 660                                 return []
 661                 except:
 662                         print 'GrooveShark: Could not parse playlists. Got this:'
 663                         print items
 664                         return []