[clinton/xbmc-groove.git] / resources / lib / GroovesharkAPI.py

import socket, hmac, urllib, urllib2, pprint, md5, uuid, re, hashlib, time, random, os, pickle

# GrooveAPI constants
THUMB_URL = 'http://beta.grooveshark.com/static/amazonart/'
THUMB_URL_DEFAULT = 'http://grooveshark.com/webincludes/logo/Grooveshark_Logo_No-Text.png'
SONG_LIMIT = 25
ALBUM_LIMIT = 15
ARTIST_LIMIT = 15

# GrooveSong constants
DOMAIN = "grooveshark.com"
HOME_URL = "http://listen." + DOMAIN
TOKEN_URL = "http://cowbell." + DOMAIN + "/more.php"
API_URL = "http://cowbell." + DOMAIN + "/more.php"
SERVICE_URL = "http://cowbell." + DOMAIN + "/service.php"

CLIENT_NAME = "gslite" #htmlshark #jsqueue
CLIENT_VERSION = "20101012.37" #"20100831.25"
HEADERS = {"Content-Type": "application/json",
	"User-Agent": "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.12) Gecko/20101026 Firefox/3.6.12 (.NET CLR 3.5.30729)",			
	"Referer": "http://listen.grooveshark.com/main.swf?cowbell=fe87233106a6cef919a1294fb2c3c05f"}

RE_SESSION = re.compile('"sessionID":"\s*?([A-z0-9]+)"') #re.compile('sessionID:\s*?\'([A-z0-9]+)\',')
RANDOM_CHARS = "1234567890abcdef"

# Get a song
class GrooveSong:
	
	def __init__(self, cacheDir):

		import simplejson
		self.simplejson = simplejson

		self.cacheDir = cacheDir
		self._lastTokenTime = 0
		self.uuid = self._getUUID()
		self.sessionID = self._getSession(HOME_URL)
		if self.sessionID == None:
			raise StandardError("Cannot get session id")
		
	# The actual call to the API
	def _callRemote(self, method, params, type="default"):
		postData = {
			"header": {
				"client": CLIENT_NAME,
				"clientRevision": CLIENT_VERSION,
				"uuid": self.uuid,
				"session": self.sessionID},
				"country": {"IPR":"1021", "ID":"223", "CC1":"0", "CC2":"0", "CC3":"0", "CC4":"2147483648"},
				"privacy": 1,
			"parameters": params,
			"method": method}
		
		token = self._getMethodToken(method)
		if token == None:
			raise StandardError("Cannot get token")

		postData["header"]["token"] = token
		if type == "service":
			url = SERVICE_URL + "?" + method
		else:
			url = API_URL + "?" + method

		postData = self.simplejson.dumps(postData)
		print "GrooveSong URL: " + url
		request = urllib2.Request(url, postData, HEADERS)
		
		response = urllib2.urlopen(request).read()
		try:
			response = self.simplejson.loads(response)
			print "GrooveSong Response..."
			pprint.pprint(response)
		except:
			raise StandardError("API error: " + response)
		try:
			response["fault"]
		except KeyError:
			return response
		else:
			raise StandardError("API error: " + response["fault"]["message"])	

	# Generate a random uuid
	def _getUUID(self):
		return str(uuid.uuid4())

	#  Make a token ready for a request header
	def _getMethodToken(self, method):
		if (time.time() - self._lastTokenTime) >= 1000:
			self._token = self._getCommunicationToken()
			if self._token == None:
				return None
			self._lastTokenTime = time.time()

		randomChars = ""
		while 6 > len(randomChars):
			randomChars = randomChars + random.choice(RANDOM_CHARS)

		token = hashlib.sha1(method + ":" + self._token + ":quitStealinMahShit:" + randomChars).hexdigest()
		return randomChars + token

	# Generate a communication token
	def _getCommunicationToken(self):
		params = {"secretKey": self._getSecretKey(self.sessionID)}
		postData = {
			"header": {
				"client": CLIENT_NAME,
				"clientRevision": CLIENT_VERSION,
				"uuid": self.uuid,
				"session": self.sessionID},
				"country": {"IPR":"1021", "ID":"223", "CC1":"0", "CC2":"0", "CC3":"0", "CC4":"2147483648"},
				"privacy": 1,
			"parameters": params,
			"method": "getCommunicationToken"}
		
		postData = self.simplejson.dumps(postData)
		request = urllib2.Request(TOKEN_URL, postData, HEADERS)
		response = urllib2.urlopen(request).read()
		try:
			response = self.simplejson.loads(response)
		except:
			raise StandardError("API error: " + response)
		try:
			response["fault"]
		except KeyError:
			return response["result"]
		else:
			return None	
		
	# Generate a secret key from a sessionID
	def _getSecretKey(self, sessionID):
		return hashlib.md5(sessionID).hexdigest()
	
	# Get a session id from some HTML
	def _getSession(self, html):
		html = urllib2.urlopen(HOME_URL).read()
		session = RE_SESSION.search(html)
		if session:
			return session.group(1)
		else:
			return None
	
	# Gets a stream key and host to get song content
	def _getStreamDetails(self, songID):
		params = {
			"songID": songID,
			"prefetch": False,
			"mobile": False, 
			"country": {"IPR":"1021","ID":"223", "CC1":"0", "CC2":"0", "CC3":"0", "CC4":"2147483648"}
			}
		response = self._callRemote("getStreamKeyFromSongIDEx", params)
		self._lastStreamKey = response["result"]["streamKey"]
		self._lastStreamServer = response["result"]["ip"]
		self._lastStreamServerID = response["result"]["streamServerID"]
		
	# Tells Grooveshark you have downloaded a song
	def _markSongDownloaded(self, songID):
		params = {
			"streamKey": self._lastStreamKey,
			"streamServerID": self._lastStreamServerID,
			"songID": songID}
		self._callRemote("markSongDownloaded", params)

	# Download a song to a temporary file
	def getSongURL(self, songID):
		filename = os.path.join(self.cacheDir, songID + '.mp3')
		if os.path.isfile(filename) == False:
			self._getStreamDetails(songID)
			postData = {"streamKey": self._lastStreamKey}
			postData = urllib.urlencode(postData)
			urllib.FancyURLopener().retrieve( "http://" + self._lastStreamServer + "/stream.php", filename, data=postData)
			self._markSongDownloaded(songID)
		return filename


