Merge lp:~mblayman/entertainer/pythonize-musiclib into lp:entertainer/future

[Matt Layman]

Made the music library code follow more pythonic behavior.

[Matt Layman (mblayman)]

This is a chunk of work to eliminate some of the Java-ness of the MusicLibrary classes. It cleans up a lot of getters and setters and makes the code look much cleaner.

Here is the diffstat for the curious:

 client/client.py | 2
 client/medialibrary/music.py | 678 ++++++++--------------------------------
 client/medialibrary/playable.py | 31 -
 gui/screens/album.py | 23 -
 gui/screens/artist.py | 2
 gui/screens/audio_play.py | 4
 gui/screens/disc.py | 10
 gui/screens/music.py | 2
 gui/tabs/albums_tab.py | 8
 gui/tabs/lyrics_tab.py | 2
 gui/tabs/playing_tab.py | 35 --
 gui/tabs/tracks_tab.py | 12
 tests/mock.py | 18 -
 tests/test_music.py | 346 ++++++--------------
 14 files changed, 315 insertions(+), 858 deletions(-)

[lp:~mblayman/entertainer/pythonize-musiclib]

452. By Matt Layman on 2010-01-03

Merged from parent and resolved conflicts.

[Matt Layman (mblayman)]

Discussed on IRC that I can use my discretion for merges for the time being to bootstrap some contribution.

review: Approve

=== modified file 'entertainerlib/client/medialibrary/music.py'
--- entertainerlib/client/medialibrary/music.py	2009-09-08 02:40:16 +0000
+++ entertainerlib/client/medialibrary/music.py	2010-01-03 23:00:31 +0000
@@ -2,19 +2,15 @@
 '''Music Library - Interface for Entertainer music library cache'''
 
 import os
+
 import CDDB, DiscID
 from pysqlite2 import dbapi2 as sqlite
 
+from entertainerlib.client.medialibrary.playable import Playable
 from entertainerlib.configuration import Configuration
-
-from entertainerlib.client.medialibrary.playable import Playable
 from entertainerlib.download import LyricsDownloader
 
 
-class MusicLibraryException(Exception):
-    '''Exception to handle MusicLibrary issues'''
-    pass
-
 class AlbumHasNoTracks(Exception):
     '''Exception to handle Albums with no tracks'''
     pass
@@ -23,12 +19,8 @@
     '''Exception to handle track errors'''
     pass
 
-class TrackRatingOutOfRange(Exception):
-    '''Exception to handle track rating problems'''
-    pass
-
 class MusicLibrary:
-    """Interface for Entertainer's music cache."""
+    '''Interface for Entertainer's music cache.'''
 
     def __init__(self):
         self.config = Configuration()
@@ -39,171 +31,66 @@
         self.cursor = self.db_connection.cursor()
 
     def __del__(self):
-        """
-        Close connection when this object is destroyed
-        """
+        '''Close the connection when this object is destroyed.'''
         self.db_connection.close()
 
     def get_compact_disc_information(self):
-        """
-        Get the CompactDisc object of the current disc in drive. This
-        method queries CD information from Internet database (CDDB).
-        @return: CompactDisc
-        """
+        '''Get the CompactDisc object of the current disc in drive by querying
+        CD information from an Internet database (CDDB).'''
         cdrom = DiscID.open()
         disc_id = DiscID.disc_id(cdrom)
         return CompactDisc(disc_id)
 
-    def get_playlists(self):
-        """
-        Get list of playlist names.
-        @return: String list
-        """
-        self.cursor.execute("SELECT title FROM playlist")
-        playlists = []
-        for row in self.cursor:
-            playlists.append(row[0])
-        return playlists
-
-    def get_num_of_tracks_on_playlist(self, name):
-        """
-        Get list of playlist names.
-        @param name: Playlist name (see: get_playlists)
-        @return: Integer (number of tracks)
-        """
-        self.cursor.execute("""SELECT COUNT(filename)
-                          FROM playlist_relation
-                          WHERE title=:name""", { "name" : name })
-        result = self.cursor.fetchall()
-        return result[0][0]
-
-    def get_tracks_on_playlist(self, name):
-        """
-        Retrun list of tracks on given playlist.
-        @param name: Playlist name
-        @return: List of Track objects
-        """
-        self.cursor.execute(
-            """SELECT filename, title, tracknumber,  artist,  album,
-                genre, bitrate, year, rating, length, comment, lyrics
-               FROM   track, playlist_relation
-               WHERE  playlist_relation.title=:name
-               AND    playlist_relation.filename=track.filename
-               ORDER BY title""", { "name" : name })
-        tracks = []
-        for row in self.cursor:
-            tracks.append(Track(row[0], row[1], row[2], row[3], row[4],
-                                row[5], row[6], row[7], row[8], row[9],
-                                row[10], row[11]))
-        return tracks
-
     def get_all_artists(self):
-        """
-        Get a list of all artists.
-        @return: list of Strings
-        """
-        self.cursor.execute(
-            "SELECT DISTINCT artist FROM track ORDER BY artist")
+        '''Return all the artists names.'''
+        self.cursor.execute("SELECT DISTINCT artist FROM track ORDER BY artist")
 
         artists = []
         for row in self.cursor:
             artists.append(row[0])
         return artists
 
-    def get_all_tracks(self):
-        """
-        Get all tracks in music cache.
-        @return: List of Track objects
-        """
-        self.cursor.execute(
-            """SELECT filename, title, tracknumber,  artist,  album,
-                genre, bitrate, year, rating, length, comment, lyrics
-               FROM track
-               ORDER BY title""")
-        tracks = []
-        for row in self.cursor:
-            tracks.append(Track(row[0], row[1], row[2], row[3], row[4],
-                                row[5], row[6], row[7], row[8], row[9],
-                                row[10], row[11]))
-        return tracks
-
-    def get_tracks_by_genre(self, genre):
-        """
-        Get albums from music cache by genre.
-        @param genre: Genre (string)
-        @return: List of Track objects
-        """
-        self.cursor.execute(
-            """SELECT filename, title, tracknumber,  artist,  album,
-                genre, bitrate, year, rating, length, comment, lyrics
-               FROM   track
-               WHERE  genre=:genre
-               ORDER BY title""", { "genre" : genre})
-        tracks = []
-        for row in self.cursor:
-            tracks.append(Track(row[0], row[1], row[2], row[3], row[4],
-                                row[5], row[6], row[7], row[8], row[9],
-                                row[10], row[11]))
-        return tracks
-
     def get_tracks_by_artist(self, artist):
-        """
-        Get tracks from music cache by artist.
-        @param artist: Name of the artist (string)
-        """
+        '''Return track objects from the given artist.'''
         self.cursor.execute(
             """SELECT filename, title, tracknumber,  artist,  album,
-                genre, bitrate, year, rating, length, comment, lyrics
+                year, length, lyrics
                FROM   track
                WHERE  artist=:artist
                ORDER BY title""", { "artist" : artist})
         tracks = []
         for row in self.cursor:
-            tracks.append(Track(row[0], row[1], row[2], row[3], row[4],
-                                row[5], row[6], row[7], row[8], row[9],
-                                row[10], row[11]))
+            tracks.append(Track(row[0], row[1], row[2], row[3], row[4], row[5],
+                row[6], row[7], self._create_album))
         return tracks
 
     def get_all_albums(self):
-        """
-        Get all albums in music cache.
-        @return: List of Album objects
-        """
+        '''Return all the albums in the library.'''
         self.cursor.execute("SELECT DISTINCT album FROM track ORDER BY album")
         albums = []
         for row in self.cursor.fetchall():
