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

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

SESSION_EXPIRY = 518400 # 6 days in seconds

# GrooveAPI constants
THUMB_URL = 'http://beta.grooveshark.com/static/amazonart/'
SONG_LIMIT = 25
ALBUM_LIMIT = 15
ARTIST_LIMIT = 15
SONG_SUFFIX = '.mp3'

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

CLIENT_NAME = "gslite"
CLIENT_VERSION = "20101012.37"
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]+)"')
RANDOM_CHARS = "1234567890abcdef"

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

		import simplejson
		self.simplejson = simplejson
		
		self.cacheDir = os.path.join(tempfile.gettempdir(), 'groovesong')
		self._lastSessionTime = 0
		self.uuid = self._getUUID()
		
		self._getSavedSession()
		# session ids last 1 week
		if self.sessionID == '' or time.time() - self._lastSessionTime >= SESSION_EXPIRY:
			self.sessionID = self._getSession(HOME_URL)
			if self.sessionID == '':
				raise StandardError('Failed to get session id')
			else:
				print "New GrooveSong session id: " + self.sessionID
				self._setSavedSession()
		
	# 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):
		self._token = self._getCommunicationToken()
		if self._token == None:
			return None

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

		token = sha.new(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 md5.new(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:
			self._lastSessionTime = time.time()
			return session.group(1)
		else:
			return None
		
	def _getSavedSession(self):
		path = os.path.join(self.cacheDir, '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 _setSavedSession(self):			
		try:
			# Create the 'data' directory if it doesn't exist.
			if not os.path.exists(self.cacheDir):
				os.makedirs(self.cacheDir)
			path = os.path.join(self.cacheDir, '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 occurred during save session"
			pass
	
	# 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)
		try: 
			self._lastStreamKey = response["result"]["streamKey"]
			self._lastStreamServer = response["result"]["ip"]
			self._lastStreamServerID = response["result"]["streamServerID"]
			return True
		except:
			return False
		
	# Tells Grooveshark you have downloaded a song
	def _markSongDownloaded(self, songID):
		params = {
			"streamKey": self._lastStreamKey,
			"streamServerID": self._lastStreamServerID,
			"songID": songID}
		self._callRemote("markSongDownloaded", params)

	# Get the song URL
	def getSongURL(self, songID):
		if self._getStreamDetails(songID) == True:
			postData = {"streamKey": self._lastStreamKey}
			postData = urllib.urlencode(postData)
			return "http://" + self._lastStreamServer + "/stream.php?" + str(postData)
		else:
			return ''

# Main API
class GrooveAPI:

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

	# Constructor
	def __init__(self):
		
		import simplejson
		self.simplejson = simplejson
		socket.setdefaulttimeout(40)
		
		self.cacheDir = os.path.join(tempfile.gettempdir(), 'grooveapi')
		if os.path.isdir(self.cacheDir) == False:
			os.makedirs(self.cacheDir)
			print "Made " + self.cacheDir

		self._getSavedSession()
		# session ids last 1 week
		if self.sessionID == '' or time.time()- self.lastSessionTime >= SESSION_EXPIRY:
			self.sessionID = self._getSessionID()
			if self.sessionID == '':
				raise StandardError('Failed to get session id')
			else:
				print "New GrooveAPI session id: " + self.sessionID
				self._setSavedSession()

	# 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()
		print "Response..."
		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 _getSavedSession(self):
		path = os.path.join(self.cacheDir, 'session.dmp')
		try:
			f = open(path, 'rb')
			session = pickle.load(f)
			self.sessionID = session['sessionID']
			self.lastSessionTime = session['lastSessionTime']
			self.userID = session['userID']
			f.close()
		except:
			self.sessionID = ''
			self.lastSessionTime = 0
			self.userID = 0
			pass		

	def _setSavedSession(self):			
		try:
			# Create the directory if it doesn't exist.
			if not os.path.exists(self.cacheDir):
				os.makedirs(self.cacheDir)
			path = os.path.join(self.cacheDir, 'session.dmp')
			f = open(path, 'wb')
			session = { 'sessionID' : self.sessionID, 'lastSessionTime' : self.lastSessionTime, 'userID': self.userID}
			pickle.dump(session, f, protocol=pickle.HIGHEST_PROTOCOL)
			f.close()
		except:
			print "An error occurred 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):
		if self.userID <= 0:
			# Check cache
			self._getSavedSession()
			if self.userID <= 0: 
				token = self._getUserToken(username, password)
				self.userID = self._authenticateUser(username, token)
				if self.userID > 0:
					self._setSavedSession()
		return self.userID
		
	# Logs the user out
	def logout(self):
		result = self._callRemote('logout', {'sessionID' : self.sessionID})
		if 'result' in result and result['result']['success'] == True: 
			self.userID = 0
			self._setSavedSession()
			return True
		return False

	# 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 []
		
	# Get artists albums
	def getArtistAlbums(self, artistID, limit=ALBUM_LIMIT):
		result = self._callRemote('getArtistAlbums', {'artistID' : artistID})
		if 'result' in result:
			return self._parseAlbums(result, limit)
		else:
			return []

	# Get album songs
	def getAlbumSongs(self, albumID, limit=SONG_LIMIT):
		result = self._callRemote('getAlbumSongsEx', {'albumID' : albumID, '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:
			# Note limit is broken in the Grooveshark getPopularSongsToday method
			return self._parseSongs(result, limit)
		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 []
		
	# Add song to user favorites
	def addUserFavoriteSong(self, songID):
		if (self.userID == 0):
			return False;
		result = self._callRemote('addUserFavoriteSong', {'sessionID' : self.sessionID, 'songID' : songID})
		return result['result']['success']

	# Get the url to link to a song on Grooveshark
	def getSongURLFromSongID(self, songID):
		song = GrooveSong()
		url = song.getSongURL(songID)
		print "Got song URL " + url
		return url

	# 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'] = 'None'
			return info
		else:
			return 'None'

	# 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 []

	# Check the service
	def pingService(self,):
		result = self._callRemote('pingService', {});
		if 'result' in result and result['result'] != '':
			return True
		else:
			return False
	
	# Extract song data	
	def _parseSongs(self, items, limit=0):
		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 = ''
			if limit > 0 and l > limit:
				l = limit
			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 = 'None'
				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, limit=0):
		if 'result' in items:
			i = 0
			list = []
			try:
				albums = items['result']['albums']
			except:
				res = items['result'][0]
				albums = res['albums']
			l = len(albums)
			if limit > 0 and l > limit:
				l = limit
			while(i < l):
				s = albums[i]
				if 'CoverArtFilename' in s and s['CoverArtFilename'] != None:
					coverart = THUMB_URL+s['CoverArtFilename'].encode('ascii', 'ignore')
				else:
					coverart = 'None'
				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['Name'].encode('ascii', 'ignore'), s['PlaylistID']])
				i = i + 1
			return list
		else:
			return []

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