# Main API
class GrooveAPI:

	sessionID = ''
	userID = 0
	host = 'api.grooveshark.com'
	lastSessionTime = 0

	# Constructor
	def __init__(self, cacheDir):
		import simplejson
		self.simplejson = simplejson
		socket.setdefaulttimeout(40)
		self.cacheDir = cacheDir
		self._getSavedSessionID()
		# session ids last 1 week
		if self.sessionID == '' or time.time()- self.lastSessionTime >= 6*86400:
			self.sessionID = self._getSessionID()
			if self.sessionID == '':
				raise StandardError('Failed to get session id')
			else:
				print "New session id: " + self.sessionID
				self._setSavedSessionID()

	# Sort keys		
	def _keySort(self, d):
		return [(k,d[k]) for k in sorted(d.keys())]
	
	# Make a message sig
	def _createMessageSig(self, method, params, secret):
		args = self._keySort(params);
		data = '';
		for arg in args:
			data += str(arg[0])
			data += str(arg[1])
		data = method + data
		
		h = hmac.new(secret, data)
		return h.hexdigest()
	
	# The actual call to the API
	def _callRemote(self, method, params = {}):
		url = 'http://%s/ws/2.1/?method=%s&%s&wsKey=wordpress&sig=%s&format=json' % (self.host, method, urllib.urlencode(params), self._createMessageSig(method, params, 'd6c59291620c6eaa5bf94da08fae0ecc'))
		print url
		req = urllib2.Request(url)
		response = urllib2.urlopen(req)
		result = response.read()
		pprint.pprint(result)
		response.close()
		try:
			result = self.simplejson.loads(result)
			return result
		except:
			return []

	# Get a session id
	def _getSessionID(self):
		params = {}
		result = self._callRemote('startSession', params)
		self.lastSessionTime = time.time()
		return result['result']['sessionID']
	
	def _getSavedSessionID(self):
		path = os.path.join(self.cacheDir, 'session', 'session.dmp')
		try:
			f = open(path, 'rb')
			session = pickle.load(f)
			self.sessionID = session['sessionID']
			self.lastSessionTime = session['lastSessionTime']
			f.close()
		except:
			self.sessionID = ''
			self.lastSessionTime = 0
			pass		

	def _setSavedSessionID(self):			
		try:
			dir = os.path.join(self.cacheDir, 'session')
			# Create the 'data' directory if it doesn't exist.
			if not os.path.exists(dir):
				os.makedirs(dir)
			path = os.path.join(dir, 'session.dmp')
			f = open(path, 'wb')
			session = { 'sessionID' : self.sessionID, 'lastSessionTime' : self.lastSessionTime}
			pickle.dump(session, f, protocol=pickle.HIGHEST_PROTOCOL)
			f.close()
		except:
			print "An error occured during save session"
			pass
	
	# Make user authentication token
	def _getUserToken(self, username, password):
		return md5.new(username.lower() + md5.new(password).hexdigest()).hexdigest()

	# Authenticates the user for current API session
	def _authenticateUser(self, username, token):
		params = {'sessionID': self.sessionID, 'username': username, 'token': token}
		result = self._callRemote('authenticateUser', params)
		return result['result']['UserID']
	
	# Login
	def login(self, username, password):
		token = self._getUserToken(username, password)
		self.userID = self._authenticateUser(username, token)
		return self.userID
		
	# Logs the user out
	def logout(self):
		self._callRemote('logout', {'sessionID' : self.sessionID})

	# Return user id
	def getUserID(self):
		return self.userID
	
	# Search for albums
	def getArtistSearchResults(self, query, limit=ARTIST_LIMIT):
		result = self._callRemote('getArtistSearchResults', {'query' : query,'limit' : limit})
		if 'result' in result:
			return self._parseArtists(result)
		else:
			return []

	# Search for albums
	def getAlbumSearchResults(self, query, limit=ALBUM_LIMIT):
		result = self._callRemote('getAlbumSearchResults', {'query' : query,'limit' : limit})
		if 'result' in result:
			return self._parseAlbums(result)
		else:
			return []
		
	# Search for songs
	def getSongSearchResults(self, query, limit=SONG_LIMIT):
		result = self._callRemote('getSongSearchResultsEx', {'query' : query, 'limit' : limit})
		if 'result' in result:
			return self._parseSongs(result)
		else:
			return []
	
	# Gets the popular songs
	def getPopularSongsToday(self, limit=SONG_LIMIT):
		result = self._callRemote('getPopularSongsToday', {'limit' : limit})
		if 'result' in result:
			return self._parseSongs(result)
		else:
			return []

	# Gets the favorite songs of the logged-in user
	def getUserFavoriteSongs(self):
		if (self.userID == 0):
			return [];
		result = self._callRemote('getUserFavoriteSongs', {'sessionID' : self.sessionID})
		if 'result' in result:
			return self._parseSongs(result)
		else:
			return []
		
	# Get the url to link to a song on Grooveshark
	def getSongURLFromSongID(self, songID):
		song = GrooveSong(self.cacheDir)
		return song.getSongURL(songID)

	# Get the url to link to a song on Grooveshark
	def getSongInfo(self, songID):
		result = self._callRemote('getSongInfoEx', {'songID' : songID})
		if 'result' in result and 'SongID' in result['result']:
			info = result['result']
			if 'CoverArtFilename' in info and info['CoverArtFilename'] != None:
				info['CoverArtFilename'] = THUMB_URL+info['CoverArtFilename'].encode('ascii', 'ignore')
			else:
				info['CoverArtFilename'] = THUMB_URL_DEFAULT
			return info
		else:
			return ''

	# Gets the playlists of the logged-in user
	def getUserPlaylists(self):
		if (self.userID == 0):
			return [];
		result = self._callRemote('getUserPlaylists', {'sessionID' : self.sessionID})
		if 'result' in result:
			return self._parsePlaylists(result)
		else:
			return []

	# Creates a playlist with songs
	def createPlaylist(self, name, songIDs):
		result = self._callRemote('createPlaylist', {'name' : name, 'songIDs' : songIDs, 'sessionID' : self.sessionID})
		if 'result' in result and result['result']['success'] == 'true': 
			return result['result']['PlaylistID']
		elif 'errors' in result:
			return 0

	# Sets the songs for a playlist
	def setPlaylistSongs(self, playlistID, songIDs):
		result = self._callRemote('setPlaylistSongs', {'playlistID' : playlistID, 'songIDs' : songIDs, 'sessionID' : self.sessionID})
		if 'result' in result and result['result']['success'] == 'true': 
			return True;
		else:
			return False;

	# Gets the songs of a playlist
	def getPlaylistSongs(self, playlistID):
		result = self._callRemote('getPlaylistSongs', {'playlistID' : playlistID});
		if 'result' in result:
			return self._parseSongs(result)
		else:
			return []
	
	# Extract song data	
	def _parseSongs(self, items):
		if 'result' in items:
			i = 0
			list = []
			if 'songs' in items['result']:
				l = len(items['result']['songs'])
				index = 'songs'
			elif 'song' in items['result']:
				l = 1
				index = 'song'
			else:
				l = len(items['result'])
				index = ''
			while(i < l):
				if index == 'songs':
					s = items['result'][index][i]
				elif index == 'song':
					s = items['result'][index]
				else:
					s = items['result'][i]
				if 'CoverArtFilename' not in s:
					info = self.getSongInfo(s['SongID'])
					coverart = info['CoverArtFilename']
				elif s['CoverArtFilename'] != None:
					coverart = THUMB_URL+s['CoverArtFilename'].encode('ascii', 'ignore')
				else:
					coverart = THUMB_URL_DEFAULT
				list.append([s['SongName'].encode('ascii', 'ignore'),\
				s['SongID'],\
				s['AlbumName'].encode('ascii', 'ignore'),\
				s['AlbumID'],\
				s['ArtistName'].encode('ascii', 'ignore'),\
				s['ArtistID'],\
				coverart])
				i = i + 1
			return list
		else:
			return []

	# Extract artist data	
	def _parseArtists(self, items):
		if 'result' in items:
			i = 0
			list = []
			artists = items['result']['artists']
			while(i < len(artists)):
				s = artists[i]
				list.append([s['ArtistName'].encode('ascii', 'ignore'),\
				s['ArtistID']])
				i = i + 1
			return list
		else:
			return []

	# Extract album data	
	def _parseAlbums(self, items):
		if 'result' in items:
			i = 0
			list = []
			albums = items['result']['albums']
			while(i < len(albums)):
				s = albums[i]
				if 'CoverArtFilename' in s and s['CoverArtFilename'] != None:
					coverart = THUMB_URL+s['CoverArtFilename'].encode('ascii', 'ignore')
				else:
					coverart = THUMB_URL_DEFAULT
				list.append([s['ArtistName'].encode('ascii', 'ignore'),\
				s['ArtistID'],\
				s['AlbumName'].encode('ascii', 'ignore'),\
				s['AlbumID'],\
				coverart])
				i = i + 1
			return list
		else:
			return []

	def _parsePlaylists(self, items):
		if 'result' in items:
			i = 0
			list = []
			playlists = items['result']
			while(i < len(playlists)):
				s = playlists[i]
				list.append([s['PlaylistID'],\
				s['Name'].encode('ascii', 'ignore')])
				i = i + 1
			return list
		else:
			return []
		

