lastfm.user

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, Shoutable 9 from lastfm.lazylist import lazylist 10 import lastfm.playlist

11 12 -class User(LastfmBase, Cacheable, Shoutable):

13 """A class representing an user."""

14 - def init(self, 15 api, 16 name = None, 17 real_name = None, 18 url = None, 19 image = None, 20 stats = None):

21 if not isinstance(api, Api): 22 raise InvalidParametersError("api reference must be supplied as an argument") 23 Shoutable.init(self, api) 24 self._api = api 25 self._name = name 26 self._real_name = real_name 27 self._url = url 28 self._image = image 29 self._stats = stats and Stats( 30 subject = self, 31 match = stats.match, 32 weight = stats.weight, 33 playcount = stats.playcount 34 ) 35 self._library = User.Library(api, self)

36 37 @property

38 - def name(self):

39 """name of the user""" 40 return self._name

41 42 @property

43 - def real_name(self):

44 """real name of the user""" 45 return self._real_name

46 47 @property

48 - def url(self):

49 """url of the user's page""" 50 return self._url

51 52 @property

53 - def image(self):

54 """image of the user""" 55 return self._image

56 57 @property

58 - def stats(self):

59 """stats for the user""" 60 return self._stats

61 62 @property 63 @LastfmBase.autheticate

64 - def language(self):

65 """lang for the user""" 66 return self._language

67 68 @property 69 @LastfmBase.autheticate

70 - def country(self):

71 """country for the user""" 72 return self._country

73 74 @property 75 @LastfmBase.autheticate

76 - def age(self):

77 """age for the user""" 78 return self._age

79 80 @property 81 @LastfmBase.autheticate

82 - def gender(self):

83 """stats for the user""" 84 return self._gender

85 86 @property 87 @LastfmBase.autheticate

88 - def subscriber(self):

89 """is the user a subscriber""" 90 return self._subscriber

91 92 @property

93 - def autheticated(self):

94 """is the user autheticated""" 95 return self._api.get_authenticated_user() == self

96 97 @LastfmBase.cached_property

98 - def events(self):

99 params = self._default_params({'method': 'user.getEvents'}) 100 data = self._api._fetch_data(params).find('events') 101 102 return [ 103 Event.create_from_data(self._api, e) 104 for e in data.findall('event') 105 ]

106

107 - def get_past_events(self, 108 limit = None):

109 params = self._default_params({'method': 'user.getPastEvents'}) 110 if limit is not None: 111 params.update({'limit': limit}) 112 113 @lazylist 114 def gen(lst): 115 data = self._api._fetch_data(params).find('events') 116 total_pages = int(data.attrib['totalPages']) 117 118 @lazylist 119 def gen2(lst, data): 120 for e in data.findall('event'): 121 yield Event.create_from_data(self._api, e)

122 123 for e in gen2(data): 124 yield e 125 126 for page in xrange(2, total_pages+1): 127 params.update({'page': page}) 128 data = self._api._fetch_data(params).find('events') 129 for e in gen2(data): 130 yield e

131 return gen() 132 133 @LastfmBase.cached_property

134 - def past_events(self):

135 return self.get_past_events()

136 137 @LastfmBase.autheticate

138 - def get_recommended_events(self, limit = None):

139 params = {'method': 'user.getRecommendedEvents'} 140 if limit is not None: 141 params.update({'limit': limit}) 142 143 @lazylist 144 def gen(lst): 145 data = self._api._fetch_data(params, sign = True, session = True).find('events') 146 total_pages = int(data.attrib['totalPages']) 147 148 @lazylist 149 def gen2(lst, data): 150 for e in data.findall('event'): 151 yield Event.create_from_data(self._api, e)

152 153 for e in gen2(data): 154 yield e 155 156 for page in xrange(2, total_pages+1): 157 params.update({'page': page}) 158 data = self._api._fetch_data(params, sign = True, session = True).find('events') 159 for e in gen2(data): 160 yield e 161 return gen() 162 163 @LastfmBase.cached_property

164 - def recommended_events(self):

165 return self.get_recommended_events()

166

167 - def get_friends(self, 168 limit = None):

