Merge lp:~mblayman/entertainer/videolibz into lp:entertainer

[Matt Layman]

Video classes are now more Pythonic and do not talk directly to the database anymore.

I did the same clean up to the video library as I did early to the music library. Now all the video classes are just plain Python objects. Any method that talks to the database has been pushed into some factory methods in the VideoLibrary. This leaves only the VideoLibrary to work with when we move away from directly using the database directly (first to Storm, then to Twisted probably).

[Matt Layman (mblayman)]

review: Approve

=== modified file 'entertainerlib/client/media_player.py'
--- entertainerlib/client/media_player.py	2009-12-21 22:21:55 +0000
+++ entertainerlib/client/media_player.py	2010-04-03 23:02:16 +0000
@@ -15,17 +15,10 @@
 from entertainerlib.logger import Logger
 
 class MediaPlayer(gobject.GObject, object):
-    '''
-    MediaPlayer class for Entertainer
-
-    MediaPlayer uses Gstreamer backend and is able to play all video and audio
-    files that gstreamer supports. Entertainer has only one MediaPlayer object
-    at runtime.
-
-    MediaPlayer can play objects that implement Playable interface. These
-    classes are Track, Movie, TVEpisode, Movie, VideoClip and CompactDiscTrack.
-    (and Channel in the future)
-    '''
+    '''MediaPlayer uses Gstreamer to play all video and audio files. Entertainer
+    has only one MediaPlayer object at runtime. MediaPlayer can play objects
+    that implement Playable interface.'''
+
     __gsignals__ = {
         'play' : ( gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, () ),
         'pause' : ( gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, () ),

=== modified file 'entertainerlib/client/medialibrary/videos.py'
--- entertainerlib/client/medialibrary/videos.py	2010-04-03 14:33:37 +0000
+++ entertainerlib/client/medialibrary/videos.py	2010-04-03 23:02:16 +0000
@@ -2,15 +2,14 @@
 '''Video Library - Interface for Entertainer video library cache'''
 
 import os
+
 from pysqlite2 import dbapi2 as sqlite
 
 from entertainerlib.client.medialibrary.playable import Playable
 from entertainerlib.configuration import Configuration
-from entertainerlib.logger import Logger
-
-
-class VideoLibrary:
-    """Interface for Entertainer's video cache."""
+
+class VideoLibrary(object):
+    '''Interface for Entertainer's video cache.'''
 
     def __init__(self):
         self.config = Configuration()
@@ -18,778 +17,291 @@
         if not os.path.exists(self.config.VIDEO_DB):
             raise Exception("Video database doesn't exist!")
 
+        self.connection = sqlite.connect(self.config.VIDEO_DB)
+        self.cursor = self.connection.cursor()
+
+    def __del__(self):
+        '''Close the db connection when this object is deleted.'''
+        self.connection.close()
+
     def get_movies(self):
-        """
-        Get all movies
-        @return: List of Movie objects
-        """
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT videofile.filename
+        '''Get all the movies.'''
+        self.cursor.execute("""SELECT videofile.filename
                           FROM   videofile, metadata
                           WHERE  type='MOVIE'
                           AND    videofile.filename=metadata.filename
                           ORDER BY title""")
         movies = []
-        for row in cursor:
-            movies.append(Movie(row[0]))
-        connection.close()
+        for row in self.cursor.fetchall():
+            movies.append(self._create_movie(row[0]))
         return movies
 
+    def _create_movie(self, filename):
+        '''Factory method to create a movie.'''
+        self.cursor.execute(
+            """SELECT metadata.filename, hash, length, resolution,
+                                 title, runtime, genres, rating, year,
+                                 plot_outline, plot, actor_1, actor_2,
+                                 actor_3, actor_4, actor_5, writer_1,
+                                 writer_2, director_1, director_2
+                          FROM   videofile, metadata
+                          WHERE  metadata.filename=:fn
+                          AND    videofile.filename=metadata.filename
+                          ORDER BY title""", { "fn" : filename })
+        result = self.cursor.fetchall()
+        db_movie = result[0]
+
+        movie = Movie()
+        movie.filename = db_movie[0]
+        movie.art_hash = db_movie[1]
+        movie.title = db_movie[4]
+        movie.runtime = db_movie[5]
+        movie.genres = db_movie[6].split(',')
+        movie.plot = db_movie[10]
+        movie.rating = db_movie[7]
+        movie.short_plot = db_movie[9]
+        movie.year = db_movie[8]
+
+        for i in range(11, 16):
+            if len(db_movie[i]) > 0:
+                movie.actors.append(db_movie[i])
+
+        for i in [16, 17]:
+            if len(db_movie[i]) > 0:
+                movie.writers.append(db_movie[i])
+
+        for i in [18, 19]:
+            if len(db_movie[i]) > 0:
+                movie.directors.append(db_movie[i])
+
+        return movie
+
     def get_tv_series(self):
-        """
-        Get all TV-series.
-        @return: List of TV-series titles (strings)
-        """
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT DISTINCT series_title
+        '''Get all the TV series.'''
+        self.cursor.execute("""SELECT DISTINCT series_title
                           FROM   metadata
                           WHERE  type='TV-SERIES'
                           ORDER BY title""")
         series = []
-        for row in cursor:
-            series.append(TVSeries(row[0]))
-        connection.close()
+        for row in self.cursor.fetchall():
+            series.append(self._create_tv_series(row[0]))
         return series
 
+    def _create_tv_series(self, title):
+        '''Factory method to create a TV series.'''
+        tv_series = TVSeries(title)
+
+        self.cursor.execute(
+            "SELECT DISTINCT season FROM metadata WHERE series_title=:title",
+            { "title" : title })
+        for row in self.cursor.fetchall():
+            tv_series.seasons.append(row[0])
+
+        self.cursor.execute(
+            "SELECT COUNT(filename) FROM metadata WHERE series_title=:title",
+            { "title" : title })
+        result = self.cursor.fetchall()
+        tv_series.number_of_episodes = result[0][0]
+
+        return tv_series
+
     def get_video_clips(self):
-        """
-        Get List of videos that or not movies or tv-series episodes.
-        @return: List of VideoClip objects
-        """
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT filename
+        '''Get all the video clips.'''
+        self.cursor.execute("""SELECT filename
                           FROM   metadata
                           WHERE  type='CLIP'
                           ORDER BY title""")
         clips = []
-        for row in cursor:
-            clips.append(VideoClip(row[0]))
-        connection.close()
+        for row in self.cursor.fetchall():
+            clips.append(self._create_video_clip(row[0]))
         return clips
 
+    def _create_video_clip(self, filename):
+        '''Factory method to create a video clip.'''
+        self.cursor.execute(
+            """SELECT videofile.filename, hash, title
+                          FROM   videofile, metadata
+                          WHERE  videofile.filename=:fn
+                          AND    videofile.filename=metadata.filename
+                          ORDER BY title""", { "fn" : filename })
+        result = self.cursor.fetchall()
+
+        video_item = VideoItem()
+        video_item.filename = result[0][0]
+        video_item.art_hash = result[0][1]
+        video_item.title = result[0][2]
+        return video_item
+
     def get_number_of_movies(self):
-        """
-        Get number of movies in the video library
-        @return: Integer
-        """
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT COUNT(filename)
-                          FROM   metadata
-                          WHERE  type='MOVIE'""")
-        result = cursor.fetchall()
-        connection.close()
+        '''Get the number of movies.'''
+        self.cursor.execute(
+            """SELECT COUNT(filename) FROM metadata WHERE type='MOVIE'""")
+        result = self.cursor.fetchall()
         return result[0][0]
 
     def get_number_of_tv_series(self):
-        """
-        Get number of TV-series in the video library
-        @return: Integer
-        """
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT DISTINCT COUNT(series_title)
+        '''Get the number of TV series.'''
+        self.cursor.execute("""SELECT DISTINCT COUNT(series_title)
                           FROM   metadata
                           WHERE  type='TV-SERIES'""")
-        result = cursor.fetchall()
-        connection.close()
+        result = self.cursor.fetchall()
         return result[0][0]
 
     def get_number_of_video_clips(self):
-        """
-        Get number of misc. VideoClips in the video library
-        @return: Integer
-        """
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT COUNT(filename)
+        '''Get the number of video clips.'''
+        self.cursor.execute(
+            """SELECT COUNT(filename) FROM metadata WHERE type='CLIP'""")
+        result = self.cursor.fetchall()
+        return result[0][0]
+
+    def get_episodes_from_season(self, series_title, season_number):
+        '''Get TV episodes from the series' season.'''
+        self.cursor.execute("""SELECT filename
                           FROM   metadata
-                          WHERE  type='CLIP'""")
-        result = cursor.fetchall()
-        connection.close()
-        return result[0][0]
+                          WHERE  series_title=:title
+                          AND    season=:season
+                          ORDER BY episode""",
+                          { "title" : series_title, "season" : season_number })
+        episodes = []
+        for row in self.cursor.fetchall():
+            episodes.append(self._create_tv_episode(row[0]))
+        return episodes
+
+    def _create_tv_episode(self, filename):
+        '''Factory method to create a TV episode.'''
+        self.cursor.execute(
+            """SELECT videofile.filename, hash, title, plot, episode
+                          FROM   videofile, metadata
+                          WHERE  videofile.filename=:fn
+                          AND    videofile.filename=metadata.filename
+                          ORDER BY title""", { "fn" : filename })
+        result = self.cursor.fetchall()
+        db_episode = result[0]
+
+        tv_episode = TVEpisode()
+        tv_episode.filename = db_episode[0]
+        tv_episode.art_hash = db_episode[1]
+        tv_episode.title = db_episode[2]
+        tv_episode.plot = db_episode[3]
+        tv_episode.number = db_episode[4]
+
+        return tv_episode
 
 
 class VideoItem(Playable):
