Package lastfm :: Module tag

[hide private]
[frames] | no frames]

# Source Code for Module lastfm.tag

      1  #!/usr/bin/env python
      2
      3  __author__ = "Abhinav Sarkar <abhinav@abhinavsarkar.net>"
      4  __version__ = "0.2"
      5  __license__ = "GNU Lesser General Public License"
      6
      7  from lastfm.base import LastfmBase
      8  from lastfm.mixins import Cacheable, Searchable
      9  from lastfm.lazylist import lazylist
     10  from lastfm.decorators import cached_property, top_property
     11
     12 -class Tag(LastfmBase, Cacheable, Searchable):
     13      """A class representing a tag."""
     14 -    def init(self,
     15                   api,
     16                   name = None,
     17                   url = None,
     18                   streamable = None,
     19                   stats = None,
     20                   **kwargs):
     21          if not isinstance(api, Api):
     22              raise InvalidParametersError("api reference must be supplied as an argument")
     23          self._api = api
     24          self._name = name
     25          self._url = url
     26          self._streamable = streamable
     27          self._stats = stats and Stats(
     28                               subject = self,
     29                               count = stats.count,
     30                               rank = stats.rank
     31                               )
     32
     33      @property
     34 -    def name(self):
     35          """name of the tag"""
     36          return self._name
     37
     38      @property
     39 -    def url(self):
     40          """url of the tag's page"""
     41          return self._url
     42
     43      @property
     44 -    def streamable(self):
     45          """is the tag streamable"""
     46          return self._streamable
     47
     48      @property
     49 -    def stats(self):
     50          return self._stats
     51
     52      @cached_property
     53 -    def similar(self):
     54          """tags similar to this tag"""
     55          params = self._default_params({'method': 'tag.getSimilar'})
     56          data = self._api._fetch_data(params).find('similartags')
     57          return [
     58                  Tag(
     59                      self._api,
     60                      subject = self,
     61                      name = t.findtext('name'),
     62                      url = t.findtext('url'),
     63                      streamable = (t.findtext('streamable') == "1"),
     64                      )
     65                  for t in data.findall('tag')
     66                  ]
     67
     68      @top_property("similar")
     69 -    def most_similar(self):
     70          """most similar tag to this tag"""
     71          pass
     72
     73      @cached_property
     74 -    def top_albums(self):
     75          """top albums for the tag"""
     76          params = self._default_params({'method': 'tag.getTopAlbums'})
     77          data = self._api._fetch_data(params).find('topalbums')
     78          return [
     79                  Album(
     80                        self._api,
     81                        subject = self,
     82                        name = a.findtext('name'),
     83                        artist = Artist(
     84                                        self._api,
     85                                        subject = self,
     86                                        name = a.findtext('artist/name'),
     87                                        mbid = a.findtext('artist/mbid'),
     88                                        url = a.findtext('artist/url'),
     89                                        ),
     90                        mbid = a.findtext('mbid'),
     91                        url = a.findtext('url'),
     92                        image = dict([(i.get('size'), i.text) for i in a.findall('image')]),
     93                        stats = Stats(
     94                                      subject = a.findtext('name'),
     95                                      tagcount = a.findtext('tagcount') and int(a.findtext('tagcount')) or None,
     96                                      rank = a.attrib['rank'].strip() and int(a.attrib['rank']) or None
     97                                      )
     98                        )
     99                  for a in data.findall('album')
    100                  ]
    101
    102      @top_property("top_albums")
    103 -    def top_album(self):
    104          """top album for the tag"""
    105          pass
    106
    107      @cached_property
    108 -    def top_artists(self):
    109          """top artists for the tag"""
    110          params = self._default_params({'method': 'tag.getTopArtists'})
    111          data = self._api._fetch_data(params).find('topartists')
    112          return [
    113                  Artist(
    114                         self._api,
    115                         subject = self,
    116                         name = a.findtext('name'),
    117                         mbid = a.findtext('mbid'),
    118                         stats = Stats(
    119                                       subject = a.findtext('name'),
    120                                       rank = a.attrib['rank'].strip() and int(a.attrib['rank']) or None,
    121                                       tagcount = a.findtext('tagcount') and int(a.findtext('tagcount')) or None
    122                                       ),
    123                         url = a.findtext('url'),
    124                         streamable = (a.findtext('streamable') == "1"),
    125                         image = dict([(i.get('size'), i.text) for i in a.findall('image')]),
    126                         )
    127                  for a in data.findall('artist')
    128                  ]
    129
    130      @top_property("top_artists")
    131 -    def top_artist(self):
    132          """top artist for the tag"""
    133          pass
    134
    135      @cached_property
    136 -    def top_tracks(self):
    137          """top tracks for the tag"""
    138          params = self._default_params({'method': 'tag.getTopTracks'})
    139          data = self._api._fetch_data(params).find('toptracks')
    140          return [
    141                  Track(
    142                        self._api,
    143                        subject = self,
    144                        name = t.findtext('name'),
    145                        artist = Artist(
    146                                        self._api,
    147                                        subject = self,
    148                                        name = t.findtext('artist/name'),
    149                                        mbid = t.findtext('artist/mbid'),
    150                                        url = t.findtext('artist/url'),
    151                                        ),
    152                        mbid = t.findtext('mbid'),
    153                        stats = Stats(
    154                                      subject = t.findtext('name'),
    155                                      rank = t.attrib['rank'].strip() and int(t.attrib['rank']) or None,
    156                                      tagcount = t.findtext('tagcount') and int(t.findtext('tagcount')) or None
    157                                      ),
    158                        streamable = (t.findtext('streamable') == '1'),
    159                        full_track = (t.find('streamable').attrib['fulltrack'] == '1'),
    160                        image = dict([(i.get('size'), i.text) for i in t.findall('image')]),
    161                        )
    162                  for t in data.findall('track')
    163                  ]
    164
    165      @top_property("top_tracks")
    166 -    def top_track(self):
    167          """top track for the tag"""
    168          pass
    169
    170      @cached_property
    171 -    def playlist(self):
    172          return Playlist.fetch(self._api,
    173                                "lastfm://playlist/tag/%s/freetracks" % self.name)
    174
    175      @cached_property
    176 -    def weekly_chart_list(self):
    177          params = self._default_params({'method': 'tag.getWeeklyChartList'})
    178          data = self._api._fetch_data(params).find('weeklychartlist')
    179          return [
    180                  WeeklyChart.create_from_data(self._api, self, c)
    181                  for c in data.findall('chart')
    182                  ]
    183
    184 -    def get_weekly_artist_chart(self,
    185                               start = None,
    186                               end = None,
    187                               limit = None):
    188          params = self._default_params({'method': 'tag.getWeeklyArtistChart'})
    189          if limit is not None:
    190              params['limit'] = limit
    191          params = WeeklyArtistChart._check_weekly_chart_params(params, start, end)
    192          data = self._api._fetch_data(params).find('weeklyartistchart')
    193          return WeeklyArtistChart.create_from_data(self._api, self, data)
    194
    195      @cached_property
    196 -    def recent_weekly_artist_chart(self):
    197          return self.get_weekly_artist_chart()
    198
    199      @cached_property
    200 -    def weekly_artist_chart_list(self):
    201          wcl = list(self.weekly_chart_list)
    202          wcl.reverse()
    203          @lazylist
    204          def gen(lst):
    205              for wc in wcl:
    206                  try:
    207                      yield self.get_weekly_artist_chart(wc.start, wc.end)
    208                  except LastfmError:
    209                      pass
    210          return gen()
    211
    212      @staticmethod
    213 -    def get_top_tags(api):
    214          params = {'method': 'tag.getTopTags'}
    215          data = api._fetch_data(params).find('toptags')
    216          return [
    217                  Tag(
    218                      api,
    219                      name = t.findtext('name'),
    220                      url = t.findtext('url'),
    221                      stats = Stats(
    222                                    subject = t.findtext('name'),
    223                                    count = int(t.findtext('count')),
    224                                    )
    225                      )
    226                  for t in data.findall('tag')
    227                  ]
    228
    229 -    def _default_params(self, extra_params = {}):
    230          if not self.name:
    231              raise InvalidParametersError("tag has to be provided.")
    232          params = {'tag': self.name}
    233          params.update(extra_params)
    234          return params
    235
    236      @staticmethod
    237 -    def _search_yield_func(api, tag):
    238          return Tag(
    239                     api,
    240                     name = tag.findtext('name'),
    241                     url = tag.findtext('url'),
    242                     stats = Stats(
    243                                   subject = tag.findtext('name'),
    244                                   count = int(tag.findtext('count')),
    245                                   )
    246                      )
    247
    248      @staticmethod
    249 -    def _hash_func(*args, **kwds):
    250          try:
    251              return hash(kwds['name'])
    252          except KeyError:
    253              raise InvalidParametersError("name has to be provided for hashing")
    254
    255 -    def __hash__(self):
    256          return self.__class__._hash_func(name = self.name)
    257
    258 -    def __eq__(self, other):
    259          return self.name == other.name
    260
    261 -    def __lt__(self, other):
    262          return self.name < other.name
    263
    264 -    def __repr__(self):
    265          return "<lastfm.Tag: %s>" % self.name
    266
    267  from lastfm.album import Album
    268  from lastfm.api import Api
    269  from lastfm.artist import Artist
    270  from lastfm.error import LastfmError, InvalidParametersError
    271  from lastfm.playlist import Playlist
    272  from lastfm.stats import Stats
    273  from lastfm.track import Track
    274  from lastfm.weeklychart import WeeklyChart, WeeklyArtistChart
    275