-            albums.append(Album(row[0], self.cursor))
+            albums.append(self._create_album(row[0]))
         return albums
 
     def get_albums_by_artist(self, artist):
-        """
-        Get albums from music cache by artist.
-        @param artist: Artist name (string)
-        @return: List of Album objects
-        """
+        '''Return all albums from the given artist.'''
         self.cursor.execute("""SELECT DISTINCT album
                           FROM track
                           WHERE artist=:artist
                           ORDER BY album""", { "artist" : artist})
         albums = []
         for row in self.cursor.fetchall():
-            albums.append(Album(row[0], self.cursor))
+            albums.append(self._create_album(row[0]))
         return albums
 
     def number_of_tracks(self):
-        """
-        Get the number of tracks in music cache.
-        @return: Integer (number of tracks)
-        """
+        '''Return the number of tracks.'''
         self.cursor.execute("SELECT COUNT(filename) FROM track")
         result = self.cursor.fetchall()
         return result[0][0]
 
     def number_of_tracks_by_artist(self, artist):
-        """
-        Get the number of tracks made by given artist
-        @param artist: Artist name (string)
-        """
+        '''Return the number of tracks from the given artist.'''
         self.cursor.execute("""SELECT COUNT(filename)
                           FROM track
                           WHERE artist=:artist""", { "artist" : artist})
@@ -211,10 +98,7 @@
         return result[0][0]
 
     def number_of_albums_by_artist(self, artist):