-    """
-    Objects from this class represents video items
-    """
+    '''Representation of a playable video item.'''
 
     def __init__(self):
-        """Initialize the VideoItem object"""
+        # XXX: laymansterms - VideoItem should really have a few mandatory
+        # parameters. title, filename, maybe more.
         Playable.__init__(self)
         self.config = Configuration()
 
-        #Setting default values
-        self.logger = Logger().getLogger(
-            'client.medialibrary.videos.VideoItem')
-        self.__title = ""
-        self.__filename = ""
-        self.__length = 0
-        self.__resolution = ""
-        self.__art_hash = ""
-
-    def get_cover_art_url(self):
-        """
-        Get absolute filename of the cover art image file.
-        @return: String
-        """
-        return os.path.join(self.config.MOVIE_ART_DIR,
-            self.get_title() + ".jpg")
-
-    def get_filename(self):
-        """
-        Get filename (abs path) of the VideoItem
-        @return: String
-        """
-        return self.__filename
-
-    def set_filename(self, filename):
-        """
-        Sets the filename of the VideoItem
-        @param filename String
-        """
-        self.__filename = filename
-
-    def get_title(self):
-        """
-        Get title of the VideoItem
-        @return: String
-        """
-        if (self.__title == "") or (self.__title == None):
-            return self.get_filename()
-        else:
-            return self.__title
-
-    def set_title(self, title):
-        """
-        Sets the title of the VideoItem
-        @param title String
-        """
-        self.__title = title
-
-    def get_length(self):
-        """
-        Get length of the VideoItem
-        @return: Integer
-        """
-        return self.__length
-
-    def set_length(self, length):
-        """
-        Sets the length of the VideoItem
-        @param length Integer
-        """
-        self.__length = length
-
-    def get_resolution(self):
-        """
-        Get resolution of the VideoItem
-        @return: String
-        """
-        return self.__resolution
-
-    def set_resolution(self, res):
-        """
-        Sets the resolution of the VideoItem
-        @param res String
-        """
-        self.__resolution = res
-
-    def get_thumbnail_url(self):
-        """
-        Get absolute path of the thumbnail image file.
-        @return: String
-        """
-        if self.get_art_hash() is not None:
-            thumb = os.path.join(self.config.VIDEO_THUMB_DIR,
-                self.get_art_hash() + ".jpg")
-            if os.path.exists(thumb):
-                return thumb
-            else:
-                self.logger.error("Thumbnail does not exist for " + \
-                    self.get_filename() + ", using default art instead")
-                return os.path.join(self.config.theme_path,
-                    "images/default_movie_art.png")
-        else:
-            self.logger.error("Thumbnail does not exist for " + \
-                self.get_filename() + ", using default art instead")
-            return os.path.join(self.config.theme_path,
-                "images/default_movie_art.png")
+        self._title = ""
+        self.filename = ""
+        self.art_hash = ""
+
+    def _get_title(self):
+        '''Get the title.'''
+        if (self._title == "") or (self._title == None):
+            return self.filename
+        else:
+            return self._title
+
+    def _set_title(self, title):
+        '''Set the title.'''
+        self._title = title
+
+    title = property(_get_title, _set_title)
 
     def has_thumbnail(self):