# Test

res = []
groovesharkApi = GrooveAPI('/tmp')
#res = groovesharkApi.login('stephendenham', '*******')
#res = groovesharkApi.getSongSearchResults('jimmy jazz', 3)
#res = groovesharkApi.getPopularSongsToday()
#res = groovesharkApi.getSongURLFromSongID('27425375')
#res = groovesharkApi.getAlbumSearchResults('london calling', 3)
#res = groovesharkApi.getArtistSearchResults('the clash', 3)
#res = groovesharkApi.getUserFavoriteSongs()
#res = groovesharkApi.getUserPlaylists()
res = groovesharkApi.getSongInfo('27425375')
#res = groovesharkApi.getPlaylistSongs(40902662)

#pprint.pprint(res)
Commit	Line	Data
1413d357	1	import socket, hmac, urllib, urllib2, pprint, md5, uuid, re, hashlib, time, random, os, pickle
	2
	3	# GrooveAPI constants
	4	THUMB_URL = 'http://beta.grooveshark.com/static/amazonart/'
	5	THUMB_URL_DEFAULT = 'http://grooveshark.com/webincludes/logo/Grooveshark_Logo_No-Text.png'
	6	SONG_LIMIT = 25
	7	ALBUM_LIMIT = 15
	8	ARTIST_LIMIT = 15
	9
	10	# GrooveSong constants
	11	DOMAIN = "grooveshark.com"
	12	HOME_URL = "http://listen." + DOMAIN
	13	TOKEN_URL = "http://cowbell." + DOMAIN + "/more.php"
	14	API_URL = "http://cowbell." + DOMAIN + "/more.php"
	15	SERVICE_URL = "http://cowbell." + DOMAIN + "/service.php"
	16
	17	CLIENT_NAME = "gslite" #htmlshark #jsqueue
	18	CLIENT_VERSION = "20101012.37" #"20100831.25"
	19	HEADERS = {"Content-Type": "application/json",
	20	"User-Agent": "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.2.12) Gecko/20101026 Firefox/3.6.12 (.NET CLR 3.5.30729)",
	21	"Referer": "http://listen.grooveshark.com/main.swf?cowbell=fe87233106a6cef919a1294fb2c3c05f"}
	22
	23	RE_SESSION = re.compile('"sessionID":"\s?([A-z0-9]+)"') #re.compile('sessionID:\s?\'([A-z0-9]+)\',')
	24	RANDOM_CHARS = "1234567890abcdef"
	25
	26	# Get a song
	27	class GrooveSong:
	28
	29	def __init__(self, cacheDir):
	30
	31	import simplejson
	32	self.simplejson = simplejson
	33
	34	self.cacheDir = cacheDir
	35	self._lastTokenTime = 0
	36	self.uuid = self._getUUID()
	37	self.sessionID = self._getSession(HOME_URL)
	38	if self.sessionID == None:
	39	raise StandardError("Cannot get session id")
	40
	41	# The actual call to the API
	42	def _callRemote(self, method, params, type="default"):
	43	postData = {
	44	"header": {
	45	"client": CLIENT_NAME,
	46	"clientRevision": CLIENT_VERSION,
	47	"uuid": self.uuid,
	48	"session": self.sessionID},
	49	"country": {"IPR":"1021", "ID":"223", "CC1":"0", "CC2":"0", "CC3":"0", "CC4":"2147483648"},
	50	"privacy": 1,
	51	"parameters": params,
	52	"method": method}
	53
	54	token = self._getMethodToken(method)
	55	if token == None:
	56	raise StandardError("Cannot get token")
	57
	58	postData["header"]["token"] = token
	59	if type == "service":
	60	url = SERVICE_URL + "?" + method
	61	else:
	62	url = API_URL + "?" + method
	63
	64	postData = self.simplejson.dumps(postData)