-        """
-        Get the number of albums made by given artist
-        @param artist: Artist name (string)
-        """
+        '''Return the number of albums from the given artist.'''
         self.cursor.execute("""SELECT DISTINCT album
                           FROM track
                           WHERE artist=:artist
@@ -223,363 +107,173 @@
         return len(result)
 
     def save_lyrics(self, track, lyrics):
-        """
-        Save lyrics to database.
-        @param track: Track which lyrics we are saving
-        @param lyrics: Lyrics string
-        """
-        track.set_lyrics(lyrics) # Be certain to save for this track instance,
-                                 # not just persistent storage
-        self.cursor.execute("""UPDATE track
-                               SET lyrics=:lyrics
-                               WHERE filename=:fn""", {
-                               "lyrics" : lyrics,
-                               "fn" : track.get_filename()})
+        '''Save the lyrics to the database.'''
+        track.lyrics = lyrics # Be certain to save for this track instance,
+                              # not just persistent storage
+        self.cursor.execute(
+            """UPDATE track SET lyrics=:lyrics WHERE filename=:fn""",
+            { "lyrics" : lyrics, "fn" : track.filename})
         self.db_connection.commit()
 
-
-class Album(object):
-    """
-    Objects from this class represents albums. Album contains tracks.
-    """
-
-    def __init__(self, title, cursor=None):
-        """Initialize album (Fetch data from music cache)"""
-        self.config = Configuration()
-        self.tracks = []
-        self.title = title
-        self.total_length = 0
-
-        if not cursor:
-            self.db_connection = sqlite.connect(self.config.MUSIC_DB)
-            self.cursor = self.db_connection.cursor()
-        else:
-            self.cursor = cursor
+    def _create_album(self, title):
+        '''Factory method to create an Album object.'''
         self.cursor.execute(
             """SELECT filename, title, tracknumber,  artist,  album,
-                genre, bitrate, year, rating, length, comment, lyrics
+                year, length, lyrics
                FROM   track
                WHERE  album=:title
                ORDER BY tracknumber""", {"title" : title})
 
+        length = 0
+        tracks = []
         for row in self.cursor:
-            self.tracks.append(Track(row[0], row[1], row[2], row[3], self,
-                                     row[5], row[6], row[7], row[8], row[9],
-                                     row[10], row[11]))
-            self.total_length += int(row[9])
-        if len(self.tracks) == 0:
+            tracks.append(Track(row[0], row[1], row[2], row[3], row[4], row[5],
+                row[6], row[7], self._create_album))
+            length += int(row[6])
+        if len(tracks) == 0:
             raise AlbumHasNoTracks()
-        self.artist = self.tracks[0].artist
-
-    def __str__(self):
-        return self.title
-
-    def get_title(self):
-        """
-        Get title ot the album.
-        @return: String
-        """
-        return self.title
+
+        artist = tracks[0].artist
+
+        for track in tracks:
+            if track.artist != artist:
+                artist = _("Various")
+                break
+
+        encoded_path = artist + ' - ' + title
+        encoded_path = encoded_path.encode('base64')
+        album_art_url = os.path.join(self.config.ALBUM_ART_DIR,
+            encoded_path + '.jpg')
+
+        return Album(artist, title, length, tracks[0].year, album_art_url,
+            tracks)
+
+
+class Album(object):
+    '''Representation of music album which contains tracks.'''
+
+    def __init__(self, artist, title, length, year, album_art_url, tracks):
+        self.config = Configuration()
+        self.artist = artist
+        self.title = title
+        self.length = length
+        self.year = year
+        self.album_art_url = album_art_url
+        self.tracks = tracks
 
     def has_album_art(self):
-        """
-        Has this album album art graphics.
-        @return: Boolean
-        """
-        artist_album = self.artist + " - " + self.title
-        artist_album = artist_album.encode("base64")
-        album_art = os.path.join(self.config.ALBUM_ART_DIR,
-            artist_album + ".jpg")
-
-        return os.path.exists(album_art)
-
-    def get_album_art_url(self):
-        """
-        Get absolute path of album art file or raises Exception.
-        @return: String
-        """
-        artist_album = self.artist + " - " + self.title
-        artist_album = artist_album.encode("base64")
-        return os.path.join(self.config.ALBUM_ART_DIR, artist_album + ".jpg")
-
-    def get_tracks(self):
-        """
-        Get tracks from this Album.
-        @return: List of Track object
-        """
-        return self.tracks
-
-    def get_number_of_tracks(self):
-        """
-        Get the number of tracks on this album.
-        @return: Integer
-        """
-        return len(self.tracks)
-
-    def get_year(self):
-        """
-        Get release year of this album. This is taken from the first track.
-        @return: String
-        """
-        return self.tracks[0].get_year()
-
-    def get_genre(self):
-        """
-        Get genre of this album. This is taken from the first track.
-        @return: String
-        """
-        return self.tracks[0].get_genre()
-
-    def get_artist(self):
-        """
-        Get the artist of this album. This is taken from the first track.
-        @return: String
-        """
-        artist = self.tracks[0].get_artist()
-        text = self.tracks[0].get_artist()
-
-        for track in self.get_tracks():
-            if track.get_artist() != artist:
-                text = _("Various")
-                break
-            else:
-                artist = track.get_artist()
-
-        return text
-
-    def get_total_length(self):
-        """
-        Get total length of the album.
-        @return: Integer (Length in seconds)
-        """
-        return self.total_length
+        '''Test if the album has album art.'''
+        return os.path.exists(self.album_art_url)
 
 
 class Track(Playable):
-    """
-    Track is a Playable object that represents one song in Music library.
-    """
-
-    def __init__(self, filename, title, tracknumber, artist, album, genre,
-                 bitrate, year, rating, length, comment, lyrics):
-        """
-        Initialize track. Notice that album parameter can be either
-        Album name as string or Album object! getAlbum() returns always object.
-        """
-
-        # Check that these four fields are integers
-        for field in [tracknumber, year, rating, length]:
-            if rating == None: # By default, there is no rating for a track
-                continue
+    '''Representation of a music track.'''
+
+    def __init__(self, filename, title, number, artist, album, year, length,
+        lyrics, create_album_callback):
+
+        # Check that these fields are integers
+        for field in [number, year, length]:
             if type(field) != int:
                 raise TrackTypeError("%s is not an integer" % field)
 
-        # Check that the rating is in range 1-5
-        if rating != None and rating not in range(1, 6):
-            raise TrackRatingOutOfRange()
-
-        self.filename = str(filename)     # Filename of the track
-        self.title = str(title)           # Track title
-        self.tracknumber = tracknumber    # Number of the track
-        self.artist = str(artist)         # Artist of the track
-        if isinstance(album, Album):
-            # Album that contains this track (str OR Album object!)
-            self.album = album
-        else:
-            self.album = str(album)
-        self.genre = str(genre)           # Genre of the track
-        self.bitrate = str(bitrate)       # Bitrate of the track
-        self.year = year                  # Release year
-        self.rating = rating              # Rating of the track (1-5)
+        self.filename = filename
+        self.title = title
+        self.number = number
+        self.artist = artist
+        self._album = album
+        self.year = year
         # Length of the track in seconds (example 240)
         self.length = length
-        self.comment = str(comment)       # Comment about this track
-        self.lyrics = str(lyrics)         # Lyrics of the track
-
-    def get_filename(self):
-        """
-        Get filename of the track
-        @return: String
-        """
-        return self.filename
-
-    def get_title(self):
-        """
-        Get title ot the track__MUSIC_DB
-        @return: String
-        """
-        return self.title
-
-    def get_tracknumber(self):
-        """
-        Get track number of the track
-        @return: Interger
-        """
-        return self.tracknumber
-
-    def get_artist(self):
-        """
-        Get artist of the track
-        @return: String
-        """
-        return self.artist
-
-    def get_album(self, cursor=False):
-        """
-        Get album that contains this Track.
-        @return: Album object
-        """
-        if not isinstance(self.album, Album):
-            album = Album(self.album, cursor)
-            self.album = album
+        self._lyrics = lyrics
+        self.create_album_callback = create_album_callback
+
+    @property
+    def album(self):
+        '''Get the album object and use the callback if it's not an instance.'''
+        if not isinstance(self._album, Album):
+            album = self.create_album_callback(self._album)
+            self._album = album
             return album
         else:
-            return self.album
-
-    def get_album_art_url(self, cursor=False):
-        """
-        Get album art URL of this Track
-        @return: String (or None if there is no album art for this track)
-        """
-        self.get_album(cursor) # Need to have an album object
-
-        if self.album.has_album_art():
-            return self.album.get_album_art_url()
-        else:
-            return None
-
-    def get_genre(self):
-        """
-        Get genre of the track
-        @return: String
-        """
-        return self.genre
-
-    def get_bitrate(self):
-        """
-        Get bitrate of the track
-        @return: String
-        """
-        return self.bitrate
-
-    def get_year(self):
-        """
-        Get year of the track
-        @return: Integer
-        """
-        return self.year
-
-    def get_rating(self):
-        """
-        Return rating of the track
-        @return: Integer
-        """
-        return self.rating
-
-    def get_length(self):
-        """
-        Get length of the track in seconds
-        @return: Integer
-        """
-        return self.length
-
-    def get_length_string(self):
-        """
-        Get length of the track as human readable string. Example: 02:46
-        @return: Timestamp as string
-        """
+            return self._album
+
+    @property
+    def length_string(self):
+        '''Return length as a human readable string. Example: 2:46.'''
         return str(self.length / 60) + ":" + str.zfill(str(self.length % 60), 2)
 
-    def get_comment(self):
-        """
-        Get comment of the track
-        @return: String
-        """
-        return self.comment
+    def _get_lyrics(self):
+        '''Get the track lyrics.'''
+        return self._lyrics
+
+    def _set_lyrics(self, lyrics):
+        '''Set the lyrics. LyricsDownloader returns None if it can't find
+        anything so ensure that using lyrics is always a string.'''
+        if lyrics is None:
+            self._lyrics = ''
+        else:
+            self._lyrics = lyrics
+
+    lyrics = property(_get_lyrics, _set_lyrics)
 
     def has_lyrics(self):
-        """
-        Is there lyrics for this track in music cache
-        @return: Boolean, true if lyrics exists
-        """
+        '''Test if the track has any lyrics.'''
         if self.lyrics == "":
             return False
         else:
             return True
 
     def fetch_lyrics(self, callback=False):
-        """
-        Fetch lyrics from the Internet using the LyricsDownloader, use
+        '''Fetch lyrics from the Internet using the LyricsDownloader, use a
         callback function to indicate completion since LyricsDownloader is
         asynchronous. Callback function must take lyrics as only input
-        parameter.
-        @param callback: Function called when fetch_lyrics completes
-        """
+        parameter.'''
         if not callback:
             callback = self.set_lyrics
         if not self.has_lyrics():
-            self.ld = LyricsDownloader(self.get_title(), self.get_artist(),
-                                       callback)
+            self.ld = LyricsDownloader(self.title, self.artist, callback)
             self.ld.search()
 
-    def get_lyrics(self):
-        """
-        Get lyrics of the track
-        @return: String
-        """
-        return self.lyrics
-
-    def set_lyrics(self, lyrics):
-        """
-        Set lyrics to track object instance, use save lyrics for persistent
-        storage of lyrics
-        @param lyrics: Lyrics of track
-        """
-        if lyrics is None:
-            self.lyrics = ""
+    def get_album_art_url(self):
+        '''Get the album art location if it exists.'''
+        if self.album.has_album_art():
+            return self.album.album_art_url
         else:
-            self.lyrics = lyrics
+            return None
 
     # Implement playable interface
+    def get_title(self):
+        '''Get the title.'''
+        return self.title
+
     def get_type(self):
-        """
-        Track is an audio stream.
-        @return: Integer
-        """
+        '''Get the type.'''
         return Playable.AUDIO_STREAM
 
     def get_uri(self):
-        """
-        Get URI of the audio file
-        @return: String
-        """
+        '''Get the URI.'''
         return "file://" + self.filename
 
 
 class CompactDisc(object):
-    """
-    CompactDisc
-
-    Represents one CD. This object is a simple container that includes CD
-    artist, album name and track listing.
-    """
+    '''Representation of a CD.'''
 
     def __init__(self, disc_id):
-        """
-        Create a new CompactDisc object. Initialization queries track
-        information from the Internet.
+        # Assume that no results will be found.
+        self.artist = _("Unknown artist")
+        self.length = 0
+        self.title = _("Unknown title")
+        self.tracks = []
 
-        @param disc_id: DiscID
-        """
-        self.tracks = []
         try:
             (query_status, query_info) = CDDB.query(disc_id)
         except IOError:
             # Set query_status to 0 to act like an unknown CD.
             query_status = 0
 
-        #See CDDB documentation for more information.
-        #http://cddb-py.sourceforge.net/CDDB/README
+        # See CDDB documentation for more information.
+        # http://cddb-py.sourceforge.net/CDDB/README
         # query_info variable's type depends on query_status
 
         if query_status == 200:
@@ -592,11 +286,9 @@
             self._get_information_from_result_element(query_info[0], disc_id)
         else:
             # No metadata found for this disc
-            self.album = _("Unknown title")
-            self.artist = _("Unknown artist")
             for i in range(disc_id[1]):
                 self.tracks.append(CompactDiscTrack(i + 1,
-                    _("Unknown track %(num)s.") % {'num': str(i+1)}, 0))
+                    _("Unknown track %(num)s.") % {'num': str(i + 1)}, 0))
 
     def _get_information_from_result_element(self, result, disc_id):
         """Catch any information from a CDDB result dictionnary"""