-        """
-        Is there a thumbnail for this VideoItem
-        @return Boolean
-        """
+        '''Test if there is a thumbnail.'''
         thumb_path = os.path.join(self.config.VIDEO_THUMB_DIR,
-            self.get_art_hash() + ".jpg")
+            self.art_hash + ".jpg")
         return os.path.exists(thumb_path)
 
-    def get_art_hash(self):
-        """
-        Gets the art hash
-        @return String
-        """
-        return self.__art_hash
-
-    def set_art_hash(self, arthash):
-        """
-        Sets the art hash
-        @param arthash String
-        """
-        self.__art_hash = arthash
-
-    def has_cover_art(self):
-        """
-        Is there cover art file for this VideoItem
-        @return: Boolean
-        """
-        art_path =  os.path.join(self.config.MOVIE_ART_DIR,
-            self.get_title() + ".jpg")
-        return os.path.exists(art_path)
+    @property
+    def thumbnail_url(self):
+        '''Get the path to the thumbnail or a default.'''
+        thumb = os.path.join(self.config.VIDEO_THUMB_DIR,
+            self.art_hash + ".jpg")
+        if os.path.exists(thumb):
+            return thumb
+        else:
+            return os.path.join(self.config.theme_path,
+                "images/default_movie_art.png")
 
     # Implement playable interface
+    def get_title(self):
+        '''Get the title.'''
+        return self.title
+
     def get_type(self):
-        """
-        Track is an video stream.
-        @return: Integer
-        """
+        '''Get the type.'''
         return Playable.VIDEO_STREAM
 
     def get_uri(self):
-        """
-        Get URI of the video file
-        @return: String
-        """
-        return "file://" + self.get_filename()
+        '''Get the URI.'''
+        return "file://" + self.filename
 
 
 class VideoFilm(VideoItem):
-    '''Objects from this class represents video films'''
+    '''Generic representation of a film.'''
+
     def __init__(self):
         VideoItem.__init__(self)
-        #initialise values
-        self.__plot_outline = ""
-        self.__plot = ""
-        self.__actors = []
-        self.__writers = []
-        self.__directors = []
-        self.__runtime = ""
-        self.__genres = []
-        self.__rating = 0.0
-        self.__year = 2000
-
-    def get_short_plot(self):
-        """
-        Get plot outline text.
-        @return: String
-        """
-        return self.__plot_outline
-
-    def set_short_plot(self, plot):
-        """
-        Set plot outline
-        @param plot String
-        """
-        self.__plot_outline = plot
-
-    def get_plot(self):
-        """
-        Get long plot text.
-        @return: String
-        """
-        return self.__plot
-
-    def set_plot(self, plot):
-        """
-        Sets the long plot
-        @param plot String
-        """
-        self.__plot = plot
-
-    def get_actors(self):
-        """
-        Get list of actors
-        @return: List of strings
-        """
-        return self.__actors
-
-    def set_actors(self, actors):
-        """
-        Sets list of actors
-        @param actors List of Strings
-        """
-        self.__actors = actors
-
-    def get_writers(self):
-        """
-        Get list of writers
-        @return: List of strings
-        """
-        return self.__writers
-
-    def set_writers(self, writers):
-        """
-        Sets list of writers
-        @param writers List of Strings
-        """
-        self.__writers = writers
-
-    def get_directors(self):
-        """
-        Get list of directors
-        @return: List of strings
-        """
-        return self.__directors
-
-    def set_directors(self, directors):
-        """
-        Sets list of directors
-        @param directors List of Strings
-        """
-        self.__directors = directors
-
-    def get_runtime(self):
-        """
-        Get runtime of the VideoFilm
-        @return: String
-        """
-        return self.__runtime
-
-    def set_runtime(self, run):
-        """
-        Set runtime of the VideoFilm
-        @param run String
-        """
-        self.__runtime = run
-
-    def get_genres(self):
-        """
-        Get list of genre strings
-        @return: List of strings
-        """
-        return self.__genres
-
-    def set_genres(self, genres):
-        """
-        Sets list of genres
-        @param genres List of Strings
-        """
-        self.__genres = genres
-
-    def get_rating(self):
-        """
-        Get rating of the VideoFilm (1-5)
-        @return: Integer
-        """
-        return int(self.__rating)
-
-    def set_rating(self, rating):
-        """
-        Sets rating of the VideoFilm (1-5)
-        @param rating Integer
-        """
-        self.__rating = int(rating)
-
-    def get_year(self):
-        """
-        Get release year of the VideoFilm.
-        @return: String
-        """
-        return int(self.__year)
-
-    def set_year(self, year):
-        """
-        Sets the year of the VideoFilm
-        @param year String
-        """
-        try:
-            self.__year = int(year)
-        except ValueError:
-            self.__year = 0
-            print "Year for Video should be an integer, not: ", year
-
-
-class VideoClip(VideoItem):
-    """
-    Objects from this class represents video files.
-    """
-
-    def __init__(self, filename):
-        """
-        Initialize Clip information
-        @param filename: Absolute path of the video clip file
-        """
-        VideoItem.__init__(self)
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute(
-            """SELECT videofile.filename, hash, length, resolution, title
-                          FROM   videofile, metadata
-                          WHERE  videofile.filename=:fn
-                          AND    videofile.filename=metadata.filename
-                          ORDER BY title""", { "fn" : filename })
-        result = cursor.fetchall()
-        self.set_filename(result[0][0])    # Filename of the clip
-        self.set_art_hash(result[0][1])   # Cover art hash
-        self.set_length(result[0][2])      # Lenght of the movie
-        self.set_resolution(result[0][3])  # Video resolution
-        self.set_title(result[0][4])       # Clip title
-        connection.close()
+        self.actors = []
+        self.directors = []
+        self.genres = []
+        self.plot = ''
+        self.runtime = ''
+        self.short_plot = ''
+        self.writers = []
+        self.rating = 0
+        self.year = 2000
 
 
 class Movie(VideoFilm):
