Use google app engine.
[clinton/xbmc-groove.git] / resources / lib / GroovesharkAPI.py
1 import socket, hmac, urllib, urllib2, pprint, md5, os, pickle, tempfile, time, re, simplejson
2
3 SESSION_EXPIRY = 1209600 # 2 weeks
4
5 # Web app
6 WEB_APP_URL = "http://xbmc-groove.appspot.com/"
7
8 # GrooveAPI constants
9 THUMB_URL = 'http://beta.grooveshark.com/static/amazonart/m'
10 SONG_LIMIT = 25
11 ALBUM_LIMIT = 15
12 ARTIST_LIMIT = 15
13 SONG_SUFFIX = '.mp3'
14
15 # Main API
16 class GrooveAPI:
17
18 _ip = '0.0.0.0'
19 _country = ''
20 _sessionID = ''
21 _userID = 0
22 _lastSessionTime = 0
23 _lastStreamKey = ''
24 _lastStreamServerID = ''
25
26 # Constructor
27 def __init__(self):
28
29 self.simplejson = simplejson
30 socket.setdefaulttimeout(40)
31 self.cacheDir = os.path.join(tempfile.gettempdir(), 'groovesharkapi')
32 if os.path.isdir(self.cacheDir) == False:
33 os.makedirs(self.cacheDir)
34 print "Made " + self.cacheDir
35 self._getSavedSession()
36 # session ids last 2 weeks
37 if self._sessionID == '' or time.time()- self._lastSessionTime >= SESSION_EXPIRY:
38 self._sessionID = self._getSessionID()
39 self._ip = self._getIP()
40 self._country = self._getCountry()
41 if self._sessionID == '':
42 raise StandardError('Failed to get session id')
43 else:
44 print "New GrooveAPI session id: " + self._sessionID
45 self._setSavedSession()
46
47 # Call to API
48 def _callRemote(self, method, params):
49 try:
50 res = self._getRemote(method, params)
51 url = res['url']
52 postData = res['postData']
53 req = urllib2.Request(url, postData)
54 response = urllib2.urlopen(req)
55 result = response.read()
56 print "Response..."
57 pprint.pprint(result)
58 response.close()
59 result = simplejson.loads(result)
60 return result
61 except:
62 return []
63
64 # Get the API call
65 def _getRemote(self, method, params = {}):
66 postData = { "method": method, "sessionid": self._sessionID, "parameters": params }
67 postData = simplejson.dumps(postData)
68 url = WEB_APP_URL + "?postData=" + urllib.quote_plus(postData)
69 req = urllib2.Request(url)
70 response = urllib2.urlopen(req)
71 result = response.read()
72 print "Request..."
73 pprint.pprint(result)
74 response.close()
75 try:
76 result = simplejson.loads(result)
77 return result
78 except:
79 return []
80
81 # Get a session id
82 def _getSessionID(self):
83 params = {}
84 result = self._callRemote('startSession', params)
85 self._lastSessionTime = time.time()
86 if 'result' in result:
87 return result['result']['sessionID']
88 else:
89 return ''
90
91 def _getSavedSession(self):
92 path = os.path.join(self.cacheDir, 'session.dmp')
93 try:
94 f = open(path, 'rb')
95 session = pickle.load(f)
96 self._sessionID = session['sessionID']
97 self._lastSessionTime = session['lastSessionTime']
98 self._userID = session['userID']
99 self._ip = session['ip']
100 self._country = session['country']
101 f.close()
102 except:
103 self._sessionID = ''
104 self._lastSessionTime = 0
105 self._userID = 0
106 self._ip = '0.0.0.0'
107 self._country = ''
108 pass
109
110 def _setSavedSession(self):
111 try:
112 # Create the directory if it doesn't exist.
113 if not os.path.exists(self.cacheDir):
114 os.makedirs(self.cacheDir)
115 path = os.path.join(self.cacheDir, 'session.dmp')
116 f = open(path, 'wb')
117 session = { 'sessionID' : self._sessionID, 'lastSessionTime' : self._lastSessionTime, 'userID': self._userID, 'ip' : self._ip, 'country' : self._country }
118 pickle.dump(session, f, protocol=pickle.HIGHEST_PROTOCOL)
119 f.close()
120 except:
121 print "An error occurred during save session"
122 pass
123
124 def _setParams(self, params):
125 try:
126 # Create the directory if it doesn't exist.
127 if not os.path.exists(self.cacheDir):
128 os.makedirs(self.cacheDir)
129 path = os.path.join(self.cacheDir, 'params.dmp')
130 f = open(path, 'wb')
131 pickle.dump(params, f, protocol=pickle.HIGHEST_PROTOCOL)
132 f.close()
133 except:
134 print "An error occurred during save params"
135 pass
136
137 # Get IP
138 def _getIP(self):
139 try:
140 myip = urllib2.urlopen('http://whatismyip.org').read()
141 if re.match("^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$", myip):
142 print "IP is " + myip
143 return myip
144 except:
145 return '0.0.0.0'
146
147 # Get country
148 def _getCountry(self):
149 params = { 'ip' : self._ip }
150 response = self._callRemote("getCountry", params)
151 return response['result']
152
153 # Get userid from name
154 def _getUserIDFromUsername(self, username):
155 result = self._callRemote('getUserIDFromUsername', {'username' : username})
156 if 'result' in result and result['result']['UserID'] > 0:
157 return result['result']['UserID']
158 else:
159 return 0
160
161 # Authenticates the user for current API session
162 def _authenticate(self, login, password):
163 md5pwd = md5.new(password).hexdigest()
164 params = {'login': login, 'password': md5pwd}
165
166 result = self._callRemote('authenticate', params)
167 try:
168 uid = result['result']['UserID']
169 except:
170 uid = 0
171 if (uid > 0):
172 return uid
173 else:
174 return 0
175
176 # Check the service
177 def pingService(self,):
178 result = self._callRemote('pingService', {});
179 if 'result' in result and result['result'] != '':
180 return True
181 else:
182 return False
183
184 # Login
185 def login(self, username, password):
186 if self._userID <= 0:
187 # Check cache
188 self._getSavedSession()
189 if self._userID <= 0:
190 self._userID = self._authenticate(username, password)
191 if self._userID > 0:
192 self._setSavedSession()
193 return self._userID
194
195 # Logs the user out
196 def logout(self):
197 result = self._callRemote('logout', {'sessionID' : self._sessionID})
198 if 'result' in result and result['result']['success'] == True:
199 self._userID = 0
200 self._setSavedSession()
201 return True
202 return False
203
204 # Gets a stream key and host to get song content
205 def getSubscriberStreamKey(self, songID):
206 params = { "songID": songID, "country": self._country }
207 response = self._callRemote("getSubscriberStreamKey", params)
208 try:
209 self._lastStreamKey = response["result"]["StreamKey"]
210 self._lastStreamServerID = response["result"]["StreamServerID"]
211 res = response["result"]
212 return res
213 except:
214 return False
215
216 # Search for albums
217 def getArtistSearchResults(self, query, limit=ARTIST_LIMIT):
218 result = self._callRemote('getArtistSearchResults', {'query' : query,'limit' : limit})
219 if 'result' in result:
220 return self._parseArtists(result)
221 else:
222 return []
223
224 # Search for albums
225 def getAlbumSearchResults(self, query, limit=ALBUM_LIMIT):
226 result = self._callRemote('getAlbumSearchResults', {'query' : query,'limit' : limit})
227 if 'result' in result:
228 return self._parseAlbums(result)
229 else:
230 return []
231
232 # Search for songs
233 def getSongSearchResults(self, query, limit=SONG_LIMIT):
234 result = self._callRemote('getSongSearchResults', {'query' : query, 'country' : self._country, 'limit' : limit})
235 if 'result' in result:
236 return self._parseSongs(result)
237 else:
238 return []
239
240 # Get artists albums
241 def getArtistAlbums(self, artistID, limit=ALBUM_LIMIT):
242 result = self._callRemote('getArtistAlbums', {'artistID' : artistID})
243 if 'result' in result:
244 return self._parseAlbums(result, limit)
245 else:
246 return []
247
248 # Get album songs
249 def getAlbumSongs(self, albumID, limit=SONG_LIMIT):
250 result = self._callRemote('getAlbumSongs', {'albumID' : albumID, 'limit' : limit})
251 if 'result' in result:
252 return self._parseSongs(result)
253 else:
254 return []
255
256 # Get artist's popular songs
257 def getArtistPopularSongs(self, artistID, limit = SONG_LIMIT):
258 result = self._callRemote('getArtistPopularSongs', {'artistID' : artistID})
259 if 'result' in result:
260 return self._parseSongs(result, limit)
261 else:
262 return []
263
264 # Gets the popular songs
265 def getPopularSongsToday(self, limit=SONG_LIMIT):
266 result = self._callRemote('getPopularSongsToday', {'limit' : limit})
267 if 'result' in result:
268 # Note limit is broken in the Grooveshark getPopularSongsToday method
269 return self._parseSongs(result, limit)
270 else:
271 return []
272
273 # Gets the favorite songs of the logged-in user
274 def getUserFavoriteSongs(self):
275 if (self._userID == 0):
276 return [];
277 result = self._callRemote('getUserFavoriteSongs', {})
278 if 'result' in result:
279 return self._parseSongs(result)
280 else:
281 return []
282
283 # Get song info
284 def getSongsInfo(self, songIDs):
285 result = self._callRemote('getSongsInfo', {'songIDs' : songIDs})
286 if 'result' in result and 'SongID' in result['result']:
287 info = result['result']
288 if 'CoverArtFilename' in info and info['CoverArtFilename'] != None:
289 info['CoverArtFilename'] = THUMB_URL+info['CoverArtFilename'].encode('ascii', 'ignore')
290 else:
291 info['CoverArtFilename'] = 'None'
292 return info
293 else:
294 return 'None'
295
296 # Add song to user favorites
297 def addUserFavoriteSong(self, songID):
298 if (self._userID == 0):
299 return False;
300 result = self._callRemote('addUserFavoriteSong', {'songID' : songID})
301 return result['result']['success']
302
303 # Remove songs from user favorites
304 def removeUserFavoriteSongs(self, songIDs):
305 if (self._userID == 0):
306 return False;
307 result = self._callRemote('removeUserFavoriteSongs', {'songIDs' : songIDs})
308 return result['result']['success']
309
310 # Gets the playlists of the logged-in user
311 def getUserPlaylists(self):
312 if (self._userID == 0):
313 return [];
314 result = self._callRemote('getUserPlaylists', {})
315 if 'result' in result:
316 return self._parsePlaylists(result)
317 else:
318 return []
319
320 # Gets the playlists of the logged-in user
321 def getUserPlaylistsByUsername(self, username):
322 userID = self._getUserIDFromUsername(username)
323 if (userID > 0):
324 result = self._callRemote('getUserPlaylistsByUserID', {'userID' : userID})
325 if 'result' in result and result['result']['playlists'] != None:
326 playlists = result['result']['playlists']
327 return self._parsePlaylists(playlists)
328 else:
329 return []
330
331 # Creates a playlist with songs
332 def createPlaylist(self, name, songIDs):
333 result = self._callRemote('createPlaylist', {'name' : name, 'songIDs' : songIDs})
334 if 'result' in result and result['result']['success'] == True:
335 return result['result']['playlistID']
336 elif 'errors' in result:
337 return 0
338
339 # Sets the songs for a playlist
340 def setPlaylistSongs(self, playlistID, songIDs):
341 result = self._callRemote('setPlaylistSongs', {'playlistID' : playlistID, 'songIDs' : songIDs})
342 if 'result' in result and result['result']['success'] == True:
343 return True
344 else:
345 return False
346
347 # Gets the songs of a playlist
348 def getPlaylistSongs(self, playlistID):
349 result = self._callRemote('getPlaylistSongs', {'playlistID' : playlistID});
350 if 'result' in result:
351 return self._parseSongs(result)
352 else:
353 return []
354
355
356 def playlistDelete(self, playlistId):
357 result = self._callRemote("deletePlaylist", {"playlistID": playlistId})
358 if 'fault' in result:
359 return 0
360 else:
361 return 1
362
363 def playlistRename(self, playlistId, name):
364 result = self._callRemote("renamePlaylist", {"playlistID": playlistId, "name": name})
365 if 'fault' in result:
366 return 0
367 else:
368 return 1
369
370 def getSimilarArtists(self, artistId, limit):
371 items = self._callRemote("getSimilarArtists", {"artistID": artistId, "limit": limit})
372 if 'result' in items:
373 i = 0
374 list = []
375 artists = items['result']['artists']
376 while(i < len(artists)):
377 s = artists[i]
378 list.append([s['artistName'].encode('ascii', 'ignore'),\
379 s['artistID']])
380 i = i + 1
381 return list
382 else:
383 return []
384
385 # After 30s play time
386 def markStreamKeyOver30Secs(self):
387 params = { "streamKey" : self._lastStreamKey, "streamServerID" : self._lastStreamServerID }
388 self._callRemote("markStreamKeyOver30Secs", params)
389
390 # Song complete
391 def markSongComplete(self, songid):
392 params = { "songID" : songid, "streamKey" : self._lastStreamKey, "streamServerID" : self._lastStreamServerID }
393 self._callRemote("markSongComplete", params)
394
395 # Extract song data
396 def _parseSongs(self, items, limit=0):
397 if 'result' in items:
398 i = 0
399 list = []
400 index = ''
401 l = -1
402 try:
403 if 'songs' in items['result'][0]:
404 l = len(items['result'][0]['songs'])
405 index = 'songs[]'
406 except: pass
407 try:
408 if l < 0 and 'songs' in items['result']:
409 l = len(items['result']['songs'])
410 index = 'songs'
411 except: pass
412 try:
413 if l < 0 and 'song' in items['result']:
414 l = 1
415 index = 'song'
416 except: pass
417 try:
418 if l < 0:
419 l = len(items['result'])
420 except: pass
421
422 if limit > 0 and l > limit:
423 l = limit
424 while(i < l):
425 if index == 'songs[]':
426 s = items['result'][0]['songs'][i]
427 elif index == 'songs':
428 s = items['result'][index][i]
429 elif index == 'song':
430 s = items['result'][index]
431 else:
432 s = items['result'][i]
433 if 'CoverArtFilename' not in s:
434 info = self.getSongsInfo(s['SongID'])
435 coverart = info['CoverArtFilename']
436 elif s['CoverArtFilename'] != None:
437 coverart = THUMB_URL+s['CoverArtFilename'].encode('ascii', 'ignore')
438 else:
439 coverart = 'None'
440 list.append([s['SongName'].encode('ascii', 'ignore'),\
441 s['SongID'],\
442 s['AlbumName'].encode('ascii', 'ignore'),\
443 s['AlbumID'],\
444 s['ArtistName'].encode('ascii', 'ignore'),\
445 s['ArtistID'],\
446 coverart])
447 i = i + 1
448 return list
449 else:
450 return []
451
452 # Extract artist data
453 def _parseArtists(self, items):
454 if 'result' in items:
455 i = 0
456 list = []
457 artists = items['result']['artists']
458 while(i < len(artists)):
459 s = artists[i]
460 list.append([s['ArtistName'].encode('ascii', 'ignore'),\
461 s['ArtistID']])
462 i = i + 1
463 return list
464 else:
465 return []
466
467 # Extract album data
468 def _parseAlbums(self, items, limit=0):
469 if 'result' in items:
470 i = 0
471 list = []
472 try:
473 albums = items['result']['albums']
474 except:
475 res = items['result'][0]
476 albums = res['albums']
477 l = len(albums)
478 if limit > 0 and l > limit:
479 l = limit
480 while(i < l):
481 s = albums[i]
482 if 'CoverArtFilename' in s and s['CoverArtFilename'] != None:
483 coverart = THUMB_URL+s['CoverArtFilename'].encode('ascii', 'ignore')
484 else:
485 coverart = 'None'
486 list.append([s['ArtistName'].encode('ascii', 'ignore'),\
487 s['ArtistID'],\
488 s['AlbumName'].encode('ascii', 'ignore'),\
489 s['AlbumID'],\
490 coverart])
491 i = i + 1
492 return list
493 else:
494 return []
495
496 def _parsePlaylists(self, items):
497 i = 0
498 list = []
499 if 'result' in items:
500 playlists = items['result']['playlists']
501 elif len(items) > 0:
502 playlists = items
503 else:
504 return []
505
506 while (i < len(playlists)):
507 s = playlists[i]
508 list.append([str(s['PlaylistName']).encode('ascii', 'ignore'), s['PlaylistID']])
509 i = i + 1
510 return list