pylast/pylast.py

# -*- coding: utf-8 -*-
#
# pylast - Python bindings for the Last.fm webservices.
# Copyright (C) 2008-2009  Amr Hassan
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
# USA
#
# For help regarding using this library, please visit the official
# documentation at http://code.google.com/p/pylast/wiki/Documentation

LIB_NAME = 'pyLast'
LIB_VERSION = '0.20.02a'

API_SERVER = 'ws.audioscrobbler.com'
API_SUBDIR = '/2.0/'

import md5
import httplib
import urllib
import threading
from xml.dom import minidom

STATUS_OK = 'ok'
STATUS_FAILED = 'failed'
STATUS_INVALID_SERVICE = 2
STATUS_INVALID_METHOD = 3
STATUS_AUTH_FAILED = 4
STATUS_INVALID_FORMAT = 5
STATUS_INVALID_PARAMS = 6
STATUS_INVALID_RESOURCE = 7
STATUS_TOKEN_ERROR = 8
STATUS_INVALID_SK = 9
STATUS_INVALID_API_KEY = 10
STATUS_OFFLINE = 11
STATUS_SUBSCRIBERS_ONLY = 12
STATUS_TOKEN_UNAUTHORIZED = 14
STATUS_TOKEN_EXPIRED = 15

EVENT_ATTENDING = '0'
EVENT_MAYBE_ATTENDING = '1'
EVENT_NOT_ATTENDING = '2'

PERIOD_OVERALL = 'overall'
PERIOD_3MONTHS = '3month'
PERIOD_6MONTHS = '6month'
PERIOD_12MONTHS = '12month'

IMAGE_SMALL = 0
IMAGE_MEDIUM = 1
IMAGE_LARGE = 2

DOMAIN_ENGLISH = 'www.last.fm'
DOMAIN_GERMAN = 'www.lastfm.de'
DOMAIN_SPANISH = 'www.lastfm.es'
DOMAIN_FRENCH = 'www.lastfm.fr'
DOMAIN_ITALIAN = 'www.lastfm.it'
DOMAIN_POLISH = 'www.lastfm.pl'
DOMAIN_PORTUGUESE = 'www.lastfm.com.br'
DOMAIN_SWEDISH = 'www.lastfm.se'
DOMAIN_TURKISH = 'www.lastfm.com.tr'
DOMAIN_RUSSIAN = 'www.lastfm.ru'
DOMAIN_JAPANESE = 'www.lastfm.jp'
DOMAIN_CHINESE = 'cn.last.fm'

def _status2str(lastfm_status):
	
	statuses = {
		STATUS_OK: 'OK',
		STATUS_FAILED: 'Failed',
		STATUS_INVALID_METHOD: 'Invalid Method - No method with that name in this package',
		STATUS_TOKEN_ERROR: 'There was an error granting the request token.',
		STATUS_INVALID_SERVICE: 'Invalid service - This service does not exist',
		STATUS_AUTH_FAILED: 'Authentication Failed - You do not have permissions to access the service',
		STATUS_INVALID_FORMAT: "Invalid format - This service doesn't exist in that format",
		STATUS_INVALID_PARAMS: 'Invalid parameters - Your request is missing a required parameter',
		STATUS_INVALID_RESOURCE: 'Invalid resource specified',
		STATUS_INVALID_SK: 'Invalid session key - Please re-authenticate',
		STATUS_INVALID_API_KEY: 'Invalid API key - You must be granted a valid key by last.fm',
		STATUS_OFFLINE: 'Service Offline - This service is temporarily offline. Try again later.',
		STATUS_SUBSCRIBERS_ONLY: 'Subscribers Only - This service is only available to paid last.fm subscribers',
		STATUS_TOKEN_UNAUTHORIZED: 'This token has not been authorized',
		STATUS_TOKEN_EXPIRED: 'This token has expired'
	}
	
	return statuses[int(lastfm_status)]

class ServiceException(Exception):
	"""Exception related to the Last.fm web service"""
	
	def __init__(self, lastfm_status):
		self.lastfm_status = lastfm_status
	
	def __str__(self):
		return "Last.fm Service Error: %s" % _status2str(self.lastfm_status)

class Asynchronizer(threading.Thread):
	"""Hopingly, this class would help perform asynchronous operations less painfully.
	For inherited use only. And you must call Asynchronizer.__init__(descendant) before usage.
	"""
	
	def __init__(self):
		threading.Thread.__init__(self)
		
		self._calls = {}		#calls is structured like this: {call_pointer: (arg1, arg2, ...)}
		self._callbacks = {} 	#callbacks is structred like this: {call_pointer: callback_pointer}
	
	def run(self):
		"""Avoid running this function. Use start() to begin the thread's work."""
		for call in self._calls.keys():
			output = call(*(self._calls[call]))
			callback = self._callbacks[call]
			callback(self, output)
			
			del self._calls[call]
			del self._callbacks[call]
	
	def async_call(self, callback, call, *call_args):
		"""This is the function for setting up an asynchronous operation.
		callback: the function to callback afterwards, accepting two argument, one being the sender and the other is the return of the target call.
		call: the target call.
		*call_args: any number of arguments to pass to the target call function.
		"""
		
		self._calls[call] = call_args
		self._callbacks[call] = callback

class Exceptionable(object):
	"""An abstract class that adds support for error reporting."""
	
	def __init__(self, parent = None, raising_exceptions = False):
		self.__errors = []
		self.__raising_exceptions = raising_exceptions
		
		#An Exceptionable parent to mirror all the errors to automatically.
		self._parent = parent
	
	def last_error(self):
		"""Returns the last error, or None."""
		
		if len(self.__errors):
			return self.__errors[len(self.__errors) -1]
		else:
			return None
	
	def _report_error(self, exception):
		self.__errors.append(exception)
		
		if self._parent:
			self._parent._mirror_errors(self)
	
	def _mirror_errors(self, exceptional):
		"""Mirrors the errors from another Exceptional object"""
		
		for e in exceptional.get_all_errors():
			self._report_error(e)
	
	def clear_erros(self):
		"""Clear the error log for this object."""
		self.__errors = []
	
	def get_all_errors(self):
		"""Return a list of exceptions raised about this object."""
		
		return self.__errors
	
	def enable_raising_exceptions(self):
		"""Enable raising the exceptions about this object."""
		self.__raising_exceptions = True
	
	def disable_raising_exceptions(self):
		"""Disable raising the exceptions about this object, but still report them to the log."""
		self.__raising_exceptions = False
	
	def get_raising_exceptions(self):
		"""Get the status on raising exceptions."""
		return self.__raising_exceptions
	
class Request(Exceptionable):
	"""Representing an abstract web service operation."""
	
	def __init__(self, parent, method_name, api_key, params, sign_it = False, secret = None):
		Exceptionable.__init__(self, parent)
		
		self.method_name = method_name
		self.api_key = api_key
		self.params = params
		self.sign_it = sign_it
		self.secret = secret
	
	def _getSignature(self):
		"""Returns a 32-character hexadecimal md5 hash of the signature string."""
		
		keys = self.params.keys()[:]
		
		keys.sort()
		
		string = unicode()
		
		for name in keys:
			string += name
			string += self.params[name]
		
		string += self.secret
		
		hash = md5.new()
		hash.update(string)
		
		return hash.hexdigest()
	
	def execute(self):
		"""Returns the XML DOM response of the POST request from the server"""
		
		self.params['api_key'] = self.api_key
		self.params['method'] = self.method_name
		if self.sign_it:
			self.params['api_sig'] = self._getSignature()
		
		data = []
		for name in self.params.keys():
			data.append('='.join((name, self.params[name])))
		
		try:
			conn = httplib.HTTPConnection(API_SERVER)
			headers = {
				"Content-type": "application/x-www-form-urlencoded",
				'Accept-Charset': 'utf-8',
				'User-Agent': LIB_NAME + '/' + LIB_VERSION
				}
			conn.request('POST', API_SUBDIR, '&'.join(data), headers)
			response = conn.getresponse()
		except Exception, e:
			self._report_error(e)
			return None
		
		doc = minidom.parse(response)
		
		if self.__checkResponseStatus(doc) == STATUS_OK:
			return doc
		
		return None
		
	def __checkResponseStatus(self, xml_dom):
		"""Checks the response for errors and raises one if any exists."""
		
		doc = xml_dom
		e = doc.getElementsByTagName('lfm')[0]
		
		if e.getAttribute('status') == STATUS_OK:
			return STATUS_OK
		else:
			e = doc.getElementsByTagName('error')[0]
			status = e.getAttribute('code')
			self._report_error(ServiceException(status))