-    """
-    Objects from this class represents movie.
-    """
-
-
-    def __init__(self, filename):
-        """
-        Initialize Movie information
-        @param filename: Absolute path of the Movie file
-        """
-        VideoFilm.__init__(self)
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT metadata.filename, hash, length, resolution,
-                                 title, runtime, genres, rating, year,
-                                 plot_outline, plot, actor_1, actor_2,
-                                 actor_3, actor_4, actor_5, writer_1,
-                                 writer_2, director_1, director_2
-                          FROM   videofile, metadata
-                          WHERE  metadata.filename=:fn
-                          AND    videofile.filename=metadata.filename
-                          ORDER BY title""", { "fn" : filename })
-        result = cursor.fetchall()
-        self.set_filename(result[0][0])
-        self.set_art_hash(result[0][1])
-        self.set_length(result[0][2])
-        self.set_resolution(result[0][3])
-        self.set_title(result[0][4])
-        self.set_runtime(result[0][5])
-        self.set_genres(result[0][6].split(','))
-        self.set_rating(result[0][7])
-        self.set_year(result[0][8])
-        self.set_short_plot(result[0][9])
-        self.set_plot(result[0][10])
-        self.set_actors([])
-        self.set_art_hash([])
-        self.set_directors([])
-
-        # Actors
-        if len(result[0][11]) > 0:
-            self.get_actors().append(result[0][11])
-        if len(result[0][12]) > 0:
-            self.get_actors().append(result[0][12])
-        if len(result[0][13]) > 0:
-            self.get_actors().append(result[0][13])
-        if len(result[0][14]) > 0:
-            self.get_actors().append(result[0][14])
-        if len(result[0][15]) > 0:
-            self.get_actors().append(result[0][15])
-
-        # Writers
-        if len(result[0][16]) > 0:
-            self.get_writers().append(result[0][16])
-        if len(result[0][17]) > 0:
-            self.get_writers().append(result[0][17])
-
-        # Directors
-        if len(result[0][18]) > 0:
-            self.get_directors().append(result[0][18])
-        if len(result[0][19]) > 0:
-            self.get_directors().append(result[0][19])
-
-        connection.close()
+    '''Representation of a movie.'''
+
+    def has_cover_art(self):
+        '''Test if there is cover art in the cache.'''
+        art_path =  os.path.join(self.config.MOVIE_ART_DIR, self.title + ".jpg")
+        return os.path.exists(art_path)
+
+    @property
+    def cover_art_url(self):
+        '''Get the URL to the cover art.'''
+        return os.path.join(self.config.MOVIE_ART_DIR, self.title + ".jpg")
 
 
 class TVSeries(object):
-    """
-    TV Series
-
-    TV Series contains TVEpisodes organized by seasons.
-    """
+    '''TV Series contains TVEpisodes organized by seasons.'''
 
     def __init__(self, title):
-        """
-        Initialize TV-Series
-        @param title: Series title
-        """
         self.config = Configuration()
 
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT DISTINCT series_title
-                          FROM   metadata
-                          WHERE  series_title=:title""", { "title" : title })
-        result = cursor.fetchall()
-        self.__title = None
-        if len(result) == 0:
-            raise Exception("No such TV-series as " + title)
-        else:
-            self.__title = title
-        connection.close()
-
-    def get_title(self):
-        """
-        Get title of the series
-        @return: String
-        """
-        return self.__title
-
-    def set_title(self, title):
-        """
-        Sets title of the series
-        @param title String
-        """
-        self.__title = title
+        self.number_of_episodes = 0
+        # Season list of numbers. For example [1,2,3,5] in case that user
+        # doesn't have episodes from season 4.
+        self.seasons = []
+        self.title = title
 
     def has_cover_art(self):
-        """
-        Is there cover art file for this TV-serie
-        @return: String
-        """
-        art_path =  os.path.join(self.config.MOVIE_ART_DIR,
-            self.get_title() + ".jpg")
+        '''Test if there is cover art in the cache.'''
+        art_path =  os.path.join(self.config.MOVIE_ART_DIR, self.title + ".jpg")
         return os.path.exists(art_path)
 
-    def get_cover_art_url(self):
-        """
-        Get absolute filename of the cover art image file.
-        @return: String
-        """
-        return os.path.join(self.config.MOVIE_ART_DIR,
-            self.get_title() + ".jpg")
-
-    def get_seasons(self):
-        """
-        Return list of numbers. For example [1,2,3,5] in case that user
-        doesn't have episodes from season 4.
-        @return: List of Integers
-        """
-        seasons = []
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT DISTINCT season
-                          FROM   metadata
-                          WHERE  series_title=:title""",
-                          { "title" : self.get_title() })
-        for row in cursor:
-            seasons.append(row[0])
-        connection.close()
-        return seasons
-
-    def get_number_of_episodes(self):
-        """
-        Get number of episodes available on this series
-        @return: Integer
-        """
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT COUNT(filename)
-                          FROM   metadata
-                          WHERE  series_title=:title""",
-                          { "title" : self.get_title() })
-        result = cursor.fetchall()
-        connection.close()
-        return result[0][0]
-
-    def get_number_of_seasons(self):
-        """
-        Get number of seasons available on this series
-        @return: Integer
-        """
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT COUNT(DISTINCT season)
-                          FROM   metadata
-                          WHERE  series_title=:title""",
-                          { "title" : self.get_title() })
-        result = cursor.fetchall()
-        connection.close()
-        return result[0][0]
-
-    def get_episodes_from_season(self, season):
-        """
-        Get all episodes of the season.
-        @param season: Season number (Integer)
-        """
-        episodes = []
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT filename, episode
-                          FROM   metadata
-                          WHERE  series_title=:title
-                          AND    season=:season
-                          ORDER BY episode""",
-                          { "title" : self.get_title(), "season" : season })
-        for row in cursor:
-            episodes.append(TVEpisode(row[0], self))
-        connection.close()
-        return episodes
-
-    def get_episode_from_season(self, season, episode):
-        """
-        Get specific episode from this series.
-        @param season: Season number (Integer)
-        @param episode: Episode number (Integer)
-        @return TVEpisode object
-        """
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT filename
-                          FROM   metadata
-                          WHERE  series_title=:title
-                          AND    episode=:episode
-                          AND    season=:season""",
-                          { "title" : self.get_title(),
-                            "season" : season,
-                            "episode" : episode })
-        result = cursor.fetchall()
-        episode = TVEpisode(result[0][0], self)
-        connection.close()
-        return episode
-
-    def get_episodes(self):
-        """
-        Get all episodes of this series.
-        @return: List of TVEpisode objects
-        """
-        episodes = []
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT filename, season, episode
-                          FROM   metadata
-                          WHERE  series_title=:title
-                          ORDER BY season, episode""",
-                          { "title" : self.get_title() })
-        for row in cursor:
-            episodes.append(TVEpisode(row[0], self))
-        connection.close()
-        return episodes
+    @property
+    def cover_art_url(self):
+        '''Get the URL to the cover art.'''
+        return os.path.join(self.config.MOVIE_ART_DIR, self.title + ".jpg")
 
 
 class TVEpisode(VideoFilm):