169 params = self._default_params({'method': 'user.getFriends'}) 170 if limit is not None: 171 params.update({'limit': limit}) 172 data = self._api._fetch_data(params).find('friends') 173 return [ 174 User( 175 self._api, 176 subject = self, 177 name = u.findtext('name'), 178 image = dict([(i.get('size'), i.text) for i in u.findall('image')]), 179 url = u.findtext('url'), 180 ) 181 for u in data.findall('user') 182 ]

183 184 185 @LastfmBase.cached_property

186 - def friends(self):

187 """friends of the user""" 188 return self.get_friends()

189

190 - def get_neighbours(self, limit = None):

191 params = self._default_params({'method': 'user.getNeighbours'}) 192 if limit is not None: 193 params.update({'limit': limit}) 194 data = self._api._fetch_data(params).find('neighbours') 195 return [ 196 User( 197 self._api, 198 subject = self, 199 name = u.findtext('name'), 200 image = {'medium': u.findtext('image')}, 201 url = u.findtext('url'), 202 stats = Stats( 203 subject = u.findtext('name'), 204 match = u.findtext('match') and float(u.findtext('match')), 205 ), 206 ) 207 for u in data.findall('user') 208 ]

209 210 @LastfmBase.cached_property

211 - def neighbours(self):

212 """neighbours of the user""" 213 return self.get_neighbours()

214 215 @LastfmBase.top_property("neighbours")

216 - def nearest_neighbour(self):

217 """nearest neightbour of the user""" 218 pass

219 220 @LastfmBase.cached_property

221 - def playlists(self):

222 """playlists of the user""" 223 params = self._default_params({'method': 'user.getPlaylists'}) 224 data = self._api._fetch_data(params).find('playlists') 225 return [ 226 User.Playlist( 227 self._api, 228 id = int(p.findtext('id')), 229 title = p.findtext('title'), 230 date = datetime(*( 231 time.strptime( 232 p.findtext('date').strip(), 233 '%Y-%m-%dT%H:%M:%S' 234 )[0:6]) 235 ), 236 size = int(p.findtext('size')), 237 creator = self 238 ) 239 for p in data.findall('playlist') 240 ]

241 242 @LastfmBase.autheticate

243 - def create_playlist(self, title, description = None):

244 params = {'method': 'playlist.create', 245 'title': title} 246 if description is not None: 247 params['description'] = description 248 self._api._post_data(params) 249 self._playlists = None

250 251 @LastfmBase.cached_property

252 - def loved_tracks(self):

253 params = self._default_params({'method': 'user.getLovedTracks'}) 254 data = self._api._fetch_data(params).find('lovedtracks') 255 return [ 256 Track( 257 self._api, 258 subject = self, 259 name = t.findtext('name'), 260 artist = Artist( 261 self._api, 262 subject = self, 263 name = t.findtext('artist/name'), 264 mbid = t.findtext('artist/mbid'), 265 url = t.findtext('artist/url'), 266 ), 267 mbid = t.findtext('mbid'), 268 image = dict([(i.get('size'), i.text) for i in t.findall('image')]), 269 loved_on = datetime(*( 270 time.strptime( 271 t.findtext('date').strip(), 272 '%d %b %Y, %H:%M' 273 )[0:6]) 274 ) 275 ) 276 for t in data.findall('track') 277 ]

278

279 - def get_recent_tracks(self, limit = None):

280 params = self._default_params({'method': 'user.getRecentTracks'}) 281 data = self._api._fetch_data(params, no_cache = True).find('recenttracks') 282 return [ 283 Track( 284 self._api, 285 subject = self, 286 name = t.findtext('name'), 287 artist = Artist( 288 self._api, 289 subject = self, 290 name = t.findtext('artist'), 291 mbid = t.find('artist').attrib['mbid'], 292 ), 293 album = Album( 294 self._api, 295 subject = self, 296 name = t.findtext('album'), 297 artist = Artist( 298 self._api, 299 subject = self, 300 name = t.findtext('artist'), 301 mbid = t.find('artist').attrib['mbid'], 302 ), 303 mbid = t.find('album').attrib['mbid'], 304 ), 305 mbid = t.findtext('mbid'), 306 streamable = (t.findtext('streamable') == '1'), 307 url = t.findtext('url'), 308 image = dict([(i.get('size'), i.text) for i in t.findall('image')]), 309 played_on = datetime(*( 310 time.strptime( 311 t.findtext('date').strip(), 312 '%d %b %Y, %H:%M' 313 )[0:6]) 314 ) 315 ) 316 for t in data.findall('track') 317 ]

