How to use the pylast._BaseObject function in pylast

o DOMAIN_ITALIAN
          o DOMAIN_POLISH
          o DOMAIN_PORTUGUESE
          o DOMAIN_SWEDISH
          o DOMAIN_TURKISH
          o DOMAIN_RUSSIAN
          o DOMAIN_JAPANESE
          o DOMAIN_CHINESE 
        """
        
        country_name = _url_safe(self.get_name())
        
        return self.network._get_url(domain_name, "country") %{'country_name': country_name}


class Library(_BaseObject):
    """A user's Last.fm library."""
    
    user = None
    
    def __init__(self, user, network):
        _BaseObject.__init__(self, network)
        
        if isinstance(user, User):
            self.user = user
        else:
            self.user = User(user, self.network)
        
        self._albums_index = 0
        self._artists_index = 0
        self._tracks_index = 0

o DOMAIN_POLISH
          o DOMAIN_PORTUGUESE
          o DOMAIN_SWEDISH
          o DOMAIN_TURKISH
          o DOMAIN_RUSSIAN
          o DOMAIN_JAPANESE
          o DOMAIN_CHINESE
        """

        english_url = _extract(self._get_info_node(), "url")
        appendix = english_url[english_url.rfind("/") + 1:]

        return self.network._get_url(domain_name, "playlist") %{'appendix': appendix, "user": self.get_user().get_name()}


class Tag(_BaseObject):
    """A Last.fm object tag."""

    # TODO: getWeeklyArtistChart (too lazy, i'll wait for when someone requests it)

    name = None

    __hash__ = _BaseObject.__hash__

    def __init__(self, name, network):
        _BaseObject.__init__(self, network)

        self.name = name

    def __repr__(self):
        return "pylast.Tag(%s, %s)" %(repr(self.name), repr(self.network))

return seq

    def get_recommended_artists(self, limit=50):
        """
        Returns a sequence of Event objects
        if limit==None it will return all
        """

        seq = []
        for node in _collect_nodes(limit, self, "user.getRecommendedArtists", False):
            seq.append(Artist(_extract(node, "name"), self.network))

        return seq

class _Search(_BaseObject):
    """An abstract class. Use one of its derivatives."""

    def __init__(self, ws_prefix, search_terms, network):
        _BaseObject.__init__(self, network)

        self._ws_prefix = ws_prefix
        self.search_terms = search_terms

        self._last_page_index = 0

    def _get_params(self):
        params = {}

        for key in self.search_terms.keys():
            params[key] = self.search_terms[key]

if album:
            params["album"] = album
        
        seq = []
        for node in _collect_nodes(limit, self, "library.getTracks", True, params):
            name = _extract(node, "name")
            artist = _extract(node, "name", 1)
            playcount = _number(_extract(node, "playcount"))
            tagcount = _number(_extract(node, "tagcount"))
            
            seq.append(LibraryItem(Track(artist, name, self.network), playcount, tagcount))
        
        return seq
            

class Playlist(_BaseObject):
    """A Last.fm user playlist."""
    
    id = None
    user = None
    
    def __init__(self, user, id, network):
        _BaseObject.__init__(self, network)
        
        if isinstance(user, User):
            self.user = user
        else:
            self.user = User(user, self.network)
        
        self.id = id
    
    @_string_output

self.underlying_error = underlying_error
    
    def __str__(self):
        return "Malformed response from Last.fm. Underlying error: %s" %str(self.underlying_error)

class NetworkError(Exception):
    """Exception conveying a problem in sending a request to Last.fm"""
    
    def __init__(self, network, underlying_error):
        self.network = network
        self.underlying_error = underlying_error
    
    def __str__(self):
        return "NetworkError: %s" %str(self.underlying_error)

class Album(_BaseObject, _Taggable):
    """An album."""
    
    title = None
    artist = None
    
    def __init__(self, artist, title, network):
        """
        Create an album instance.
        # Parameters:
            * artist: An artist name or an Artist object.
            * title: The album title.
        """
        
        _BaseObject.__init__(self, network)
        _Taggable.__init__(self, 'album')

"""Remove a scrobble from a user's Last.fm library. Parameters:
            artist (Required) : The artist that composed the track
            title (Required) : The name of the track
            timestamp (Required) : The unix timestamp of the scrobble
                                   that you wish to remove
        """

        params = self._get_params()
        params["artist"] = artist
        params["track"] = title
        params["timestamp"] = timestamp

        self._request("library.removeScrobble", False, params)


class Playlist(_BaseObject):
    """A Last.fm user playlist."""

    id = None
    user = None

    __hash__ = _BaseObject.__hash__

    def __init__(self, user, id, network):
        _BaseObject.__init__(self, network)

        if isinstance(user, User):
            self.user = user
        else:
            self.user = User(user, self.network)

        self.id = id

def get_members(self, limit=50):
        """
            Returns a sequence of User objects
            if limit==None it will return all
        """
        
        nodes = _collect_nodes(limit, self, "group.getMembers", False)
        
        users = []
        
        for node in nodes:
            users.append(User(_extract(node, "name"), self.network))
        
        return users

class XSPF(_BaseObject):
    "A Last.fm XSPF playlist."""
    
    uri = None
    
    def __init__(self, uri, network):
        _BaseObject.__init__(self, network)
        
        self.uri = uri
    
    def _get_params(self):
        return {'playlistURL': self.get_uri()}
    
    @_string_output
    def __str__(self):
        return self.get_uri()

def get_shouts(self, limit=50):
        """
            Returns a sequqence of Shout objects
        """
        
        shouts = []
        for node in _collect_nodes(limit, self, "track.getShouts", False):
            shouts.append(Shout(
                                _extract(node, "body"),
                                User(_extract(node, "author"), self.network),
                                _extract(node, "date")
                                )
                            )
        return shouts
        
class Group(_BaseObject):
    """A Last.fm group."""
    
    name = None
    
    def __init__(self, group_name, network):
        _BaseObject.__init__(self, network)
        
        self.name = group_name
    
    def __repr__(self):
        return "pylast.Group(%s, %s)" %(repr(self.name), repr(self.network))
    
    @_string_output
    def __str__(self):
        return self.get_name()

)
                            )
        return shouts

    def shout(self, message):
        """
            Post a shout
        """

        params = self._get_params()
        params["message"] = message

        self._request("artist.Shout", False, params)


class Event(_BaseObject):
    """An event."""

    id = None

    __hash__ = _BaseObject.__hash__

    def __init__(self, event_id, network):
        _BaseObject.__init__(self, network)

        self.id = event_id

    def __repr__(self):
        return "pylast.Event(%s, %s)" %(repr(self.id), repr(self.network))

    @_string_output
    def __str__(self):

)
                            )
        return shouts
    
    def shout(self, message):
        """
            Post a shout
        """
        
        params = self._get_params()
        params["message"] = message
        
        self._request("artist.Shout", False, params)
        

class Event(_BaseObject):
    """An event."""
    
    id = None
    
    def __init__(self, event_id, network):
        _BaseObject.__init__(self, network)
        
        self.id = event_id
    
    def __repr__(self):
        return "pylast.Event(%s, %s)" %(repr(self.id), repr(self.network))
    
    @_string_output
    def __str__(self):
        return "Event #" + self.get_id()