-    """
-    Objects from this class represents TV-Episode video file.
-    """
+    '''Representation of a TV show episode.'''
 
-    def __init__(self, filename, series):
-        """
-        Initialize episode information.
-        @param filename: Name of the video file
-        @param series: TVSeries object
-        """
+    def __init__(self):
         VideoFilm.__init__(self)
-        connection = sqlite.connect(self.config.VIDEO_DB)
-        cursor = connection.cursor()
-        cursor.execute("""SELECT videofile.filename, hash, length, resolution,
-                                 title, runtime, genres, rating, year,
-                                 plot_outline, plot, actor_1, actor_2,
-                                 actor_3, actor_4, actor_5, writer_1,
-                                 writer_2, director_1, director_2,
-                                 series_title, season, episode
-                          FROM   videofile, metadata
-                          WHERE  videofile.filename=:fn
-                          AND    videofile.filename=metadata.filename
-                          ORDER BY title""", { "fn" : filename })
-        result = cursor.fetchall()
-        self.set_filename(result[0][0])
-        self.set_art_hash(result[0][1])
-        self.set_length(result[0][2])
-        self.set_resolution(result[0][3])
-        self.set_title(result[0][4])
-        self.set_runtime(result[0][5])
-        self.set_genres(result[0][6].split(','))
-        self.set_rating(result[0][7])
-        self.set_year(result[0][8])
-        self.set_short_plot(result[0][9])
-        self.set_plot(result[0][10])
-
-        # Actors
-        self.set_actors([])
-        if len(result[0][11]) > 0:
-            self.get_actors().append(result[0][11])
-        if len(result[0][12]) > 0:
-            self.get_actors().append(result[0][12])
-        if len(result[0][13]) > 0:
-            self.get_actors().append(result[0][13])
-        if len(result[0][14]) > 0:
-            self.get_actors().append(result[0][14])
-        if len(result[0][15]) > 0:
-            self.get_actors().append(result[0][15])
-
-        # Writers
-        self.set_writers([])
-        if len(result[0][16]) > 0:
-            self.get_writers().append(result[0][16])
-        if len(result[0][17]) > 0:
-            self.get_writers().append(result[0][17])
-
-        # Directors
-        self.set_directors([])
-        if len(result[0][18]) > 0:
-            self.get_directors().append(result[0][18])
-        if len(result[0][19]) > 0:
-            self.get_directors().append(result[0][19])
-
-        self.__series = series
-        self.__season = result[0][21]
-        self.__episode_number = result[0][22]
-        connection.close()
-
-    def get_cover_art_url(self):
-        """
-        Get absolute filename of the cover art image file.
-        @return: String
-        """
-        return os.path.join(self.config.MOVIE_ART_DIR,
-            self.get_series() + ".jpg")
-
-    def get_series(self):
-        """
-        Get TV-series
-        @return: TVSeries objects
-        """
-        return self.__series
-
-    def set_series(self, series):
-        """
-        Sets TV-Series
-        @param series TVSeries
-        """
-        self.__series = series
-
-    def get_episode_number(self):
-        """
-        Get number of the episode
-        @return: Integer
-        """
-        return int(self.__episode_number)
-
-    def set_episode_number(self, num):
-        """
-        Sets the number of the episode
-        @param num Integer
-        """
-        self.__episode_number = int(num)
-
-    def get_season(self):
-        """
-        Get number of the season
-        @return: Interger
-        """
-        return int(self.__season)
-
-    def set_season(self, season):
-        """
-        Sets number of the season
-        @param season Integer
-        """
-        self.__season = int(season)
+        self.number = 0
 

=== modified file 'entertainerlib/gui/screens/factory.py'
--- entertainerlib/gui/screens/factory.py	2010-04-02 22:28:04 +0000
+++ entertainerlib/gui/screens/factory.py	2010-04-03 23:02:16 +0000
@@ -135,6 +135,7 @@
     def _generate_tv_series(self, kwargs):
         '''Generate a TvSeries screen.'''
         kwargs['move_to_new_screen_callback'] = self.move_to_new_screen_callback
+        kwargs['video_library'] = self.video_library
         return TvSeries(**kwargs)
 
     def _generate_tv_episodes(self, kwargs):

=== modified file 'entertainerlib/gui/screens/movie.py'
--- entertainerlib/gui/screens/movie.py	2009-12-22 00:07:29 +0000
+++ entertainerlib/gui/screens/movie.py	2010-04-03 23:02:16 +0000
@@ -45,8 +45,7 @@
 
         # Movie art texture
         if self.movie.has_cover_art():
-            pixbuf = gtk.gdk.pixbuf_new_from_file(
-                self.movie.get_cover_art_url())
+            pixbuf = gtk.gdk.pixbuf_new_from_file(self.movie.cover_art_url)
         else:
             pixbuf = gtk.gdk.pixbuf_new_from_file(
                 self.theme.getImage("default_movie_art"))
@@ -54,21 +53,21 @@
         self.add(movie_art)
 
         # Movie title