65	print "GrooveSong URL: " + url
66	request = urllib2.Request(url, postData, HEADERS)
67
68	response = urllib2.urlopen(request).read()
69	try:
70	response = self.simplejson.loads(response)
71	print "GrooveSong Response..."
72	pprint.pprint(response)
73	except:
74	raise StandardError("API error: " + response)
75	try:
76	response["fault"]
77	except KeyError:
78	return response
79	else:
80	raise StandardError("API error: " + response["fault"]["message"])
81
82	# Generate a random uuid
83	def _getUUID(self):
84	return str(uuid.uuid4())
85
86	# Make a token ready for a request header
87	def _getMethodToken(self, method):
88	if (time.time() - self._lastTokenTime) >= 1000:
89	self._token = self._getCommunicationToken()
90	if self._token == None:
91	return None
92	self._lastTokenTime = time.time()
93
94	randomChars = ""
95	while 6 > len(randomChars):
96	randomChars = randomChars + random.choice(RANDOM_CHARS)
97
98	token = hashlib.sha1(method + ":" + self._token + ":quitStealinMahShit:" + randomChars).hexdigest()
99	return randomChars + token
100
101	# Generate a communication token
102	def _getCommunicationToken(self):
103	params = {"secretKey": self._getSecretKey(self.sessionID)}
104	postData = {
105	"header": {
106	"client": CLIENT_NAME,
107	"clientRevision": CLIENT_VERSION,
108	"uuid": self.uuid,
109	"session": self.sessionID},
110	"country": {"IPR":"1021", "ID":"223", "CC1":"0", "CC2":"0", "CC3":"0", "CC4":"2147483648"},
111	"privacy": 1,
112	"parameters": params,
113	"method": "getCommunicationToken"}
114
115	postData = self.simplejson.dumps(postData)
116	request = urllib2.Request(TOKEN_URL, postData, HEADERS)
117	response = urllib2.urlopen(request).read()
118	try:
119	response = self.simplejson.loads(response)
120	except:
121	raise StandardError("API error: " + response)
122	try:
123	response["fault"]
124	except KeyError:
125	return response["result"]
126	else:
127	return None
128
129	# Generate a secret key from a sessionID
130	def _getSecretKey(self, sessionID):
131	return hashlib.md5(sessionID).hexdigest()
132
133	# Get a session id from some HTML
134	def _getSession(self, html):
135	html = urllib2.urlopen(HOME_URL).read()
136	session = RE_SESSION.search(html)
137	if session:
138	return session.group(1)
139	else:
140	return None
141
142	# Gets a stream key and host to get song content
143	def _getStreamDetails(self, songID):
144	params = {
145	"songID": songID,
146	"prefetch": False,
147	"mobile": False,
148	"country": {"IPR":"1021","ID":"223", "CC1":"0", "CC2":"0", "CC3":"0", "CC4":"2147483648"}
149	}
150	response = self._callRemote("getStreamKeyFromSongIDEx", params)
151	self._lastStreamKey = response["result"]["streamKey"]
152	self._lastStreamServer = response["result"]["ip"]
153	self._lastStreamServerID = response["result"]["streamServerID"]
154
155	# Tells Grooveshark you have downloaded a song
156	def _markSongDownloaded(self, songID):
157	params = {
158	"streamKey": self._lastStreamKey,
159	"streamServerID": self._lastStreamServerID,
160	"songID": songID}
161	self._callRemote("markSongDownloaded", params)
162
163	# Download a song to a temporary file
164	def getSongURL(self, songID):
165	filename = os.path.join(self.cacheDir, songID + '.mp3')
166	if os.path.isfile(filename) == False:
167	self._getStreamDetails(songID)
168	postData = {"streamKey": self._lastStreamKey}
169	postData = urllib.urlencode(postData)
170	urllib.FancyURLopener().retrieve( "http://" + self._lastStreamServer + "/stream.php", filename, data=postData)
171	self._markSongDownloaded(songID)
172	return filename
173
174
175	# Main API
176	class GrooveAPI:
177
178	sessionID = ''
179	userID = 0
180	host = 'api.grooveshark.com'
0e7dbdf7	181	lastSessionTime = 0
1413d357	182
	183	# Constructor
	184	def __init__(self, cacheDir):
	185	import simplejson
	186	self.simplejson = simplejson
	187	socket.setdefaulttimeout(40)
	188	self.cacheDir = cacheDir