318 319 @property

320 - def recent_tracks(self):

321 """recent tracks played by the user""" 322 return self.get_recent_tracks()

323 324 @LastfmBase.top_property("recent_tracks")

325 - def most_recent_track(self):

326 """most recent track played by the user""" 327 pass

328

329 - def get_top_albums(self, period = None):

330 params = self._default_params({'method': 'user.getTopAlbums'}) 331 if period is not None: 332 params.update({'period': period}) 333 data = self._api._fetch_data(params).find('topalbums') 334 335 return [ 336 Album( 337 self._api, 338 subject = self, 339 name = a.findtext('name'), 340 artist = Artist( 341 self._api, 342 subject = self, 343 name = a.findtext('artist/name'), 344 mbid = a.findtext('artist/mbid'), 345 url = a.findtext('artist/url'), 346 ), 347 mbid = a.findtext('mbid'), 348 url = a.findtext('url'), 349 image = dict([(i.get('size'), i.text) for i in a.findall('image')]), 350 stats = Stats( 351 subject = a.findtext('name'), 352 playcount = int(a.findtext('playcount')), 353 rank = int(a.attrib['rank']) 354 ) 355 ) 356 for a in data.findall('album') 357 ]

358 359 @LastfmBase.cached_property

360 - def top_albums(self):

361 """overall top albums of the user""" 362 return self.get_top_albums()

363 364 @LastfmBase.top_property("top_albums")

365 - def top_album(self):

366 """overall top most album of the user""" 367 pass

368

369 - def get_top_artists(self, period = None):

370 params = self._default_params({'method': 'user.getTopArtists'}) 371 if period is not None: 372 params.update({'period': period}) 373 data = self._api._fetch_data(params).find('topartists') 374 375 return [ 376 Artist( 377 self._api, 378 subject = self, 379 name = a.findtext('name'), 380 mbid = a.findtext('mbid'), 381 stats = Stats( 382 subject = a.findtext('name'), 383 rank = a.attrib['rank'].strip() and int(a.attrib['rank']) or None, 384 playcount = a.findtext('playcount') and int(a.findtext('playcount')) or None 385 ), 386 url = a.findtext('url'), 387 streamable = (a.findtext('streamable') == "1"), 388 image = dict([(i.get('size'), i.text) for i in a.findall('image')]), 389 ) 390 for a in data.findall('artist') 391 ]

392 393 @LastfmBase.cached_property

394 - def top_artists(self):

395 """top artists of the user""" 396 return self.get_top_artists()

397 398 @LastfmBase.top_property("top_artists")

399 - def top_artist(self):

400 """top artist of the user""" 401 pass

402 403 @LastfmBase.cached_property 404 @LastfmBase.autheticate

405 - def recommended_artists(self):

406 params = {'method': 'user.getRecommendedArtists'} 407 408 @lazylist 409 def gen(lst): 410 data = self._api._fetch_data(params, sign = True, session = True).find('recommendations') 411 total_pages = int(data.attrib['totalPages']) 412 413 @lazylist 414 def gen2(lst, data): 415 for a in data.findall('artist'): 416 yield Artist( 417 self._api, 418 name = a.findtext('name'), 419 mbid = a.findtext('mbid'), 420 url = a.findtext('url'), 421 streamable = (a.findtext('streamable') == "1"), 422 image = dict([(i.get('size'), i.text) for i in a.findall('image')]), 423 )

424 425 for a in gen2(data): 426 yield a 427 428 for page in xrange(2, total_pages+1): 429 params.update({'page': page}) 430 data = self._api._fetch_data(params, sign = True, session = True).find('recommendations') 431 for a in gen2(data): 432 yield a 433 return gen() 434

435 - def get_top_tracks(self, period = None):