-        title = Label(0.04, "title", 0.47, 0.1, self.movie.get_title(),
+        title = Label(0.04, "title", 0.47, 0.1, self.movie.title,
             font_weight="bold")
         title.set_ellipsize(pango.ELLIPSIZE_END)
         title.set_size(0.5124, 0.05208)
         self.add(title)
 
         # Movie release year
-        year_text = _("Released in %(year)s") % {'year': self.movie.get_year()}
+        year_text = _("Released in %(year)s") % {'year': self.movie.year}
         year = Label(0.032, "subtitle", 0.47, 0.3, year_text)
         year.set_ellipsize(pango.ELLIPSIZE_END)
         year.set_size(0.5124, 0.05208)
         self.add(year)
 
         # Show only 2 genres (or one if there is only one)
-        genres_list = self.movie.get_genres()
+        genres_list = self.movie.genres
         if len(genres_list) == 0:
             genres_text = _("Unknown")
         else:
@@ -76,7 +75,7 @@
 
         # Runtime and genres
         info_text = _("%(runtime)s min, %(genre)s") % \
-            {'runtime': self.movie.get_runtime(), 'genre': genres_text}
+            {'runtime': self.movie.runtime, 'genre': genres_text}
         info = Label(0.032, "subtitle", 0.47, 0.24, info_text)
         info.set_ellipsize(pango.ELLIPSIZE_END)
         info.set_size(0.5124, 0.05208)
@@ -90,7 +89,7 @@
         star2.hide()
         self.add(star2)
 
-        for i in range(self.movie.get_rating()):
+        for i in range(self.movie.rating):
             tex = clutter.Clone(star)
             tex.set_position(
                 self.get_abs_x(0.47) + (self.get_abs_x(0.0366) * i),
@@ -98,16 +97,16 @@
             tex.set_size(self.get_abs_x(0.024), self.get_abs_y(0.04))
             self.add(tex)
 
-        dark_star = 5 - self.movie.get_rating()
+        dark_star = 5 - self.movie.rating
         for i in range(dark_star):
             tex = clutter.Clone(star2)
             tex.set_position(self.get_abs_x(0.47) + (self.get_abs_x(0.0366) * \
-                (i+ self.movie.get_rating())), self.get_abs_y(0.17))
+                (i + self.movie.rating)), self.get_abs_y(0.17))
             tex.set_size(self.get_abs_x(0.024), self.get_abs_y(0.04))
             self.add(tex)
 
         # Plot
-        plot = Label(0.029, "subtitle", 0, 0, self.movie.get_plot())
+        plot = Label(0.029, "subtitle", 0, 0, self.movie.plot)
         plot.set_justify(True)
         plot.set_line_wrap_mode(pango.WRAP_WORD)
         plot.set_line_wrap(True)
@@ -118,7 +117,7 @@
         # Actors
         self.add(Label(0.032, "title", 0.33, 0.8, _("Starring")))
 
-        actors_list = self.movie.get_actors()
+        actors_list = self.movie.actors
         if len(actors_list) == 0:
             actors_text = _("Unknown")
         else:
@@ -131,7 +130,7 @@
         # Directors
         self.add(Label(0.032, "title", 0.33, 0.86, _("Directed by")))
 
-        directors_list = self.movie.get_directors()
+        directors_list = self.movie.directors
         if len(directors_list) == 0:
             directors_text = _("Unknown")
         else:
@@ -144,7 +143,7 @@
         # Writers
         self.add(Label(0.032, "title", 0.33, 0.92, _("Written by")))
 
-        writers_list = self.movie.get_writers()
+        writers_list = self.movie.writers
         if len(directors_list) == 0:
             writers_text = _("Unknown")
         else:

=== modified file 'entertainerlib/gui/screens/tv_episodes.py'
--- entertainerlib/gui/screens/tv_episodes.py	2009-12-22 00:34:27 +0000
+++ entertainerlib/gui/screens/tv_episodes.py	2010-04-03 23:02:16 +0000
@@ -14,18 +14,17 @@
 class TvEpisodes(Screen):
     '''Screen contains list of all episodes of one specific season.'''
 
-    def __init__(self, media_player, move_to_new_screen_callback,
-        season_number, tv_series):
+    def __init__(self, media_player, move_to_new_screen_callback, episodes,
+        tv_series):
         Screen.__init__(self, 'TvEpisodes', move_to_new_screen_callback)
 
+        self.episodes = episodes
         self.media_player = media_player
         self.theme = self.config.theme
         self.tv_series = tv_series
-        self.season_number = season_number
 
         # Screen Title (Displayed at the bottom left corner)
-        screen_title = Label(0.13, "screentitle", 0, 0.87,
-            self.tv_series.get_title())
+        screen_title = Label(0.13, "screentitle", 0, 0.87, self.tv_series.title)
         self.add(screen_title)
 
         self.scroll_area = None
@@ -37,8 +36,7 @@
 
         #List indicator
         self.li = ListIndicator(0.8, 0.9, 0.2, 0.045, ListIndicator.VERTICAL)
-        self.li.set_maximum(
-            len(self.tv_series.get_episodes_from_season(self.season_number)))
+        self.li.set_maximum(len(self.episodes))
         self.add(self.li)
 
         self.menu.connect("moved", self._update_episode_info)
@@ -49,10 +47,9 @@
         """Create a list of available seasons."""
         menu = TextMenu(0.4978, 0.1563, 0.4393, 0.0781)
 
-        episodes = self.tv_series.get_episodes_from_season(self.season_number)
         episodes_list = [[_("%(num)d. %(title)s") % \
-            {'num': episode.get_episode_number(), 'title': episode.get_title()},
-            None, episode] for episode in episodes]
+            {'num': episode.number, 'title': episode.title},
+            None, episode] for episode in self.episodes]
         menu.async_add(episodes_list)
 
         menu.active = True
@@ -65,7 +62,7 @@
             self.thumb.hide()
 
         # Thumbnail. Use cover art if thumbnail doesn't exist
-        thumbnail = self.menu.selected_userdata.get_thumbnail_url()
+        thumbnail = self.menu.selected_userdata.thumbnail_url
         if(thumbnail is not None):
             pixbuf = gtk.gdk.pixbuf_new_from_file(thumbnail)
             thumb_width = 0.2928
@@ -79,7 +76,7 @@
             thumb_y = 0.15
             if(self.tv_series.has_cover_art()):
                 pixbuf = gtk.gdk.pixbuf_new_from_file(
-                    self.tv_series.get_cover_art_url())
+                    self.tv_series.cover_art_url)
             else:
                 pixbuf = gtk.gdk.pixbuf_new_from_file(
                     self.theme.getImage("default_movie_art"))
@@ -97,16 +94,14 @@
 
         # Title
         self.title = Label(0.04, "title", 0.05, 0.55,
-            self.menu.selected_userdata.get_title(),
-            font_weight="bold")
+            self.menu.selected_userdata.title, font_weight="bold")
         self.title.set_ellipsize(pango.ELLIPSIZE_END)
         self.title.set_line_wrap(False)
         self.title.width = 0.4
         self.add(self.title)
 
         # Plot
-        plot = Label(0.029, "subtitle", 0, 0,
-            self.menu.selected_userdata.get_plot())
+        plot = Label(0.029, "subtitle", 0, 0, self.menu.selected_userdata.plot)
         plot.width = 0.4
 
         self.scroll_area = ScrollArea(0.05, 0.63, 0.4, 0.15, plot)