@@ -605,105 +297,46 @@
         disc = unicode(result['disc_id'], "iso-8859-1")
 
         self.artist = title[:title.index(' / ')]
-        self.album = title[title.index(' / ') + 3:]
+        self.title = title[title.index(' / ') + 3:]
 
         # Get track titles
         info = CDDB.read(category, disc)[1]
-        cumulative_length = 0
         for i in range(disc_id[1]):
             if i + 4 == len(disc_id):
-                # We must calculate last track length different way
-                length = disc_id[len(disc_id) - 1] - cumulative_length
+                # We must calculate last track length in a different way
+                length = disc_id[len(disc_id) - 1] - self.length
             else:
                 # Calculate track length in seconds
                 length = (disc_id[i + 3] - disc_id[ i + 2]) / 75
-                cumulative_length = cumulative_length + length
 
+            self.length += length
             track_title = unicode(info['TTITLE' + str(i)], "iso-8859-1")
             self.tracks.append(CompactDiscTrack(i + 1, track_title, length))
 
-    def get_artist(self):
-        """
-        Get the name of the artist
-        @return: Artist name as string
-        """
-        return self.artist
-
-    def get_title(self):
-        """
-        Get name of the album.
-        @return: name as string
-        """
-        return self.album
-
-    def get_tracks(self):
-        """
-        Get a list of track names.
-        @return: Tracknames in a string list
-        """
-        return self.tracks
-
-    def get_length(self):
-        """
-        Get length of the album. This is the sum of the track lengths.
-        @return: Integer, length in seconds
-        """
-        length = 0
-        for track in self.tracks:
-            length = length + track.get_length()
-        return length
-
 
 class CompactDiscTrack(Playable):
-    """
-    CompactDiscTrack is a Playable object that is a one track of the Audio CD.
-    """
+    '''Representation of a CD track.'''
 
-    def __init__(self, track_number, title, track_length):
-        """
-        Create a new CD track.
-        @param track_number: Number of the track on the Audio CD.
-        @param title: Title of the track
-        @param track_length: Track length in seconds (integer)
-        """
+    def __init__(self, number, title, length):
         self.title = title
-        self.uri = "cdda://" + str(track_number)
-        self.track_length = track_length
-
+        self.uri = "cdda://" + str(number)
+        self.length = length
+
+    @property
+    def length_string(self):
+        '''Return length as a human readable string. Example: 2:46.'''
+        return str(self.length / 60) + ":" + str.zfill(str(self.length % 60), 2)
+
+    # Implement playable interface
     def get_title(self):
-        """
-        Get title of the track
-        @return: String
-        """
+        '''Get the title.'''
         return self.title
 
+    def get_type(self):
+        '''Get the type.'''
+        return Playable.AUDIO_STREAM
+
     def get_uri(self):
-        """
-        Get URI of the playable stream.
-        @return: String
-        """
+        '''Get the URI.'''
         return self.uri
 
-    def get_length(self):
-        """
-        Get track length in seconds
-        @return: Integer, length in seconds
-        """
-        return self.track_length
-
-    def get_length_string(self):
-        """
-        Get length of the track as human readable string. Example: 02:46
-        @return: Timestamp as string
-        """
-        return str.zfill(str(self.track_length / 60), 2) + ":" + \
-                str.zfill(str(self.track_length % 60), 2)
-
-    def get_type(self):
-        """
-        Get type of the stream. This is one of the
-        constants defined in Playable class.
-        @return: Integer
-        """
-        return Playable.AUDIO_STREAM
-

=== modified file 'entertainerlib/client/medialibrary/playable.py'
--- entertainerlib/client/medialibrary/playable.py	2009-05-06 02:58:08 +0000
+++ entertainerlib/client/medialibrary/playable.py	2010-01-03 23:00:32 +0000
@@ -1,41 +1,22 @@
 # Copyright (c) 2009 Entertainer Developers - See COPYING - GPLv2
 '''Playable - Interface for playable streams. MediaPlayer plays Playables'''
 
-class Playable:
-    """
-    Interface for playable media.
-
-    This is an interface for all of those objects that can be played with the
-    MediaPlayer object. MediaPlayer playes only files that implement this
-    interface.
-
-    At the moment following classes implement this:
-        - Track
-        - VideoItem
-    """
+class Playable(object):
+    '''An interface for all objects that can be played with the MediaPlayer.
+    MediaPlayer playes only files that implement this interface.'''
 
     VIDEO_STREAM = 0
     AUDIO_STREAM = 1
 
     def get_uri(self):
-        """
-        Get URI of the playable stream.
-        @return: String
-        """
+        '''Get the URI.'''
         return None
 
     def get_type(self):
-        """
-        Get type of the stream. This is one of the
-        constants defined in Playable class.
-        @return: Integer
-        """
+        '''Get the type (as defined by the Playable constants.'''
         return None
 
     def get_title(self):
-        """
-        Gets the title of the stream.
-        @return: String
-        """
+        '''Get the title.'''
         return None
 

=== modified file 'entertainerlib/gui/screens/album.py'
--- entertainerlib/gui/screens/album.py	2009-07-29 03:09:34 +0000
+++ entertainerlib/gui/screens/album.py	2010-01-03 23:00:32 +0000
@@ -38,7 +38,7 @@
 
         #List indicator
         self.li = ListIndicator(0.74, 0.85, 0.2, 0.045, ListIndicator.VERTICAL)
-        self.li.set_maximum(len(self.album.get_tracks()))
+        self.li.set_maximum(len(self.album.tracks))
         self.add(self.li)
 
         self.track_menu.active = True
@@ -51,8 +51,7 @@
         displays album cover art.
         """
         if(self.album.has_album_art()):
-            pixbuf = gtk.gdk.pixbuf_new_from_file(
-                self.album.get_album_art_url())
+            pixbuf = gtk.gdk.pixbuf_new_from_file(self.album.album_art_url)
         else:
             pixbuf = gtk.gdk.pixbuf_new_from_file(
                 self.theme.getImage("default_album_art"))
@@ -64,19 +63,19 @@
         """
         Create album info labels.
         """
-        if self.album.get_year() != 0:
-            album_text = self.album.get_title() + ", " + \
-                str(self.album.get_year())
+        if self.album.year != 0:
+            album_text = self.album.title + ", " + str(self.album.year)
         else:
-            album_text = self.album.get_title()
+            album_text = self.album.title
         album = Label(0.0416, "text", 0.5, 0.13, album_text, font_weight="bold")
         album.set_ellipsize(pango.ELLIPSIZE_END)
+        album.set_line_wrap(False)
         album.width = 0.45
         self.add(album)
 
-        length = str(self.album.get_total_length() / 60)
+        length = str(self.album.length / 60)
         num_of_tracks_text = _("%(total)s tracks, %(time)s minutes") % \
-            {'total': self.album.get_number_of_tracks(), 'time': length}
+            {'total': len(self.album.tracks), 'time': length}
         num_of_tracks = Label(0.028, "subtitle", 0.5, 0.18,
             num_of_tracks_text, font_weight="bold")
         self.add(num_of_tracks)
@@ -87,8 +86,8 @@
         """
         menu = TextMenu(0.4978, 0.2344, 0.4393, 0.0781)
 