class SessionGenerator(Asynchronizer, Exceptionable):
	"""Steps of authorization:
	1. Retrieve token: token = getToken()
	2. Authorize this token by openning the web page at the URL returned by getAuthURL(token)
	3. Call getSessionData(token) to collect the session parameters.
	
	A session key's lifetime is infinie, unless the user provokes the rights of the given API Key.
	"""
	
	def __init__(self, api_key, secret):
		Asynchronizer.__init__(self)
		Exceptionable.__init__(self)
		
		self.api_key = api_key
		self.secret = secret
	
	
	def getToken(self):
		"""Retrieves a token from Last.fm.
		The token then has to be authorized from getAuthURL before creating session.
		"""
		
		
		doc = Request(self, 'auth.getToken', self.api_key, dict(), True, self.secret).execute()
		
		if not doc:
			return None
		
		e = doc.getElementsByTagName('token')[0]
		return e.firstChild.data
		
	
	def getAuthURL(self, token):
		"""The user must open this page, and authorize the given token."""
		
		url = 'http://www.last.fm/api/auth/?api_key=%(api)s&token=%(token)s' % \
			{'api': self.api_key, 'token': token}
		return url
	
	def getSessionData(self, token):
		"""Retrieves session data for the authorized token.
		getSessionData(token) --> {'name': str, 'key': str, 'subscriber': bool}
		"""
		
		params = {'token': token}
		doc = Request(self, 'auth.getSession', self.api_key, params, True, self.secret).execute()
		
		if not doc:
			return None
		
		name_e = doc.getElementsByTagName('name')[0]
		key_e = doc.getElementsByTagName('key')[0]
		subscriber_e = doc.getElementsByTagName('subscriber')[0]
		
		data = {}
		data['name'] = name_e.firstChild.data
		data['key'] = key_e.firstChild.data
		data['subscriber'] = bool(subscriber_e.firstChild.data)
		
		return data

class BaseObject(Asynchronizer, Exceptionable):
	"""An abstract webservices object."""
		
	def __init__(self, api_key, secret, session_key):
		Asynchronizer.__init__(self)
		Exceptionable.__init__(self)
		
		self.api_key = api_key
		self.secret = secret
		self.session_key = session_key
		
		self.auth_data = (self.api_key, self.secret, self.session_key)
	
	def _extract(self, node, name, index = 0):
		"""Extracts a value from the xml string"""
		
		nodes = node.getElementsByTagName(name)
		
		if len(nodes):
			if nodes[index].firstChild:
				return nodes[index].firstChild.data.strip()
		else:
			return None
	
	def _extract_all(self, node, name, limit_count = None):
		"""Extracts all the values from the xml string. returning a list."""
		
		list = []
		
		for i in range(0, len(node.getElementsByTagName(name))):
			if len(list) == limit_count:
				break
			
			list.append(self._extract(node, name, i))
		
		return list
	
	def _get_url_safe(self, text):
		
		if type(text) == type(unicode()):
			text = text.encode('utf-8')
		
		return urllib.quote_plus(text)

	def toStr():
		return ""
	
	def _hash(self):
		return self.toStr().lower()
	
	def __str__(self):
		return self.toStr()

class Cacheable(object):
	"""Common functions for objects that can have cached metadata"""
	
	def __init__(self, user_set_data = False):
		
		# user_set_data identifies objects like Track that doesn't have
		# a getInfo function, so the user sets the extra data from other feeds
		
		self._cached_info = None
		self._user_set_data = user_set_data
	
	def _getInfo(self):
		"""Abstract function, should be inherited"""
	
	def _getCachedInfo(self):
		"""Returns the cached collection of info regarding this object
		If not available in cache, it will be downloaded first
		"""
		
		if self._user_set_data:
			return None
		
		if not self._cached_info:
			self._cached_info = self._getInfo()
		
		return self._cached_info
	
	def _setCachedInfo(self, info):
		"""Set the info for objects that does not have a getInfo function"""
		
		self._cached_info = info


class Album(BaseObject, Cacheable):
	
	def __init__(self, artist_name, album_title, api_key, secret, session_key):
		BaseObject.__init__(self, api_key, secret, session_key)
		Cacheable.__init__(self)
		
		self._artist_name = artist_name
		self._album_title = album_title
		
		self._cached_info = None
	
	def _getParams(self):
		return {'artist': self._artist_name, 'album': self._album_title, 'sk': self.session_key}

	def _getInfo(self):
		"""Get the metadata for an album"""	
		
		params = self._getParams()
		
		doc = Request(self, 'album.getInfo', self.api_key, params).execute()
		
		if not doc:
			return None
		
		data = {}
		
		data['name'] = self._extract(doc, 'name')
		data['artist'] = self._extract(doc, 'artist')
		data['id'] = self._extract(doc, 'id')
		data['release_date'] = self._extract(doc, 'releasedate')
		data['images'] = self._extract_all(doc, 'image')
		data['listeners'] = self._extract(doc, 'listeners')
		data['play_count'] = self._extract(doc, 'playcount')
		
		tags_element = doc.getElementsByTagName('toptags')[0]
		data['top_tags'] = self._extract_all(tags_element, 'name')
		
		return data
	
	def getArtist(self):
		"""Returns the associated Artist object. """
		
		return Artist(self._artist_name, *self.auth_data)
	
	def getTitle(self):
		"""Returns the album title."""
		
		return self._album_title
	
	def getReleaseDate(self):
		"""Retruns the release date of the album."""
		
		return self._getCachedInfo()['release_date']
	
	def getImage(self, size = IMAGE_LARGE):
		"""Returns the associated image URL.
		* size: The image size. Can be one of three values: IMAGE_LARGE, IMAGE_MEDIUM, or IMAGE_SMALL. 
		"""
		
		return self._getCachedInfo()['images'][size]
	
	def getID(self):
		"""Returns the Last.fm ID. """
		
		return self._getCachedInfo()['id']
	
	def getPlayCount(self):
		"""Returns the number of plays on Last.fm."""
		
		return self._getCachedInfo()['play_count']
	
	def getListenerCount(self):
		"""Returns the number of liteners on Last.fm."""
		
		return self._getCachedInfo()['listeners']
	
	def getTopTags(self):
		"""Returns a list of the most-applied tags to this album. """
		
		l = []
		for tag in self._getCachedInfo()['top_tags']:
			l.append(Tag(tag, *self.auth_data))
		
		return l
	
	def addTags(self, *tags):
		"""Adds one or several tags.
		* *tags: Any number of tag names or Tag objects. 
		"""
		
		#last.fm currently accepts a max of 10 tags at a time
		while(len(tags) > 10):
			section = tags[0:9]
			tags = tags[9:]
			self.addTags(section)
		
		if len(tags) == 0:
			return None
		
		ntags = []
		for tag in tags:
			if isinstance(tag, Tag):
				ntags.append(tag.getName())
			else:
				ntags.append(tag)
		
		tagstr = ','.join(ntags)
		
		params = self._getParams()
		params['tags'] = tagstr
		
		Request(self, 'album.addTags', self.api_key, params, True, self.secret).execute()
	
	def getTags(self):
		"""Returns a list of the user-set tags to this album."""
		
		params = self._getParams()
		doc = Request(self, 'album.getTags', self.api_key, params, True, self.secret).execute()
		
		if not doc:
			return None
		
		tag_names = self._extract_all(doc, 'name')
		tags = []
		for tag in tag_names:
			tags.append(Tag(tag, *self.auth_data))
		
		return tags
	
	def _removeTag(self, single_tag):
		"""Remove a user's tag from an album"""
		
		if isinstance(single_tag, Tag):
			single_tag = single_tag.getName()
		
		params = self._getParams()
		params['tag'] = single_tag
		
		Request(self, 'album.removeTag', self.api_key, params, True, self.secret).execute()
	
	def removeTags(self, *tags):
		"""Removes one or several tags from this album.
		    * *tags: Any number of tag names or Tag objects. 
		"""
		
		for tag in tags:
			self._removeTag(tag)
	
	def clearTags(self):
		"""Clears all the user-set tags. """
		
		self.removeTags(*(self.getTags()))
	
	def fetchPlaylist(self):
		"""Returns the list of Tracks on this album. """
		
		uri = 'lastfm://playlist/album/%s' %self._getCachedInfo()['id']
		
		return Playlist(uri, self.api_key).fetch()
	
	def getURL(self, domain_name = DOMAIN_ENGLISH):
		url = 'http://%(domain)s/music/%(artist)s/%(album)s'
		
		artist = self._get_url_safe(self.getArtist().getName())
		album = self._get_url_safe(self.getTitle())
		
		return url %{'domain': domain_name, 'artist': artist, 'album': album}

	def toStr(self):
		"""Returns a string representation of the object."""
		
		return self.getArtist().getName() + u' - ' + self.getTitle()