0e7dbdf7	189	self._getSavedSessionID()
	190	# session ids last 1 week
	191	if self.sessionID == '' or time.time()- self.lastSessionTime >= 6*86400:
1413d357	192	self.sessionID = self._getSessionID()
	193	if self.sessionID == '':
	194	raise StandardError('Failed to get session id')
	195	else:
0e7dbdf7	196	print "New session id: " + self.sessionID
	197	self._setSavedSessionID()
	198
1413d357	199	# Sort keys
	200	def _keySort(self, d):
	201	return [(k,d[k]) for k in sorted(d.keys())]
	202
	203	# Make a message sig
	204	def _createMessageSig(self, method, params, secret):
	205	args = self._keySort(params);
	206	data = '';
	207	for arg in args:
	208	data += str(arg[0])
	209	data += str(arg[1])
	210	data = method + data
	211
	212	h = hmac.new(secret, data)
	213	return h.hexdigest()
	214
	215	# The actual call to the API
	216	def _callRemote(self, method, params = {}):
	217	url = 'http://%s/ws/2.1/?method=%s&%s&wsKey=wordpress&sig=%s&format=json' % (self.host, method, urllib.urlencode(params), self._createMessageSig(method, params, 'd6c59291620c6eaa5bf94da08fae0ecc'))
	218	print url
	219	req = urllib2.Request(url)
	220	response = urllib2.urlopen(req)
	221	result = response.read()
	222	pprint.pprint(result)
	223	response.close()
	224	try:
	225	result = self.simplejson.loads(result)
	226	return result
	227	except:
	228	return []
	229
	230	# Get a session id
	231	def _getSessionID(self):
	232	params = {}
	233	result = self._callRemote('startSession', params)