436 params = self._default_params({'method': 'user.getTopTracks'}) 437 if period is not None: 438 params.update({'period': period}) 439 data = self._api._fetch_data(params).find('toptracks') 440 return [ 441 Track( 442 self._api, 443 subject = self, 444 name = t.findtext('name'), 445 artist = Artist( 446 self._api, 447 subject = self, 448 name = t.findtext('artist/name'), 449 mbid = t.findtext('artist/mbid'), 450 url = t.findtext('artist/url'), 451 ), 452 mbid = t.findtext('mbid'), 453 stats = Stats( 454 subject = t.findtext('name'), 455 rank = t.attrib['rank'].strip() and int(t.attrib['rank']) or None, 456 playcount = t.findtext('playcount') and int(t.findtext('playcount')) or None 457 ), 458 streamable = (t.findtext('streamable') == '1'), 459 full_track = (t.find('streamable').attrib['fulltrack'] == '1'), 460 image = dict([(i.get('size'), i.text) for i in t.findall('image')]), 461 ) 462 for t in data.findall('track') 463 ]

464 465 @LastfmBase.cached_property

466 - def top_tracks(self):

467 """top tracks of the user""" 468 return self.get_top_tracks()

469 470 @LastfmBase.top_property("top_tracks")

471 - def top_track(self):

472 """top track of the user""" 473 return (len(self.top_tracks) and self.top_tracks[0] or None)

474

475 - def get_top_tags(self, limit = None):

476 params = self._default_params({'method': 'user.getTopTags'}) 477 if limit is not None: 478 params.update({'limit': limit}) 479 data = self._api._fetch_data(params).find('toptags') 480 return [ 481 Tag( 482 self._api, 483 subject = self, 484 name = t.findtext('name'), 485 url = t.findtext('url'), 486 stats = Stats( 487 subject = t.findtext('name'), 488 count = int(t.findtext('count')) 489 ) 490 ) 491 for t in data.findall('tag') 492 ]

493 494 @LastfmBase.cached_property

495 - def top_tags(self):

496 """top tags of the user""" 497 return self.get_top_tags()

498 499 @LastfmBase.top_property("top_tags")

500 - def top_tag(self):

501 """top tag of the user""" 502 pass

503 504 @LastfmBase.cached_property

505 - def weekly_chart_list(self):

506 params = self._default_params({'method': 'user.getWeeklyChartList'}) 507 data = self._api._fetch_data(params).find('weeklychartlist') 508 return [ 509 WeeklyChart.create_from_data(self._api, self, c) 510 for c in data.findall('chart') 511 ]

512

513 - def get_weekly_album_chart(self, 514 start = None, 515 end = None):

516 params = self._default_params({'method': 'user.getWeeklyAlbumChart'}) 517 params = WeeklyChart._check_weekly_chart_params(params, start, end) 518 data = self._api._fetch_data(params).find('weeklyalbumchart') 519 return WeeklyAlbumChart.create_from_data(self._api, self, data)

520 521 @LastfmBase.cached_property

522 - def recent_weekly_album_chart(self):

523 return self.get_weekly_album_chart()

524 525 @LastfmBase.cached_property

526 - def weekly_album_chart_list(self):

527 wcl = list(self.weekly_chart_list) 528 wcl.reverse() 529 @lazylist 530 def gen(lst): 531 for wc in wcl: 532 try: 533 yield self.get_weekly_album_chart(wc.start, wc.end) 534 except LastfmError: 535 pass

536 return gen() 537

538 - def get_weekly_artist_chart(self, 539 start = None, 540 end = None):

541 params = self._default_params({'method': 'user.getWeeklyArtistChart'}) 542 params = WeeklyChart._check_weekly_chart_params(params, start, end) 543 data = self._api._fetch_data(params).find('weeklyartistchart') 544 return WeeklyArtistChart.create_from_data(self._api, self, data)

545 546 @LastfmBase.cached_property

547 - def recent_weekly_artist_chart(self):

548 return self.get_weekly_artist_chart()

549 550 @LastfmBase.cached_property

551 - def weekly_artist_chart_list(self):

552 wcl = list(self.weekly_chart_list) 553 wcl.reverse() 554 @lazylist 555 def gen(lst): 556 for wc in wcl: 557 try: 558 yield self.get_weekly_artist_chart(wc.start, wc.end) 559 except LastfmError: 560 pass