class Track(BaseObject, Cacheable):
	def __init__(self, artist_name, title, api_key, secret, session_key, extra_info = None):
		BaseObject.__init__(self, api_key, secret, session_key)
		Cacheable.__init__(self, True)
		
		self._artist_name = artist_name
		self._title = title
		
		self._setCachedInfo(extra_info)
	
	def _getParams(self):
		return {'sk': self.session_key, 'artist': self._artist_name, 'track': self._title}
	
	def getArtist(self):
		"""Returns the track artist"""
		
		return Artist(self._artist_name, *self.auth_data)
	
	def getTitle(self):
		"""Return the track title"""
		
		return self._title
	
	def addTags(self, *tags):
		"""Adds a list of tags to this track"""
		
		#last.fm currently accepts a max of 10 tags at a time
		while(len(tags) > 10):
			section = tags[0:9]
			tags = tags[9:]
			self.addTags(section)
		
		if len(tags) == 0:
			return None
		
		tagstr = ','.join(tags)
		
		params = self._getParams()
		params['tags'] = tagstr
		
		Request(self, 'track.addTags', self.api_key, params, True, self.secret).execute()
	
	def addToPlaylist(self, playlist_id):
		"""Add this track to a user playlist
		playlist_id can be obtained from user.getPlaylists"""
		
		params = self._getParams()
		params['playlistID'] = unicode(playlist_id)
		
		Request(self, 'playlist.addTrack', self.api_key, params, True, self.secret).execute()
	
	def love(self):
		"""Love a track for a user profile"""
		
		params = self._getParams()
		Request(self, 'track.love', self.api_key, params, True, self.secret).execute()
	
	def ban(self):
		"""Ban a track for a given user profile"""
		
		params = self._getParams()
		Request(self, 'track.ban', self.api_key, params, True, self.secret).execute()
	
	def getSimilar(self):
		"""Get the similar tracks for this track on Last.fm, based on listening data
		Returns a list of dictionaries representing each track"""
		
		params = self._getParams()
		doc = Request(self, 'track.getSimilar', self.api_key, params).execute()
		
		if not doc:
			return None
		
		tracks = doc.getElementsByTagName('track')
		
		data = []
		for track in tracks:
			t = {}
			
			t['title'] = self._extract(track, 'name', 0)
			t['artist'] = self._extract(track, 'name', 1)
			t['images'] = self._extract_all(track, 'image')
			t['match'] = self._extract(track, 'match')
			data.append(t)
		
		return data
	
	def getTags(self):
		"""Get the tags applied by an individual user to a track on Last.fm"""
		
		params = self._getParams()
		doc = Request(self, 'track.getTags', self.api_key, params, True, self.secret).execute()
		
		if not doc:
			return None
		
		return self._extract_all(doc, 'name')
	
	def getTopFans(self):
		"""Get the top fans for this track on Last.fm, based on listening data
		Returns a list of dictionaries, each for a user profile data"""
		
		params = self._getParams()
		doc = Request(self, 'track.getTopFans', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		for track in doc.getElementsByTagName('user'):
			t = {}
			
			t['name'] = self._extract(track, 'name')
			t['weight'] = self._extract(track, 'weight')
			t['images'] = self._extract_all(track, 'image')
			
			list.append(t)
		
		return list
	
	def getTopTags(self):
		"""Get the top tags for this track on Last.fm, ordered by tag count"""
		
		params = self._getParams()
		doc = Request(self, 'track.getTopTags', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		tags = doc.getElementsByTagName('tag')
		for tag in tags:
			t = {}
			t['name'] = self._extract(tag, 'name')
			t['count'] = self._extract(tag, 'count')
			
			list.append(t)
		
		return list
	
	def _removeTag(self, single_tag):
		"""Remove a user's tag from a track"""
		
		if isinstance(single_tag, Tag):
			single_tag = single_tag.getName()
		
		params = self._getParams()
		params['tag'] = single_tag
		
		Request(self, 'track.removeTag', self.api_key, params, True, self.secret).execute()

	def removeTags(self, *tags):
		"""Remove one or several user tags"""
		
		for tag in tags:
			self._removeTag(tag)
	
	def clearTags(self):
		"""Clear all the user tags"""
		
		self.removeTags(*(self.getTags()))
	
	def share(self, users, message = None):
		"""Share a track twith one or more Last.fm users or other friends"""
		
		#last.fm currently accepts a max of 10 recipient at a time
		while(len(users) > 10):
			section = users[0:9]
			users = users[9:]
			self.share(section, message)
		
		nusers = []
		for user in users:
			if isinstance(user, User):
				nusers.append(user.getName())
			else:
				nusers.append(user)
		
		params = self._getParams()
		recipients = ','.join(nusers)
		params['recipient'] = recipients
		if message: params['message'] = message
		
		Request(self, 'track.share', self.api_key, params, True, self.secret).execute()
	
	def getURL(self, domain_name = DOMAIN_ENGLISH):
		url = 'http://%(domain)s/music/%(artist)s/_/%(title)s'
		
		artist = self._get_url_safe(self.getArtist().getName())
		title = self._get_url_safe(self.getTitle())
		
		return url %{'domain': domain_name, 'artist': artist, 'title': title}

	def toStr(self):
		"""Returns a string representation of the object."""
		
		return self.getArtist().getName() + u' - ' + self.getTitle()
		
class Artist(BaseObject, Cacheable):
	
	def __init__(self, artist_name, api_key, secret, session_key):
		BaseObject.__init__(self, api_key, secret, session_key)
		Cacheable.__init__(self)
		
		self._artist_name = artist_name
	
	def _getParams(self):
		return {'sk': self.session_key, 'artist': self._artist_name}

	def _getInfo(self):
		"""Get the metadata for an artist on Last.fm, Includes biography"""
		
		params = self._getParams()
		doc = Request(self, 'artist.getInfo', self.api_key, params).execute()
		
		if not doc:
			return None
		
		data = {}
		
		data['name'] = self._extract(doc, 'name')
		data['images'] = self._extract_all(doc, 'image', 3)
		data['streamable'] = self._extract(doc, 'streamable')
		data['listeners'] = self._extract(doc, 'listeners')
		data['play_count'] = self._extract(doc, 'playcount')
		bio = {}
		bio['published'] = self._extract(doc, 'published')
		bio['summary'] = self._extract(doc, 'summary')
		bio['content'] = self._extract(doc, 'content')
		data['bio'] = bio
		
		return data
	
	def getName(self):
		"""Return the artist name"""
		
		return self._artist_name
	
	def getImage(self, size = IMAGE_LARGE):
		"""Return the associated image with this artist
		size can be IMAGE_LARGE, IMAGE_MEDIUM, or IMAGE_SMALL"""
		
		return self._getCachedInfo()['images'][size]
	
	def getPlayCount(self):
		"""Return the play count"""
		
		return self._getCachedInfo()['play_count']
	
	def getListenerCount(self):
		"""Return the listeners count"""
		
		return self._getCachedInfo()['listeners']
	
	def getBioPublishedDate(self):
		"""Return the publishing date of the bio"""
		
		return self._getCachedInfo()['bio']['published']
	
	def getBioSummary(self):
		"""Return the summary of the bio"""
		
		return self._getCachedInfo()['bio']['summary']
	
	def getBioContent(self):
		"""Return the content of the bio"""
		
		return self._getCachedInfo()['bio']['summary']
	
	def addTags(self, *tags):
		"""Tag an artist with one or more user supplied tags
		Accepts Tag objects or tag names"""
		
		#last.fm currently accepts a max of 10 tags at a time
		while(len(tags) > 10):
			section = tags[0:9]
			tags = tags[9:]
			self.addTags(section)
		
		if len(tags) == 0:
			return None
		
		ntags = []
		for tag in tags:
			if isinstance(tag, Tag):
				ntags.append(tag.getName())
			else:
				ntags.append(tag)
		
		tagstr = ','.join(ntags)
		
		params = self._getParams()
		params['tags'] = tagstr
		
		Request(self, 'artist.addTags', self.api_key, params, True, self.secret).execute()
	
	def getEvents(self):
		"""Get a list of upcoming events (Event objects) for this artist"""
		
		params = self._getParams()
		doc = Request(self, 'artist.getEvents', self.api_key, params).execute()
		
		ids = self._extract_all(doc, 'id')
		
		events = []
		for id in ids:
			events.append(Event(id, *self.auth_data))
		
		return events
	
	def getSimilar(self, limit = None):
		"""Get all the artists similar to this artist"""
		
		params = self._getParams()
		if limit:
			params['limit'] = unicode(limit)
		
		doc = Request(self, 'artist.getSimilar', self.api_key, params).execute()
		
		if not doc:
			return None
		
		names = self._extract_all(doc, 'name')
		
		artists = []
		for name in names:
			artists.append(Artist(name, *self.auth_data))
		
		return artists
	
	def getTags(self):
		"""Get the tags applied by an individual user to an artist"""
		
		params = self._getParams()
		doc = Request(self, 'album.getTags', self.api_key, params, True, self.secret).execute()
		
		if not doc:
			return None
		
		tag_names = self._extract_all(doc, 'name')
		tags = []
		for tag in tag_names:
			tags.append(Tag(tag, *self.auth_data))
		
		return tags
	
	def getTopAlbums(self):
		"""Get the top albums for an artist on Last.fm, ordered by popularity"""
		
		params = self._getParams()
		doc = Request(self, 'artist.getTopAlbums', self.api_key, params).execute()
		
		if not doc:
			return None
		
		names = self._extract_all(doc, 'name')
		
		albums = []
		for name in names:
			albums.append(Album(name, *self.auth_data))
		
		return albums
	
	def getTopFans(self):
		"""Get the top fans for an artist on Last.fm, based on listening data"""
		
		params = self._getParams()
		doc = Request(self, 'artist.getTopFans', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		
		for u in doc.getElementsByTagName('user'):
			user = {}
			user['name'] = self._extract(u, 'name')
			user['images'] = self._extract_all(u, 'image')
			user['weight'] = self._extract(u, 'weight')
			
			list.append(user)
		
		return list
		#TODO change to list of users
	
	def getTopTags(self):
		"""Get the top tags for an artist"""
		
		params = self._getParams()
		doc = Request(self, 'artist.getTopTags', self.api_key, params).execute()
		
		if not doc:
			return None
		
		names = self._extract_all(doc, 'name')
		tags = []
		for name in names:
			tags.append(Tag(name, *self.auth_data))
		
		return tags
	
	def getTopTracks(self):
		"""Get the top tracks by an artist"""
		
		params = self._getParams()
		doc = Request(self, 'artist.getTopTracks', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		
		for track in doc.getElementsByTagName('track'):
			t = {}
			title = self._extract(track, 'name')
			artist = self.getName()
			
			data = {}
			data['play_count'] = self._extract(track, 'playcount')
			data['images'] = self._extract_all(track, 'image')
			
			list.append(Track(artist, title, self.api_key, self.secret, self.session_key, data))
		
		return list
	
	def _removeTag(self, single_tag):
		"""Remove a user's tag from an artist"""
		
		if isinstance(single_tag, Tag):
			single_tag = single_tag.getName()
		
		params = self._getParams()
		params['tag'] = single_tag
		
		Request(self, 'artist.removeTag', self.api_key, params, True, self.secret).execute()

	def removeTags(self, *tags):
		"""Remove user tags from an artist"""
		
		for tag in tags:
			self._removeTag(tag)

	def clearTags(self):
		"""Clear all the user tags"""
		
		self.removeTags(*(self.getTags()))

	def share(self, users, message = None):
		"""Share an artist with Last.fm users or other friends"""
		
		#last.fm currently accepts a max of 10 recipient at a time
		while(len(users) > 10):
			section = users[0:9]
			users = users[9:]
			self.share(section, message)
		
		nusers = []
		for user in users:
			if isinstance(user, User):
				nusers.append(user.getName())
			else:
				nusers.append(user)
		
		params = self._getParams()
		recipients = ','.join(nusers)
		params['recipient'] = recipients
		if message: params['message'] = message
		
		Request(self, 'artist.share', self.api_key, params, True, self.secret).execute()
	
	def getURL(self, domain_name = DOMAIN_ENGLISH):
		url = 'http://%(domain)s/music/%(artist)s'
		
		artist = self._get_url_safe(self.getName())
		
		return url %{'domain': domain_name, 'artist': artist}
	
	def toStr(self):
		"""Returns a string representation of the object."""
		
		return self.getName()

class Event(BaseObject, Cacheable):
	"""Represents an event"""
	
	def __init__(self, event_id, api_key, secret, session_key):
		BaseObject.__init__(self, api_key, secret, session_key)
		Cacheable.__init__(self)
		
		self._event_id = unicode(event_id)
	
	def _getParams(self):
		return {'sk': self.session_key, 'event': self.getID()}
	
	def attend(self, attending_status):
		"""Set a user's attendance status for an event
		attending_status can be EVENT_ATTENDING, EVENT_MAYBE_ATTENDING, or EVENT_NOT_ATTENDING 
		"""
		
		params = self._getParams()
		params['status'] = attending_status
		
		doc = Request(self, 'event.attend', self.api_key, params, True, self.secret).execute()
	
	def _getInfo(self):
		"""Get the metadata for an event on Last.fm
		Includes attendance and lineup information"""
		
		params = self._getParams()
		
		doc = Request(self, 'event.getInfo', self.api_key, params).execute()
		
		if not doc:
			return None
		
		data = {}
		data['title'] = self._extract(doc, 'title')
		artists = []
		for i in range(0, len(doc.getElementsByTagName('artist'))):
			artists.append(self._extract(doc, 'artist', i))
		data['artists'] = artists
		data['headliner'] = self._extract(doc, 'headliner')
		
		venue = {}
		venue['name'] = self._extract(doc, 'name')
		venue['city'] = self._extract(doc, 'city')
		venue['country'] = self._extract(doc, 'country')
		venue['street'] = self._extract(doc, 'street')
		venue['postal_code'] = self._extract(doc, 'postalcode')
		
		geo = {}
		geo['lat'] = self._extract(doc, 'geo:lat')
		geo['long'] = self._extract(doc, 'geo:long')
		
		venue['geo'] = geo
		venue['time_zone'] = self._extract(doc, 'timezone')
		
		data['venue'] = venue
		data['description'] = self._extract(doc, 'description')
		data['images'] = self._extract_all(doc, 'image')
		data['attendance'] = self._extract(doc, 'attendance')
		data['reviews'] = self._extract(doc, 'reviews')
		
		
		return data
	
	def getID(self):
		return self._event_id
	
	def getTitle(self):
		"""Return title of the event"""
		
		return self._getCachedInfo()['title']
	
	def getHeadliner(self):
		"""Return the headliner of the event"""
		
		return self._getCachedInfo()['headliner']
	
	def getArtists(self):
		"""Return a list of the paritipating artists"""
		
		names = self._getCachedInfo()['artists']
		
		artists = []
		for name in names:
			artists.append(Artist(name, *self.auth_data))
		
		return artists
	
	def getVenueName(self):
		"""Return the name of the venue where this event is held"""
		
		return self._getCachedInfo()['venue']['name']
	
	def getCityName(self):
		"""Return the city name of the venue where this event is held"""
		
		return self._getCachedInfo()['venue']['city']
	
	def getCountryName(self):
		"""Return the country name of the venue where this event is held"""
		
		return self._getCachedInfo()['venue']['country']

	def getPostalCode(self):
		"""Return the postal code of the venue where this event is held"""
		
		return self._getCachedInfo()['venue']['postal_code']

	def getStreetName(self):
		"""Return the street name of the venue where this event is held"""
		
		return self._getCachedInfo()['venue']['street']
	
	def getGeoPoint(self):
		"""Returns a pair of latitude and longitude of where the event is held"""
		
		return (self._getCachedInfo()['geo']['lat'], self._getCachedInfo()['geo']['long'])
	
	def getTimeZone(self):
		"""Return the timezone of where the event is held"""
		
		return self._getCachedInfo()['time_zone']
	
	def getDescription(self):
		"""Return the description of the event"""
		
		return self._getCachedInfo()['description']
	
	def getImage(self, size = IMAGE_LARGE):
		"""Return the associated image with this event
		size can be IMAGE_LARGE, IMAGE_MEDIUM, or IMAGE_SMALL"""
		
		return self._getCachedInfo()['images'][size]
	
	def getAttendanceCount(self):
		"""Return the number of attending people"""
		
		return self._getCachedInfo()['attendance']
	
	def getReviewCount(self):
		"""Return the number of available reviews for this event"""
		
		return self._getCachedInfo()['reviews']
	
	def getURL(self, domain_name = DOMAIN_ENGLISH):
		url = 'http://%(domain)s/event/%(id)s'
		
		return url %{'domain': domain_name, 'id': self.getID()}

	def toStr(self):
		"""Returns a string representation of the object."""
		
		sa = ""
		artists = self.getArtists()
		for i in range(0, len(artists)):
			if i == 0:
				sa = artists[i].getName()
				continue
			elif i< len(artists)-1:
				sa += ', '
				sa += artists[i].getName()
				continue
			elif i == len(artists) - 1:
				sa += ' and '
				sa += artists[i].getName()
		
		return sa + ' at ' + self.getVenueName()

class Country(BaseObject):
	
	def __init__(self, country_name, api_key, secret, session_key):
		BaseObject.__init__(self, api_key, secret, session_key)
		
		self._country_name = country_name
	
	def _getParams(self):
		return {'country': self.country_name}
	
	def getName(self):
		"""Return country name"""
		
		return self._country_name
	
	def getTopArtists(self):
		"""Get the most popular artists on Last.fm by country"""
		
		params = self._getParams()
		doc = Request(self, 'geo.getTopArtists', self.api_key, params).execute()
		
		if not doc:
			return None
		
		names = self._extract_all(doc, 'name')
		
		artists = []
		for name in names:
			artists.append(Artist(name, *self.auth_data))
		
		return artists
	
	def getTopTracks(self, location = None):
		"""Get the most popular tracks on Last.fm by country"""
		
		params = self._getParams()
		doc = Request(self, 'geo.getTopTracks', self.api_key, params).execute()
		
		list = []
		
		for n in doc.getElementsByTagName('track'):
			
			title = self._extract(n, 'name')
			artist = self._extract(n, 'name', 1)
			
			info = {}
			info['play_count'] = self._extract(n, 'playcount')
			info['images'] = self._extract_all(n, 'image')
			
			list.append(Track(artist, title, *self.auth_data))
		
		return list
	
	def getURL(self, domain_name = DOMAIN_ENGLISH):
		url = 'http://%(domain)s/place/%(country_name)s'
		
		country_name = self._get_url_safe(self.getName())
		
		return url %{'domain': domain_name, 'country_name': country_name}

	def toStr(self):
		"""Returns a string representation of the object."""
		
		return self.getName()
	
class Group(BaseObject):
	
	def __init__(self, group_name, api_key, secret, session_key):
		BaseObject.__init__(self, api_key, secret, session_key)
		
		self._group_name = group_name
	
	def _getParams(self):
		return {'group': self._group_name}
	
	def getName(self):
		return self._group_name
	
	def getTopWeeklyAlbums(self, from_value = None, to_value = None):
		"""Get the top weekly albums, for a given date range
		If no date range is supplied, it will return the most recent album chart for this group"""
		
		params = self._getParams()
		if from_value and to_value:
			params['from'] = unicode(from_value)
			params['to'] = unicode(to_value)
		
		doc = Request(self, 'group.getWeeklyAlbumChart', self.api_key, params).execute()
		
		list = []
		
		for n in doc.getElementsByTagName('album'):
			artist = self._extract(n, 'artist')
			name = self._extract(n, 'name')
			
			list.append(Album(artist, name, *self.auth_data))
		
		return list
	
	def getTopWeeklyArtists(self, from_value = None, to_value = None):
		"""Get the top weekly artists, for a given date range
		If no date range is supplied, it will return the most recent album chart for this group"""
		
		params = self._getParams()
		if from_value and to_value:
			params['from'] = unicode(from_value)
			params['to'] = unicode(to_value)
		
		doc = Request(self, 'group.getWeeklyArtistChart', self.api_key, params).execute()
		
		list = []
		
		names = self._extract_all(doc, 'name')
		for name in names:
			list.append(Artist(name, *self.auth_data))
		
		return list

	def getTopWeeklyTracks(self, from_value = None, to_value = None):
		"""Get the top weekly tracks, for a given date range
		If no date range is supplied, it will return the most recent album chart for this user"""
		
		params = self._getParams()
		if from_value and to_value:
			params['from'] = from_value
			params['to'] = to_value
		
		doc = Request(self, 'group.getWeeklyTrackChart', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		for track in doc.getElementsByTagName('track'):
			artist = self._extract(track, 'artist')
			title = self._extract(track, 'name')
			
			info = {}
			info['play_count'] = self._extract(track, 'playcount')
			
			list.append(Track(artist, title, self.api_key, self.secret, self.session_key, info))
		
		return list

	def getWeeklyChartList(self):
		"""Get a list of available charts for this group, expressed as date ranges which can be sent to the chart services"""
		
		params = self._getParams()
		doc = Request(self, 'group.getWeeklyChartList', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		for chart in doc.getElementsByTagName('chart'):
			c = {}
			c['from'] = chart.getAttribute('from')
			c['to'] = chart.getAttribute('to')
			
			list.append(c)
		
		return list

	def getURL(self, domain_name = DOMAIN_ENGLISH):
		url = 'http://%(domain)s/group/%(name)s'
		
		name = self._get_url_safe(self.getName())
		
		return url %{'domain': domain_name, 'name': name}

	def toStr(self):
		"""Returns a string representation of the object."""
		
		return self.getName()

class Library(BaseObject):
	"""Represents a user's library."""
	
	def __init__(self, username, api_key, secret, session_key):
		BaseObject.__init__(self, api_key, secret, session_key)
		
		self._username = username
		
		self._albums_playcounts = {}
		self._albums_tagcounts = {}
		self._artists_playcounts = {}
		self._artists_tagcounts = {}
		self._tracks_playcounts = {}
		self._tracks_tagcounts = {}
		
		self._album_pages = None
		self._album_perpage = None
		self._artist_pages = None
		self._artist_perpage = None
		self._track_pages = None
		self._track_perpage = None

	def _getParams(self):
		return {'sk': self.session_key, 'user': self._username}
	
	def getUser(self):
		"""Returns the user who owns this library."""
		
		return User(self._username, *self.auth_data)
	
	def _get_albums_info(self):
		
		params = self._getParams()
		doc = Request(self, 'library.getAlbums', self.api_key, params).execute()
		
		if not doc:
			return None
		
		self._album_pages = int(doc.getElementsByTagName('albums')[0].getAttribute('totalPages'))
		self._album_perpage = int(doc.getElementsByTagName('albums')[0].getAttribute('perPage'))

	def _get_artists_info(self):
		
		params = self._getParams()
		doc = Request(self, 'library.getArtists', self.api_key, params).execute()
		
		if not doc:
			return None
		
		self._artist_pages = int(doc.getElementsByTagName('artists')[0].getAttribute('totalPages'))
		self._artist_perpage = int(doc.getElementsByTagName('artists')[0].getAttribute('perPage'))

	def _get_tracks_info(self):
		
		params = self._getParams()
		doc = Request(self, 'library.getTracks', self.api_key, params).execute()
		
		if not doc:
			return None
		
		self._track_pages = int(doc.getElementsByTagName('tracks')[0].getAttribute('totalPages'))
		self._track_perpage = int(doc.getElementsByTagName('tracks')[0].getAttribute('perPage'))

	def getAlbumsPageCount(self):
		"""Returns the number of pages of albums."""
		
		if self._album_pages:
			return self._album_pages
		
		self._get_albums_info()
		
		return self._album_pages
	
	def getAlbumsPerPage(self):
		"""Returns the number of albums per page."""
		
		if self._album_perpage:
			return self._album_perpage
		
		self._get_albums_info()
		
		return self._album_perpage

	def getArtistsPageCount(self):
		"""Returns the number of pages of artists."""
		
		if self._artist_pages:
			return self._artist_pages
		
		self._get_artists_info()
		
		return self._artist_pages
	
	def getArtistsPerPage(self):
		"""Returns the number of artists per page."""
		
		if self._artist_perpage:
			return self._artist_perpage
		
		self._get_artists_info()
		
		return self._artist_perpage

	def getTracksPageCount(self):
		"""Returns the number of pages of trackts."""
		
		if self._track_pages:
			return self._track_pages
		
		self._get_tracks_info()
		
		return self._track_pages
	
	def getTracksPerPage(self):
		"""Returns the number of tracks per page."""
		
		if self._track_perpage:
			return self._track_perpage
		
		self._get_tracks_info()
		
		return self._track_perpage
	
	def getAlbums(self, limit = None, page = None):
		"""Returns a paginated list of all the albums in a user's library."""
		
		params = self._getParams()
		if limit: params['limit'] = str(limit)
		if page: params['page'] = str(page)
		
		doc = Request(self, 'library.getAlbums', self.api_key, params).execute()
		
		if not doc:
			return None
		
		albums = doc.getElementsByTagName('album')
		list = []
		
		for album in albums:
			artist = self._extract(album, 'name', 1)
			name = self._extract(album, 'name')
			
			playcount = self._extract(album, 'playcount')
			tagcount = self._extract(album, 'tagcount')
			
			a = Album(artist, name, *self.auth_data)
			list.append(a)
			
			self._albums_playcounts[a._hash()] = playcount
			self._albums_tagcounts[a._hash()] = tagcount
		
		return list

	def getArtists(self, limit = None, page = None):
		"""Returns a paginated list of all the artists in a user's library."""
		
		params = self._getParams()
		if limit: params['limit'] = str(limit)
		if page: params['page'] = str(page)
		
		doc = Request(self, 'library.getArtists', self.api_key, params).execute()
		
		if not doc:
			return None
		
		artists = doc.getElementsByTagName('artist')
		list = []
		
		for artist in artists:
			name = self._extract(artist, 'name')
			
			playcount = self._extract(artist, 'playcount')
			tagcount = self._extract(artist, 'tagcount')
			
			a = Artist(name, *self.auth_data)
			list.append(a)
			
			self._artists_playcounts[a._hash()] = playcount
			self._artists_tagcounts[a._hash()] = tagcount
		
		return list

	def getTracks(self, limit = None, page = None):
		"""Returns a paginated list of all the tracks in a user's library."""
		
		params = self._getParams()
		if limit: params['limit'] = str(limit)
		if page: params['page'] = str(page)
		
		doc = Request(self, 'library.getTracks', self.api_key, params).execute()
		
		if not doc:
			return None
		
		tracks = doc.getElementsByTagName('track')
		list = []
		
		for track in tracks:
			
			title = self._extract(track, 'name')
			artist = self._extract(track, 'name', 1)
			
			playcount = self._extract(track, 'playcount')
			tagcount = self._extract(track, 'tagcount')
			
			t = Track(artist, title, *self.auth_data)
			list.append(t)
			
			self._tracks_playcounts[t._hash()] = playcount
			self._tracks_tagcounts[t._hash()] = tagcount
		
		return list
	
	def getAlbumPlaycount(self, album_object):
		"""Goes through the library until it finds the playcount of this album."""
		
		key = album_object._hash()
		if key in self._albums_playcounts.keys():
			return self._albums_playcounts[key]
		
		for i in range(1, self.getAlbumsPageCount() +1):
			stack = self.getAlbums(page = i)
			
			for album in stack:
				if album._hash() == album_object._hash():
					return self._albums_playcounts[album._hash()]

	def getAlbumTagcount(self, album_object):
		"""Goes through the library until it finds the tag count of this album."""
		
		key = album_object._hash()
		if key in self._albums_tagcounts.keys():
			return self._albums_tagcounts[key]
		
		for i in range(1, self.getAlbumsPageCount() +1):
			stack = self.getAlbums(page = i)
			
			for album in stack:
				if album._hash() == album_object._hash():
					return self._albums_tagcounts[album._hash()]

	def getArtistPlaycount(self, artist_object):
		"""Goes through the library until it finds the playcount of this artist."""
		
		key = artist_object._hash()
		if key in self._artists_playcounts.keys():
			return self._artists_playcounts[key]
		
		for i in range(1, self.getArtistsPageCount() +1):
			stack = self.getArtists(page = i)
			
			for artist in stack:
				if artist._hash() == artist_object._hash():
					return self._artists_playcounts[artist._hash()]

	def getArtistTagcount(self, artist_object):
		"""Goes through the library until it finds the tag count of this artist."""
		
		key = artist_object._hash()
		if key in self._artists_tagcounts.keys():
			return self._artists_tagcounts[key]
		
		for i in range(1, self.getArtistsPageCount() +1):
			stack = self.getArtist(page = i)
			
			for artist in stack:
				if artist._hash() == artist_object._hash():
					return self._artists_tagcounts[artist._hash()]

	def getTrackPlaycount(self, track_object):
		"""Goes through the library until it finds the playcount of this track."""
		
		key = track_object._hash()
		if key in self._tracks_playcounts.keys():
			return self._tracks_playcounts[key]
		
		for i in range(1, self.getTracksPageCount() +1):
			stack = self.getTracks(page = i)
			
			for track in stack:
				if track._hash() == track_object._hash():
					return self._tracks_playcounts[track._hash()]

	def getTrackTagcount(self, track_object):
		"""Goes through the library until it finds the tag count of this track."""
		
		key = track_object._hash()
		if key in self._tracks_tagcounts.keys():
			return self._tracks_tagcounts[key]
		
		for i in range(1, self.getTracksPageCount() +1):
			stack = self.getTracks(page = i)
			
			for track in stack:
				if track._hash() == track_object._hash():
					return self._tracks_tagcounts[track._hash()]

class Playlist(BaseObject):
	
	def __init__(self, playlist_uri, api_key, secret, session_key):
		BaseObject.__init__(self, api_key, secret, session_key)
		
		self._playlist_uri = playlist_uri
	
	def _getParams(self):
		return {'playlistURL': self._playlist_uri}
	
	def getPlaylistURI(self):
		return self._playlist_uri
	
	def fetch(self):
		"""Fetch a parsed XSPF playlist"""
		
		params = self._getParams()
		
		doc = Request(self, 'playlist.fetch', self.api_key, params).execute()
		
		if not doc:
			return None
		
		data = {}
		
		data['title'] = self._extract(doc, 'title')
		list = []
		
		for n in doc.getElementsByTagName('track'):
			title = self._extract(n, 'title')
			artist = self._extract(n, 'creator')
			
			list.append(Track(artist, title, *self.auth_data))
		
		return list

	def toStr(self):
		"""Returns a string representation of the object."""
		
		return self.getPlaylistURI()

class Tag(BaseObject):
	
	def __init__(self, tag_name, api_key, secret, session_key):
		BaseObject.__init__(self, api_key, secret, session_key)
		
		self._tag_name = tag_name
	
	def _getParams(self):
		return {'tag': self._tag_name}
	
	def getName(self):
		"""Return the tag name"""
		
		return self._tag_name

	def getSimilar(self):
		"""Search for tags similar to this one. Returns tags ranked by similarity, based on listening data"""
		
		params = self._getParams()
		doc = Request(self, 'tag.getSimilar', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		names = self._extract_all(doc, 'name')
		for name in names:
			list.append(Tag(name, *self.auth_data))
		
		return list
	
	def getTopAlbums(self):
		"""Get the top albums tagged by this tag, ordered by tag count"""
		
		params = self._getParams()
		doc = Request(self, 'tag.getTopAlbums', self.api_key, params).execute()
		
		list = []
		
		for n in doc.getElementsByTagName('album'):
			name = self._extract(n, 'name')
			artist = self._extract(n, 'name', 1)
			
			list.append(Album(artist, name, *self.auth_data))
		
		return list
	
	def getTopArtists(self):
		"""Get the top artists tagged by this tag, ordered by tag count"""
		
		params = self._getParams()
		doc = Request(self, 'tag.getTopArtists', self.api_key, params).execute()
		
		list = []
		
		names = self._extract_all(doc, 'name')
		
		for name in names:
			list.append(Artist(name, *self.auth_data))
		
		return list
	
	def getTopTracks(self):
		"""Get the top tracks tagged by this tag, ordered by tag count"""
		
		params = self._getParams()
		doc = Request(self, 'tag.getTopTracks', self.api_key, params).execute()
		
		list = []
		
		for n in doc.getElementsByTagName('track'):
			title = self._extract(n, 'name')
			artist = self._extract(n, 'name', 1)
			
			info = {}
			info['images'] = self._extract_all(n, 'image')
			
			list.append(Track(artist, title, self.api_key, self.secret, self.session_key, info))
		
		return list
	
	def fetchPlaylist(self, free_tracks_only = False):
		"""Fetch the parsed playlist of this track"""
		
		uri = 'lastfm://playlist/tag/%s' %self.tag
		if free_tracks_only:
			uri += '/freetracks'
		
		print uri
		
		return Playlist(uri, self.api_key).fetch()

	def getURL(self, domain_name = DOMAIN_ENGLISH):
		url = 'http://%(domain)s/tag/%(name)s'
		
		name = self._get_url_safe(self.getName())
		
		return url %{'domain': domain_name, 'name': name}

	def toStr(self):
		"""Returns a string representation of the object."""
		
		return self.getName()

class User(BaseObject):
	
	def __init__(self, user_name, api_key, api_secret, session_key):
		BaseObject.__init__(self, api_key, api_secret, session_key)
		
		self._user_name = user_name
	
	def _getParams(self):
		return {'sk': self.session_key, 'user': self._user_name}
	
	def getName(self):
		"""Returns the user name"""
		
		return self._user_name
	
	def getEvents(self):
		"""Get a list of upcoming events (only event IDs) that this user is attending"""
		
		params = self._getParams()
		doc = Request(self, 'user.getEvents', self.api_key, params).execute()
		
		if not doc:
			return None
		
		ids = self._extract_all(doc, 'id')
		events = []
		
		for id in ids:
			events.append(Event(id, *self.auth_data))
		
		return events
	
	def getFriends(self, limit = None):
		"""Get a list of the user's friends on Last.fm"""
		
		params = self._getParams()
		if limit:
			params['limit'] = limit
		
		doc = Request(self, 'user.getFriends', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		users = doc.getElementsByTagName('user')
		
		names = self._extract_all(doc, 'name')
		
		for name in names:
			list.append(User(name, *self.auth_data))
		
		return list
	
	def getLovedTracks(self):
		"""Get the last 50 tracks loved by a user"""
		
		params = self._getParams()
		doc = Request(self, 'user.getLovedTracks', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		
		for track in doc.getElementsByTagName('track'):
			title = self._extract(track, 'name', 0)
			artist = self._extract(track, 'name', 1)
			
			list.append(Track(artist, title, *self.auth_data))
		
		return list
	
	def getNeighbours(self, limit = None):
		"""Get a list of a user's neighbours on Last.fm"""
		
		params = self._getParams()
		if limit:
			params['limit'] = limit
		
		doc = Request(self, 'user.getNeighbours', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		names = self._extract_all(doc, 'name')
		
		for name in names:
			list.append(User(name, *self.auth_data))
		
		return list
	
	def getPastEvents(self, limit = None):
		"""Get a the list of events a user has attended in the past"""
		
		params = self._getParams()
		if limit:
			params['limit'] = limit
		
		doc = Request(self, 'user.getPastEvents', self.api_key, params).execute()
		
		if not doc:
			return None
		
		ids = self._extract_all(doc, 'id')
		list = []
		for id in ids:
			list.append(User(id, *self.auth_data))
		
		return list
	
	def getPlaylistIDs(self):
		"""Get a list of the IDs of a user's playlists"""
		
		params = self._getParams()
		doc = Request(self, 'user.getPlaylists', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []		
		for playlist in doc.getElementsByTagName('playlist'):
			p = {}
			p['id'] = self._extract(playlist, 'id')
			p['title'] = self._extract(playlist, 'title')
			p['date'] = self._extract(playlist, 'date')
			p['size'] = self._extract(playlist, 'size')
			
			list.append(p)
		
		return list
	
	def fetchPlaylist(self, playlist_id):
		"""Fetch the parsed playlist of the given id"""
		
		uri = u'lastfm://playlist/%s' %unicode(playlist_id)
		
		return Playlist(uri, self.api_key).fetch()
	
	def getNowPlaying(self):
		"""Returns the currently playing track, or None"""
		
		params = self._getParams()
		params['limit'] = '1'
		
		list = []
		
		doc = Request(self, 'user.getRecentTracks', self.api_key, params).execute()
		
		if not doc:
			return None
		
		e = doc.getElementsByTagName('track')[0]
		
		if not e.hasAttribute('nowplaying'):
			return None
		
		artist = self._extract(e, 'artist')
		title = self._extract(e, 'name')
		
		return Track(artist, title, *self.auth_data)


	def getRecentTracks(self, limit = None):
		"""Get a list of the recent tracks listened to by this user
		Indicates now playing track if the user is currently listening"""
		
		params = self._getParams()
		if limit:
			params['limit'] = unicode(limit)
		
		list = []
		
		doc = Request(self, 'user.getRecentTracks', self.api_key, params).execute()
		
		if not doc:
			return None
		
		for track in doc.getElementsByTagName('track'):
			title = self._extract(track, 'name')
			artist = self._extract(track, 'artist')
			
			if track.hasAttribute('nowplaying'):
				continue	#to prevent the now playing track from sneaking in here
				
			list.append(Track(artist, title, *self.auth_data))
		
		return list
	
	def getTopAlbums(self, period = PERIOD_OVERALL):
		"""Get the top albums listened to by a user
		You can stipulate a time period
		Sends the overall chart by default"""
		
		params = self._getParams()
		params['period'] = period
		
		doc = Request(self, 'user.getTopAlbums', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		for album in doc.getElementsByTagName('album'):
			name = self._extract(album, 'name')
			artist = self._extract(album, 'name', 1)
			
			list.append(Album(artist, name, *self.auth_data))
		
		return list
	
	def getTopArtists(self, period = PERIOD_OVERALL):
		"""Get the top artists listened to by a user
		You can stipulate a time period
		Sends the overall chart by default"""
		
		params = self._getParams()
		params['period'] = period
		
		doc = Request(self, 'user.getTopArtists', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		
		names = self._extract_all(doc, 'name')
		for name in names:
			list.append(Artist(name, *self.auth_data))
		
		return list
		
	def getTopTags(self, limit = None):
		"""Get the top tags used by this user"""
		
		params = self._getParams()
		if limit:
			params['limit'] = limit
		
		doc = Request(self, 'user.getTopTags', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		names = self._extract_all(doc, 'name')
		
		for name in names:
			list.append(Tag(name, *self.auth_data))
		
		return list
	
	def getTopTracks(self, period = PERIOD_OVERALL):
		"""Get the top tracks listened to by a user
		You can stipulate a time period
		Sends the overall chart by default"""
		
		params = self._getParams()
		params['period'] = period
		
		doc = Request(self, 'user.getTopTracks', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		for track in doc.getElementsByTagName('track'):
			title = self._extract(track, 'name')
			artist = self._extract(track, 'name', 1)
			
			info = {}
			info['play_count'] = self._extract(track, 'playcount')
			info['images'] = self._extract_all(track, 'image')
		
			list.append(Track(artist, title, self.api_key, self.secret, self.session_key, info))
		
		return list
	
	def getTopWeeklyAlbums(self, from_value = None, to_value = None):
		"""Get an album chart for a user profile, for a given date range
		If no date range is supplied, it will return the most recent album chart for this user"""
		
		params = self._getParams()
		if from_value and to_value:
			params['from'] = from_value
			params['to'] = to_value
		
		doc = Request(self, 'user.getWeeklyAlbumChart', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		
		for n in doc.getElementsByTagName('album'):
			artist = self._extract(n, 'artist')
			name = self._extract(n, 'name')
			
			list.append(Album(artist, name, *self.auth_data))
		
		return list
	
	def getTopWeeklyArtists(self, from_value = None, to_value = None):
		"""Get an artist chart for a user profile, for a given date range
		If no date range is supplied, it will return the most recent album chart for this user"""
		
		params = self._getParams()
		if from_value and to_value:
			params['from'] = from_value
			params['to'] = to_value
		
		doc = Request(self, 'user.getWeeklyArtistChart', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		
		names = self._extract_all(doc, 'name')
		for name in names:
			list.append(Artist(name, *self.auth_data))
		
		return list
	
	def getTopWeeklyTracks(self, from_value = None, to_value = None):
		"""Get a track chart for a user profile, for a given date range
		If no date range is supplied, it will return the most recent album chart for this user"""
		
		params = self._getParams()
		if from_value and to_value:
			params['from'] = from_value
			params['to'] = to_value
		
		doc = Request(self, 'user.getWeeklyTrackChart', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		for track in doc.getElementsByTagName('track'):
			artist = self._extract(track, 'artist')
			title = self._extract(track, 'name')
			
			info = {}
			info['play_count'] = self._extract(track, 'playcount')
			
			list.append(Track(artist, title, self.api_key, self.secret, self.session_key, info))
		
		return list
	
	def getWeeklyChartList(self):
		"""Get a list of available charts for this user, expressed as date ranges which can be sent to the chart services"""
		
		params = self._getParams()
		doc = Request(self, 'user.getWeeklyChartList', self.api_key, params).execute()
		
		if not doc:
			return None
		
		list = []
		for chart in doc.getElementsByTagName('chart'):
			c = {}
			c['from'] = chart.getAttribute('from')
			c['to'] = chart.getAttribute('to')
			
			list.append(c)
		
		return list

	def getURL(self, domain_name = DOMAIN_ENGLISH):
		url = 'http://%(domain)s/user/%(name)s'
		
		name = self._get_url_safe(self.getName())
		
		return url %{'domain': domain_name, 'name': name}

	def getLibrary(self):
		"""Returns the library object of this user."""
		
		return Library(self.getName(), *self.auth_data)

	def toStr(self):
		"""Returns a string representation of the object."""
		
		return self.getName()

class Search(BaseObject):
	"""An abstract search class. Use one of its derivatives."""
	
	def __init__(self, api_key, api_secret, session_key):
		BaseObject.__init__(self, api_key, api_secret, session_key)
		
		self._limit = None
		self._page = None
		self._total_result_count = None

	def getLimit(self):
		"""Returns the limit of the search."""
		
		return self._limit
	
	def getPage(self):
		"""Returns the last page retrieved."""
		
		return self._page
	
	def getTotalResultCount(self):
		"""Returns the total count of all the results."""
		
		return self._total_result_count
	
	def getResults(self, limit = 30, page = 1):
		pass
	
	def getFirstMatch(self):
		"""Returns the first match."""
		
		matches = self.getResults(1)
		if matches:
			return matches[0]

class ArtistSearch(Search):
	"""Search for an artist by artist name."""
	
	def __init__(self, artist_name, api_key, api_secret, session_key):
		Search.__init__(self, api_key, api_secret, session_key)
		
		self._artist_name = artist_name

	def _getParams(self):
		return {'sk': self.session_key, 'artist': self.getArtistName()}
		
	def getArtistName(self):
		"""Returns the artist name."""
		
		return self._artist_name

	def getResults(self, limit = 30, page = 1):
		"""Returns the matches sorted by relevance.
		  * limit: Limit the number of artists returned at one time. Default (maximum) is 30.
		  * page: Scan into the results by specifying a page number. Defaults to first page.
		"""
		
		params = self._getParams()
		params['limit'] = unicode(limit)
		params['page'] = unicode(page)
		
		doc = Request(self, 'artist.search', self.api_key, params).execute()
		
		if not doc:
			return None
		
		self._total_result_count = self._extract(doc, 'opensearch:totalResults')
		self._page = page
		self._limit = limit
		
		e = doc.getElementsByTagName('artistmatches')[0]
		
		names = self._extract_all(e, 'name')
		
		list = []
		for name in names:
			list.append(Artist(name, *self.auth_data))
		
		return list

class TagSearch(Search):
	"""Search for a tag by tag name."""
	
	def __init__(self, tag_name, api_key, api_secret, session_key):
		Search.__init__(self, api_key, api_secret, session_key)
		
		self._tag_name = tag_name

	def _getParams(self):
		return {'sk': self.session_key, 'tag': self.getTagName()}
		
	def getTagName(self):
		"""Returns the tag name."""
		
		return self._tag_name

	def getResults(self, limit = 30, page = 1):
		"""Returns the matches sorted by relevance.
		  * limit: Limit the number of artists returned at one time. Default (maximum) is 30.
		  * page: Scan into the results by specifying a page number. Defaults to first page.
		"""
		
		params = self._getParams()
		params['limit'] = unicode(limit)
		params['page'] = unicode(page)
		
		doc = Request(self, 'tag.search', self.api_key, params).execute()
		
		if not doc:
			return None
		
		self._total_result_count = self._extract(doc, 'opensearch:totalResults')
		self._page = page
		self._limit = limit
		
		e = doc.getElementsByTagName('tagmatches')[0]
		
		names = self._extract_all(e, 'name')
		
		list = []
		for name in names:
			list.append(Tag(name, *self.auth_data))
		
		return list

class TrackSearch(Search):
	"""Search for a track by track title. If you don't wanna narrow the results down
	by specifying the artist name, set it to None"""
	
	def __init__(self, track_title, artist_name, api_key, api_secret, session_key):
		Search.__init__(self, api_key, api_secret, session_key)
		
		self._track_title = track_title
		self._artist_name = artist_name

	def _getParams(self):
		params = {'sk': self.session_key, 'track': self.getTrackTitle()}
		if self.getTrackArtistName():
			params['artist'] = self.getTrackArtistName()
		
		return params
		
	def getTrackTitle(self):
		"""Returns the track title."""
		
		return self._track_title
	
	def getTrackArtistName(self):
		"""Returns the artist name."""
		
		return self._artist_name

	def getResults(self, limit = 30, page = 1):
		"""Returns the matches sorted by relevance.
		  * limit: Limit the number of artists returned at one time. Default (maximum) is 30.
		  * page: Scan into the results by specifying a page number. Defaults to first page.
		"""
		
		params = self._getParams()
		params['limit'] = unicode(limit)
		params['page'] = unicode(page)
		
		doc = Request(self, 'track.search', self.api_key, params).execute()
		
		if not doc:
			return None
		
		self._total_result_count = self._extract(doc, 'opensearch:totalResults')
		self._page = page
		self._limit = limit
		
		e = doc.getElementsByTagName('trackmatches')[0]
		
		titles = self._extract_all(e, 'name')
		artists = self._extract_all(e, 'artist')
		
		list = []
		for i in range(0, len(titles)):
			list.append(Track(artists[i], titles[i], *self.auth_data))
		
		return list