-        tracks = self.album.get_tracks()
-        tracks_list = [[track.get_title(), track.get_length_string(), track] \
+        tracks = self.album.tracks
+        tracks_list = [[track.title, track.length_string, track] \
             for track in tracks]
         menu.async_add(tracks_list)
 
@@ -132,6 +131,6 @@
         '''Update of the list indicator and the screen's title'''
         self.li.set_current(self.track_menu.selected_index + 1)
         track = self.track_menu.selected_userdata
-        self.screen_title.set_text(track.get_artist())
+        self.screen_title.set_text(track.artist)
         self.screen_title.show()
 

=== modified file 'entertainerlib/gui/screens/artist.py'
--- entertainerlib/gui/screens/artist.py	2009-06-17 02:49:44 +0000
+++ entertainerlib/gui/screens/artist.py	2010-01-03 23:00:32 +0000
@@ -51,6 +51,6 @@
         better documentation.
         """
         album = self.tab_group.tab("albums").selected_album
-        self.media_player.set_playlist(Playlist(album.get_tracks()))
+        self.media_player.set_playlist(Playlist(album.tracks))
         self.media_player.play()
 

=== modified file 'entertainerlib/gui/screens/audio_play.py'
--- entertainerlib/gui/screens/audio_play.py	2009-07-12 17:02:32 +0000
+++ entertainerlib/gui/screens/audio_play.py	2010-01-03 23:00:32 +0000
@@ -18,11 +18,11 @@
         Screen.__init__(self, 'AudioPlay', has_tabs=True)
 
         self.theme = self.config.theme
-        album = track.get_album()
+        album = track.album
 
         # Create album art (this is displayed on all tab pages
         if(album.has_album_art()):
-            pixbuf = gtk.gdk.pixbuf_new_from_file(album.get_album_art_url())
+            pixbuf = gtk.gdk.pixbuf_new_from_file(album.album_art_url)
         else:
             pixbuf = gtk.gdk.pixbuf_new_from_file(
                 self.theme.getImage("default_album_art"))

=== modified file 'entertainerlib/gui/screens/disc.py'
--- entertainerlib/gui/screens/disc.py	2009-07-29 03:09:34 +0000
+++ entertainerlib/gui/screens/disc.py	2010-01-03 23:00:32 +0000
@@ -60,12 +60,12 @@
         try:
             disc = self.music_library.get_compact_disc_information()
 
-            title = disc.get_title()
-            artist = disc.get_artist()
-            tracks = disc.get_tracks()
+            title = disc.title
+            artist = disc.artist
+            tracks = disc.tracks
 
             self.playlist = Playlist(tracks)
-            self._create_album_info(title, artist, tracks, disc.get_length())
+            self._create_album_info(title, artist, tracks, disc.length)
             self.track_menu = self._create_track_menu(tracks)
             self.add(self.track_menu)
             self._create_album_cover_texture(artist, title)
@@ -177,7 +177,7 @@
         menu = TextMenu(0.4978, 0.2344, 0.4393, 0.0781)
         menu.visible_rows = 7
 
-        tracks_list = [[track.get_title(), track.get_length_string(), index] \
+        tracks_list = [[track.title, track.length_string, index] \
             for index, track in enumerate(tracks)]
         menu.async_add(tracks_list)
 

=== modified file 'entertainerlib/gui/screens/music.py'
--- entertainerlib/gui/screens/music.py	2009-06-17 02:49:44 +0000
+++ entertainerlib/gui/screens/music.py	2010-01-03 23:00:32 +0000
@@ -85,7 +85,7 @@
             self.media_player.play()
         elif self.tab_group.tab("albums").active:
             album = self.tab_group.tab("albums").selected_album
-            self.media_player.set_playlist(Playlist(album.get_tracks()))
+            self.media_player.set_playlist(Playlist(album.tracks))
             self.media_player.play()
 
     def handle_user_event(self, event):

=== modified file 'entertainerlib/gui/tabs/albums_tab.py'
--- entertainerlib/gui/tabs/albums_tab.py	2010-01-03 23:00:30 +0000
+++ entertainerlib/gui/tabs/albums_tab.py	2010-01-03 23:00:32 +0000
@@ -42,7 +42,7 @@
         self.menu.items_per_col = self.menu.visible_rows
         self.add(self.menu)
 
-        albums_list = [[album.get_album_art_url(), album] for album in albums]
+        albums_list = [[album.album_art_url, album] for album in albums]
         self.menu.async_add_albums(albums_list)
 
         self.li = ListIndicator(0.77, 0.8, 0.18, 0.045,
@@ -83,10 +83,10 @@
         '''Update the album information labels.'''
         if self.active:
             album = self.menu.selected_userdata
-            self.album_title.set_text(album.get_title())
-            self.album_artist.set_text(album.get_artist())
+            self.album_title.set_text(album.title)
+            self.album_artist.set_text(album.artist)
             self.album_tracks.set_text(_("%(total)s tracks") % \
-                {'total': album.get_number_of_tracks()})
+                {'total': len(album.tracks)})
             self.li.show()
             self.li.set_current(self.menu.selected_index + 1)
         else:

=== modified file 'entertainerlib/gui/tabs/lyrics_tab.py'
--- entertainerlib/gui/tabs/lyrics_tab.py	2009-08-04 01:09:03 +0000
+++ entertainerlib/gui/tabs/lyrics_tab.py	2010-01-03 23:00:32 +0000
@@ -22,7 +22,7 @@
         self.lyrics_text = ""
 
         if self.track.has_lyrics():
-            self.lyrics_text = self.track.get_lyrics()
+            self.lyrics_text = self.track.lyrics
             lyrics = Label(0.037, "subtitle", 0, 0, self.lyrics_text)
             lyrics.set_line_wrap_mode(pango.WRAP_WORD)
             lyrics.width = 0.366

=== modified file 'entertainerlib/gui/tabs/playing_tab.py'
--- entertainerlib/gui/tabs/playing_tab.py	2009-06-17 02:49:44 +0000
+++ entertainerlib/gui/tabs/playing_tab.py	2010-01-03 23:00:32 +0000
@@ -14,14 +14,14 @@
             tab_title=_("Currently playing")):
         Tab.__init__(self, name, tab_title)
 
-        album = track.get_album()
+        album = track.album
 
         # Track name
-        if track.get_tracknumber() == 0:
-            track_label_text = str(track.get_title())
+        if track.number == 0:
+            track_label_text = track.title
         else:
             track_label_text =  _("From %(number)d. %(title)s") % \
-                {'number':track.get_tracknumber(), 'title': track.get_title()}
+                {'number': track.number, 'title': track.title}
 
         self.track_label = Label(0.05, "text", 0.5, 0.33, track_label_text)
         self.track_label.set_ellipsize(pango.ELLIPSIZE_END)
@@ -29,12 +29,11 @@
         self.add(self.track_label)
 
         # Album name
-        if album.get_year() == 0:
-            album_label_text = _("From %(title)s") % \
-                {'title': album.get_title()}
+        if album.year == 0:
+            album_label_text = _("From %(title)s") % {'title': album.title}
         else:
             album_label_text = _("From %(title)s, %(year)s") % \
-                {'title': album.get_title(), 'year': album.get_year()}
+                {'title': album.title, 'year': album.year}
 
         self.album_label = Label(0.042, "subtitle", 0.5, 0.43, album_label_text)
         self.album_label.set_ellipsize(pango.ELLIPSIZE_END)
@@ -42,7 +41,7 @@
         self.add(self.album_label)
 
         # Artist name
-        artist_text = _("By %(artist)s") % {'artist': track.get_artist()}
+        artist_text = _("By %(artist)s") % {'artist': track.artist}
         self.artist_label = Label(0.042, "subtitle", 0.5, 0.53, artist_text)
         self.artist_label.set_ellipsize(pango.ELLIPSIZE_END)
         self.artist_label.width = 0.4
@@ -57,23 +56,21 @@
         Called when currently playing changes tracks. The provided track
         is used to update all the necessary labels.
         '''
-        track = track
-        album = track.get_album()
+        album = track.album
 
-        if track.get_tracknumber() == 0:
-            self.track_label.set_text(str(track.get_title()))
+        if track.number == 0:
+            self.track_label.set_text(track.title)
         else:
-            self.track_label.set_text(str(track.get_tracknumber()) + \
-                ". " + track.get_title())
+            self.track_label.set_text(str(track.number) + ". " + track.title)
 
-        if album.get_year() != 0:
+        if album.year != 0:
             self.album_label.set_text(_("From %(title)s, %(year)s") % \
-            {'title': album.get_title(), 'year': album.get_year()})
+            {'title': album.title, 'year': album.year})
         else:
             self.album_label.set_text(_("From %(album)s") % \
-                {'album': album.get_title()})
+                {'album': album.title})
             self.artist_label.set_text(_("By %(artist)s") % \
-                {'artist': track.get_artist()})
+                {'artist': track.artist})
 
     def can_activate(self):
         '''No interaction is available on the PlayingTab.'''

=== modified file 'entertainerlib/gui/tabs/tracks_tab.py'
--- entertainerlib/gui/tabs/tracks_tab.py	2010-01-03 23:00:31 +0000
+++ entertainerlib/gui/tabs/tracks_tab.py	2010-01-03 23:00:33 +0000
@@ -29,7 +29,7 @@
         self.menu.cursor = None
         self.add(self.menu)
 
-        tracks_list = [[track.get_title(), None, track] for track in tracks]
+        tracks_list = [[track.title, None, track] for track in tracks]
         self.menu.async_add_artists(tracks_list)
 
         self.track_title = Label(0.045, "title", 0.22, 0.79, "")
@@ -69,12 +69,10 @@
         '''Update the track information labels'''
         if self.active:
             track = self.menu.selected_userdata
-            self.track_title.set_text(track.get_title())
-            self.track_length.set_text(str(track.get_length() / 60) + ":" + \
-                str(track.get_length() % 60).zfill(2))
-            self.track_number.set_text(_("Track %(track)s from %(album)s") % \
-                {'track': track.get_tracknumber(),
-                'album': track.get_album().get_title()})
+            self.track_title.set_text(track.title)
+            self.track_length.set_text(track.length_string)
+            self.track_number.set_text(_("Track %(track)d from %(album)s") % \
+                {'track': track.number, 'album': track.album.title})
             self.li.show()
             self.li.set_current(self.menu.selected_index + 1)
         else:

=== modified file 'entertainerlib/tests/mock.py'
--- entertainerlib/tests/mock.py	2009-09-08 02:40:16 +0000
+++ entertainerlib/tests/mock.py	2010-01-03 23:00:33 +0000
@@ -23,17 +23,7 @@
         if make_track:
             self.mock_track = MockTrack(make_album=False)
 
-    def get_number_of_tracks(self):
-        '''See `Album.get_number_of_tracks`.'''
-        return 1
-
-    def get_tracks(self):
-        '''See `Album.get_tracks`.'''
-        return [self.mock_track]
-
-    def get_year(self):
-        '''See `Album.get_year`.'''
-        return '2009'
+        self.tracks = [self.mock_track]
 
     def has_album_art(self):
         '''See `Album.has_album_art`.'''
@@ -284,10 +274,6 @@
         if make_album:
             self.album = MockAlbum(make_track=False)
 
-    def get_album(self, cursor=False):
-        '''See `Track.get_album`.'''
-        return self.album
-
 
 class MockVideoLibrary(VideoLibrary):
     '''Mock entertainerlib.client.medialibrary.videos.VideoLibrary'''

=== modified file 'entertainerlib/tests/test_music.py'
--- entertainerlib/tests/test_music.py	2009-09-08 02:40:16 +0000
+++ entertainerlib/tests/test_music.py	2010-01-03 23:00:33 +0000
@@ -6,8 +6,10 @@
 from pysqlite2 import dbapi2 as sqlite
 
 from entertainerlib.client.medialibrary.music import (
-    Album, AlbumHasNoTracks, MusicLibrary, Track, CompactDisc,
-    TrackRatingOutOfRange, TrackTypeError)
+    Album, AlbumHasNoTracks,
+    CompactDisc, CompactDiscTrack,
+    MusicLibrary,
+    Track, TrackTypeError)
 from entertainerlib.client.medialibrary.playable import Playable
 from entertainerlib.tests import EntertainerTest
 
@@ -16,7 +18,6 @@
     classes that need to access the music cache"""
 
     def setUp(self):
-        """See unittest.TestCase"""
         EntertainerTest.setUp(self)
 
         self.debug = False
@@ -85,161 +86,83 @@
 
     def setUp(self):
         TestMusic.setUp(self)
+        self.music_library = MusicLibrary()
         self.track = Track('/path/to/track.mp3', # filename
                            'title',
                            1, # tracknumber
                            'artist0',
                            'album0',
-                           'genre',
-                           '128', # bitrate
                            2008, # year
-                           5, # rating
                            240, # length
-                           'comment',
-                           'lyrics')
-
-    def tearDown(self):
-        TestMusic.tearDown(self)
-
-    def testTrackConstructor(self):
-        """testTrackConstructor - Ensures that a Track object is created"""
+                           'lyrics',
+                            self.music_library._create_album)
+
+    def test_constructor(self):
+        '''Test that a Track object is created.'''
         self.assertTrue(isinstance(self.track, Track))