@@ -118,11 +113,10 @@
         self.li.set_current(self.menu.selected_index + 1)
 
         self._create_thumbnail_texture()
-        self.title.set_text(self.menu.selected_userdata.get_title())
+        self.title.set_text(self.menu.selected_userdata.title)
         self.title.width = 0.4
 
-        plot = Label(0.029, "subtitle", 0, 0,
-            self.menu.selected_userdata.get_plot())
+        plot = Label(0.029, "subtitle", 0, 0, self.menu.selected_userdata.plot)
         plot.width = 0.4
         self.scroll_area.set_content(plot)
 

=== modified file 'entertainerlib/gui/screens/tv_series.py'
--- entertainerlib/gui/screens/tv_series.py	2009-07-29 03:09:34 +0000
+++ entertainerlib/gui/screens/tv_series.py	2010-04-03 23:02:16 +0000
@@ -12,15 +12,15 @@
 class TvSeries(Screen):
     '''Screen that contains all seasons of one TV series.'''
 
-    def __init__(self, move_to_new_screen_callback, tv_series):
+    def __init__(self, video_library, move_to_new_screen_callback, tv_series):
         Screen.__init__(self, 'TvSeries', move_to_new_screen_callback)
 
         self.theme = self.config.theme
         self.tv_series = tv_series
+        self.video_library = video_library
 
         # Screen Title (Displayed at the bottom left corner)
-        screen_title = Label(0.13, "screentitle", 0, 0.87,
-            self.tv_series.get_title())
+        screen_title = Label(0.13, "screentitle", 0, 0.87, self.tv_series.title)
         self.add(screen_title)
 
         self.art = None
@@ -31,7 +31,7 @@
 
         #List indicator
         self.li = ListIndicator(0.8, 0.9, 0.2, 0.045, ListIndicator.VERTICAL)
-        self.li.set_maximum(len(self.tv_series.get_seasons()))
+        self.li.set_maximum(len(self.tv_series.seasons))
         self.add(self.li)
 
         self.menu.connect("moved", self._update_season_info)
@@ -43,7 +43,7 @@
         """
         menu = TextMenu(0.4978, 0.1563, 0.4393, 0.0781)
 
-        seasons = self.tv_series.get_seasons()
+        seasons = self.tv_series.seasons
         seasons.sort()
 
         seasons_list = [[_("Season %(num)s") % {'num': season}, None, season] \
@@ -60,8 +60,7 @@
         displays album cover art.
         """
         if(self.tv_series.has_cover_art()):
-            pixbuf = gtk.gdk.pixbuf_new_from_file(
-                self.tv_series.get_cover_art_url())
+            pixbuf = gtk.gdk.pixbuf_new_from_file(self.tv_series.cover_art_url)
         else:
             pixbuf = gtk.gdk.pixbuf_new_from_file(
                 self.theme.getImage("default_movie_art"))
@@ -83,6 +82,8 @@
     def _handle_select(self, event=None):
         '''Handle UserEvent.NAVIGATE_SELECT.'''
         season = self.menu.selected_userdata
-        kwargs = { 'tv_series' : self.tv_series, 'season_number' : season }
+        episodes = self.video_library.get_episodes_from_season(
+            self.tv_series.title, season)
+        kwargs = { 'episodes' : episodes, 'tv_series' : self.tv_series }
         self.callback("tv_episodes", kwargs)
 

=== modified file 'entertainerlib/gui/tabs/movies_tab.py'
--- entertainerlib/gui/tabs/movies_tab.py	2009-12-21 17:22:33 +0000
+++ entertainerlib/gui/tabs/movies_tab.py	2010-04-03 23:02:16 +0000
@@ -80,7 +80,7 @@
         menu.visible_cols = 7
 
         movies = self.video_library.get_movies()
-        movies_list = [[movie.get_cover_art_url(), movie] for movie in movies]
+        movies_list = [[movie.cover_art_url, movie] for movie in movies]
         menu.async_add_videos(movies_list)
 
         # Create list indicator
@@ -114,17 +114,17 @@
         '''Update the movie information labels.'''
         if self.active:
             movie = self.menu.selected_userdata
-            genres = movie.get_genres()
+            genres = movie.genres
             if len(genres) > 1:
                 genre = genres[0] + "/" + genres[1]
             else:
                 genre = genres[0]
 
-            self.movie_title.set_text(_("%(title)s (%(year)d)") % \
-                {'title': movie.get_title(), 'year': movie.get_year()})
+            self.movie_title.set_text(_("%(title)s (%(year)s)") % \
+                {'title': movie.title, 'year': movie.year})
             self.movie_info.set_text(_("%(min)d min, (%(genre)s)") % \
-                {'min': movie.get_runtime(), 'genre': genre})
-            self.movie_plot.set_text(movie.get_short_plot())
+                {'min': movie.runtime, 'genre': genre})
+            self.movie_plot.set_text(movie.short_plot)
             self.list_indicator.show()
             self.list_indicator.set_current(self.menu.selected_index + 1)
         else:

=== modified file 'entertainerlib/gui/tabs/series_tab.py'
--- entertainerlib/gui/tabs/series_tab.py	2009-12-21 17:22:33 +0000
+++ entertainerlib/gui/tabs/series_tab.py	2010-04-03 23:02:16 +0000
@@ -79,7 +79,7 @@
         menu.visible_cols = 7
 
         series = self.video_library.get_tv_series()
-        series_list = [[serie.get_cover_art_url(), serie] for serie in series]
+        series_list = [[serie.cover_art_url, serie] for serie in series]
         menu.async_add_videos(series_list)
 
         # Create list indicator
@@ -107,11 +107,10 @@
         if self.active:
             series = self.menu.selected_userdata
             info = _("%(season)d Seasons\n%(episode)d Episodes") % {'season':
-                series.get_number_of_seasons(), 'episode':
-                series.get_number_of_episodes()}
+                len(series.seasons), 'episode': series.number_of_episodes}
 
             self.series_info.set_text(info)
-            self.series_title.set_text(series.get_title())
+            self.series_title.set_text(series.title)
             self.list_indicator.show()
             self.list_indicator.set_current(self.menu.selected_index + 1)
         else:

=== modified file 'entertainerlib/gui/tabs/video_clips_tab.py'
--- entertainerlib/gui/tabs/video_clips_tab.py	2009-12-21 17:22:33 +0000
+++ entertainerlib/gui/tabs/video_clips_tab.py	2010-04-03 23:02:16 +0000
@@ -79,7 +79,7 @@
         menu.visible_cols = 4
 
         clips = self.video_library.get_video_clips()
-        clips_list = [[clip.get_thumbnail_url(), clip] for clip in clips]
+        clips_list = [[clip.thumbnail_url, clip] for clip in clips]
         menu.async_add_clips(clips_list)
 
         # Create list indicator
@@ -109,7 +109,7 @@
         '''Update the VideoClip information labels.'''
         if self.active:
             clip = self.menu.selected_userdata
-            (folder, filename) = os.path.split(clip.get_filename())
+            (folder, filename) = os.path.split(clip.filename)
             self.clip_title.set_text(filename)
             self.clip_info.set_text(folder)
             self.list_indicator.show()

=== modified file 'entertainerlib/tests/mock.py'
--- entertainerlib/tests/mock.py	2010-04-02 23:13:48 +0000
+++ entertainerlib/tests/mock.py	2010-04-03 23:02:16 +0000
@@ -84,43 +84,15 @@
     '''Mock entertainerlib.client.medialibrary.videos.Movie'''
 
     def __init__(self, filename=None):
-        '''Override init to prevent a database connection'''
-
-    def get_actors(self):
-        '''See `Movie.get_actors`.'''
-        return ['Tim Robbins']
-
-    def get_directors(self):
-        '''See `Movie.get_directors`.'''
-        return ['Frank Darabont']
-
-    def get_genres(self):
-        '''See `Movie.get_genres`.'''
-        return ['Drama']
-
-    def get_plot(self):
-        '''See `Movie.get_plot`.'''
-        return 'An innocent man is sent to prison'
-
-    def get_rating(self):
-        '''See `Movie.get_rating`.'''
-        return 5
-
-    def get_runtime(self):
-        '''See `Movie.get_runtime`.'''
-        return ""
-
-    def get_title(self):
-        '''See `Movie.get_title`.'''
-        return 'The Shawshank Redemption'
-
-    def get_writers(self):
-        '''See `Movie.get_writers`.'''
-        return ['Frank Darabont']
-
-    def get_year(self):
-        '''See `Movie.get_year`.'''
-        return 1994
+        self.actors = ['Tim Robbins']
+        self.directors = ['Frank Darabont']
+        self.genres = ['Drama']
+        self.plot = 'An innocent man is sent to prison'
+        self.rating = 5
+        self.runtime = ''
+        self.title = 'The Shawshank Redemption'
+        self.writers = ['Frank Darabont']
+        self.year = 1994
 
     def has_cover_art(self):
         '''See `Movie.has_cover_art`.'''
@@ -158,42 +130,22 @@
 
     def __init__(self, title=None):
         '''Override init to prevent a database connection'''
-
-    def get_episode_number(self):
-        '''See `TVEpisode.get_episode_number`.'''
-        return 1
-
-    def get_plot(self):
-        '''See `TVEpisode.get_plot`.'''
-        return 'Dr. House continues to be a jerk'
-
-    def get_thumbnail_url(self):
-        '''See `TVEpisode.get_thumbnail_url`.'''
+        self.number = 1
+        self.title = 'Something clever'
+        self.plot = 'Dr. House continues to be a jerk'
+
+    @property
+    def thumbnail_url(self):
+        '''Thumbnail URL getter.'''
         return None
 
-    def get_title(self):
-        '''See `TVEpisode.get_title`.'''
-        return 'Something clever'
-
-
 class MockTVSeries(TVSeries):
     '''Mock entertainerlib.client.medialibrary.videos.TVSeries'''
 
     def __init__(self, title=None):
         '''Override init to prevent a database connection'''
-
-    def get_episodes_from_season(self, season_number=1):
-        '''See `TVSeries.get_episodes_from_season`.'''
-        mock_episode = MockTVEpisode()
-        return [mock_episode]
-
-    def get_seasons(self):
-        '''See `TVSeries.get_seasons`.'''
-        return []
-
-    def get_title(self):
-        '''See `TVSeries.get_title`.'''
-        return 'House'
+        self.seasons = []
+        self.title = 'House'
 
     def has_cover_art(self):
         '''See `TVSeries.has_cover_art`.'''
@@ -205,6 +157,9 @@
     def __init__(self):
         '''Override the intial behavior.'''
 
+    def __del__(self):
+        '''Override the delete behavior.'''
+
     def get_number_of_movies(self):
         '''See `VideoLibrary.get_number_of_movies`.'''
         return 0

=== modified file 'entertainerlib/tests/test_mediaplayer.py'
--- entertainerlib/tests/test_mediaplayer.py	2009-07-14 04:56:55 +0000
+++ entertainerlib/tests/test_mediaplayer.py	2010-04-03 23:02:16 +0000
@@ -19,8 +19,7 @@
 
         self.player = MediaPlayer(clutter.Stage(), 100, 100)
         self.video_item = VideoItem()
-        self.video_item.set_filename(
-            THIS_DIR + '/data/VideoThumbnailer/test.avi')
+        self.video_item.filename = THIS_DIR + '/data/VideoThumbnailer/test.avi'
         self.player.set_media(self.video_item)
 
     def test_create(self):

=== modified file 'entertainerlib/tests/test_screenfactory.py'
--- entertainerlib/tests/test_screenfactory.py	2010-04-02 23:13:48 +0000
+++ entertainerlib/tests/test_screenfactory.py	2010-04-03 23:02:16 +0000
@@ -28,6 +28,7 @@
 from entertainerlib.tests.mock import MockMediaPlayer
 from entertainerlib.tests.mock import MockMovie
 from entertainerlib.tests.mock import MockMusicLibrary
+from entertainerlib.tests.mock import MockTVEpisode
 from entertainerlib.tests.mock import MockTVSeries
 from entertainerlib.tests.mock import MockVideoLibrary
 
@@ -129,7 +130,7 @@
 
     def test__generate_tv_episodes(self):
         '''Test _generate_tv_episodes returns a TvEpisodes screen'''
-        self.kwargs['season_number'] = 1
+        self.kwargs['episodes'] = [MockTVEpisode()]
         self.kwargs['tv_series'] = MockTVSeries()
         screen = self.factory._generate_tv_episodes(self.kwargs)
         self.assertTrue(isinstance(screen, TvEpisodes))