0e7dbdf7	234	self.lastSessionTime = time.time()
1413d357	235	return result['result']['sessionID']
	236
	237	def _getSavedSessionID(self):
0e7dbdf7	238	path = os.path.join(self.cacheDir, 'session', 'session.dmp')
1413d357	239	try:
1413d357	240	f = open(path, 'rb')
0e7dbdf7	241	session = pickle.load(f)
	242	self.sessionID = session['sessionID']
	243	self.lastSessionTime = session['lastSessionTime']
1413d357	244	f.close()
1413d357	245	except:
0e7dbdf7	246	self.sessionID = ''
0e7dbdf7	247	self.lastSessionTime = 0
1413d357	248	pass
1413d357	249
	250	def _setSavedSessionID(self):
	251	try:
	252	dir = os.path.join(self.cacheDir, 'session')
	253	# Create the 'data' directory if it doesn't exist.
	254	if not os.path.exists(dir):
	255	os.makedirs(dir)
0e7dbdf7	256	path = os.path.join(dir, 'session.dmp')
1413d357	257	f = open(path, 'wb')
0e7dbdf7	258	session = { 'sessionID' : self.sessionID, 'lastSessionTime' : self.lastSessionTime}
0e7dbdf7	259	pickle.dump(session, f, protocol=pickle.HIGHEST_PROTOCOL)
1413d357	260	f.close()
	261	except:
	262	print "An error occured during save session"
	263	pass
	264
	265	# Make user authentication token
	266	def _getUserToken(self, username, password):
	267	return md5.new(username.lower() + md5.new(password).hexdigest()).hexdigest()
	268
	269	# Authenticates the user for current API session
	270	def _authenticateUser(self, username, token):
	271	params = {'sessionID': self.sessionID, 'username': username, 'token': token}
	272	result = self._callRemote('authenticateUser', params)
	273	return result['result']['UserID']
	274
	275	# Login
	276	def login(self, username, password):
	277	token = self._getUserToken(username, password)
	278	self.userID = self._authenticateUser(username, token)
	279	return self.userID
	280
	281	# Logs the user out
	282	def logout(self):
	283	self._callRemote('logout', {'sessionID' : self.sessionID})
	284
	285	# Return user id
	286	def getUserID(self):
	287	return self.userID
	288
	289	# Search for albums
	290	def getArtistSearchResults(self, query, limit=ARTIST_LIMIT):
	291	result = self._callRemote('getArtistSearchResults', {'query' : query,'limit' : limit})
	292	if 'result' in result:
	293	return self._parseArtists(result)
	294	else:
	295	return []
	296
	297	# Search for albums
	298	def getAlbumSearchResults(self, query, limit=ALBUM_LIMIT):
	299	result = self._callRemote('getAlbumSearchResults', {'query' : query,'limit' : limit})
	300	if 'result' in result:
	301	return self._parseAlbums(result)
	302	else:
	303	return []
	304
	305	# Search for songs
	306	def getSongSearchResults(self, query, limit=SONG_LIMIT):
	307	result = self._callRemote('getSongSearchResultsEx', {'query' : query, 'limit' : limit})
	308	if 'result' in result:
	309	return self._parseSongs(result)
	310	else:
	311	return []
	312
	313	# Gets the popular songs
	314	def getPopularSongsToday(self, limit=SONG_LIMIT):
	315	result = self._callRemote('getPopularSongsToday', {'limit' : limit})
	316	if 'result' in result:
	317	return self._parseSongs(result)
	318	else:
	319	return []
	320
	321	# Gets the favorite songs of the logged-in user
	322	def getUserFavoriteSongs(self):
	323	if (self.userID == 0):