+        self.assertEqual(self.track.artist, 'artist0')
+        self.assertEqual(self.track.filename, '/path/to/track.mp3')
+        self.assertEqual(self.track.length, 240)
+        self.assertEqual(self.track.length_string, '4:00')
+        self.assertEqual(self.track.lyrics, 'lyrics')
+        self.assertEqual(self.track.number, 1)
+        self.assertEqual(self.track.title, 'title')
+        self.assertEqual(self.track.year, 2008)
 
-    def testTrackBadConstructor(self):
-        """testTrackBadConstructor - Ensures that bad track construction
-        raises an exception for the integer fields"""
-        for i in [2, 7, 8, 9]:
-            t = ['a', 'b', 1, 'c', 'd', 'e', 'f', 2, 3, 4, 'g', 'h']
+    def test_bad_constructor(self):
+        '''Test that bad track construction raises an exception for the integer
+        fields.'''
+        for i in [2, 5, 6]:
+            t = ['', '', 1, '', '', 2, 3, '']
             t[i] = str(t[i])
             self.assertRaises(TrackTypeError, Track, t[0], t[1], t[2], t[3],
-                              t[4], t[5], t[6], t[7], t[8], t[9], t[10], t[11])
-
-    def testTrackRatingInRange(self):
-        """testTrackRatingInRange - Ensures that the ratings in range create
-        valid Track objects"""
-        for i in range(1, 6):
-            self.track = Track('a', 'b', 1, 'c', 'd', 'e', 'f', 2, i, 3, 'g',
-                               'h')
-            self.assertTrue(isinstance(self.track, Track))
-            self.assertEqual(self.track.get_rating(), i)
-
-    def testTrackRatingOutOfRange(self):
-        """testTrackRatingOutOfRange - Ensures that the rating raises an
-        exception for something out of range in construction"""
-        for i in [0, 6]:
-            self.assertRaises(TrackRatingOutOfRange, Track, 'a', 'b', 1, 'c',
-                              'd', 'e', 'f', 2, i, 3, 'g', 'h')
-
-    def testTrackGetFilename(self):
-        """testTrackGetFilename - Ensures that the filename is returned"""
-        result = self.track.get_filename()
-        self.assertEqual(result, '/path/to/track.mp3')
-
-    def testTrackGetTitle(self):
-        """testTrackGetTitle - Ensures that the title is returned"""
-        result = self.track.get_title()
-        self.assertEqual(result, 'title')
-
-    def testTrackGetTrackNumber(self):
-        """testTrackGetTrackNumber - Ensures that the tracknumber is
-        returned"""
-        result = self.track.get_tracknumber()
-        self.assertEqual(result, 1)
-
-    def testTrackGetArtist(self):
-        """testTrackGetArtist - Ensures that the artist is returned"""
-        result = self.track.get_artist()
-        self.assertEqual(result, 'artist0')
-
-    def testTrackGetAlbum(self):
-        """testTrackGetAlbum - Ensures that an album object is returned"""
-        result = self.track.get_album(self.cursor)
+                t[4], t[5], t[6], t[7], None)
+
+    def test_album_property(self):
+        '''Test that an album object is returned.'''
+        result = self.track.album
         self.assertTrue(isinstance(result, Album))