561 return gen() 562

563 - def get_weekly_track_chart(self, 564 start = None, 565 end = None):

566 params = self._default_params({'method': 'user.getWeeklyTrackChart'}) 567 params = WeeklyChart._check_weekly_chart_params(params, start, end) 568 data = self._api._fetch_data(params).find('weeklytrackchart') 569 return WeeklyTrackChart.create_from_data(self._api, self, data)

570 571 @LastfmBase.cached_property

572 - def recent_weekly_track_chart(self):

573 return self.get_weekly_track_chart()

574 575 @LastfmBase.cached_property

576 - def weekly_track_chart_list(self):

577 wcl = list(self.weekly_chart_list) 578 wcl.reverse() 579 @lazylist 580 def gen(lst): 581 for wc in wcl: 582 try: 583 yield self.get_weekly_track_chart(wc.start, wc.end) 584 except LastfmError: 585 pass

586 return gen() 587

588 - def get_weekly_tag_chart(self, 589 start = None, 590 end = None):

591 WeeklyChart._check_weekly_chart_params({}, start, end) 592 return WeeklyTagChart.create_from_data(self._api, self, start, end)

593 594 @LastfmBase.cached_property

595 - def recent_weekly_tag_chart(self):

596 return self.get_weekly_tag_chart()

597 598 @LastfmBase.cached_property

599 - def weekly_tag_chart_list(self):

600 wcl = list(self.weekly_chart_list) 601 wcl.reverse() 602 @lazylist 603 def gen(lst): 604 for wc in wcl: 605 try: 606 yield self.get_weekly_tag_chart(wc.start, wc.end) 607 except LastfmError: 608 pass

609 return gen() 610

611 - def compare(self, other, limit = None):

612 return Tasteometer.compare(self._api, 613 'user', 'user', 614 self.name, other.name, 615 limit)

616 @property

617 - def library(self):

618 return self._library

619 620 621 @staticmethod

622 - def get_authenticated_user(api):

623 data = api._fetch_data({'method': 'user.getInfo'}, sign = True, session = True).find('user') 624 user = User( 625 api, 626 name = data.findtext('name'), 627 url = data.findtext('url'), 628 ) 629 user._language = data.findtext('lang') 630 user._country = Country(api, name = Country.ISO_CODES[data.findtext('country')]) 631 user._age = int(data.findtext('age')) 632 user._gender = data.findtext('gender') 633 user._subscriber = (data.findtext('subscriber') == "1") 634 user._stats = Stats(subject = user, playcount = data.findtext('playcount')) 635 return user

636

637 - def _default_params(self, extra_params = {}):

638 if not self.name: 639 raise InvalidParametersError("user has to be provided.") 640 params = {'user': self.name} 641 params.update(extra_params) 642 return params

643 644 @staticmethod

645 - def _hash_func(*args, **kwds):

646 try: 647 return hash(kwds['name']) 648 except KeyError: 649 raise InvalidParametersError("name has to be provided for hashing")

650

651 - def __hash__(self):

652 return self.__class__._hash_func(name = self.name)

653

654 - def __eq__(self, other):

655 return self.name == other.name

656

657 - def __lt__(self, other):

658 return self.name < other.name

659

660 - def __repr__(self):

661 return "<lastfm.User: %s>" % self.name

662

663 - class Playlist(lastfm.playlist.Playlist):

664 """A class representing a playlist belonging to the user."""

665 - def init(self, api, id, title, date, size, creator):

666 super(User.Playlist, self).init(api, "lastfm://playlist/%s" % id) 667 self._id = id 668 self._title = title 669 self._date = date 670 self._size = size 671 self._creator = creator

672 673 @property

674 - def id(self):

675 return self._id

676 677 @property

678 - def title(self):

679 return self._title

680 681 @property

682 - def date(self):

683 return self._date

684 685 @property

686 - def size(self):

687 return self._size

688 689 @property

690 - def creator(self):

691 return self._creator

692 693 @property

694 - def user(self):

695 return self._creator

696 697 @LastfmBase.autheticate

698 - def add_track(self, track, artist = None):