324	return [];
325	result = self._callRemote('getUserFavoriteSongs', {'sessionID' : self.sessionID})
326	if 'result' in result:
327	return self._parseSongs(result)
328	else:
329	return []
330
331	# Get the url to link to a song on Grooveshark
332	def getSongURLFromSongID(self, songID):
333	song = GrooveSong(self.cacheDir)
334	return song.getSongURL(songID)
335
336	# Get the url to link to a song on Grooveshark
337	def getSongInfo(self, songID):
338	result = self._callRemote('getSongInfoEx', {'songID' : songID})
339	if 'result' in result and 'SongID' in result['result']:
340	info = result['result']
341	if 'CoverArtFilename' in info and info['CoverArtFilename'] != None:
342	info['CoverArtFilename'] = THUMB_URL+info['CoverArtFilename'].encode('ascii', 'ignore')
343	else:
344	info['CoverArtFilename'] = THUMB_URL_DEFAULT
345	return info
346	else:
347	return ''
348
349	# Gets the playlists of the logged-in user
350	def getUserPlaylists(self):
351	if (self.userID == 0):
352	return [];
353	result = self._callRemote('getUserPlaylists', {'sessionID' : self.sessionID})
354	if 'result' in result:
355	return self._parsePlaylists(result)
356	else:
357	return []
358
359	# Creates a playlist with songs
360	def createPlaylist(self, name, songIDs):
361	result = self._callRemote('createPlaylist', {'name' : name, 'songIDs' : songIDs, 'sessionID' : self.sessionID})
362	if 'result' in result and result['result']['success'] == 'true':
363	return result['result']['PlaylistID']
364	elif 'errors' in result:
365	return 0
366
367	# Sets the songs for a playlist
368	def setPlaylistSongs(self, playlistID, songIDs):
369	result = self._callRemote('setPlaylistSongs', {'playlistID' : playlistID, 'songIDs' : songIDs, 'sessionID' : self.sessionID})
370	if 'result' in result and result['result']['success'] == 'true':
371	return True;
372	else:
373	return False;
374
375	# Gets the songs of a playlist
376	def getPlaylistSongs(self, playlistID):
377	result = self._callRemote('getPlaylistSongs', {'playlistID' : playlistID});
378	if 'result' in result:
379	return self._parseSongs(result)
380	else:
381	return []
382
383	# Extract song data
384	def _parseSongs(self, items):
385	if 'result' in items:
386	i = 0
387	list = []
388	if 'songs' in items['result']:
389	l = len(items['result']['songs'])
390	index = 'songs'
391	elif 'song' in items['result']:
392	l = 1
393	index = 'song'
394	else:
395	l = len(items['result'])
396	index = ''
397	while(i < l):
398	if index == 'songs':
399	s = items['result'][index][i]
400	elif index == 'song':
401	s = items['result'][index]
402	else:
403	s = items['result'][i]
404	if 'CoverArtFilename' not in s:
405	info = self.getSongInfo(s['SongID'])
406	coverart = info['CoverArtFilename']
407	elif s['CoverArtFilename'] != None:
408	coverart = THUMB_URL+s['CoverArtFilename'].encode('ascii', 'ignore')
409	else:
410	coverart = THUMB_URL_DEFAULT
411	list.append([s['SongName'].encode('ascii', 'ignore'),\
412	s['SongID'],\
413	s['AlbumName'].encode('ascii', 'ignore'),\
414	s['AlbumID'],\
415	s['ArtistName'].encode('ascii', 'ignore'),\
416	s['ArtistID'],\
417	coverart])
418	i = i + 1
419	return list
420	else:
421	return []
422
423	# Extract artist data
424	def _parseArtists(self, items):
425	if 'result' in items:
426	i = 0
427	list = []
428	artists = items['result']['artists']
429	while(i < len(artists)):
430	s = artists[i]
431	list.append([s['ArtistName'].encode('ascii', 'ignore'),\
432	s['ArtistID']])
433	i = i + 1
434	return list
435	else:
436	return []
437
438	# Extract album data
439	def _parseAlbums(self, items):
440	if 'result' in items:
441	i = 0
442	list = []
443	albums = items['result']['albums']
444	while(i < len(albums)):
445	s = albums[i]
446	if 'CoverArtFilename' in s and s['CoverArtFilename'] != None:
447	coverart = THUMB_URL+s['CoverArtFilename'].encode('ascii', 'ignore')
448	else:
449	coverart = THUMB_URL_DEFAULT
450	list.append([s['ArtistName'].encode('ascii', 'ignore'),\
451	s['ArtistID'],\
452	s['AlbumName'].encode('ascii', 'ignore'),\
453	s['AlbumID'],\
454	coverart])
455	i = i + 1
456	return list
457	else:
458	return []
459
460	def _parsePlaylists(self, items):
461	if 'result' in items:
462	i = 0
463	list = []
464	playlists = items['result']
465	while(i < len(playlists)):
466	s = playlists[i]
467	list.append([s['PlaylistID'],\
468	s['Name'].encode('ascii', 'ignore')])
469	i = i + 1
470	return list
471	else:
472	return []
473
474
475
476	# Test
477
0e7dbdf7	478	res = []
0e7dbdf7	479	groovesharkApi = GrooveAPI('/tmp')
1413d357	480	#res = groovesharkApi.login('stephendenham', '*******')
	481	#res = groovesharkApi.getSongSearchResults('jimmy jazz', 3)
	482	#res = groovesharkApi.getPopularSongsToday()
	483	#res = groovesharkApi.getSongURLFromSongID('27425375')
	484	#res = groovesharkApi.getAlbumSearchResults('london calling', 3)
	485	#res = groovesharkApi.getArtistSearchResults('the clash', 3)
	486	#res = groovesharkApi.getUserFavoriteSongs()
	487	#res = groovesharkApi.getUserPlaylists()
0e7dbdf7	488	res = groovesharkApi.getSongInfo('27425375')
1413d357	489	#res = groovesharkApi.getPlaylistSongs(40902662)
	490
	491	#pprint.pprint(res)
	492
	493
	494