-        self.assertEqual(result.get_title(), 'album0')
-
-    def testTrackGetAlbumNot(self):
-        """testTrackGetAlbumNot - Ensures that a bad album in the track
-        returns AlbumHasNoTracks"""
-        self.badTrack = Track('path', 'title', 1, 'artist',
-                              'foo-bar-baz**', # Here is the bad input
-                              'genre', '128', 2008, 5, 240, 'comment',
-                              'lyrics')
-        self.assertRaises(AlbumHasNoTracks, self.badTrack.get_album,
-                          self.cursor)
-
-    def testTrackGetAlbumArtUrlExists(self):
-        """testTrackGetAlbumArtUrl - Ensures that the album art url is
-        returned"""
+        self.assertEqual(result.title, 'album0')
+
+    def test_bad_album(self):
+        '''Test that a bad album in the track returns AlbumHasNoTracks.'''
+        bad_track = Track('', '', 1, '', 'foo-bar-baz**', 2, 3, '',
+            self.music_library._create_album)
+        try:
+            album = bad_track.album
+            self.fail()
+        except AlbumHasNoTracks:
+            pass
+
+    def test_get_album_art_url(self):
+        '''Test that the album art url is returned.'''
         album_artist = "artist0 - album0"
         album_artist = album_artist.encode("base64")
         album_art = os.path.join(self.art_path, album_artist + ".jpg")
         open(album_art, "wb").close()
-        result = self.track.get_album_art_url(self.cursor)
+        result = self.track.get_album_art_url()
         self.assertEqual(result, album_art)
         if os.path.exists(album_art):
             os.remove(album_art)
 
-    def testTrackGetAlbumArtUrlNotExists(self):
-        """testTrackGetAlbumArtUrlNotExists - Ensures that when art does
-        not exist, None is returned"""
-        result = self.track.get_album_art_url(self.cursor)
+        result = self.track.get_album_art_url()
         self.assertEqual(result, None)
 
-    def testTrackGetGenre(self):
-        """testTrackGetGenre - Ensures that the genre is returned"""
-        result = self.track.get_genre()
-        self.assertEqual(result, 'genre')
-
-    def testTrackGetBitrate(self):
-        """testTrackGetBitrate - Ensures that the bitrate is returned"""
-        result = self.track.get_bitrate()
-        self.assertEqual(result, '128')
-
-    def testTrackGetYear(self):
-        """testTrackGetYear - Ensures that the year is returned"""
-        result = self.track.get_year()
-        self.assertEqual(result, 2008)
-
-    def testTrackGetRating(self):
-        """testTrackGetRating - Ensures that the rating is returned"""
-        result = self.track.get_rating()
-        self.assertEqual(result, 5)
-
-    def testTrackGetLength(self):
-        """testTrackGetLength - Ensures that the length is returned"""
-        result = self.track.get_length()
-        self.assertEqual(result, 240)
-
-    def testTrackGetComment(self):
-        """testTrackGetComment - Ensures that the comment is returned"""
-        result = self.track.get_comment()
-        self.assertEqual(result, 'comment')
-
-    def testTrackGetLyrics(self):
-        """testTrackGetLyrics - Ensures that the lyrics are returned"""
-        result = self.track.get_lyrics()
-        self.assertEqual(result, 'lyrics')
-
-    def testTrackSetLyrics(self):
-        """testTrackSetLyrics - Ensures that lyrics are properly set"""
-        self.track.set_lyrics('some new lyrics')
-        self.assertEqual(self.track.get_lyrics(), 'some new lyrics')
-
-    def testTrackSetNoneLyrics(self):
-        """testTrackSetNoneLyrics - Ensures that lyrics are set to empty
-        string when None is passed as lyrics input"""
-        self.track.set_lyrics(None)
-        self.assertEqual(self.track.get_lyrics(), '')
-
-    def testTrackGetType(self):
-        """testTrackGetType - Ensures that the type is returned"""
-        result = self.track.get_type()
-        self.assertEqual(result, Playable.AUDIO_STREAM)
-
-    def testTrackGetUri(self):
-        """testTrackGetUri - Ensures that the uri is returned"""
-        result = self.track.get_uri()
-        self.assertEqual(result, 'file:///path/to/track.mp3')
+    def test_lyrics_property(self):
+        '''Test the lyrics property.'''
+        self.track.lyrics = 'some new lyrics'
+        self.assertEqual(self.track.lyrics, 'some new lyrics')
+
+        self.track.lyrics = None
+        self.assertEqual(self.track.lyrics, '')
+
+    def test_get_type(self):
+        '''Test that the type is returned.'''
+        self.assertEqual(self.track.get_type(), Playable.AUDIO_STREAM)
+
+    def test_get_uri(self):
+        '''Test that the uri is returned.'''
+        self.assertEqual(self.track.get_uri(), 'file:///path/to/track.mp3')
 
 
 class TestMusicLibrary(TestMusic):
@@ -249,9 +172,8 @@
         TestMusic.setUp(self)
         self.musiclibrary = MusicLibrary()
 
-    def testMusicLibraryConstructor(self):
-        """testMusicLibraryContructor - Ensures instantiation of MusicLibrary
-        class"""
+    def test_music_library_constructor(self):
+        '''Test that the music library contructor works.'''
         self.assertTrue(isinstance(self.musiclibrary, MusicLibrary))
 
     def testGetAllArtists(self):
@@ -260,34 +182,13 @@
         result = self.musiclibrary.get_all_artists()
         self.assertEqual(result, ['artist0'])
 
-    def testGetAllTracks(self):
-        """testGetAllTracks - Ensures that all tracks are returned"""
-        result = self.musiclibrary.get_all_tracks()
-        for i in result:
-            self.assertTrue(isinstance(i, Track))
-        self.assertEqual(len(result), 8)
-
-    def testGetTracksByGenre(self):
-        """testGetTracksByGenre - Ensures tracks of a certain genre are
-        returned"""
-        result = self.musiclibrary.get_tracks_by_genre('genre0')
-        self.assertEqual(len(result), 4)
-        for i in result:
-            self.assertEqual(i.get_genre(), 'genre0')
-
-    def testGetTracksByMissingGenre(self):
-        """testGetTracksByMissingGenre - Ensures proper handling of a missing
-        genre"""
-        self.assertEquals(
-            len(self.musiclibrary.get_tracks_by_genre('foo-bar-baz**')), 0)
-
     def testGetTracksByArtist(self):
         """testGetTracksByArtist - Ensure tracks by a certain artist are
         returned"""
         result = self.musiclibrary.get_tracks_by_artist('artist0')
         self.assertEqual(len(result), 8)
         for i in result:
