def _check_chart_params(params, subject, start=None, end=None):
if xor(start is None, end is None):
raise InvalidParametersError(
"both start and end have to be provided.")
if start is not None and end is not None:
if not (isinstance(start, datetime) and isinstance(end, datetime)):
raise InvalidParametersError(
"start and end must be datetime.datetime instances")
params.update({
'from': int(calendar.timegm(start.timetuple())),
'to': int(calendar.timegm(end.timetuple()))
})
return params
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
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
def _default_params(self, extra_params=None):
if not self.name:
raise InvalidParametersError("tag has to be provided.")
params = {'tag': self.name}
if extra_params is not None:
params.update(extra_params)
return params
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
def init(self, api, **kwargs):
"""
Create a Location object by providing all the data related to it.
@param api: an instance of L{Api}
@type api: L{Api}
@param city: city in which the location is situated
@type city: L{str}
@param country: country in which the location is situated
@type country: L{Country}
@param street: street in which the location is situated
@type street: L{str}
@param postal_code: postal code of the location
@type postal_code: L{str}
@param latitude: latitude of the location
@type latitude: L{float}
@param longitude: longitude of the location
@type longitude: L{float}
@param timezone: timezone in which the location is situated
@type timezone: L{str}
@raise InvalidParametersError: If an instance of L{Api} is not provided as the first
parameter then an Exception is raised.
"""
if not isinstance(api, Api):
raise InvalidParametersError(
"api reference must be supplied as an argument")
self._api = api
super(Location, self).init(**kwargs)
def __init__(self,
api_key,
secret=None,
session_key=None,
input_encoding=None,
request_headers=None,
no_cache=False,
debug=None,
logfile=None):
"""
Create an Api object to access the last.fm webservice API. Use this object as a
starting point for accessing all the webservice methods.
@param api_key: last.fm API key
@type api_key: L{str}
@param secret: last.fm API secret (optional, required only for
authenticated webservice methods)
@type secret: L{str}
@param session_key: session key for the authenticated session (optional,
required only for authenticated webservice methods)
@type session_key: L{str}
@param input_encoding: encoding of the input data (optional)
@type input_encoding: L{str}
@param request_headers: HTTP headers for the requests to last.fm webservices
(optional)
@type request_headers: L{dict}
@param no_cache: flag to switch off file cache (optional)
@type no_cache: L{bool}
@param debug: flag to switch on debugging (optional)
@type debug: L{bool}
"""
self._api_key = api_key
self._secret = secret
self._session_key = session_key
self._urllib = urllib2
self._cache_timeout = Api.DEFAULT_CACHE_TIMEOUT
self._initialize_request_headers(request_headers)
self._initialize_user_agent()
self._input_encoding = input_encoding
self._no_cache = no_cache
self._logfile = logfile
self._last_fetch_time = datetime.now()
if self._no_cache:
self._cache = None
else:
self._cache = FileCache()
if debug is not None:
if debug in Api.DEBUG_LEVELS:
self._debug = Api.DEBUG_LEVELS[debug]
else:
raise InvalidParametersError(
"debug parameter must be one of the keys in Api.DEBUG_LEVELS dict"
)
else:
self._debug = None
if self._debug is not None:
Wormhole.enable()
logging.set_api(self)
def _hash_func(*args, **kwds):
try:
return hash("%s%s%s%s" %
(kwds['subject'].__class__.__name__,
kwds['subject'].name, kwds['start'], kwds['end']))
except KeyError:
raise InvalidParametersError(
"subject, start and end have to be provided for hashing")
def __getitem__(self, name):
if name not in ObjectCache.keys:
raise InvalidParametersError("Key does not correspond to a valid class")
else:
if name in _registry:
return sorted(_registry[name].values())
else:
return []
def _hash_func(*args, **kwds):
try:
return hash(kwds['name'].lower())
except KeyError:
try:
return hash(args[1].lower())
except IndexError:
raise InvalidParametersError(
"name has to be provided for hashing")
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 init(self, api, **kwargs):
if not isinstance(api, Api):
raise InvalidParametersError(
"api reference must be supplied as an argument")
self._api = api
super(Tag, self).init(**kwargs)
self._stats = hasattr(self, '_stats') and Stats(
subject=self, count=self._stats.count,
rank=self._stats.rank) or None
def _hash_func(*args, **kwds):
try:
return hash("latlong%s%s" % (kwds['latitude'], kwds['longitude']))
except KeyError:
try:
return hash("name%s" % kwds['city'])
except KeyError:
raise InvalidParametersError(
"either latitude and longitude or city has to be provided for hashing"
)
def top_tracks(self):
"""
top tracks for the location
@rtype: L{list} of L{Track}
"""
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)
def _check_params(params, artist=None, track=None, mbid=None):
if not ((artist and track) or mbid):
raise InvalidParametersError(
"either (artist and track) or mbid has to be given as argument."
)
if artist and track:
params.update({'artist': artist, 'track': track})
elif mbid:
params.update({'mbid': mbid})
return params
def _check_chart_params(params, subject, start=None, end=None):
params = Chart._check_chart_params(params, subject, start, end)
if start is not None and end is not None:
wcl = subject.weekly_chart_list
is_valid = False
for wc in wcl:
if wc.start == start and wc.end == end:
is_valid = True
if not is_valid:
raise InvalidParametersError(
"%s - %s chart dates are invalid" % (start, end))
return params
def init(self, api, **kwargs):
if not isinstance(api, Api):
raise InvalidParametersError("api reference must be supplied as an argument")
self._api = api
super(User, self).init(**kwargs)
self._stats = hasattr(self, "_stats") and Stats(
subject = self,
match = self._stats.match,
weight = self._stats.weight,
playcount = self._stats.playcount
) or None
self._library = User.Library(api, self)
def _check_chart_params(cls, params, subject, start=None, end=None):
duration = cls._period['duration']
params = Chart._check_chart_params(params, subject, start, end)
if start is not None and end is not None:
mcl = MonthlyChart.get_chart_list(subject)
is_valid = False
for i in xrange(len(mcl) - (duration - 1)):
if mcl[i].start == start and mcl[i +
(duration - 1)].end == end:
is_valid = True
if not is_valid:
raise InvalidParametersError(
"%s - %s chart dates are invalid" % (start, end))
return params
def init(self, api, subject=None, **kwargs):
"""
Create an Artist object by providing all the data related to it.
@param api: an instance of L{Api}
@type api: L{Api}
@param name: the artist name
@type name: L{str}
@param mbid: MBID of the artist
@type mbid: L{str}
@param url: URL of the artist on last.fm
@type url: L{str}
@param image: the images of the artist in various sizes
@type image: L{dict}
@param streamable: flag indicating if the artist is streamable from last.fm
@type streamable: L{bool}
@param stats: the artist statistics
@type stats: L{Stats}
@param similar: artists similar to the provided artist
@type similar: L{list} of L{Artist}
@param top_tags: top tags for the artist
@type top_tags: L{list} of L{Tag}
@param bio: biography of the artist
@type bio: L{Wiki}
@param subject: the subject to which this instance belongs to
@type subject: L{User} OR L{Artist} OR L{Tag} OR L{Track} OR L{WeeklyChart}
@raise InvalidParametersError: If an instance of L{Api} is not provided as the first
parameter then an Exception is raised.
"""
if not isinstance(api, Api):
raise InvalidParametersError(
"api reference must be supplied as an argument")
self._api = api
super(Artist, self).init(**kwargs)
self._stats = hasattr(self, "_stats") and Stats(
subject=self,
listeners=self._stats.listeners,
playcount=self._stats.playcount,
weight=self._stats.weight,
match=self._stats.match,
rank=self._stats.rank) or None
self._bio = hasattr(self, "_bio") and Wiki(
subject=self,
published=self._bio.published,
summary=self._bio.summary,
content=self._bio.content) or None
self._subject = subject
def get_events(api,
location,
latitude=None,
longitude=None,
distance=None,
page=None):
"""
Get the events for a location.
@param api: an instance of L{Api}
@type api: L{Api}
@param location: location to retrieve events for (optional)
@type location: L{str}
@param latitude: latitude value to retrieve events for (optional)
@type latitude: L{float}
@param longitude: longitude value to retrieve events for (optional)
@type longitude: L{float}
@param distance: find events within a specified distance (optional)
@type distance: L{float}
@return: events for the location
@rtype: L{lazylist} of L{Event}
@raise InvalidParametersError: Either location or latitude and longitude
has to be provided. Otherwise exception is
raised.
@note: Use L{Location.events} instead of using this method directly.
"""
if reduce(lambda x, y: x and y is None,
[location, latitude, longitude], True):
raise InvalidParametersError(
"Either location or latitude and longitude has to be provided")
params = {'method': 'geo.getEvents', 'location': location}
if distance is not None:
params.update({'distance': distance})
if latitude is not None and longitude is not None:
params.update({'lat': latitude, 'long': longitude})
if page is not None:
params.update({'page': page})
data = api._fetch_data(params).find('events')
total_pages = int(data.attrib['totalpages'])
yield total_pages
for e in data.findall('event'):
yield Event.create_from_data(api, e)
def attend(self, status = STATUS_ATTENDING):
"""
Set the attendance status of the authenticated user for this event.
@param status: attendance status, should be one of:
L{Event.STATUS_ATTENDING} OR L{Event.STATUS_MAYBE} OR L{Event.STATUS_NOT}
@type status: L{int}
@raise InvalidParametersError: If status parameters is not one of the allowed values
then an exception is raised.
"""
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 init(self, api, **kwargs):
"""
Create a Country object by providing all the data related to it.
@param api: an instance of L{Api}
@type api: L{Api}
@param name: name of the country
@type name: L{str}
@raise InvalidParametersError: If an instance of L{Api} is not provided as the first
parameter then an Exception is raised.
"""
if not isinstance(api, Api):
raise InvalidParametersError(
"api reference must be supplied as an argument")
self._api = api
super(Country, self).init(**kwargs)
def init(self, api, **kwargs):
if not isinstance(api, Api):
raise InvalidParametersError(
"api reference must be supplied as an argument")
self._api = api
super(Track, self).init(**kwargs)
self._stats = hasattr(self, "_stats") and Stats(
subject=self,
match=self._stats.match,
playcount=self._stats.playcount,
rank=self._stats.rank,
listeners=self._stats.listeners,
) or None
self._wiki = hasattr(self, "_wiki") and Wiki(
subject=self,
published=self._wiki.published,
summary=self._wiki.summary,
content=self._wiki.content) or None
def init(self, api, subject=None, **kwargs):
"""
Create an Album object by providing all the data related to it.
@param api: an instance of L{Api}
@type api: L{Api}
@param name: the album name
@type name: L{str}
@param artist: the album artist name
@type artist: L{Artist}
@param id: the album ID
@type id: L{str}
@param mbid: MBID of the album
@type mbid: L{str}
@param url: URL of the album on last.fm
@type url: L{str}
@param release_date: release date of the album
@type release_date: C{datetime.datetime}
@param image: the cover images of the album in various sizes
@type image: L{dict}
@param stats: the album statistics
@type stats: L{Stats}
@param top_tags: top tags for the album
@type top_tags: L{list} of L{Tag}
@param streamable: flag indicating if the album is streamable from last.fm
@type streamable: L{bool}
@param subject: the subject to which this instance belongs to
@type subject: L{User} OR L{Artist} OR L{Tag} OR L{WeeklyChart}
@raise InvalidParametersError: If an instance of L{Api} is not provided as the first
parameter then an Exception is raised.
"""
if not isinstance(api, Api):
raise InvalidParametersError(
"api reference must be supplied as an argument")
self._api = api
super(Album, self).init(**kwargs)
self._stats = hasattr(self, "_stats") and Stats(
subject=self,
listeners=self._stats.listeners,
playcount=self._stats.playcount,
match=self._stats.match,
rank=self._stats.rank) or None
self._subject = subject
def get_venue(self, venue, callback = None):
"""
Get a venue object.
@param venue: the venue name
@type venue: L{str}
@param callback: callback function for asynchronous invocation (optional)
@type callback: C{function}
@return: a venue object corresponding to the venue name provided
@rtype: L{Venue}
@raise InvalidParametersError: Exception is raised if an non-existant venue name is supplied.
@see: L{search_venue}
@see: L{async_callback}
"""
try:
return self.search_venue(venue)[0]
except IndexError:
raise InvalidParametersError("No such venue exists")
def init(self, api, **kwargs):
"""
Create an Event object by providing all the data related to it.
@param api: an instance of L{Api}
@type api: L{Api}
@param id: ID of the event
@type id: L{int}
@param title: title of the event
@type title: L{str}
@param artists: artists performing in the event
@type artists: L{list} of L{Artist}
@param headliner: headliner artist of the event
@type headliner: L{Artist}
@param venue: venue of the event
@type venue: L{Venue}
@param start_date: start date and time of the event
@type start_date: C{datetime.datetime}
@param description: description of the event
@type description: L{str}
@param image: poster images of the event in various sizes
@type image: L{dict}
@param url: URL of the event on last.fm
@type url: L{str}
@param stats: the statistics of the event (attendance and no. of reviews)
@type stats: L{Stats}
@param tag: tag for the event
@type tag: L{str}
"""
if not isinstance(api, Api):
raise InvalidParametersError(
"api reference must be supplied as an argument")
self._api = api
super(Event, self).init(**kwargs)
self._stats = hasattr(self, "_stats") and Stats(
subject=self,
attendance=self._stats.attendance,
reviews=self._stats.reviews) or None
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_func(*args, **kwds):
try:
return hash("%s%s" % (kwds['body'], kwds['author']))
except KeyError:
raise InvalidParametersError(
"body and author have to be provided for hashing")
def _hash_func(*args, **kwds):
try:
return hash(kwds['id'])
except KeyError:
raise InvalidParametersError("id has to be provided for hashing")
def _default_params(self, extra_params = {}):
if not self.id:
raise InvalidParametersError("venue id has to be provided.")
params = {'venue': self.id}
params.update(extra_params)
return params