699 params = {'method': 'playlist.addTrack', 'playlistID': self.id} 700 if isinstance(track, Track): 701 params['artist'] = track.artist.name 702 params['track'] = track.name 703 else: 704 if artist is None: 705 track = self._api.search_track(track)[0] 706 params['artist'] = track.artist.name 707 params['track'] = track.name 708 else: 709 params['artist'] = isinstance(artist, Artist) and artist.name or artist 710 params['track'] = track 711 self._api._post_data(params) 712 self._data = None

713 714 @staticmethod

715 - def _hash_func(*args, **kwds):

716 try: 717 return hash(kwds['id']) 718 except KeyError: 719 raise InvalidParametersError("id has to be provided for hashing")

720

721 - def __hash__(self):

722 return self.__class__._hash_func(id = self.id)

723

724 - def __repr__(self):

725 return "<lastfm.User.Playlist: %s>" % self.title

726

727 - class Library(object):

728 """A class representing the music library of the user."""

729 - def __init__(self, api, user):

730 self._api = api 731 self._user = user

732 733 @property

734 - def user(self):

735 return self._user

736

737 - def get_albums(self, 738 limit = None):

739 params = self._default_params({'method': 'library.getAlbums'}) 740 if limit is not None: 741 params.update({'limit': limit}) 742 743 @lazylist 744 def gen(lst): 745 data = self._api._fetch_data(params).find('albums') 746 total_pages = int(data.attrib['totalPages']) 747 748 @lazylist 749 def gen2(lst, data): 750 for a in data.findall('album'): 751 yield Album( 752 self._api, 753 subject = self, 754 name = a.findtext('name'), 755 artist = Artist( 756 self._api, 757 subject = self, 758 name = a.findtext('artist/name'), 759 mbid = a.findtext('artist/mbid'), 760 url = a.findtext('artist/url'), 761 ), 762 mbid = a.findtext('mbid'), 763 url = a.findtext('url'), 764 image = dict([(i.get('size'), i.text) for i in a.findall('image')]), 765 stats = Stats( 766 subject = a.findtext('name'), 767 playcount = int(a.findtext('playcount')), 768 ) 769 )

770 771 772 for a in gen2(data): 773 yield a 774 775 for page in xrange(2, total_pages+1): 776 params.update({'page': page}) 777 try: 778 data = self._api._fetch_data(params).find('albums') 779 except LastfmError: 780 continue 781 for a in gen2(data): 782 yield a

783 return gen() 784 785 @LastfmBase.cached_property

786 - def albums(self):

787 return self.get_albums()

788 789 @LastfmBase.autheticate

790 - def add_album(self, album, artist = None):

791 params = {'method': 'library.addAlbum'} 792 if isinstance(album, Album): 793 params['artist'] = album.artist.name 794 params['album'] = album.name 795 else: 796 if artist is None: 797 album = self._api.search_album(album)[0] 798 params['artist'] = album.artist.name 799 params['album'] = album.name 800 else: 801 params['artist'] = isinstance(artist, Artist) and artist.name or artist 802 params['album'] = album 803 804 self._api._post_data(params) 805 self._albums = None

806

807 - def get_artists(self, 808 limit = None):

809 params = self._default_params({'method': 'library.getArtists'}) 810 if limit is not None: 811 params.update({'limit': limit}) 812 813 @lazylist 814 def gen(lst): 815 data = self._api._fetch_data(params).find('artists') 816 total_pages = int(data.attrib['totalPages']) 817 818 @lazylist 819 def gen2(lst, data): 820 for a in data.findall('artist'): 821 yield Artist( 822 self._api, 823 subject = self, 824 name = a.findtext('name'), 825 mbid = a.findtext('mbid'), 826 stats = Stats( 827 subject = a.findtext('name'), 828 playcount = a.findtext('playcount') and int(a.findtext('playcount')) or None, 829 tagcount = a.findtext('tagcount') and int(a.findtext('tagcount')) or None 830 ), 831 url = a.findtext('url'), 832 streamable = (a.findtext('streamable') == "1"), 833 image = dict([(i.get('size'), i.text) for i in a.findall('image')]), 834 )