-            self.assertEqual(i.get_artist(), 'artist0')
+            self.assertEqual(i.artist, 'artist0')
 
     def testGetTracksByUnknownArtist(self):
         """testGetTracksByUnknownArtist - Ensure proper handling of an missing
@@ -308,7 +209,7 @@
         result = self.musiclibrary.get_albums_by_artist('artist0')
         self.assertEqual(len(result), 2)
         for i in result:
-            self.assertEqual(i.get_artist(), 'artist0')
+            self.assertEqual(i.artist, 'artist0')
 
     def testGetAlbumsByUnknownArtist(self):
         """testGetAlbumsByUnknownArtist - Ensures proper handling of an
@@ -350,42 +251,32 @@
         database"""
         # Only need a filename that matches something in the database, the rest
         # of the track is for construction purposes only
-        self.track = Track('/filename/000', '', 0, '', '', '', '', 0, 1, 0, '',
-                           '')
-        self.musiclibrary.save_lyrics(self.track, 'some lyrics here')
-        self.assertEqual(self.track.get_lyrics(), 'some lyrics here')
+        track = Track('/filename/000', '', 0, '', '', 0, 1, '', None)
+        self.musiclibrary.save_lyrics(track, 'some lyrics here')
+        self.assertEqual(track.lyrics, 'some lyrics here')
 
 
 class TestAlbum(TestMusic):
     '''Tests Album'''
 
     def setUp(self):
-        """See unittest.TestCase"""
         TestMusic.setUp(self)
-        self.album = Album('album1', self.cursor)
-
-    def tearDown(self):
-        """Clean up after the test"""
-        TestMusic.tearDown(self)
+        self.music_library = MusicLibrary()
+        self.album = self.music_library._create_album('album1')
 
     def testAlbumConstructor(self):
         """Test that an Album object is properly constructed"""
         self.assertTrue(isinstance(self.album, Album))
+        self.assertEqual(self.album.artist, 'artist0')
+        self.assertEqual(self.album.length, 8)
+        self.assertEqual(self.album.title, 'album1')
+        self.assertEqual(self.album.year, 0)
 
     def testAlbumConstructorNot(self):
         """Test that an AlbumHasNoTracks exception is raised when the created
         album doesn't exist in the cache"""
-        self.assertRaises(AlbumHasNoTracks, Album, 'foo', self.cursor)
-
-    def testAlbumStr(self):
-        """Test that title is returned in string conversion"""
-        result = str(self.album)
-        self.assertEqual(result, 'album1')
-
-    def testAlbumGetTitle(self):
-        """Test that the album title is returned"""
-        result = self.album.get_title()
-        self.assertEqual(result, 'album1')
+        self.assertRaises(AlbumHasNoTracks, self.music_library._create_album,
+            'foo')
 
     def testAlbumHasAlbumArt(self):
         """Test that album art exists for the file"""
@@ -399,12 +290,12 @@
 
     def testAlbumHasAlbumArtNot(self):
         """Test that missing album art is reported back"""
-        otherAlbum = Album('album1', self.cursor)
-        self.assertFalse(otherAlbum.has_album_art())
+        other_album = self.music_library._create_album('album1')
+        self.assertFalse(other_album.has_album_art())
 
     def testAlbumGetAlbumArtUrl(self):
         """Test that the path to the album's art is returned"""
-        result = self.album.get_album_art_url()
+        result = self.album.album_art_url
         album_artist = "artist0 - album1"
         album_artist = album_artist.encode("base64")
         album_art = os.path.join(self.art_path, album_artist + ".jpg")
@@ -412,60 +303,30 @@
 
     def testAlbumGetTracks(self):
         """Test that all tracks for an album are returned"""
-        result = self.album.get_tracks()
+        result = self.album.tracks
         self.assertEqual(len(result), 4)
         for i in result:
             self.assertTrue(isinstance(i, Track))
 
-    def testAlbumGetNumberOfTracks(self):
-        """Test correct number of tracks from album is returned"""
-        self.assertEqual(self.album.get_number_of_tracks(), 4)
-
-    def testAlbumGetYear(self):
-        """Test that year of album is returned"""
-        self.assertEqual(self.album.get_year(), 0)
-
-    def testAlbumGetGenre(self):
-        """Test that genre of album is returned"""
-        self.assertEqual(self.album.get_genre(), 'genre0')
-
-    def testAlbumGetArtist(self):
-        """Test that artist of album is returned"""
-        self.assertEqual(self.album.get_artist(), 'artist0')
-
-    def testAlbumGetTotalLength(self):
-        """Test that total length of album is returned"""
-        self.assertEqual(self.album.get_total_length(), 8)
-
 
 class TestCompactDisc(TestMusic):
     '''Tests CompactDisc'''
 
     def setUp(self):
-        """See unittest.TestCase"""
         TestMusic.setUp(self)
         self.cd = CompactDisc([2299253003L, 11, 150, 25433, 46436, 68737, 89292,
             108536, 130667, 144099, 160174, 181568, 203695, 3027])
 
-    def tearDown(self):
-        """Clean up after the test"""
-        TestMusic.tearDown(self)
-
-    def testCompactDiscConstructor(self):
-        """Test that a CompactDisc object is properly constructed"""
+    def test_constructor(self):
+        '''Test that a CompactDisc object is properly constructed.'''
         self.assertTrue(isinstance(self.cd, CompactDisc))
-
-    def testCompactDiscGetTitle(self):
-        """Test that album title is returned from CDDB"""
-        self.assertEqual(self.cd.get_title(), 'The Joshua Tree')
-
-    def testCompactDiscGetArtist(self):
-        """Test that artist is returned from CDDB"""
-        self.assertEqual(self.cd.get_artist(), 'U2')
-
-    def testCompactDiscGetTracks(self):
-        """Test that tracks names are returned from CDDB"""
-        tracks = [track.get_title() for track in self.cd.get_tracks()]
+        self.assertEqual(self.cd.artist, 'U2')
+        self.assertEqual(self.cd.length, 3027)
+        self.assertEqual(self.cd.title, 'The Joshua Tree')
+
+    def test_tracks(self):
+        '''Test that track names are returned from CDDB.'''
+        tracks = [track.title for track in self.cd.tracks]
 
         self.assertEqual(tracks, ['Where the Streets Have No Name',
             "I Still haven't Found What I'm Looking For", 'With or Without You',
@@ -474,7 +335,24 @@
             'Trip Through Your Wires', 'One Tree Hill', 'Exit',
             'Mothers of the Disappeared'])
 
-    def testCompactDiscGetLength(self):
-        """Test that the sum of the track lengths is returned"""
-        self.assertEqual(self.cd.get_length(), 3027)
+class TestCompactDiscTrack(TestMusic):
+    '''Tests CompactDiscTrack'''
+
+    def setUp(self):
+        TestMusic.setUp(self)
+        self.track = CompactDiscTrack(1, 'test', 120)
+
+    def test_constructor(self):
+        '''Test that a CompactDiscTrack object is properly constructed.'''
+        self.assertTrue(isinstance(self.track, CompactDiscTrack))
+        self.assertEqual(self.track.length, 120)
+        self.assertEqual(self.track.title, 'test')
+
+    def test_get_uri(self):
+        '''Test that the URI is in the proper CD format.'''
+        self.assertEqual(self.track.uri, 'cdda://1')
+
+    def test_length_string_property(self):
+        '''Test the length_string property.'''
+        self.assertEqual(self.track.length_string, '2:00')