abhin4v
/
python-lastfm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

more changes for PEP8 compliance

This commit is contained in:
Abhinav Sarkar 2008-12-30 13:51:04 +00:00
parent c6bd6ec95f
commit 21f591a450
20 changed files with 937 additions and 915 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
src/album.py
View File

@ -23,76 +23,76 @@ class Album(Taggable, LastfmBase):
if not isinstance(api, Api):
raise InvalidParametersError("api reference must be supplied as an argument")
Taggable.init(self, api)
self.__api = api
self.__name = name
self.__artist = artist
self.__id = id
self.__mbid = mbid
self.__url = url
self.__release_date = release_date
self.__image = image
self.__stats = stats and Stats(
self._api = api
self._name = name
self._artist = artist
self._id = id
self._mbid = mbid
self._url = url
self._release_date = release_date
self._image = image
self._stats = stats and Stats(
subject = self,
listeners = stats.listeners,
playcount = stats.playcount,
match = stats.match,
rank = stats.rank
)
self.__top_tags = top_tags
self._top_tags = top_tags
@property
def name(self):
"""name of the album"""
return self.__name
return self._name
@property
def artist(self):
"""artist of the album"""
return self.__artist
return self._artist
@property
def id(self):
"""id of the album"""
if self.__id is None:
if self._id is None:
self._fill_info()
return self.__id
return self._id
@property
def mbid(self):
"""mbid of the album"""
if self.__mbid is None:
if self._mbid is None:
self._fill_info()
return self.__mbid
return self._mbid
@property
def url(self):
"""url of the album's page"""
if self.__url is None:
if self._url is None:
self._fill_info()
return self.__url
return self._url
@property
def release_date(self):
"""release date of the album"""
if self.__release_date is None:
if self._release_date is None:
self._fill_info()
return self.__release_date
return self._release_date
@property
def image(self):
"""cover images of the album"""
if self.__image is None:
if self._image is None:
self._fill_info()
return self.__image
return self._image
@property
def stats(self):
"""stats related to the album"""
if self.__stats is None:
if self._stats is None:
self._fill_info()
return self.__stats
return self._stats
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_tags(self):
"""top tags for the album"""
params = {'method': 'album.getInfo'}
@ -100,10 +100,10 @@ class Album(Taggable, LastfmBase):
params.update({'artist': self.artist.name, 'album': self.name})
elif self.mbid:
params.update({'mbid': self.mbid})
data = self.__api._fetch_data(params).find('album')
data = self._api._fetch_data(params).find('album')
return [
Tag(
self.__api,
self._api,
subject = self,
name = t.findtext('name'),
url = t.findtext('url')
@ -111,59 +111,14 @@ class Album(Taggable, LastfmBase):
for t in data.findall('toptags/tag')
]
@LastfmBase.topProperty("top_tags")
@LastfmBase.top_property("top_tags")
def top_tag(self):
"""top tag for the album"""
pass
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def playlist(self):
return Playlist.fetch(self.__api, "lastfm://playlist/album/%s" % self.id)
def _default_params(self, extra_params = None):
if not (self.artist and self.name):
raise InvalidParametersError("artist and album have to be provided.")
params = {'artist': self.artist.name, 'album': self.name}
if extra_params is not None:
params.update(extra_params)
return params
@staticmethod
def _fetch_data(api,
artist = None,
album = None,
mbid = None):
params = {'method': 'album.getInfo'}
if not ((artist and album) or mbid):
raise InvalidParametersError("either (artist and album) or mbid has to be given as argument.")
if artist and album:
params.update({'artist': artist, 'album': album})
elif mbid:
params.update({'mbid': mbid})
return api._fetch_data(params).find('album')
def _fill_info(self):
data = Album._fetch_data(self.__api, self.artist.name, self.name)
self.__id = int(data.findtext('id'))
self.__mbid = data.findtext('mbid')
self.__url = data.findtext('url')
self.__release_date = data.findtext('releasedate') and data.findtext('releasedate').strip() and \
datetime(*(time.strptime(data.findtext('releasedate').strip(), '%d %b %Y, 00:00')[0:6]))
self.__image = dict([(i.get('size'), i.text) for i in data.findall('image')])
self.__stats = Stats(
subject = self,
listeners = int(data.findtext('listeners')),
playcount = int(data.findtext('playcount')),
)
self.__top_tags = [
Tag(
self.__api,
subject = self,
name = t.findtext('name'),
url = t.findtext('url')
)
for t in data.findall('toptags/tag')
]
return Playlist.fetch(self._api, "lastfm://playlist/album/%s" % self.id)
@staticmethod
def get_info(api,
@ -182,15 +137,59 @@ class Album(Taggable, LastfmBase):
a._fill_info()
return a
def _default_params(self, extra_params = {}):
if not (self.artist and self.name):
raise InvalidParametersError("artist and album have to be provided.")
params = {'artist': self.artist.name, 'album': self.name}
params.update(extra_params)
return params
@staticmethod
def hash_func(*args, **kwds):
def _fetch_data(api,
artist = None,
album = None,
mbid = None):
params = {'method': 'album.getInfo'}
if not ((artist and album) or mbid):
raise InvalidParametersError("either (artist and album) or mbid has to be given as argument.")
if artist and album:
params.update({'artist': artist, 'album': album})
elif mbid:
params.update({'mbid': mbid})
return api._fetch_data(params).find('album')
def _fill_info(self):
data = Album._fetch_data(self._api, self.artist.name, self.name)
self._id = int(data.findtext('id'))
self._mbid = data.findtext('mbid')
self._url = data.findtext('url')
self._release_date = data.findtext('releasedate') and data.findtext('releasedate').strip() and \
datetime(*(time.strptime(data.findtext('releasedate').strip(), '%d %b %Y, 00:00')[0:6]))
self._image = dict([(i.get('size'), i.text) for i in data.findall('image')])
self._stats = Stats(
subject = self,
listeners = int(data.findtext('listeners')),
playcount = int(data.findtext('playcount')),
)
self._top_tags = [
Tag(
self._api,
subject = self,
name = t.findtext('name'),
url = t.findtext('url')
)
for t in data.findall('toptags/tag')
]
@staticmethod
def _hash_func(*args, **kwds):
try:
return hash("%s%s" % (kwds['name'], hash(kwds['artist'])))
except KeyError:
raise InvalidParametersError("name and artist have to be provided for hashing")
def __hash__(self):
return self.__class__.hash_func(name = self.name, artist = self.artist)
return self.__class__._hash_func(name = self.name, artist = self.artist)
def __eq__(self, other):
if self.id and other.id:

43
src/api.py
View File

@ -22,9 +22,9 @@ class Api(object):
request_headers=None,
no_cache = False,
debug = False):
self.__api_key = api_key
self.__secret = secret
self.__session_key = session_key
self._api_key = api_key
self._secret = secret
self._session_key = session_key
self._cache = FileCache()
self._urllib = urllib2
self._cache_timeout = Api.DEFAULT_CACHE_TIMEOUT
@ -37,27 +37,27 @@ class Api(object):
@property
def api_key(self):
return self.__api_key
return self._api_key
@property
def secret(self):
return self.__secret
return self._secret
@property
def session_key(self):
return self.__session_key
return self._session_key
def set_session_key(self):
params = {'method': 'auth.getSession', 'token': self.auth_token}
self.__session_key = self._fetch_data(params, sign = True).findtext('session/key')
self.__auth_token = None
self._session_key = self._fetch_data(params, sign = True).findtext('session/key')
self._auth_token = None
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def auth_token(self):
params = {'method': 'auth.getToken'}
return self._fetch_data(params, sign = True).findtext('token')
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def auth_url(self):
return "http://www.last.fm/api/auth/?api_key=%s&token=%s" % (self.api_key, self.auth_token)
@ -66,7 +66,7 @@ class Api(object):
'''Override the default cache. Set to None to prevent caching.
Args:
cache: an instance that supports the same API as the audioscrobblerws.FileCache
cache: an instance that supports the same API as the lastfm.FileCache
'''
self._cache = cache
@ -124,7 +124,7 @@ class Api(object):
def get_group(self, name):
return Group(self, name = name)
def fetch_playlist(self, url):
def get_playlist(self, url):
return Playlist.fetch(self, url)
def get_tag(self, name):
@ -314,7 +314,7 @@ class Api(object):
params['api_sig'] = self._get_api_sig(params)
xml = self._fetch_url(Api.API_ROOT_URL, params, no_cache = self._no_cache or no_cache)
return self._check_XML(xml)
return self._check_xml(xml)
def _post_url(self,
url,
@ -337,7 +337,7 @@ class Api(object):
params['api_sig'] = self._get_api_sig(params)
xml = self._post_url(Api.API_ROOT_URL, params)
return self._check_XML(xml)
return self._check_xml(xml)
def _get_api_sig(self, params):
if self.secret is not None:
@ -352,7 +352,7 @@ class Api(object):
else:
raise AuthenticationFailedError("api secret must be present to call this method")
def _check_XML(self, xml):
def _check_xml(self, xml):
data = None
try:
data = ElementTree.XML(xml)
@ -361,18 +361,18 @@ class Api(object):
if data.get('status') != "ok":
code = int(data.find("error").get('code'))
message = data.findtext('error')
if code in errorMap.keys():
raise errorMap[code](message, code)
if code in error_map.keys():
raise error_map[code](message, code)
else:
raise Error(message, code)
return data
def __repr__(self):
return "<lastfm.Api: %s>" % self.__api_key
return "<lastfm.Api: %s>" % self._api_key
from datetime import datetime
import md5
import platform
import sys
import time
import urllib
import urllib2
@ -380,7 +380,7 @@ import urlparse
from album import Album
from artist import Artist
from error import errorMap, Error, OperationFailedError, AuthenticationFailedError
from error import error_map, Error, OperationFailedError, AuthenticationFailedError
from event import Event
from filecache import FileCache
from geo import Location, Country
@ -391,8 +391,7 @@ from tasteometer import Tasteometer
from track import Track
from user import User
python_version = platform.python_version_tuple()
if python_version[0] == 2 and python_version[1] >= 5:
if sys.version_info >= (2, 5):
import xml.etree.cElementTree as ElementTree
else:
try:

253
src/artist.py
View File

@ -27,22 +27,22 @@ class Artist(LastfmBase, Taggable, Sharable, Searchable):
raise InvalidParametersError("api reference must be supplied as an argument")
Taggable.init(self, api)
Sharable.init(self, api)
self.__api = api
self.__name = name
self.__mbid = mbid
self.__url = url
self.__image = image
self.__streamable = streamable
self.__stats = stats and Stats(
self._api = api
self._name = name
self._mbid = mbid
self._url = url
self._image = image
self._streamable = streamable
self._stats = stats and Stats(
subject = self,
listeners = stats.listeners,
playcount = stats.playcount,
match = stats.match,
rank = stats.rank
)
self.__similar = similar
self.__top_tags = top_tags
self.__bio = bio and Wiki(
self._similar = similar
self._top_tags = top_tags
self._bio = bio and Wiki(
subject = self,
published = bio.published,
summary = bio.summary,
@ -52,59 +52,51 @@ class Artist(LastfmBase, Taggable, Sharable, Searchable):
@property
def name(self):
"""name of the artist"""
return self.__name
return self._name
@property
def mbid(self):
"""mbid of the artist"""
if self.__mbid is None:
if self._mbid is None:
self._fill_info()
return self.__mbid
return self._mbid
@property
def url(self):
"""url of the artist's page"""
if self.__url is None:
if self._url is None:
self._fill_info()
return self.__url
return self._url
@property
def image(self):
"""images of the artist"""
if self.__image is None:
if self._image is None:
self._fill_info()
return self.__image
return self._image
@property
def streamable(self):
"""is the artist streamable"""
if self.__streamable is None:
if self._streamable is None:
self._fill_info()
return self.__streamable
return self._streamable
@property
def stats(self):
"""stats for the artist"""
if self.__stats is None:
if self._stats is None:
self._fill_info()
return self.__stats
def _default_params(self, extraParams = None):
if not self.name:
raise InvalidParametersError("artist has to be provided.")
params = {'artist': self.name}
if extraParams is not None:
params.update(extraParams)
return params
return self._stats
def get_similar(self, limit = None):
params = self._default_params({'method': 'artist.getSimilar'})
if limit is not None:
params.update({'limit': limit})
data = self.__api._fetch_data(params).find('similarartists')
self.__similar = [
data = self._api._fetch_data(params).find('similarartists')
self._similar = [
Artist(
self.__api,
self._api,
subject = self,
name = a.findtext('name'),
mbid = a.findtext('mbid'),
@ -117,16 +109,16 @@ class Artist(LastfmBase, Taggable, Sharable, Searchable):
)
for a in data.findall('artist')
]
return self.__similar[:]
return self._similar[:]
@property
def similar(self):
"""artists similar to this artist"""
if self.__similar is None or len(self.__similar) < 6:
if self._similar is None or len(self._similar) < 6:
return self.get_similar()
return self.__similar[:]
return self._similar[:]
@LastfmBase.topProperty("similar")
@LastfmBase.top_property("similar")
def most_similar(self):
"""artist most similar to this artist"""
pass
@ -134,21 +126,21 @@ class Artist(LastfmBase, Taggable, Sharable, Searchable):
@property
def top_tags(self):
"""top tags for the artist"""
if self.__top_tags is None or len(self.__top_tags) < 6:
if self._top_tags is None or len(self._top_tags) < 6:
params = self._default_params({'method': 'artist.getTopTags'})
data = self.__api._fetch_data(params).find('toptags')
self.__top_tags = [
data = self._api._fetch_data(params).find('toptags')
self._top_tags = [
Tag(
self.__api,
self._api,
subject = self,
name = t.findtext('name'),
url = t.findtext('url')
)
for t in data.findall('tag')
]
return self.__top_tags[:]
return self._top_tags[:]
@LastfmBase.topProperty("top_tags")
@LastfmBase.top_property("top_tags")
def top_tag(self):
"""top tag for the artist"""
pass
@ -156,30 +148,30 @@ class Artist(LastfmBase, Taggable, Sharable, Searchable):
@property
def bio(self):
"""biography of the artist"""
if self.__bio is None:
if self._bio is None:
self._fill_info()
return self.__bio
return self._bio
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def events(self):
"""events for the artist"""
params = self._default_params({'method': 'artist.getEvents'})
data = self.__api._fetch_data(params).find('events')
data = self._api._fetch_data(params).find('events')
return [
Event.create_from_data(self.__api, e)
Event.create_from_data(self._api, e)
for e in data.findall('event')
]
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_albums(self):
"""top albums of the artist"""
params = self._default_params({'method': 'artist.getTopAlbums'})
data = self.__api._fetch_data(params).find('topalbums')
data = self._api._fetch_data(params).find('topalbums')
return [
Album(
self.__api,
self._api,
subject = self,
name = a.findtext('name'),
artist = self,
@ -195,19 +187,19 @@ class Artist(LastfmBase, Taggable, Sharable, Searchable):
for a in data.findall('album')
]
@LastfmBase.topProperty("top_albums")
@LastfmBase.top_property("top_albums")
def top_album(self):
"""top album of the artist"""
pass
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_fans(self):
"""top fans of the artist"""
params = self._default_params({'method': 'artist.getTopFans'})
data = self.__api._fetch_data(params).find('topfans')
data = self._api._fetch_data(params).find('topfans')
return [
User(
self.__api,
self._api,
subject = self,
name = u.findtext('name'),
url = u.findtext('url'),
@ -220,19 +212,19 @@ class Artist(LastfmBase, Taggable, Sharable, Searchable):
for u in data.findall('user')
]
@LastfmBase.topProperty("top_fans")
@LastfmBase.top_property("top_fans")
def top_fan(self):
"""top fan of the artist"""
pass
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_tracks(self):
"""top tracks of the artist"""
params = self._default_params({'method': 'artist.getTopTracks'})
data = self.__api._fetch_data(params).find('toptracks')
data = self._api._fetch_data(params).find('toptracks')
return [
Track(
self.__api,
self._api,
subject = self,
name = t.findtext('name'),
artist = self,
@ -243,17 +235,88 @@ class Artist(LastfmBase, Taggable, Sharable, Searchable):
rank = int(t.attrib['rank'])
),
streamable = (t.findtext('streamable') == '1'),
fullTrack = (t.find('streamable').attrib['fulltrack'] == '1'),
full_track = (t.find('streamable').attrib['fulltrack'] == '1'),
image = dict([(i.get('size'), i.text) for i in t.findall('image')]),
)
for t in data.findall('track')
]
@LastfmBase.topProperty("top_tracks")
@LastfmBase.top_property("top_tracks")
def top_track(self):
"""topmost fan of the artist"""
pass
@staticmethod
def get_info(api,
artist = None,
mbid = None):
data = Artist._fetch_data(api, artist, mbid)
a = Artist(api, name = data.findtext('name'))
a._fill_info()
return a
def _default_params(self, extra_params = {}):
if not self.name:
raise InvalidParametersError("artist has to be provided.")
params = {'artist': self.name}
params.update(extra_params)
return params
@staticmethod
def _fetch_data(api,
artist = None,
mbid = None):
params = {'method': 'artist.getInfo'}
if not (artist or mbid):
raise InvalidParametersError("either artist or mbid has to be given as argument.")
if artist:
params.update({'artist': artist})
elif mbid:
params.update({'mbid': mbid})
return api._fetch_data(params).find('artist')
def _fill_info(self):
data = Artist._fetch_data(self._api, self.name)
self._name = data.findtext('name')
self._mbid = data.findtext('mbid')
self._url = data.findtext('url')
self._image = dict([(i.get('size'), i.text) for i in data.findall('image')])
self._streamable = (data.findtext('streamable') == 1)
self._stats = Stats(
subject = self,
listeners = int(data.findtext('stats/listeners')),
playcount = int(data.findtext('stats/playcount'))
)
self._similar = [
Artist(
self._api,
subject = self,
name = a.findtext('name'),
url = a.findtext('url'),
image = dict([(i.get('size'), i.text) for i in a.findall('image')])
)
for a in data.findall('similar/artist')
]
self._top_tags = [
Tag(
self._api,
subject = self,
name = t.findtext('name'),
url = t.findtext('url')
)
for t in data.findall('tags/tag')
]
self._bio = Wiki(
self,
published = datetime(*(time.strptime(
data.findtext('bio/published').strip(),
'%a, %d %b %Y %H:%M:%S +0000'
)[0:6])),
summary = data.findtext('bio/summary'),
content = data.findtext('bio/content')
)
@staticmethod
def _search_yield_func(api, artist):
return Artist(
@ -265,71 +328,7 @@ class Artist(LastfmBase, Taggable, Sharable, Searchable):
streamable = (artist.findtext('streamable') == '1'),
)
@staticmethod
def _fetch_data(api,
artist = None,
mbid = None):
params = {'method': 'artist.get_info'}
if not (artist or mbid):
raise InvalidParametersError("either artist or mbid has to be given as argument.")
if artist:
params.update({'artist': artist})
elif mbid:
params.update({'mbid': mbid})
return api._fetch_data(params).find('artist')
def _fill_info(self):
data = Artist._fetch_data(self.__api, self.name)
self.__name = data.findtext('name')
self.__mbid = data.findtext('mbid')
self.__url = data.findtext('url')
self.__image = dict([(i.get('size'), i.text) for i in data.findall('image')])
self.__streamable = (data.findtext('streamable') == 1)
self.__stats = Stats(
subject = self,
listeners = int(data.findtext('stats/listeners')),
playcount = int(data.findtext('stats/playcount'))
)
self.__similar = [
Artist(
self.__api,
subject = self,
name = a.findtext('name'),
url = a.findtext('url'),
image = dict([(i.get('size'), i.text) for i in a.findall('image')])
)
for a in data.findall('similar/artist')
]
self.__top_tags = [
Tag(
self.__api,
subject = self,
name = t.findtext('name'),
url = t.findtext('url')
)
for t in data.findall('tags/tag')
]
self.__bio = Wiki(
self,
published = datetime(*(time.strptime(
data.findtext('bio/published').strip(),
'%a, %d %b %Y %H:%M:%S +0000'
)[0:6])),
summary = data.findtext('bio/summary'),
content = data.findtext('bio/content')
)
@staticmethod
def get_info(api,
artist = None,
mbid = None):
data = Artist._fetch_data(api, artist, mbid)
a = Artist(api, name = data.findtext('name'))
a._fill_info()
return a
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash(kwds['name'].lower())
except KeyError:
@ -339,7 +338,7 @@ class Artist(LastfmBase, Taggable, Sharable, Searchable):
raise InvalidParametersError("name has to be provided for hashing")
def __hash__(self):
return self.__class__.hash_func(name = self.name)
return self.__class__._hash_func(name = self.name)
def __eq__(self, other):
if self.mbid and other.mbid:
@ -352,7 +351,7 @@ class Artist(LastfmBase, Taggable, Sharable, Searchable):
return self.name < other.name
def __repr__(self):
return "<lastfm.Artist: %s>" % self.__name
return "<lastfm.Artist: %s>" % self._name
from datetime import datetime
import time

37
src/base.py
View File

@ -21,20 +21,20 @@ class LastfmBase(object):
subject = kwds['subject']
del kwds['subject']
if 'bypassRegistry' in kwds:
del kwds['bypassRegistry']
if 'bypass_registry' in kwds:
del kwds['bypass_registry']
inst = object.__new__(cls)
inst.init(*args, **kwds)
return inst
key = cls.hash_func(*args, **kwds)
key = cls._hash_func(*args, **kwds)
if subject is not None:
key = (hash(subject), key)
LastfmBase._lock.acquire()
try:
inst, alreadyRegistered = LastfmBase.register(object.__new__(cls), key)
if not alreadyRegistered:
inst, already_registered = LastfmBase.register(object.__new__(cls), key)
if not already_registered:
inst.init(*args, **kwds)
finally:
LastfmBase._lock.release()
@ -54,31 +54,29 @@ class LastfmBase(object):
return (ob, False)
@staticmethod
def topProperty(listPropertyName):
def top_property(list_property_name):
def decorator(func):
def wrapper(ob):
topList = getattr(ob, listPropertyName)
return (len(topList) and topList[0] or None)
top_list = getattr(ob, list_property_name)
return (len(top_list) and top_list[0] or None)
return property(fget = wrapper, doc = func.__doc__)
return decorator
@staticmethod
def cachedProperty(func):
frame = sys._getframe(1)
classname = frame.f_code.co_name
funcName = func.func_code.co_name
attributeName = "_%s__%s" % (classname, funcName)
def cached_property(func):
func_name = func.func_code.co_name
attribute_name = "_%s" % func_name
def wrapper(ob):
cacheAttribute = getattr(ob, attributeName, None)
if cacheAttribute is None:
cacheAttribute = func(ob)
setattr(ob, attributeName, cacheAttribute)
cache_attribute = getattr(ob, attribute_name, None)
if cache_attribute is None:
cache_attribute = func(ob)
setattr(ob, attribute_name, cache_attribute)
try:
cp = copy.copy(cacheAttribute)
cp = copy.copy(cache_attribute)
return cp
except Error:
return cacheAttribute
return cache_attribute
return property(fget = wrapper, doc = func.__doc__)
@ -94,6 +92,5 @@ class LastfmBase(object):
def __le__(self, other):
return not self.__gt__(other)
import sys
import copy
from error import Error

10
src/error.py
View File

@ -10,16 +10,16 @@ class BaseError(Exception):
message = None,
code = None):
super(BaseError, self).__init__()
self.__code = code
self.__message = message
self._code = code
self._message = message
@property
def code(self):
return self.__code
return self._code
@property
def message(self):
return self.__message
return self._message
def __str__(self):
return "%s" % self.message
@ -65,7 +65,7 @@ class TokenNotAuthorizedError(BaseError):#14
class TokenExpiredError(BaseError):#15
pass
errorMap = {
error_map = {
1: Error,
2: InvalidServiceError,
3: InvalidMethodError,

69
src/event.py
View File

@ -29,91 +29,83 @@ class Event(LastfmBase, Sharable):
if not isinstance(api, Api):
raise InvalidParametersError("api reference must be supplied as an argument")
Sharable.init(self, api)
self.__api = api
self.__id = id
self.__title = title
self.__artists = artists
self.__headliner = headliner
self.__venue = venue
self.__start_date = start_date
self.__description = description
self.__image = image
self.__url = url
self.__stats = stats and Stats(
self._api = api
self._id = id
self._title = title
self._artists = artists
self._headliner = headliner
self._venue = venue
self._start_date = start_date
self._description = description
self._image = image
self._url = url
self._stats = stats and Stats(
subject = self,
attendance = stats.attendance,
reviews = stats.reviews
)
self.__tag = tag
self._tag = tag
@property
def id(self):
"""id of the event"""
return self.__id
return self._id
@property
def title(self):
"""title of the event"""
return self.__title
return self._title
@property
def artists(self):
"""artists performing in the event"""
return self.__artists
return self._artists
@property
def headliner(self):
"""headliner artist of the event"""
return self.__headliner
return self._headliner
@property
def venue(self):
"""venue of the event"""
return self.__venue
return self._venue
@property
def start_date(self):
"""start date of the event"""
return self.__start_date
return self._start_date
@property
def description(self):
"""description of the event"""
return self.__description
return self._description
@property
def image(self):
"""poster of the event"""
return self.__image
return self._image
@property
def url(self):
"""url of the event's page"""
return self.__url
return self._url
@property
def stats(self):
"""stats of the event"""
return self.__stats
return self._stats
@property
def tag(self):
"""tags for the event"""
return self.__tag
return self._tag
def attend(self, status = STATUS_ATTENDING):
if status not in [Event.STATUS_ATTENDING, Event.STATUS_MAYBE, Event.STATUS_NOT]:
InvalidParametersError("status has to be 0, 1 or 2")
params = self._default_params({'method': 'event.attend', 'status': status})
self.__api._post_data(params)
def _default_params(self, extra_params = None):
if not self.id:
raise InvalidParametersError("id has to be provided.")
params = {'event': self.id}
if extra_params is not None:
params.update(extra_params)
return params
self._api._post_data(params)
@staticmethod
def get_info(api, event):
@ -171,7 +163,7 @@ class Event(LastfmBase, Sharable):
name = data.findtext('venue/location/country')
),
street = data.findtext('venue/location/street'),
postalCode = data.findtext('venue/location/postalcode'),
postal_code = data.findtext('venue/location/postalcode'),
latitude = float(data.findtext(
'venue/location/{%s}point/{%s}lat' % ((Location.XMLNS,)*2)
)),
@ -194,15 +186,22 @@ class Event(LastfmBase, Sharable):
tag = data.findtext('tag')
)
def _default_params(self, extra_params = []):
if not self.id:
raise InvalidParametersError("id has to be provided.")
params = {'event': self.id}
params.update(extra_params)
return params
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash(kwds['id'])
except KeyError:
raise InvalidParametersError("id has to be provided for hashing")
def __hash__(self):
return Event.hash_func(id = self.id)
return Event._hash_func(id = self.id)
def __eq__(self, other):
return self.id == other.id

96
src/geo.py
View File

@ -25,7 +25,7 @@ class Geo(object):
@lazylist
def gen(lst):
data = api._fetch_data(params).find('events')
totalPages = int(data.attrib['totalpages'])
total_pages = int(data.attrib['totalpages'])
@lazylist
def gen2(lst, data):
@ -35,7 +35,7 @@ class Geo(object):
for e in gen2(data):
yield e
for page in xrange(2, totalPages+1):
for page in xrange(2, total_pages+1):
params.update({'page': page})
data = api._fetch_data(params).find('events')
for e in gen2(data):
@ -86,7 +86,7 @@ class Geo(object):
playcount = int(t.findtext('playcount'))
),
streamable = (t.findtext('streamable') == '1'),
fullTrack = (t.find('streamable').attrib['fulltrack'] == '1'),
full_track = (t.find('streamable').attrib['fulltrack'] == '1'),
url = 'http://' + t.findtext('url'),
image = {'large': t.findtext('image')}
)
@ -99,34 +99,34 @@ class Venue(LastfmBase):
name = None,
location = None,
url = None):
self.__name = name
self.__location = location
self.__url = url
self._name = name
self._location = location
self._url = url
@property
def name(self):
"""name of the venue"""
return self.__name
return self._name
@property
def location(self):
"""location of the event"""
return self.__location
return self._location
@property
def url(self):
"""url of the event's page"""
return self.__url
return self._url
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash(kwds['url'])
except KeyError:
raise InvalidParametersError("url has to be provided for hashing")
def __hash__(self):
return self.__class__.hash_func(url = self.url)
return self.__class__._hash_func(url = self.url)
def __eq__(self, other):
return self.url == other.url
@ -152,77 +152,77 @@ class Location(LastfmBase):
timezone = None):
if not isinstance(api, Api):
raise InvalidParametersError("api reference must be supplied as an argument")
self.__api = api
self.__city = city
self.__country = country
self.__street = street
self.__postalCode = postal_code
self.__latitude = latitude
self.__longitude = longitude
self.__timezone = timezone
self._api = api
self._city = city
self._country = country
self._street = street
self._postal_code = postal_code
self._latitude = latitude
self._longitude = longitude
self._timezone = timezone
@property
def city(self):
"""city in which the location is situated"""
return self.__city
return self._city
@property
def country(self):
"""country in which the location is situated"""
return self.__country
return self._country
@property
def street(self):
"""street in which the location is situated"""
return self.__street
return self._street
@property
def postalCode(self):
def postal_code(self):
"""postal code of the location"""
return self.__postalCode
return self._postal_code
@property
def latitude(self):
"""latitude of the location"""
return self.__latitude
return self._latitude
@property
def longitude(self):
"""longitude of the location"""
return self.__longitude
return self._longitude
@property
def timezone(self):
"""timezone in which the location is situated"""
return self.__timezone
return self._timezone
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_tracks(self):
"""top tracks of the location"""
if self.country is None or self.city is None:
raise InvalidParametersError("country and city of this location are required for calling this method")
return Geo.get_top_tracks(self.__api, self.country.name, self.city)
return Geo.get_top_tracks(self._api, self.country.name, self.city)
@LastfmBase.topProperty("top_tracks")
@LastfmBase.top_property("top_tracks")
def top_track(self):
"""top track of the location"""
pass
def get_events(self,
distance = None):
return Geo.get_events(self.__api,
return Geo.get_events(self._api,
self.city,
self.latitude,
self.longitude,
distance)
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def events(self):
"""events taking place at/around the location"""
return self.get_events()
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash("latlong%s%s" % (kwds['latitude'], kwds['longitude']))
except KeyError:
@ -233,11 +233,11 @@ class Location(LastfmBase):
def __hash__(self):
if not self.city:
return self.__class__.hash_func(
return self.__class__._hash_func(
latitude = self.latitude,
longitude = self.longitude)
else:
return self.__class__.hash_func(name = self.city)
return self.__class__._hash_func(name = self.city)
def __eq__(self, other):
return self.latitude == other.latitude and self.longitude == other.longitude
@ -261,51 +261,51 @@ class Country(LastfmBase):
name = None):
if not isinstance(api, Api):
raise InvalidParametersError("api reference must be supplied as an argument")
self.__api = api
self.__name = name
self._api = api
self._name = name
@property
def name(self):
"""name of the country"""
return self.__name
return self._name
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_artists(self):
"""top artists of the country"""
return Geo.get_top_artists(self.__api, self.name)
return Geo.get_top_artists(self._api, self.name)
@LastfmBase.topProperty("top_artists")
@LastfmBase.top_property("top_artists")
def top_artist(self):
"""top artist of the country"""
pass
def get_top_tracks(self, location = None):
return Geo.get_top_tracks(self.__api, self.name, location)
return Geo.get_top_tracks(self._api, self.name, location)
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_tracks(self):
"""top tracks of the country"""
return self.get_top_tracks()
@LastfmBase.topProperty("top_tracks")
@LastfmBase.top_property("top_tracks")
def top_track(self):
"""top track of the country"""
pass
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def events(self):
"""events taking place at/around the location"""
return Geo.get_events(self.__api, self.name)
return Geo.get_events(self._api, self.name)
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash(kwds['name'])
except KeyError:
raise InvalidParametersError("name has to be provided for hashing")
def __hash__(self):
return self.__class__.hash_func(name = self.name)
return self.__class__._hash_func(name = self.name)
def __eq__(self, other):
return self.name == other.name

55
src/group.py
View File

@ -14,35 +14,35 @@ class Group(LastfmBase):
name = None):
if not isinstance(api, Api):
raise InvalidParametersError("api reference must be supplied as an argument")
self.__api = api
self.__name = name
self._api = api
self._name = name
@property
def name(self):
return self.__name
return self._name
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def weekly_chart_list(self):
params = {'method': 'group.getWeeklyChartList', 'group': self.name}
data = self.__api._fetch_data(params).find('weeklychartlist')
params = self._default_params({'method': 'group.getWeeklyChartList'})
data = self._api._fetch_data(params).find('weeklychartlist')
return [
WeeklyChart.create_from_data(self.__api, self, c)
WeeklyChart.create_from_data(self._api, self, c)
for c in data.findall('chart')
]
def get_weekly_album_chart(self,
start = None,
end = None):
params = {'method': 'group.getWeeklyAlbumChart', 'group': self.name}
params = self._default_params({'method': 'group.getWeeklyAlbumChart'})
params = WeeklyChart._check_weekly_chart_params(params, start, end)
data = self.__api._fetch_data(params).find('weeklyalbumchart')
return WeeklyAlbumChart.create_from_data(self.__api, self, data)
data = self._api._fetch_data(params).find('weeklyalbumchart')
return WeeklyAlbumChart.create_from_data(self._api, self, data)
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def recent_weekly_album_chart(self):
return self.get_weekly_album_chart()
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def weekly_album_chart_list(self):
wcl = list(self.weekly_chart_list)
wcl.reverse()
@ -55,16 +55,16 @@ class Group(LastfmBase):
def get_weekly_artist_chart(self,
start = None,
end = None):
params = {'method': 'group.getWeeklyArtistChart', 'group': self.name}
params = self._default_params({'method': 'group.getWeeklyArtistChart'})
params = WeeklyChart._check_weekly_chart_params(params, start, end)
data = self.__api._fetch_data(params).find('weeklyartistchart')
return WeeklyArtistChart.create_from_data(self.__api, self, data)
data = self._api._fetch_data(params).find('weeklyartistchart')
return WeeklyArtistChart.create_from_data(self._api, self, data)
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def recent_weekly_artist_chart(self):
return self.get_weekly_artist_chart()
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def weekly_artist_chart_list(self):
wcl = list(self.weekly_chart_list)
wcl.reverse()
@ -77,16 +77,16 @@ class Group(LastfmBase):
def get_weekly_track_chart(self,
start = None,
end = None):
params = {'method': 'group.getWeeklyTrackChart', 'group': self.name}
params = self._default_params({'method': 'group.getWeeklyTrackChart'})
params = WeeklyChart._check_weekly_chart_params(params, start, end)
data = self.__api._fetch_data(params).find('weeklytrackchart')
return WeeklyTrackChart.create_from_data(self.__api, self, data)
data = self._api._fetch_data(params).find('weeklytrackchart')
return WeeklyTrackChart.create_from_data(self._api, self, data)
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def recent_weekly_track_chart(self):
return self.get_weekly_track_chart()
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def weekly_track_chart_list(self):
wcl = list(self.weekly_chart_list)
wcl.reverse()
@ -96,15 +96,22 @@ class Group(LastfmBase):
yield self.get_weekly_track_chart(wc.start, wc.end)
return gen()
def _default_params(self, extra_params = {}):
if not self.name:
raise InvalidParametersError("group has to be provided.")
params = {'group': self.name}
params.update(extra_params)
return params
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash(kwds['name'])
except KeyError:
raise InvalidParametersError("name has to be provided for hashing")
def __hash__(self):
return self.__class__.hash_func(name = self.name)
return self.__class__._hash_func(name = self.name)
def __eq__(self, other):
return self.name == other.name

23
src/playlist.py
View File

@ -9,36 +9,36 @@ from base import LastfmBase
class Playlist(LastfmBase):
"""A class representing an XPSF playlist."""
def init(self, api, url):
self.__api = api
self.__data = None
self.__url = url
self._api = api
self._data = None
self._url = url
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def data(self):
"""playlist's data"""
params = {'method': 'playlist.fetch', 'playlistURL': self.__url}
params = {'method': 'playlist.fetch', 'playlistURL': self._url}
tmp = StringIO.StringIO()
ElementTree.ElementTree(self.__api._fetch_data(params)[0]).write(tmp)
ElementTree.ElementTree(self._api._fetch_data(params)[0]).write(tmp)
return tmp.getvalue()
@property
def url(self):
"""url of the playlist"""
return self.__url
return self._url
@staticmethod
def fetch(api, url):
return Playlist(api, url = url)
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash(kwds['url'])
except KeyError:
raise InvalidParametersError("url has to be provided for hashing")
def __hash__(self):
return self.__class__.hash_func(url = self.url)
return self.__class__._hash_func(url = self.url)
def __eq__(self, other):
return self.url == other.url
@ -50,11 +50,10 @@ class Playlist(LastfmBase):
return "<lastfm.Playlist: %s>" % self.url
import StringIO
import platform
import sys
from error import InvalidParametersError
python_version = platform.python_version_tuple()
if python_version[0] == 2 and python_version[1] >= 5:
if sys.version_info >= (2, 5):
import xml.etree.cElementTree as ElementTree
else:
try:

10
src/safelist.py
View File

@ -6,21 +6,21 @@ __license__ = "GNU Lesser General Public License"
import sys
class SafeList(object):
def __init__(self, lst, addFunc, removeFunc):
def __init__(self, lst, add_func, remove_func):
self._list = lst
self._addFunc = addFunc
self._removeFunc = removeFunc
self._add_func = add_func
self._remove_func = remove_func
def add(self, lst):
if not isinstance(lst, (list, tuple)):
lst = [lst]
self._addFunc(lst)
self._add_func(lst)
def remove(self, lst):
if not isinstance(lst, (list, tuple)):
lst = [lst]
for l in lst:
self._removeFunc(l)
self._remove_func(l)
def __iter__(self):
for i in xrange(len(self._list)):

4
src/searchable.py
View File

@ -28,7 +28,7 @@ class Searchable(object):
@lazylist
def gen(lst):
data = api._fetch_data(params).find('results')
totalPages = int(data.findtext("{%s}totalResults" % Api.SEARCH_XMLNS))/ \
total_pages = int(data.findtext("{%s}totalResults" % Api.SEARCH_XMLNS))/ \
int(data.findtext("{%s}itemsPerPage" % Api.SEARCH_XMLNS)) + 1
@lazylist
@ -39,7 +39,7 @@ class Searchable(object):
for a in gen2(data):
yield a
for page in xrange(2, totalPages+1):
for page in xrange(2, total_pages+1):
params.update({'page': page})
data = api._fetch_data(params).find('results')
for a in gen2(data):

7
src/sharable.py
View File

@ -6,7 +6,7 @@ __license__ = "GNU Lesser General Public License"
class Sharable(object):
def init(self, api):
self.__api = api
self._api = api
def share(self, recipient, message = None):
from user import User
@ -21,4 +21,7 @@ class Sharable(object):
if isinstance(recipient[i], User):
recipient[i] = recipient[i].name
params['recipient'] = ",".join(recipient)
self.__api._post_data(params)
self._api._post_data(params)
def _default_params(self, extra_params = {}):
return extra_params

42
src/stats.py
View File

@ -17,67 +17,67 @@ class Stats(object):
weight = None,
attendance = None,
reviews = None,):
self.__subject = subject
self.__listeners = listeners
self.__playcount = playcount
self.__tagcount = tagcount
self.__count = count
self.__match = match
self.__rank = rank
self.__weight = weight
self.__attendance = attendance
self.__reviews = reviews
self._subject = subject
self._listeners = listeners
self._playcount = playcount
self._tagcount = tagcount
self._count = count
self._match = match
self._rank = rank
self._weight = weight
self._attendance = attendance
self._reviews = reviews
@property
def subject(self):
"""subject of the stats"""
return self.__subject
return self._subject
@property
def rank(self):
"""rank of the subject"""
return self.__rank
return self._rank
@property
def listeners(self):
"""number of listeners of the subject"""
return self.__listeners
return self._listeners
@property
def playcount(self):
"""playcount of the subject"""
return self.__playcount
return self._playcount
@property
def tagcount(self):
"""tagcount of the subject"""
return self.__tagcount
return self._tagcount
@property
def count(self):
"""count of the subject"""
return self.__count
return self._count
@property
def match(self):
"""match of the subject"""
return self.__match
return self._match
@property
def weight(self):
"""weight of the subject"""
return self.__weight
return self._weight
@property
def attendance(self):
"""attendance of the subject"""
return self.__attendance
return self._attendance
@property
def reviews(self):
"""reviews of the subject"""
return self.__reviews
return self._reviews
def __repr__(self):
return "<lastfm.Stats: for '%s'>" % self.__subject.name
return "<lastfm.Stats: for '%s'>" % self._subject.name

79
src/tag.py
View File

@ -18,11 +18,11 @@ class Tag(LastfmBase, Searchable):
stats = None):
if not isinstance(api, Api):
raise InvalidParametersError("api reference must be supplied as an argument")
self.__api = api
self.__name = name
self.__url = url
self.__streamable = streamable
self.__stats = stats and Stats(
self._api = api
self._name = name
self._url = url
self._streamable = streamable
self._stats = stats and Stats(
subject = self,
count = stats.count
)
@ -30,30 +30,30 @@ class Tag(LastfmBase, Searchable):
@property
def name(self):
"""name of the tag"""
return self.__name
return self._name
@property
def url(self):
"""url of the tag's page"""
return self.__url
return self._url
@property
def streamable(self):
"""is the tag streamable"""
return self.__streamable
return self._streamable
@property
def stats(self):
return self.__stats
return self._stats
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def similar(self):
"""tags similar to this tag"""
params = {'method': 'tag.getSimilar', 'tag': self.name}
data = self.__api._fetch_data(params).find('similartags')
params = self._default_params({'method': 'tag.getSimilar'})
data = self._api._fetch_data(params).find('similartags')
return [
Tag(
self.__api,
self._api,
subject = self,
name = t.findtext('name'),
url = t.findtext('url'),
@ -62,23 +62,23 @@ class Tag(LastfmBase, Searchable):
for t in data.findall('tag')
]
@LastfmBase.topProperty("similar")
@LastfmBase.top_property("similar")
def most_similar(self):
"""most similar tag to this tag"""
pass
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_albums(self):
"""top albums for the tag"""
params = {'method': 'tag.getTopAlbums', 'tag': self.name}
data = self.__api._fetch_data(params).find('topalbums')
params = self._default_params({'method': 'tag.getTopAlbums'})
data = self._api._fetch_data(params).find('topalbums')
return [
Album(
self.__api,
self._api,
subject = self,
name = a.findtext('name'),
artist = Artist(
self.__api,
self._api,
subject = self,
name = a.findtext('artist/name'),
mbid = a.findtext('artist/mbid'),
@ -96,19 +96,19 @@ class Tag(LastfmBase, Searchable):
for a in data.findall('album')
]
@LastfmBase.topProperty("top_albums")
@LastfmBase.top_property("top_albums")
def top_album(self):
"""top album for the tag"""
pass
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_artists(self):
"""top artists for the tag"""
params = {'method': 'tag.getTopArtists', 'tag': self.name}
data = self.__api._fetch_data(params).find('topartists')
params = self._default_params({'method': 'tag.getTopArtists'})
data = self._api._fetch_data(params).find('topartists')
return [
Artist(
self.__api,
self._api,
subject = self,
name = a.findtext('name'),
mbid = a.findtext('mbid'),
@ -124,23 +124,23 @@ class Tag(LastfmBase, Searchable):
for a in data.findall('artist')
]
@LastfmBase.topProperty("top_artists")
@LastfmBase.top_property("top_artists")
def top_artist(self):
"""top artist for the tag"""
pass
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_tracks(self):
"""top tracks for the tag"""
params = {'method': 'tag.getTopTracks', 'tag': self.name}
data = self.__api._fetch_data(params).find('toptracks')
params = self._default_params({'method': 'tag.getTopTracks'})
data = self._api._fetch_data(params).find('toptracks')
return [
Track(
self.__api,
self._api,
subject = self,
name = t.findtext('name'),
artist = Artist(
self.__api,
self._api,
subject = self,
name = t.findtext('artist/name'),
mbid = t.findtext('artist/mbid'),
@ -153,20 +153,20 @@ class Tag(LastfmBase, Searchable):
tagcount = t.findtext('tagcount') and int(t.findtext('tagcount')) or None
),
streamable = (t.findtext('streamable') == '1'),
fullTrack = (t.find('streamable').attrib['fulltrack'] == '1'),
full_track = (t.find('streamable').attrib['fulltrack'] == '1'),
image = dict([(i.get('size'), i.text) for i in t.findall('image')]),
)
for t in data.findall('track')
]
@LastfmBase.topProperty("top_tracks")
@LastfmBase.top_property("top_tracks")
def top_track(self):
"""top track for the tag"""
pass
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def playlist(self):
return Playlist.fetch(self.__api,
return Playlist.fetch(self._api,
"lastfm://playlist/tag/%s/freetracks" % self.name)
@staticmethod
@ -186,6 +186,13 @@ class Tag(LastfmBase, Searchable):
for t in data.findall('tag')
]
def _default_params(self, extra_params = {}):
if not self.name:
raise InvalidParametersError("tag has to be provided.")
params = {'tag': self.name}
params.update(extra_params)
return params
@staticmethod
def _search_yield_func(api, tag):
return Tag(
@ -199,14 +206,14 @@ class Tag(LastfmBase, Searchable):
)
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash(kwds['name'])
except KeyError:
raise InvalidParametersError("name has to be provided for hashing")
def __hash__(self):
return self.__class__.hash_func(name = self.name)
return self.__class__._hash_func(name = self.name)
def __eq__(self, other):
return self.name == other.name

20
src/taggable.py
View File

@ -9,16 +9,16 @@ from safelist import SafeList
class Taggable(object):
def init(self, api):
self.__api = api
self._api = api
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def tags(self):
from tag import Tag
params = self._default_params({'method': '%s.getTags' % self.__class__.__name__.lower()})
data = self.__api._fetch_data(params, sign = True, session = True, no_cache = True).find('tags')
data = self._api._fetch_data(params, sign = True, session = True, no_cache = True).find('tags')
return SafeList([
Tag(
self.__api,
self._api,
name = t.findtext('name'),
url = t.findtext('url')
)
@ -46,8 +46,8 @@ class Taggable(object):
'method': '%s.addTags' % self.__class__.__name__.lower(),
'tags': ",".join(tagnames)
})
self.__api._post_data(params)
self.__tags = None
self._api._post_data(params)
self._tags = None
def remove_tag(self, tag):
from tag import Tag
@ -58,8 +58,8 @@ class Taggable(object):
'method': '%s.removeTag' % self.__class__.__name__.lower(),
'tag': tag
})
self.__api._post_data(params)
self.__tags = None
self._api._post_data(params)
self._tags = None
def _default_params(self, extra_params):
pass
def _default_params(self, extra_params = {}):
return extra_params

12
src/tasteometer.py
View File

@ -10,24 +10,24 @@ class Tasteometer(object):
score = None,
matches = None,
artists = None):
self.__score = score
self.__matches = matches
self.__artists = artists
self._score = score
self._matches = matches
self._artists = artists
@property
def score(self):
"""score of the comparison"""
return self.__score
return self._score
@property
def matches(self):
"""matches for the comparison"""
return self.__matches
return self._matches
@property
def artists(self):
"""artists for the comparison"""
return self.__artists
return self._artists
@staticmethod
def compare(api,

269
src/track.py
View File

@ -32,28 +32,28 @@ class Track(LastfmBase, Taggable, Sharable, Searchable):
raise InvalidParametersError("api reference must be supplied as an argument")
Taggable.init(self, api)
Sharable.init(self, api)
self.__api = api
self.__id = id
self.__name = name
self.__mbid = mbid
self.__url = url
self.__duration = duration
self.__streamable = streamable
self.__full_track = full_track
self.__artist = artist
self.__album = album
self.__position = position
self.__image = image
self.__stats = stats and Stats(
self._api = api
self._id = id
self._name = name
self._mbid = mbid
self._url = url
self._duration = duration
self._streamable = streamable
self._full_track = full_track
self._artist = artist
self._album = album
self._position = position
self._image = image
self._stats = stats and Stats(
subject = self,
match = stats.match,
playcount = stats.playcount,
rank = stats.rank,
listeners = stats.listeners,
)
self.__played_on = played_on
self.__loved_on = loved_on
self.__wiki = wiki and Wiki(
self._played_on = played_on
self._loved_on = loved_on
self._wiki = wiki and Wiki(
subject = self,
published = wiki.published,
summary = wiki.summary,
@ -63,99 +63,91 @@ class Track(LastfmBase, Taggable, Sharable, Searchable):
@property
def id(self):
"""id of the track"""
return self.__id
return self._id
@property
def name(self):
"""name of the track"""
return self.__name
return self._name
@property
def mbid(self):
"""mbid of the track"""
return self.__mbid
return self._mbid
@property
def url(self):
"""url of the tracks's page"""
return self.__url
return self._url
@property
def duration(self):
"""duration of the tracks's page"""
return self.__duration
return self._duration
@property
def streamable(self):
"""is the track streamable"""
if self.__streamable is None:
if self._streamable is None:
self._fill_info()
return self.__streamable
return self._streamable
@property
def full_track(self):
"""is the full track streamable"""
if self.__full_track is None:
if self._full_track is None:
self._fill_info()
return self.__full_track
return self._full_track
@property
def artist(self):
"""artist of the track"""
return self.__artist
return self._artist
@property
def album(self):
"""artist of the track"""
if self.__album is None:
if self._album is None:
self._fill_info()
return self.__album
return self._album
@property
def position(self):
"""position of the track"""
if self.__position is None:
if self._position is None:
self._fill_info()
return self.__position
return self._position
@property
def image(self):
"""image of the track's album cover"""
return self.__image
return self._image
@property
def stats(self):
"""stats of the track"""
return self.__stats
return self._stats
@property
def playedOn(self):
def played_on(self):
"""datetime the track was last played"""
return self.__played_on
return self._played_on
@property
def lovedOn(self):
def loved_on(self):
"""datetime the track was marked 'loved'"""
return self.__loved_on
return self._loved_on
@property
def wiki(self):
"""wiki of the track"""
if self.__wiki == "na":
if self._wiki == "na":
return None
if self.__wiki is None:
if self._wiki is None:
self._fill_info()
return self.__wiki
return self._wiki
def _default_params(self, extra_params = None):
if not (self.artist and self.name):
raise InvalidParametersError("artist and track have to be provided.")
params = {'artist': self.artist.name, 'track': self.name}
if extra_params is not None:
params.update(extra_params)
return params
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def similar(self):
"""tracks similar to this track"""
params = Track._check_params(
@ -164,14 +156,14 @@ class Track(LastfmBase, Taggable, Sharable, Searchable):
self.name,
self.mbid
)
data = self.__api._fetch_data(params).find('similartracks')
data = self._api._fetch_data(params).find('similartracks')
return [
Track(
self.__api,
self._api,
subject = self,
name = t.findtext('name'),
artist = Artist(
self.__api,
self._api,
subject = self,
name = t.findtext('artist/name'),
mbid = t.findtext('artist/mbid'),
@ -183,18 +175,18 @@ class Track(LastfmBase, Taggable, Sharable, Searchable):
match = float(t.findtext('match'))
),
streamable = (t.findtext('streamable') == '1'),
fullTrack = (t.find('streamable').attrib['fulltrack'] == '1'),
full_track = (t.find('streamable').attrib['fulltrack'] == '1'),
image = dict([(i.get('size'), i.text) for i in t.findall('image')]),
)
for t in data.findall('track')
]
@LastfmBase.topProperty("similar")
@LastfmBase.top_property("similar")
def most_similar(self):
"""track most similar to this track"""
pass
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_fans(self):
"""top fans of the track"""
params = Track._check_params(
@ -203,10 +195,10 @@ class Track(LastfmBase, Taggable, Sharable, Searchable):
self.name,
self.mbid
)
data = self.__api._fetch_data(params).find('topfans')
data = self._api._fetch_data(params).find('topfans')
return [
User(
self.__api,
self._api,
subject = self,
name = u.findtext('name'),
url = u.findtext('url'),
@ -219,12 +211,12 @@ class Track(LastfmBase, Taggable, Sharable, Searchable):
for u in data.findall('user')
]
@LastfmBase.topProperty("top_fans")
@LastfmBase.top_property("top_fans")
def top_fan(self):
"""topmost fan of the track"""
pass
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_tags(self):
"""top tags for the track"""
params = Track._check_params(
@ -233,10 +225,10 @@ class Track(LastfmBase, Taggable, Sharable, Searchable):
self.name,
self.mbid
)
data = self.__api._fetch_data(params).find('toptags')
data = self._api._fetch_data(params).find('toptags')
return [
Tag(
self.__api,
self._api,
subject = self,
name = t.findtext('name'),
url = t.findtext('url'),
@ -248,88 +240,18 @@ class Track(LastfmBase, Taggable, Sharable, Searchable):
for t in data.findall('tag')
]
@LastfmBase.topProperty("top_tags")
@LastfmBase.top_property("top_tags")
def top_tag(self):
"""topmost tag for the track"""
pass
def love(self):
params = self._default_params({'method': 'track.love'})
self.__api._post_data(params)
self._api._post_data(params)
def ban(self):
params = self._default_params({'method': 'track.ban'})
self.__api._post_data(params)
@staticmethod
def _search_yield_func(api, track):
return Track(
api,
name = track.findtext('name'),
artist = Artist(
api,
name=track.findtext('artist')
),
url = track.findtext('url'),
stats = Stats(
subject=track.findtext('name'),
listeners=int(track.findtext('listeners'))
),
streamable = (track.findtext('streamable') == '1'),
fullTrack = (track.find('streamable').attrib['fulltrack'] == '1'),
image = dict([(i.get('size'), i.text) for i in track.findall('image')]),
)
@staticmethod
def _fetch_data(api,
artist = None,
track = None,
mbid = None):
params = Track._check_params({'method': 'track.getInfo'}, artist, track, mbid)
return api._fetch_data(params).find('track')
def _fill_info(self):
data = Track._fetch_data(self.__api, self.artist.name, self.name)
self.__id = int(data.findtext('id'))
self.__mbid = data.findtext('mbid')
self.__url = data.findtext('url')
self.__duration = int(data.findtext('duration'))
self.__streamable = (data.findtext('streamable') == '1'),
self.__full_track = (data.find('streamable').attrib['fulltrack'] == '1'),
self.__image = dict([(i.get('size'), i.text) for i in data.findall('image')])
self.__stats = Stats(
subject = self,
listeners = int(data.findtext('listeners')),
playcount = int(data.findtext('playcount')),
)
self.__artist = Artist(
self.__api,
name = data.findtext('artist/name'),
mbid = data.findtext('artist/mbid'),
url = data.findtext('artist/url')
)
self.__album = Album(
self.__api,
artist = self.__artist,
name = data.findtext('album/title'),
mbid = data.findtext('album/mbid'),
url = data.findtext('album/url'),
image = dict([(i.get('size'), i.text) for i in data.findall('album/image')])
)
self.__position = int(data.find('album').attrib['position'])
if data.find('wiki') is not None:
self.__wiki = Wiki(
self,
published = datetime(*(time.strptime(
data.findtext('wiki/published').strip(),
'%a, %d %b %Y %H:%M:%S +0000'
)[0:6])),
summary = data.findtext('wiki/summary'),
content = data.findtext('wiki/content')
)
else:
self.__wiki = 'na'
self._api._post_data(params)
@staticmethod
def get_info(api,
@ -348,6 +270,83 @@ class Track(LastfmBase, Taggable, Sharable, Searchable):
t._fill_info()
return t
def _default_params(self, extra_params = {}):
if not (self.artist and self.name):
raise InvalidParametersError("artist and track have to be provided.")
params = {'artist': self.artist.name, 'track': self.name}
params.update(extra_params)
return params
@staticmethod
def _search_yield_func(api, track):
return Track(
api,
name = track.findtext('name'),
artist = Artist(
api,
name=track.findtext('artist')
),
url = track.findtext('url'),
stats = Stats(
subject=track.findtext('name'),
listeners=int(track.findtext('listeners'))
),
streamable = (track.findtext('streamable') == '1'),
full_track = (track.find('streamable').attrib['fulltrack'] == '1'),
image = dict([(i.get('size'), i.text) for i in track.findall('image')]),
)
@staticmethod
def _fetch_data(api,
artist = None,
track = None,
mbid = None):
params = Track._check_params({'method': 'track.getInfo'}, artist, track, mbid)
return api._fetch_data(params).find('track')
def _fill_info(self):
data = Track._fetch_data(self._api, self.artist.name, self.name)
self._id = int(data.findtext('id'))
self._mbid = data.findtext('mbid')
self._url = data.findtext('url')
self._duration = int(data.findtext('duration'))
self._streamable = (data.findtext('streamable') == '1'),
self._full_track = (data.find('streamable').attrib['fulltrack'] == '1'),
self._image = dict([(i.get('size'), i.text) for i in data.findall('image')])
self._stats = Stats(
subject = self,
listeners = int(data.findtext('listeners')),
playcount = int(data.findtext('playcount')),
)
self._artist = Artist(
self._api,
name = data.findtext('artist/name'),
mbid = data.findtext('artist/mbid'),
url = data.findtext('artist/url')
)
self._album = Album(
self._api,
artist = self._artist,
name = data.findtext('album/title'),
mbid = data.findtext('album/mbid'),
url = data.findtext('album/url'),
image = dict([(i.get('size'), i.text) for i in data.findall('album/image')])
)
self._position = int(data.find('album').attrib['position'])
if data.find('wiki') is not None:
self._wiki = Wiki(
self,
published = datetime(*(time.strptime(
data.findtext('wiki/published').strip(),
'%a, %d %b %Y %H:%M:%S +0000'
)[0:6])),
summary = data.findtext('wiki/summary'),
content = data.findtext('wiki/content')
)
else:
self._wiki = 'na'
@staticmethod
def _check_params(params,
artist = None,
@ -363,14 +362,14 @@ class Track(LastfmBase, Taggable, Sharable, Searchable):
return params
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash("%s%s" % (kwds['name'], hash(kwds['artist'])))
except KeyError:
raise InvalidParametersError("name and artist have to be provided for hashing")
def __hash__(self):
return self.__class__.hash_func(name = self.name, artist = self.artist)
return self.__class__._hash_func(name = self.name, artist = self.artist)
def __eq__(self, other):
if self.mbid and other.mbid:

302
src/user.py
View File

@ -23,117 +23,117 @@ class User(LastfmBase):
subscriber = None):
if not isinstance(api, Api):
raise InvalidParametersError("api reference must be supplied as an argument")
self.__api = api
self.__name = name
self.__url = url
self.__image = image
self.__stats = stats and Stats(
self._api = api
self._name = name
self._url = url
self._image = image
self._stats = stats and Stats(
subject = self,
match = stats.match,
weight = stats.weight,
playcount = stats.playcount
)
self.__library = User.Library(api, self)
self.__language = language
self.__country = country
self.__age = age
self.__gender = gender
self.__subscriber = subscriber
self._library = User.Library(api, self)
self._language = language
self._country = country
self._age = age
self._gender = gender
self._subscriber = subscriber
@property
def name(self):
"""name of the user"""
return self.__name
return self._name
@property
def url(self):
"""url of the user's page"""
return self.__url
return self._url
@property
def image(self):
"""image of the user"""
return self.__image
return self._image
@property
def stats(self):
"""stats for the user"""
return self.__stats
return self._stats
@property
def language(self):
"""lang for the user"""
return self.__language
return self._language
@property
def country(self):
"""country for the user"""
return self.__country
return self._country
@property
def age(self):
"""age for the user"""
return self.__age
return self._age
@property
def gender(self):
"""stats for the user"""
return self.__gender
return self._gender
@property
def subscriber(self):
"""is the user a subscriber"""
return self.__subscriber
return self._subscriber
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def events(self):
params = {'method': 'user.getEvents', 'user': self.name}
data = self.__api._fetch_data(params).find('events')
params = self._default_params({'method': 'user.getEvents'})
data = self._api._fetch_data(params).find('events')
return [
Event.create_from_data(self.__api, e)
Event.create_from_data(self._api, e)
for e in data.findall('event')
]
def get_past_events(self,
limit = None):
params = {'method': 'user.getPastEvents', 'user': self.name}
params = self._default_params({'method': 'user.getPastEvents'})
if limit is not None:
params.update({'limit': limit})
@lazylist
def gen(lst):
data = self.__api._fetch_data(params).find('events')
totalPages = int(data.attrib['totalPages'])
data = self._api._fetch_data(params).find('events')
total_pages = int(data.attrib['totalPages'])
@lazylist
def gen2(lst, data):
for e in data.findall('event'):
yield Event.create_from_data(self.__api, e)
yield Event.create_from_data(self._api, e)
for e in gen2(data):
yield e
for page in xrange(2, totalPages+1):
for page in xrange(2, total_pages+1):
params.update({'page': page})
data = self.__api._fetch_data(params).find('events')
data = self._api._fetch_data(params).find('events')
for e in gen2(data):
yield e
return gen()
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def past_events(self):
return self.get_past_events()
def get_friends(self,
limit = None):
params = {'method': 'user.getFriends', 'user': self.name}
params = self._default_params({'method': 'user.getFriends'})
if limit is not None:
params.update({'limit': limit})
data = self.__api._fetch_data(params).find('friends')
data = self._api._fetch_data(params).find('friends')
return [
User(
self.__api,
self._api,
subject = self,
name = u.findtext('name'),
image = dict([(i.get('size'), i.text) for i in u.findall('image')]),
@ -143,19 +143,19 @@ class User(LastfmBase):
]
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def friends(self):
"""friends of the user"""
return self.get_friends()
def get_neighbours(self, limit = None):
params = {'method': 'user.getNeighbours', 'user': self.name}
params = self._default_params({'method': 'user.getNeighbours'})
if limit is not None:
params.update({'limit': limit})
data = self.__api._fetch_data(params).find('neighbours')
data = self._api._fetch_data(params).find('neighbours')
return [
User(
self.__api,
self._api,
subject = self,
name = u.findtext('name'),
image = {'medium': u.findtext('image')},
@ -168,24 +168,24 @@ class User(LastfmBase):
for u in data.findall('user')
]
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def neighbours(self):
"""neighbours of the user"""
return self.get_neighbours()
@LastfmBase.topProperty("neighbours")
@LastfmBase.top_property("neighbours")
def nearest_neighbour(self):
"""nearest neightbour of the user"""
pass
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def playlists(self):
"""playlists of the user"""
params = {'method': 'user.getPlaylists', 'user': self.name}
data = self.__api._fetch_data(params).find('playlists')
params = self._default_params({'method': 'user.getPlaylists'})
data = self._api._fetch_data(params).find('playlists')
return [
User.Playlist(
self.__api,
self._api,
id = int(p.findtext('id')),
title = p.findtext('title'),
date = datetime(*(
@ -200,17 +200,17 @@ class User(LastfmBase):
for p in data.findall('playlist')
]
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def loved_tracks(self):
params = {'method': 'user.getLovedTracks', 'user': self.name}
data = self.__api._fetch_data(params).find('lovedtracks')
params = self._default_params({'method': 'user.getLovedTracks'})
data = self._api._fetch_data(params).find('lovedtracks')
return [
Track(
self.__api,
self._api,
subject = self,
name = t.findtext('name'),
artist = Artist(
self.__api,
self._api,
subject = self,
name = t.findtext('artist/name'),
mbid = t.findtext('artist/mbid'),
@ -218,7 +218,7 @@ class User(LastfmBase):
),
mbid = t.findtext('mbid'),
image = dict([(i.get('size'), i.text) for i in t.findall('image')]),
lovedOn = datetime(*(
loved_on = datetime(*(
time.strptime(
t.findtext('date').strip(),
'%d %b %Y, %H:%M'
@ -229,25 +229,25 @@ class User(LastfmBase):
]
def get_recent_tracks(self, limit = None):
params = {'method': 'user.getRecentTracks', 'user': self.name}
data = self.__api._fetch_data(params, no_cache = True).find('recenttracks')
params = self._default_params({'method': 'user.getRecentTracks'})
data = self._api._fetch_data(params, no_cache = True).find('recenttracks')
return [
Track(
self.__api,
self._api,
subject = self,
name = t.findtext('name'),
artist = Artist(
self.__api,
self._api,
subject = self,
name = t.findtext('artist'),
mbid = t.find('artist').attrib['mbid'],
),
album = Album(
self.__api,
self._api,
subject = self,
name = t.findtext('album'),
artist = Artist(
self.__api,
self._api,
subject = self,
name = t.findtext('artist'),
mbid = t.find('artist').attrib['mbid'],
@ -258,7 +258,7 @@ class User(LastfmBase):
streamable = (t.findtext('streamable') == '1'),
url = t.findtext('url'),
image = dict([(i.get('size'), i.text) for i in t.findall('image')]),
playedOn = datetime(*(
played_on = datetime(*(
time.strptime(
t.findtext('date').strip(),
'%d %b %Y, %H:%M'
@ -273,24 +273,24 @@ class User(LastfmBase):
"""recent tracks played by the user"""
return self.get_recent_tracks()
@LastfmBase.topProperty("recent_tracks")
@LastfmBase.top_property("recent_tracks")
def most_recent_track(self):
"""most recent track played by the user"""
pass
def get_top_albums(self, period = None):
params = {'method': 'user.getTopAlbums', 'user': self.name}
params = self._default_params({'method': 'user.getTopAlbums'})
if period is not None:
params.update({'period': period})
data = self.__api._fetch_data(params).find('topalbums')
data = self._api._fetch_data(params).find('topalbums')
return [
Album(
self.__api,
self._api,
subject = self,
name = a.findtext('name'),
artist = Artist(
self.__api,
self._api,
subject = self,
name = a.findtext('artist/name'),
mbid = a.findtext('artist/mbid'),
@ -308,25 +308,25 @@ class User(LastfmBase):
for a in data.findall('album')
]
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_albums(self):
"""overall top albums of the user"""
return self.get_top_albums()
@LastfmBase.topProperty("top_albums")
@LastfmBase.top_property("top_albums")
def top_album(self):
"""overall top most album of the user"""
pass
def get_top_artists(self, period = None):
params = {'method': 'user.getTopArtists', 'user': self.name}
params = self._default_params({'method': 'user.getTopArtists'})
if period is not None:
params.update({'period': period})
data = self.__api._fetch_data(params).find('topartists')
data = self._api._fetch_data(params).find('topartists')
return [
Artist(
self.__api,
self._api,
subject = self,
name = a.findtext('name'),
mbid = a.findtext('mbid'),
@ -342,28 +342,28 @@ class User(LastfmBase):
for a in data.findall('artist')
]
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_artists(self):
"""top artists of the user"""
return self.get_top_artists()
@LastfmBase.topProperty("top_artists")
@LastfmBase.top_property("top_artists")
def top_artist(self):
"""top artist of the user"""
pass
def get_top_tracks(self, period = None):
params = {'method': 'user.getTopTracks', 'user': self.name}
params = self._default_params({'method': 'user.getTopTracks'})
if period is not None:
params.update({'period': period})
data = self.__api._fetch_data(params).find('toptracks')
data = self._api._fetch_data(params).find('toptracks')
return [
Track(
self.__api,
self._api,
subject = self,
name = t.findtext('name'),
artist = Artist(
self.__api,
self._api,
subject = self,
name = t.findtext('artist/name'),
mbid = t.findtext('artist/mbid'),
@ -376,30 +376,30 @@ class User(LastfmBase):
playcount = t.findtext('playcount') and int(t.findtext('playcount')) or None
),
streamable = (t.findtext('streamable') == '1'),
fullTrack = (t.find('streamable').attrib['fulltrack'] == '1'),
full_track = (t.find('streamable').attrib['fulltrack'] == '1'),
image = dict([(i.get('size'), i.text) for i in t.findall('image')]),
)
for t in data.findall('track')
]
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_tracks(self):
"""top tracks of the user"""
return self.get_top_tracks()
@LastfmBase.topProperty("top_tracks")
@LastfmBase.top_property("top_tracks")
def top_track(self):
"""top track of the user"""
return (len(self.top_tracks) and self.top_tracks[0] or None)
def get_top_tags(self, limit = None):
params = {'method': 'user.getTopTags', 'user': self.name}
params = self._default_params({'method': 'user.getTopTags'})
if limit is not None:
params.update({'limit': limit})
data = self.__api._fetch_data(params).find('toptags')
data = self._api._fetch_data(params).find('toptags')
return [
Tag(
self.__api,
self._api,
subject = self,
name = t.findtext('name'),
url = t.findtext('url'),
@ -411,38 +411,38 @@ class User(LastfmBase):
for t in data.findall('tag')
]
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def top_tags(self):
"""top tags of the user"""
return self.get_top_tags()
@LastfmBase.topProperty("top_tags")
@LastfmBase.top_property("top_tags")
def top_tag(self):
"""top tag of the user"""
pass
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def weekly_chart_list(self):
params = {'method': 'user.getWeeklyChartList', 'user': self.name}
data = self.__api._fetch_data(params).find('weeklychartlist')
params = self._default_params({'method': 'user.getWeeklyChartList'})
data = self._api._fetch_data(params).find('weeklychartlist')
return [
WeeklyChart.create_from_data(self.__api, self, c)
WeeklyChart.create_from_data(self._api, self, c)
for c in data.findall('chart')
]
def get_weekly_album_chart(self,
start = None,
end = None):
params = {'method': 'user.getWeeklyAlbumChart', 'user': self.name}
params = self._default_params({'method': 'user.getWeeklyAlbumChart'})
params = WeeklyChart._check_weekly_chart_params(params, start, end)
data = self.__api._fetch_data(params).find('weeklyalbumchart')
return WeeklyAlbumChart.create_from_data(self.__api, self, data)
data = self._api._fetch_data(params).find('weeklyalbumchart')
return WeeklyAlbumChart.create_from_data(self._api, self, data)
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def recent_weekly_album_chart(self):
return self.get_weekly_album_chart()
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def weekly_album_chart_list(self):
wcl = list(self.weekly_chart_list)
wcl.reverse()
@ -458,16 +458,16 @@ class User(LastfmBase):
def get_weekly_artist_chart(self,
start = None,
end = None):
params = {'method': 'user.getWeeklyArtistChart', 'user': self.name}
params = self._default_params({'method': 'user.getWeeklyArtistChart'})
params = WeeklyChart._check_weekly_chart_params(params, start, end)
data = self.__api._fetch_data(params).find('weeklyartistchart')
return WeeklyArtistChart.create_from_data(self.__api, self, data)
data = self._api._fetch_data(params).find('weeklyartistchart')
return WeeklyArtistChart.create_from_data(self._api, self, data)
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def recent_weekly_artist_chart(self):
return self.get_weekly_artist_chart()
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def weekly_artist_chart_list(self):
wcl = list(self.weekly_chart_list)
wcl.reverse()
@ -483,16 +483,16 @@ class User(LastfmBase):
def get_weekly_track_chart(self,
start = None,
end = None):
params = {'method': 'user.getWeeklyTrackChart', 'user': self.name}
params = self._default_params({'method': 'user.getWeeklyTrackChart'})
params = WeeklyChart._check_weekly_chart_params(params, start, end)
data = self.__api._fetch_data(params).find('weeklytrackchart')
return WeeklyTrackChart.create_from_data(self.__api, self, data)
data = self._api._fetch_data(params).find('weeklytrackchart')
return WeeklyTrackChart.create_from_data(self._api, self, data)
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def recent_weekly_track_chart(self):
return self.get_weekly_track_chart()
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def weekly_track_chart_list(self):
wcl = list(self.weekly_chart_list)
wcl.reverse()
@ -506,13 +506,13 @@ class User(LastfmBase):
return gen()
def compare(self, other, limit = None):
return Tasteometer.compare(self.__api,
return Tasteometer.compare(self._api,
'user', 'user',
self.name, other.name,
limit)
@property
def library(self):
return self.__library
return self._library
@staticmethod
def get_authenticated_user(api):
@ -532,15 +532,22 @@ class User(LastfmBase):
)
)
def _default_params(self, extra_params = {}):
if not self.name:
raise InvalidParametersError("user has to be provided.")
params = {'user': self.name}
params.update(extra_params)
return params
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash(kwds['name'])
except KeyError:
raise InvalidParametersError("name has to be provided for hashing")
def __hash__(self):
return self.__class__.hash_func(name = self.name)
return self.__class__._hash_func(name = self.name)
def __eq__(self, other):
return self.name == other.name
@ -555,50 +562,50 @@ class User(LastfmBase):
"""A class representing a playlist belonging to the user."""
def init(self, api, id, title, date, size, creator):
super(User.Playlist, self).init(api, "lastfm://playlist/%s" % id)
self.__id = id
self.__title = title
self.__date = date
self.__size = size
self.__creator = creator
self._id = id
self._title = title
self._date = date
self._size = size
self._creator = creator
@property
def id(self):
return self.__id
return self._id
@property
def title(self):
return self.__title
return self._title
@property
def date(self):
return self.__date
return self._date
@property
def size(self):
return self.__size
return self._size
@property
def creator(self):
return self.__creator
return self._creator
def addTrack(self, track):
def add_track(self, track):
params = {'method': 'playlist.addTrack', 'playlistID': self.id}
if not isinstance(track, Track):
track = self.__api.search_track(track)[0]
track = self._api.search_track(track)[0]
params['artist'] = track.artist.name
params['track'] = track.name
self.__api._post_data(params)
self._api._post_data(params)
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash(kwds['id'])
except KeyError:
raise InvalidParametersError("id has to be provided for hashing")
def __hash__(self):
return self.__class__.hash_func(id = self.id)
return self.__class__._hash_func(id = self.id)
def __repr__(self):
return "<lastfm.User.Playlist: %s>" % self.title
@ -606,33 +613,33 @@ class User(LastfmBase):
class Library(object):
"""A class representing the music library of the user."""
def __init__(self, api, user):
self.__api = api
self.__user = user
self._api = api
self._user = user
@property
def user(self):
return self.__user
return self._user
def get_albums(self,
limit = None):
params = {'method': 'library.getAlbums', 'user': self.user.name}
params = self._default_params({'method': 'library.getAlbums'})
if limit is not None:
params.update({'limit': limit})
@lazylist
def gen(lst):
data = self.__api._fetch_data(params).find('albums')
data = self._api._fetch_data(params).find('albums')
total_pages = int(data.attrib['totalPages'])
@lazylist
def gen2(lst, data):
for a in data.findall('album'):
yield Album(
self.__api,
self._api,
subject = self,
name = a.findtext('name'),
artist = Artist(
self.__api,
self._api,
subject = self,
name = a.findtext('artist/name'),
mbid = a.findtext('artist/mbid'),
@ -654,33 +661,33 @@ class User(LastfmBase):
for page in xrange(2, total_pages+1):
params.update({'page': page})
try:
data = self.__api._fetch_data(params).find('albums')
data = self._api._fetch_data(params).find('albums')
except Error:
continue
for a in gen2(data):
yield a
return gen()
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def albums(self):
return self.get_albums()
def get_artists(self,
limit = None):
params = {'method': 'library.getArtists', 'user': self.user.name}
params = self._default_params({'method': 'library.getArtists'})
if limit is not None:
params.update({'limit': limit})
@lazylist
def gen(lst):
data = self.__api._fetch_data(params).find('artists')
data = self._api._fetch_data(params).find('artists')
total_pages = int(data.attrib['totalPages'])
@lazylist
def gen2(lst, data):
for a in data.findall('artist'):
yield Artist(
self.__api,
self._api,
subject = self,
name = a.findtext('name'),
mbid = a.findtext('mbid'),
@ -700,37 +707,37 @@ class User(LastfmBase):
for page in xrange(2, total_pages+1):
params.update({'page': page})
try:
data = self.__api._fetch_data(params).find('artists')
data = self._api._fetch_data(params).find('artists')
except Error:
continue
for a in gen2(data):
yield a
return gen()
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def artists(self):
return self.get_artists()
def get_tracks(self,
limit = None):
params = {'method': 'library.getTracks', 'user': self.user.name}
params = self._default_params({'method': 'library.getTracks'})
if limit is not None:
params.update({'limit': limit})
@lazylist
def gen(lst):
data = self.__api._fetch_data(params).find('tracks')
totalPages = int(data.attrib['totalPages'])
data = self._api._fetch_data(params).find('tracks')
total_pages = int(data.attrib['totalPages'])
@lazylist
def gen2(lst, data):
for t in data.findall('track'):
yield Track(
self.__api,
self._api,
subject = self,
name = t.findtext('name'),
artist = Artist(
self.__api,
self._api,
subject = self,
name = t.findtext('artist/name'),
mbid = t.findtext('artist/mbid'),
@ -743,37 +750,44 @@ class User(LastfmBase):
tagcount = t.findtext('tagcount') and int(t.findtext('tagcount')) or None
),
streamable = (t.findtext('streamable') == '1'),
fullTrack = (t.find('streamable').attrib['fulltrack'] == '1'),
full_track = (t.find('streamable').attrib['fulltrack'] == '1'),
image = dict([(i.get('size'), i.text) for i in t.findall('image')]),
)
for t in gen2(data):
yield t
for page in xrange(2, totalPages+1):
for page in xrange(2, total_pages+1):
params.update({'page': page})
data = None
try:
data = self.__api._fetch_data(params).find('tracks')
data = self._api._fetch_data(params).find('tracks')
except Error:
continue
for t in gen2(data):
yield t
return gen()
@LastfmBase.cachedProperty
@LastfmBase.cached_property
def tracks(self):
return self.get_tracks()
def _default_params(self, extra_params = {}):
if not self.user.name:
raise InvalidParametersError("user has to be provided.")
params = {'user': self.user.name}
params.update(extra_params)
return params
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash(kwds['user'])
except KeyError:
raise InvalidParametersError("user has to be provided for hashing")
def __hash__(self):
return self.__class__.hash_func(user = self.user)
return self.__class__._hash_func(user = self.user)
def __repr__(self):
return "<lastfm.User.Library: for user '%s'>" % self.user.name

32
src/weeklychart.py
View File

@ -11,26 +11,26 @@ class WeeklyChart(LastfmBase):
def init(self, subject, start, end,
stats = None):
self.__subject = subject
self.__start = start
self.__end = end
self.__stats = stats
self._subject = subject
self._start = start
self._end = end
self._stats = stats
@property
def subject(self):
return self.__subject
return self._subject
@property
def start(self):
return self.__start
return self._start
@property
def end(self):
return self.__end
return self._end
@property
def stats(self):
return self.__stats
return self._stats
@staticmethod
def create_from_data(api, subject, data):
@ -56,7 +56,7 @@ class WeeklyChart(LastfmBase):
return params
@staticmethod
def hash_func(*args, **kwds):
def _hash_func(*args, **kwds):
try:
return hash("%s%s%s%s" % (
kwds['subject'].__class__.__name__,
@ -68,7 +68,7 @@ class WeeklyChart(LastfmBase):
raise InvalidParametersError("subject, start and end have to be provided for hashing")
def __hash__(self):
return self.__class__.hash_func(
return self.__class__._hash_func(
subject = self.subject,
start = self.start,
end = self.end
@ -102,11 +102,11 @@ class WeeklyAlbumChart(WeeklyChart):
"""A class for representing the weekly album charts"""
def init(self, subject, start, end, stats, albums):
super(WeeklyAlbumChart, self).init(subject, start, end, stats)
self.__albums = albums
self._albums = albums
@property
def albums(self):
return self.__albums
return self._albums
@staticmethod
def create_from_data(api, subject, data):
@ -156,11 +156,11 @@ class WeeklyArtistChart(WeeklyChart):
"""A class for representing the weekly artist charts"""
def init(self, subject, start, end, stats, artists):
super(WeeklyArtistChart, self).init(subject, start, end, stats)
self.__artists = artists
self._artists = artists
@property
def artists(self):
return self.__artists
return self._artists
@staticmethod
def create_from_data(api, subject, data):
@ -204,11 +204,11 @@ class WeeklyTrackChart(WeeklyChart):
"""A class for representing the weekly track charts"""
def init(self, subject, start, end, tracks, stats):
super(WeeklyTrackChart, self).init(subject, start, end, stats)
self.__tracks = tracks
self._tracks = tracks
@property
def tracks(self):
return self.__tracks
return self._tracks
@staticmethod
def create_from_data(api, subject, data):

16
src/wiki.py
View File

@ -11,30 +11,30 @@ class Wiki(object):
published = None,
summary = None,
content = None):
self.__subject = subject
self.__published = published
self.__summary = summary
self.__content = content
self._subject = subject
self._published = published
self._summary = summary
self._content = content
@property
def subject(self):
"""artist for which the biography is"""
return self.__subject
return self._subject
@property
def published(self):
"""publication time of the biography"""
return self.__published
return self._published
@property
def summary(self):
"""summary of the biography"""
return self.__summary
return self._summary
@property
def content(self):
"""content of the biography"""
return self.__content
return self._content
def __repr__(self):
return "<lastfm.Wiki: for %s '%s'>" % (self.subject.__class__.__name__, self.subject.name)