835 836 for a in gen2(data): 837 yield a 838 839 for page in xrange(2, total_pages+1): 840 params.update({'page': page}) 841 try: 842 data = self._api._fetch_data(params).find('artists') 843 except LastfmError: 844 continue 845 for a in gen2(data): 846 yield a 847 return gen() 848 849 @LastfmBase.cached_property

850 - def artists(self):

851 return self.get_artists()

852 853 @LastfmBase.autheticate

854 - def add_artist(self, artist):

855 params = {'method': 'library.addArtist'} 856 if isinstance(artist, Artist): 857 params['artist'] = artist.name 858 else: 859 params['artist'] = artist 860 self._api._post_data(params) 861 self._artists = None

862

863 - def get_tracks(self, 864 limit = None):

865 params = self._default_params({'method': 'library.getTracks'}) 866 if limit is not None: 867 params.update({'limit': limit}) 868 869 @lazylist 870 def gen(lst): 871 data = self._api._fetch_data(params).find('tracks') 872 total_pages = int(data.attrib['totalPages']) 873 874 @lazylist 875 def gen2(lst, data): 876 for t in data.findall('track'): 877 yield Track( 878 self._api, 879 subject = self, 880 name = t.findtext('name'), 881 artist = Artist( 882 self._api, 883 subject = self, 884 name = t.findtext('artist/name'), 885 mbid = t.findtext('artist/mbid'), 886 url = t.findtext('artist/url'), 887 ), 888 mbid = t.findtext('mbid'), 889 stats = Stats( 890 subject = t.findtext('name'), 891 playcount = t.findtext('playcount') and int(t.findtext('playcount')) or None, 892 tagcount = t.findtext('tagcount') and int(t.findtext('tagcount')) or None 893 ), 894 streamable = (t.findtext('streamable') == '1'), 895 full_track = (t.find('streamable').attrib['fulltrack'] == '1'), 896 image = dict([(i.get('size'), i.text) for i in t.findall('image')]), 897 )

898 899 for t in gen2(data): 900 yield t 901 902 for page in xrange(2, total_pages+1): 903 params.update({'page': page}) 904 data = None 905 try: 906 data = self._api._fetch_data(params).find('tracks') 907 except LastfmError: 908 continue 909 for t in gen2(data): 910 yield t 911 return gen() 912 913 @LastfmBase.cached_property

914 - def tracks(self):

915 return self.get_tracks()

916 917 @LastfmBase.autheticate

918 - def add_track(self, track, artist = None):

919 params = {'method': 'library.addTrack'} 920 if isinstance(track, Track): 921 params['artist'] = track.artist.name 922 params['track'] = track.name 923 else: 924 if artist is None: 925 track = self._api.search_track(track)[0] 926 params['artist'] = track.artist.name 927 params['track'] = track.name 928 else: 929 params['artist'] = isinstance(artist, Artist) and artist.name or artist 930 params['track'] = track 931 self._api._post_data(params) 932 self._tracks = None

933

934 - def _default_params(self, extra_params = {}):

935 if not self.user.name: 936 raise InvalidParametersError("user has to be provided.") 937 params = {'user': self.user.name} 938 params.update(extra_params) 939 return params

940 941 @staticmethod

942 - def _hash_func(*args, **kwds):

943 try: 944 return hash(kwds['user']) 945 except KeyError: 946 raise InvalidParametersError("user has to be provided for hashing")

947

948 - def __hash__(self):

949 return self.__class__._hash_func(user = self.user)

950

951 - def __repr__(self):

952 return "<lastfm.User.Library: for user '%s'>" % self.user.name

953 954 from datetime import datetime 955 import time 956 957 from lastfm.api import Api 958 from lastfm.artist import Artist 959 from lastfm.album import Album 960 from lastfm.error import LastfmError, InvalidParametersError 961 from lastfm.event import Event 962 from lastfm.geo import Country 963 from lastfm.stats import Stats 964 from lastfm.tag import Tag 965 from lastfm.tasteometer import Tasteometer 966 from lastfm.track import Track 967 from lastfm.weeklychart import WeeklyChart, WeeklyAlbumChart, WeeklyArtistChart, WeeklyTrackChart, WeeklyTagChart 968

Source Code for Module lastfm.user