Index: python/MythTV/__init__.py
===================================================================
--- python/MythTV/__init__.py	(revision 25163)
+++ python/MythTV/__init__.py	(working copy)
@@ -25,10 +25,11 @@
             \
            'Record', 'Recorded', 'RecordedProgram', 'OldRecorded', 'Job', \
            'Channel', 'Guide', 'Video', 'VideoGrabber', 'InternetContent', \
-           'InternetContentArticles', 'InternetSource', \
+           'InternetContentArticles', 'InternetSource', 'Song', 'Album', \
+           'Artist', 'MusicPlaylist', 'MusicDirectory', \
             \
            'MythBE', 'BEEventMonitor', 'MythSystemEvent', 'SystemEvent', \
-           'Frontend', 'MythDB', 'MythVideo', 'MythXML']
+           'Frontend', 'MythDB', 'MythVideo', 'MythXML', 'MythMusic']
 
 import26 = """
 import warnings
@@ -61,16 +62,3 @@
 __version__ = OWN_VERSION
 static.mysqldb = MySQLdb.__version__
 
-if __name__ == '__main__':
-    banner = 'MythTV Python interactive shell.'
-    import code
-    try:
-        import readline, rlcompleter
-    except:
-        pass
-    else:
-        readline.parse_and_bind("tab: complete")
-        banner += ' TAB completion available.'
-    namespace = globals().copy()
-    namespace.update(locals())
-    code.InteractiveConsole(namespace).interact(banner)
Index: python/MythTV/utility.py
===================================================================
--- python/MythTV/utility.py	(revision 25163)
+++ python/MythTV/utility.py	(working copy)
@@ -42,16 +42,15 @@
 
             log(log.IMPORTANT, 'Updating %s from %s to %s' % \
                         (schemaname, db.settings.NULL[self.schemavar], newver))
-            c = db.cursor()
 
-            try:
-                for sql, values in updates:
-                    c.execute(sql, values)
-            except Exception, e:
-                log(log.IMPORTANT, 'Update of %s failed' % self.schemavar)
-                raise MythDBError(MythError.DB_SCHEMAUPDATE, e.args)
+            with db as c:
+                try:
+                    for sql, values in updates:
+                        c.execute(sql, values)
+                except Exception, e:
+                    log(log.IMPORTANT, 'Update of %s failed' % self.schemavar)
+                    raise MythDBError(MythError.DB_SCHEMAUPDATE, e.args)
 
-            c.close()
             db.settings.NULL[self.schemavar] = newver
 
 class databaseSearch( object ):
@@ -179,16 +178,14 @@
 
         # process query
         query = self.buildQuery(where, joinbit=joinbit)
-        c = self.inst.cursor(self.inst.log)
-        if len(where) > 0:
-            c.execute(query, fields)
-        else:
-            c.execute(query)
+        with self.inst.cursor(self.inst.log) as c:
+            if len(where) > 0:
+                c.execute(query, fields)
+            else:
+                c.execute(query)
 
-        row = c.fetchone()
-        while row is not None:
-            yield self.dbclass.fromRaw(row, self.inst)
-            row = c.fetchone()
+            for row in c:
+                yield self.dbclass.fromRaw(row, self.inst)
 
     def buildJoinOn(self, i):
         if len(self.joins[i]) == 3:
Index: python/MythTV/database.py
===================================================================
--- python/MythTV/database.py	(revision 25163)
+++ python/MythTV/database.py	(working copy)
@@ -55,36 +55,51 @@
     _schema_name = 'Database'
     _localvars = ['_field_order']
 
+    _table = None
+    _where = None
+    _key = None
+    _wheredat = None
+    _setwheredat = None
+
     @classmethod
     def getAllEntries(cls, db=None):
         """cls.getAllEntries() -> tuple of DBData objects"""
+        return cls._fromQuery("", ())
+
+    @classmethod
+    def _fromQuery(cls, where, args, db=None):
         db = DBCache(db)
+        with db as c:
+            c.execute("""SELECT * FROM %s %s""" \
+                        % (cls._table, where), args)
+            for row in c:
+                yield cls.fromRaw(row, db)
 
-        c = db.cursor()
-        count = c.execute("""SELECT * FROM %s""" % cls._table)
-        for i in xrange(count):
-            res = c.fetchone()
-            yield cls.fromRaw(res, db)
-        c.close()
-
     @classmethod
     def fromRaw(cls, raw, db=None):
         dbdata = cls(None, db=db)
         DictData.__init__(dbdata, raw)
         dbdata._evalwheredat()
-        dbdata._postinit()
         return dbdata
 
-    def _postinit(self): pass
+    def _evalwheredat(self, wheredat=None):
+        if self._where is None:
+            if self._key is None:
+                raise MythError('Invalid DBData subclass')
+            self._where = ' AND '.join(['%s=%%s' % key for key in self._key])
+        if self._setwheredat is None:
+            if self._key is None:
+                raise MythError('Invalid DBData subclass')
+            self._setwheredat = ''.join(['self.%s,' % key for key in self._key])
+        if wheredat is None:
+            self._wheredat = eval(self._setwheredat)
+        else:
+            self._wheredat = tuple(wheredat)
 
-    def _evalwheredat(self):
-        self._wheredat = eval(self._setwheredat)
-
     def _setDefs(self):
         self._field_order = self._db.tablefields[self._table]
         self._log = MythLog(self._logmodule)
         self._fillNone()
-        self._wheredat = None
 
     def __init__(self, data, db=None):
         dict.__init__(self)
@@ -97,21 +112,19 @@
         if data is None: pass
         elif None in data: pass
         else:
-            self._wheredat = tuple(data)
+            self._evalwheredat(data)
             self._pull()
-        self._postinit()
 
     def _pull(self):
         """Updates table with data pulled from database."""
-        c = self._db.cursor(self._log)
-        count = c.execute("""SELECT * FROM %s WHERE %s""" \
-                           % (self._table, self._where), self._wheredat)
-        if count == 0:
-            raise MythError('DBData() could not read from database')
-        elif count > 1:
-            raise MythError('DBData() could not find unique entry')
-        data = c.fetchone()
-        c.close()
+        with self._db.cursor(self._log) as c:
+            count = c.execute("""SELECT * FROM %s WHERE %s""" \
+                               % (self._table, self._where), self._wheredat)
+            if count == 0:
+                raise MythError('DBData() could not read from database')
+            elif count > 1:
+                raise MythError('DBData() could not find unique entry')
+            data = c.fetchone()
         DictData.update(self, self._process(data))
 
     def copy(self):
@@ -175,10 +188,9 @@
         self._fillNone()
         dict.update(self, self._defaults)
 
-    def _postinit(self):
-        DBData._postinit(self)
-        if self._wheredat is not None:
-            self._origdata = dict(self)
+    def _evalwheredat(self, wheredat=None):
+        DBData._evalwheredat(self, wheredat)
+        self._origdata = dict(self)
 
     def __init__(self, data=None, db=None):
         DBData.__init__(self, data, db)
@@ -188,9 +200,9 @@
             data = self._sanitize(data, False)
             dict.update(self, data)
 
-    def create(self,data=None):
+    def _create(self,data=None):
         """
-        obj.create(data=None) -> new database row
+        obj._create(data=None) -> new database row
 
         Creates a new database entry using given information.
         Will add any information in 'data' dictionary to local information
@@ -206,15 +218,29 @@
         for key in data.keys():
             if data[key] is None:
                 del data[key]
-        c = self._db.cursor(self._log)
         fields = ', '.join(data.keys())
         format_string = ', '.join(['%s' for d in data.values()])
-        c.execute("""INSERT INTO %s (%s) VALUES(%s)""" \
+        with self._db.cursor(self._log) as c:
+            c.execute("""INSERT INTO %s (%s) VALUES(%s)""" \
                         % (self._table, fields, format_string), data.values())
-        intid = c.lastrowid
-        c.close()
+            intid = c.lastrowid
         return intid
 
+    def create(self, data=None):
+        intid = self.create(data)
+        if self._key is None:
+            self._evalwheredat()
+        elif len(self._key) > 1:
+            self._evalwheredat()
+        elif 'auto_increment' in \
+                self._db.tablefields[self._table][self._key[0]].extra:
+            # key is an autoincrement field, pull from line creation id
+            self._evalwheredat([intid])
+        else:
+            self._evalwheredat()
+        self._pull()
+        return self
+
     def _pull(self):
         DBData._pull(self)
         self._origdata = dict.copy(self)
@@ -222,7 +248,6 @@
     def _push(self):
         if (self._where is None) or (self._wheredat is None):
             return
-        c = self._db.cursor(self._log)
         data = self._sanitize(dict(self))
         for key, value in data.items():
             if value == self._origdata[key]:
@@ -235,9 +260,9 @@
         sql_values = data.values()
         sql_values.extend(self._wheredat)
 
-        c.execute("""UPDATE %s SET %s WHERE %s""" \
+        with self._db.cursor(self._log) as c:
+            c.execute("""UPDATE %s SET %s WHERE %s""" \
                     % (self._table, format_string, self._where), sql_values)
-        c.close()
         self._pull()
 
     def update(self, *args, **keywords):
@@ -263,10 +288,9 @@
         if (self._where is None) or \
                 (self._wheredat is None):
             return
-        c = self._db.cursor(self._log)
-        c.execute("""DELETE FROM %s WHERE %s""" \
+        with self._db.cursor(self._log) as c:
+            c.execute("""DELETE FROM %s WHERE %s""" \
                         % (self._table, self._where), self._wheredat)
-        c.close()
 
 class DBDataRef( list ):
     """
@@ -357,14 +381,14 @@
     def _populate(self, force=False):
         if self._populated and (not force):
             return
-        c = self._db.cursor()
-        c.execute("""SELECT %s FROM %s WHERE %s""" % \
+        with self._db as c:
+            c.execute("""SELECT %s FROM %s WHERE %s""" % \
                          (','.join(self._datfields),
                           self._table,
                           ' AND '.join(['%s=%%s' % f for f in self._ref])),
                     self._refdat)
-        for row in c.fetchall():
-            list.append(self, self.SubData(zip(self._datfields, row)))
+            for row in c:
+                list.append(self, self.SubData(zip(self._datfields, row)))
         self._populated = True
         self._origdata = self.deepcopy()
 
@@ -404,32 +428,32 @@
         diff = self^self._origdata
         if len(diff) == 0:
             return
-        c = self._db.cursor()
         fields = list(self._ref)+list(self._datfields)
 
-        # remove old entries
-        for v in (self._origdata&diff):
-            data = list(self._refdat)+v.values()
-            wf = []
-            for i in range(len(data)):
-                if data[i] is None:
-                    wf.append('%s IS %%s' % fields[i])
-                else:
-                    wf.append('%s=%%s' % fields[i])
-            c.execute("""DELETE FROM %s WHERE %s""" % \
-                        (self._table, ' AND '.join(wf)), data)
+        with self._db as c:
+            # remove old entries
+            for v in (self._origdata&diff):
+                data = list(self._refdat)+v.values()
+                wf = []
+                for i in range(len(data)):
+                    if data[i] is None:
+                        wf.append('%s IS %%s' % fields[i])
+                    else:
+                        wf.append('%s=%%s' % fields[i])
+                c.execute("""DELETE FROM %s WHERE %s""" % \
+                            (self._table, ' AND '.join(wf)), data)
 
-        # add new entries
-        data = []
-        for v in (self&diff):
             # add new entries
-            data.append(list(self._refdat)+v.values())
-        if len(data) > 0:
-            c.executemany("""INSERT INTO %s (%s) VALUES(%s)""" % \
-                            (self._table,
-                             ','.join(fields),
-                             ','.join(['%s' for a in fields])), data)
-        c.close()
+            data = []
+            for v in (self&diff):
+                # add new entries
+                data.append(list(self._refdat)+v.values())
+            if len(data) > 0:
+                c.executemany("""INSERT INTO %s (%s) VALUES(%s)""" % \
+                                (self._table,
+                                 ','.join(fields),
+                                 ','.join(['%s' for a in fields])), data)
+
         self._origdata = self.deepcopy()
 
     def append(self, *data):
@@ -494,8 +518,8 @@
         datfields = self._datfields
         reffield = '%s.%s' % (self._table[1],self._cref[-1])
 
-        c = self._db.cursor()
-        c.execute("""SELECT %s FROM %s JOIN %s ON %s WHERE %s""" % \
+        with self._db as c:
+            c.execute("""SELECT %s FROM %s JOIN %s ON %s WHERE %s""" % \
                         (','.join(datfields+[reffield]),
                          self._table[0],
                          self._table[1],
@@ -521,53 +545,53 @@
         diff = self^self._origdata
         if len(diff) == 0:
             return
-        c = self._db.cursor()
 
-        # add new cross-references
-        newdata = self&diff
-        for d in newdata:
-            data = [d[a] for a in self._crdatfields]
-            fields = self._crdatfields
-            if c.execute("""SELECT %s FROM %s WHERE %s""" % \
-                        (self._cref[-1], self._table[1],
-                         ' AND '.join(['%s=%%s' % f for f in fields])),
-                    data):
-                # match found
-                d._cref = c.fetchone()[0]
-            else:
+        with self._db as c:
+            # add new cross-references
+            newdata = self&diff
+            for d in newdata:
+                data = [d[a] for a in self._crdatfields]
+                fields = self._crdatfields
+                if c.execute("""SELECT %s FROM %s WHERE %s""" % \
+                            (self._cref[-1], self._table[1],
+                             ' AND '.join(['%s=%%s' % f for f in fields])),
+                        data):
+                    # match found
+                    d._cref = c.fetchone()[0]
+                else:
+                    c.execute("""INSERT INTO %s (%s) VALUES(%s)""" % \
+                            (self._table[1],
+                             ','.join(self._crdatfields),
+                             ','.join(['%s' for a in data])),
+                        data)
+                    d._cref = c.lastrowid
+            # add new references
+            for d in newdata:
+                data = [d[a] for a in self._rdatfields]+[d._cref]+self._refdat
+                fields = self._rdatfields+self._cref[:1]+self._ref
                 c.execute("""INSERT INTO %s (%s) VALUES(%s)""" % \
-                        (self._table[1],
-                         ','.join(self._crdatfields),
-                         ','.join(['%s' for a in data])),
-                    data)
-                d._cref = c.lastrowid
-        # add new references
-        for d in newdata:
-            data = [d[a] for a in self._rdatfields]+[d._cref]+self._refdat
-            fields = self._rdatfields+self._cref[:1]+self._ref
-            c.execute("""INSERT INTO %s (%s) VALUES(%s)""" % \
-                        (self._table[0],
-                         ','.join(fields),
-                         ','.join(['%s' for a in data])),
-                    data)
+                            (self._table[0],
+                             ','.join(fields),
+                             ','.join(['%s' for a in data])),
+                        data)
 
-        # remove old references
-        olddata = self._origdata&diff
-        crefs = [d._cref for d in olddata]
-        for d in olddata:
-            data = [d[a] for a in self._rdatfields]+[d._cref]+self._refdat
-            fields = self._rdatfields+self._cref[:1]+self._ref
-            c.execute("""DELETE FROM %s WHERE %s""" % \
-                        (self._table[0],
-                         ' AND '.join(['%s=%%s' % f for f in fields])),
-                    data)
-        # remove unused cross-references
-        for cr in crefs:
-            c.execute("""SELECT COUNT(1) FROM %s WHERE %s=%%s""" % \
-                        (self._table[0], self._cref[0]), cr)
-            if c.fetchone()[0] == 0:
-                c.execute("""DELETE FROM %s WHERE %s=%%s""" % \
-                        (self._table[1], self._cref[-1]), cr)
+            # remove old references
+            olddata = self._origdata&diff
+            crefs = [d._cref for d in olddata]
+            for d in olddata:
+                data = [d[a] for a in self._rdatfields]+[d._cref]+self._refdat
+                fields = self._rdatfields+self._cref[:1]+self._ref
+                c.execute("""DELETE FROM %s WHERE %s""" % \
+                            (self._table[0],
+                             ' AND '.join(['%s=%%s' % f for f in fields])),
+                        data)
+            # remove unused cross-references
+            for cr in crefs:
+                c.execute("""SELECT COUNT(1) FROM %s WHERE %s=%%s""" % \
+                            (self._table[0], self._cref[0]), cr)
+                if c.fetchone()[0] == 0:
+                    c.execute("""DELETE FROM %s WHERE %s=%%s""" % \
+                            (self._table[1], self._cref[-1]), cr)
 
         self._origdata = self.deepcopy()
 
@@ -642,13 +666,12 @@
         def __getitem__(self,key):
             if key not in self:
                 # pull field list from database
-                c = self._db.cursor(self._log)
-                try:
-                    c.execute("DESC %s" % (key,))
-                except Exception, e:
-                    MythDBError(MythDBError.DB_RAW, e.args)
-                self[key] = self._FieldData(c.fetchall())
-                c.close()
+                with self._db.cursor(self._log) as c:
+                    try:
+                        c.execute("DESC %s" % (key,))
+                    except Exception, e:
+                        raise MythDBError(MythDBError.DB_RAW, e.args)
+                    self[key] = self._FieldData(c.fetchall())
 
             # return cached information
             return OrdDict.__getitem__(self,key)
@@ -678,43 +701,42 @@
 
             def __getitem__(self, key):
                 if key not in self:
-                    c = self._db.cursor(self._log)
-                    if c.execute("""SELECT data FROM settings
-                                    WHERE value=%%s
-                                    AND %s LIMIT 1""" \
-                                % self._where, key):
-                        OrdDict.__setitem__(self, key, c.fetchone()[0])
-                    else:
-                        return None
-                    c.close()
+                    with self._db.cursor(self._log) as c:
+                        if c.execute("""SELECT data FROM settings
+                                        WHERE value=%%s
+                                        AND %s LIMIT 1""" \
+                                    % self._where, key):
+                            OrdDict.__setitem__(self, key, c.fetchone()[0])
+                        else:
+                            return None
                 return OrdDict.__getitem__(self, key)
 
             def __setitem__(self, key, value):
-                c = self._db.cursor(self._log)
                 if value is None:
                     if self[key] is None:
                         return
                     del self[key]
                 else:
-                    if self[key] is not None:
-                        c.execute("""UPDATE settings
-                                     SET data=%%s
-                                     WHERE value=%%s
-                                     AND %s""" \
-                                % self._where, (value, key))
-                    else:
-                        c.execute(self._insert, (key, value))
+                    with self._db.cursor(self._log) as c:
+                        if self[key] is not None:
+                            c.execute("""UPDATE settings
+                                         SET data=%%s
+                                         WHERE value=%%s
+                                         AND %s""" \
+                                    % self._where, (value, key))
+                        else:
+                            c.execute(self._insert, (key, value))
                 OrdDict.__setitem__(self,key,value)
 
             def __delitem__(self, key):
                 if self[key] is None:
                     return
-                c = self._db.cursor(self._log)
-                c.execute("""DELETE FROM settings
-                             WHERE value=%%s
-                             AND %s""" \
-                        % self._where, (key,))
-                OrdDict.__delitem__(self, key)
+                with self._db.cursor(self._log) as c:
+                    c.execute("""DELETE FROM settings
+                                 WHERE value=%%s
+                                 AND %s""" \
+                            % self._where, (key,))
+                    OrdDict.__delitem__(self, key)
 
             def get(self, value, default=None):
                 res = self[value]
@@ -722,11 +744,11 @@
                 return res
 
             def getall(self):
-                c = self._db.cursor(self._log)
-                c.execute("""SELECT value,data FROM settings
-                             WHERE %s""" % self._where)
-                for k,v in c.fetchall():
-                    OrdDict.__setitem__(self, k, v)
+                with self._db.cursor(self._log) as c:
+                    c.execute("""SELECT value,data FROM settings
+                                 WHERE %s""" % self._where)
+                    for k,v in c.fetchall():
+                        OrdDict.__setitem__(self, k, v)
                 return self.iteritems()
 
         _localvars = ['_field_order','_log','_db']
@@ -803,7 +825,7 @@
 
         self.dbconn = dbconn
         self.ident = "sql://%s@%s:%d/" % \
-                (dbconn['DBName'],dbconn['DBHostName'],dbconn['DBPort'])
+                (dbconn['DBName'], dbconn['DBHostName'], dbconn['DBPort'])
         if self.ident in self.shared:
             # reuse existing database connection
             self.db = self.shared[self.ident]
@@ -879,15 +901,14 @@
 
     def _check_schema(self, value, local, name='Database'):
         if self.settings is None:
-            c = self.cursor(self.log)
-            lines = c.execute("""SELECT data FROM settings
+            with self.cursor(self.log) as c:
+                lines = c.execute("""SELECT data FROM settings
                                             WHERE value LIKE(%s)""",(value,))
-            if lines == 0:
-                c.close()
-                raise MythDBError(MythError.DB_SETTING, value)
+                if lines == 0:
+                    c.close()
+                    raise MythDBError(MythError.DB_SETTING, value)
 
-            sver = int(c.fetchone()[0])
-            c.close()
+                sver = int(c.fetchone()[0])
         else:
             sver = int(self.settings['NULL'][value])
 
@@ -904,32 +925,36 @@
                                             -> tuple of StorageGroup objects
         groupname and hostname can be used as optional filters
         """
-        c = self.cursor(self.log)
-        where = []
-        wheredat = []
-        if groupname:
-            where.append("groupname=%s")
-            wheredat.append(groupname)
-        if hostname:
-            where.append("hostname=%s")
-            wheredat.append(hostname)
-        if len(where):
-            where = 'WHERE '+' AND '.join(where)
-            count = c.execute("""SELECT * FROM storagegroup %s
-                                 ORDER BY id""" % where, wheredat)
-        else:
-            count = c.execute("""SELECT * FROM storagegroup
-                                 ORDER BY id""")
+        with self.cursor(self.log) as c:
+            where = []
+            wheredat = []
+            if groupname:
+                where.append("groupname=%s")
+                wheredat.append(groupname)
+            if hostname:
+                where.append("hostname=%s")
+                wheredat.append(hostname)
+            if len(where):
+                where = 'WHERE '+' AND '.join(where)
+                c.execute("""SELECT * FROM storagegroup %s
+                             ORDER BY id""" % where, wheredat)
+            else:
+                c.execute("""SELECT * FROM storagegroup
+                             ORDER BY id""")
 
-        for i in xrange(count):
-            row = c.fetchone()
-            yield StorageGroup.fromRaw(row, self)
+            for row in c:
+                yield StorageGroup.fromRaw(row, self)
 
     def cursor(self, log=None):
         if not log:
             log = self.log
         return self.db.cursor(log, self.cursorclass)
 
+    def __enter__(self):
+        return self.db.__enter__()
+    def __exit__(self, type, value, traceback):
+        self.db.__exit__(type, value, traceback)
+
 class StorageGroup( DBData ):
     """
     StorageGroup(id=None, db=None, raw=None) -> StorageGroup object
Index: python/MythTV/dataheap.py
===================================================================
--- python/MythTV/dataheap.py	(revision 25163)
+++ python/MythTV/dataheap.py	(working copy)
@@ -25,8 +25,11 @@
     """
 
     _table = 'record'
-    _where = 'recordid=%s'
-    _setwheredat = 'self.recordid,'
+    _key = ['recordid']
+
+
+#    _where = 'recordid=%s'
+#    _setwheredat = 'self.recordid,'
     _defaults = {'recordid':None,    'type':RECTYPE.kAllRecord,
                  'title':u'Unknown', 'subtitle':'',      'description':'',
                  'category':'',      'station':'',       'seriesid':'',
@@ -111,8 +114,8 @@
             'data' is a tuple containing (chanid, storagegroup)
     """
     _table = 'recorded'
-    _where = 'chanid=%s AND starttime=%s'
-    _setwheredat = 'self.chanid,self.starttime'
+    _key = ['chanid','starttime']
+
     _defaults = {'title':u'Unknown', 'subtitle':'',          'description':'',
                  'category':'',      'hostname':'',          'bookmark':0,
                  'editing':0,        'cutlist':0,            'autoexpire':0,
@@ -160,12 +163,11 @@
     def __repr__(self):
         return str(self).encode('utf-8')
 
-    def _postinit(self):
-        DBDataWrite._postinit(self)
-        if self._wheredat is not None:
-            self.cast = self._Cast(self._wheredat, self._db)
-            self.seek = self._Seek(self._wheredat, self._db)
-            self.markup = self._Markup(self._wheredat, self._db)
+    def _evalwheredat(self, *args):
+        DBDataWrite._evalwheredat(self, *args)
+        self.cast = self._Cast(self._wheredat, self._db)
+        self.seek = self._Seek(self._wheredat, self._db)
+        self.markup = self._Markup(self._wheredat, self._db)
 
     @classmethod
     def fromProgram(cls, program):
@@ -177,16 +179,6 @@
         self.seek.commit()
         self.markup.commit()
 
-    def create(self, data=None):
-        """Recorded.create(data=None) -> Recorded object"""
-        DBDataWrite.create(self, data)
-        self._wheredat = (self.chanid,self.starttime)
-        self._pull()
-        self.cast = self._Cast(self._wheredat, self._db)
-        self.seek = self._Seek(self._wheredat, self._db)
-        self.markup = self._Markup(self._wheredat, self._db)
-        return self
-
     def delete(self, force=False, rerecord=False):
         """
         Recorded.delete(force=False, rerecord=False) -> retcode
@@ -194,7 +186,7 @@
                 'force' forces a delete if the file cannot be found.
                 'rerecord' sets the file as recordable in oldrecorded
         """
-        return self.getProgram().delete(force, rerecord)
+        return Program.fromRecorded(self).delete(force, rerecord)
 
     def open(self, type='r'):
         """Recorded.open(type='r') -> file or FileTransfer object"""
@@ -466,8 +458,9 @@
 class Video( DBDataWrite, CMPVideo ):
     """Video(id=None, db=None, raw=None) -> Video object"""
     _table = 'videometadata'
-    _where = 'intid=%s'
-    _setwheredat = 'self.intid,'
+    _key = ['intid']
+#    _where = 'intid=%s'
+#    _setwheredat = 'self.intid,'
     _defaults = {'subtitle':u'',             'director':u'Unknown',
                  'rating':u'NR',             'inetref':u'00000000',
                  'year':1895,                'userrating':0.0,
@@ -495,6 +488,7 @@
         c.close()
 
     def _cat_toname(self):
+        self._fill_cm()
         if self.category is not None:
             try:
                 self.category = self._cm_toname[int(self.category)]
@@ -503,6 +497,7 @@
             self.category = 'none'
 
     def _cat_toid(self):
+        self._fill_cm()
         if self.category is not None:
             try:
                 if self.category.lower() not in self._cm_toid:
@@ -520,7 +515,6 @@
 
     def _pull(self):
         DBDataWrite._pull(self)
-        self._fill_cm()
         self._cat_toname()
 
     def _push(self):
@@ -544,38 +538,35 @@
             res += u' - '+self.subtitle
         return u"<Video '%s' at %s>" % (res, hex(id(self)))
 
-    def _postinit(self):
-        DBDataWrite._postinit(self)
-        self._fill_cm()
-        if self._wheredat is not None:
-            self._cat_toname()
-            self.cast = self._Cast((self.intid,), self._db)
-            self.genre = self._Genre((self.intid,), self._db)
-            self.country = self._Country((self.intid,), self._db)
-            self.markup = self._Markup((self.filename,), self._db)
+    def _evalwheredat(self, *args):
+        DBDataWrite._evalwheredat(self, *args)
+        self._cat_toname()
+        self.cast = self._Cast((self.intid,), self._db)
+        self.genre = self._Genre((self.intid,), self._db)
+        self.country = self._Country((self.intid,), self._db)
+        self.markup = self._Markup((self.filename,), self._db)
 
     def __init__(self, id=None, db=None):
         DBDataWrite.__init__(self, (id,), db)
 
     def create(self, data=None):
         """Video.create(data=None) -> Video object"""
-        c = self._db.cursor(self._log)
-        fields = ' AND '.join(['%s=%%s' % f for f in \
-                        ('title','subtitle','season','episode')])
-        count = c.execute("""SELECT intid FROM videometadata WHERE %s""" %
-                fields, (self.title, self.subtitle, self.season, self.episode))
-        if count:
-            id = c.fetchone()[0]
-        else:
-            self._import(data)
-            self._cat_toid()
-            id = DBDataWrite.create(self)
-        c.close()
-        self._wheredat = (id,)
-        self._pull()
-        self._postinit()
-        return self
+        if self.host is not None:
+            if self.hash == '':
+                self.hash = self.getHash()
+            if c.execute("""SELECT intid FROM videometadata
+                            WHERE hash=%s""", self.hash) > 0:
+                # existing entry found, dump all local data
+                id = c.fetchone()[0]
+                self._setwheredat([id])
+                self._pull()
+                return self
 
+        # create new entry
+        self._import(data)
+        self._cat_toid()
+        return DBDataWrite.create(self)
+
     class _Cast( DBDataCRef ):
         _table = ['videometadatacast','videocast']
         _ref = ['idvideo']
@@ -662,7 +653,7 @@
         """Video.getHash() -> file hash"""
         if self.host is None:
             return None
-        be = FileOps(self.host)
+        be = FileOps(self.host, self._db)
         hash = be.getHash(self.filename, 'Videos')
         return hash
 
@@ -783,4 +774,207 @@
         for item in xmldat.findall('item'):
             yield InternetMetadata(item)
 
+#### MYTHMUSIC ####
 
+class MythMusicSchema( object ):
+    _schema_value = 'MusicDBSchemaVer'
+    _schema_local = MUSICSCHEMA_VERSION
+    _schema_name = 'MythMusic'
+
+class Song( DBDataWrite, MythMusicSchema ):
+    _table = 'music_songs'
+    _where = 'song_id=%s'
+    _setwheredat = 'self.song_id,'
+    _defaults = {'song_id':None}
+    _logmodule = 'Python Song'
+
+    def __init__(self, id, db=None):
+        DBDataWrite.__init__(self, (id,), db)
+
+    def create(self, data=None):
+        """Song.create(data=None) -> Song object"""
+        self._wheredat = (DBDataWrite.create(self, data),)
+        self._pull()
+        return self
+
+    @classmethod
+    def fromAlbum(cls, album, db=None):
+        """Returns iterable of songs from given album."""
+        try:
+            db = album._db
+            album = album.album_id
+        except AttributeError: pass
+
+        return cls._fromQuery("WHERE album_id=%s", [album], db)
+
+    @classmethod
+    def fromArtist(cls, artist, db=None):
+        """Returns iterable of songs from given artist."""
+        try:
+            db = artist._db
+            artist = artist.artist_id
+        except AttributeError: pass
+
+        return cls._fromQuery("WHERE artist_id=%s", [artist], db)
+
+    @classmethod
+    def fromPlaylist(cls, playlist, db=None):
+        """Returns iterable of songs from given playlist."""
+        try:
+            songs = playlist._songstring()
+            db = playlist._db
+        except AttributeError:
+            db = DBCache(db)
+            songs = MusicPlaylist(playlist, db)._songstring()
+
+        return cls._fromQuery("WHERE LOCATE(song_id, %s)", songs, db)
+
+class Album( DBDataWrite, MythMusicSchema ):
+    _table = 'music_albums'
+    _where = 'album_id=%s'
+    _setwheredat = 'self.album_id,'
+    _defaults = {'album_id':None}
+    _logmodule = 'Python Album'
+
+    def __init__(self, id, db=None):
+        DBDataWrite.__init__(self, (id,), db)
+
+    def create(self, data=None):
+        """Album.create(data=None) -> Album object"""
+        self._wheredat = (DBDataWrite.create(self, data),)
+        self._pull()
+        return self
+
+    @classmethod
+    def fromArtist(cls, artist, db=None):
+        """Returns iterable of albums from given artist."""
+        try:
+            db = artist._db
+            artist = artist.artist_id
+        except AttributeError:
+            pass
+        return cls._fromQuery("WHERE artist_id=%s", [artist], db)
+
+    @classmethod
+    def fromSong(cls, song, db=None):
+        """Returns the album for the given song."""
+        try:
+            album = song.album_id
+            db = song._db
+        except AttributeError:
+            db = DBCache(db)
+            album = Song(song, db).album_id
+        return cls(album, db)
+
+class Artist( DBDataWrite, MythMusicSchema ):
+    _table = 'music_artists'
+    _where = 'artist_id=%s'
+    _setwheredat = 'self.artist_id,'
+    _defaults = {'artist_id':None}
+    _logmodule = 'Python Artist'
+
+    def __init__(self, id, db=None):
+        DBDataWrite.__init__(self, (id,), db)
+
+    def create(self, data=None):
+        """Artist.create(data=None) -> Artist object"""
+        self._wheredat = (DBDataWrite.create(self, data),)
+        self._pull()
+        return self
+
+    @classmethod
+    def fromName(cls, name, db=None):
+        db = MythDB(db)
+        c = db.cursor()
+        count = c.execute("""SELECT * FROM %s WHERE artist_name=%s""", (cls._table, name))
+        if count > 1:
+            raise MythDBError('Non-unique music_artist entry')
+        elif count == 1:
+            return cls.fromRaw(c.fetchone(), db)
+        else:
+            artist = cls(db=db)
+            artist.artist_name = name
+            return artist.create()
+   
+    @classmethod
+    def fromSong(cls, song, db=None):
+        """Returns the artist for the given song."""
+        try:
+            artist = song.artist_id
+            db = song._db
+        except AttributeError:
+            db = DBCache(db)
+            artist = Song(song, db).artist_id
+        return cls(artist, db)
+
+    @classmethod
+    def fromAlbum(cls, album, db=None):
+        """Returns the artist for the given album."""
+        try:
+            artist = album.artist_id
+            db = album._db
+        except AttributeError:
+            db = DBCache(db)
+            artist = Album(album, db).artist_id
+        return cls(artist, db)
+
+class MusicPlaylist( DBDataWrite, MythMusicSchema ):
+    _table = 'music_playlists'
+    _where = 'playlist_id=%s'
+    _setwheredat = 'self.playlist_id,'
+    _defaults = {'playlist_id':None}
+    _logmodule = 'Python Music Playlist'
+
+    def __init__(self, id, db=None):
+        DBDataWrite.__init__(self, (id,), db)
+
+    def create(self, data=None):
+        """MusicPlaylist.create(data=None) -> MusicPlaylist object"""
+        self._wheredat = (DBDataWrite.create(self, data),)
+        self._pull()
+        return self
+
+    @classmethod
+    def fromSong(cls, song, db=None):
+        """Returns an iterable of playlists containing the given song."""
+        try:
+            db = song._db
+            song = song.song_id
+        except AttributeError:
+            db = DBCache(db)
+            song = Song(song, db).song_id
+        return cls._fromQuery("WHERE LOCATE(%s, playlist_songs)", song, db)
+
+class MusicDirectory( DBDataWrite, MythMusicSchema ):
+    _table = 'music_directories'
+    _where = 'directory_id=%s'
+    _setwheredat = 'self.directory_id,'
+    _defaults = {'directory_id':None}
+    _logmodule = 'Python Music Directory'
+
+    def __init__(self, id, db=None):
+        DBDataWrite.__init__(self, (id,), db)
+
+    @classmethod
+    def fromPath(cls, path, db=None):
+        db = MythDB(db)
+        c = db.cursor()
+        count = c.execute("""SELECT * FROM %s WHERE path=%s""" \
+                                    % cls._table, path)
+        if count > 1:
+            raise MythDBError('Multiple matches for MusicDirectory.fromPath')
+        elif count == 1:
+            return cls.fromRaw(c.fetchone())
+        else:
+            directory = cls()
+            directory.path = path
+            if path.find('/') != -1:
+                directory.parent_id = \
+                        cls.fromPath(path.rsplit('/',1)[0]).directory_id
+            return directory.create()
+
+    def create(self, data=None):
+        """MusicDirectory.create(data=None) -> MusicDirectory object"""
+        self._wheredat = (DBDataWrite.create(self, data),)
+        self._pull()
+        return self
Index: python/MythTV/methodheap.py
===================================================================
--- python/MythTV/methodheap.py	(revision 25163)
+++ python/MythTV/methodheap.py	(working copy)
@@ -13,7 +13,8 @@
 from mythproto import BEEvent, FileOps, Program
 from dataheap import Record, Recorded, RecordedProgram, \
                      OldRecorded, Job, Guide, Video, \
-                     InternetSource, InternetContentArticles
+                     InternetSource, InternetContentArticles, \
+                     Song
 
 import re
 
@@ -1029,4 +1030,42 @@
         except StopIteration:            
             return None
 
+class MythMusic( DBCache ):
+    """
+    Provides convenient methods to access the MythTV MythMusic database.
+    """
+    def __init__(self,db=None):
+        """
+        Initialise the MythDB connection.
+        """
+        DBCache.__init__(self,db)
 
+        # check schema version
+        self._check_schema('MusicDBSchemaVer', 
+                                MUSICSCHEMA_VERSION, 'MythMusic')
+
+    @databaseSearch
+    def searchMusic(self, init=False, key=None, value=None):
+        """
+        obj.searchVideos(**kwargs) -> iterable of Song objects
+
+        Supports the following keywords:
+            name,  track,  disc_number, artist,      album,   year
+            genre, rating, format,      sample_rate, bitrate
+        """
+        if init:
+            return ('music_songs', Song, (),
+                    ('music_artists','music_songs',('artist_id',)), #1
+                    ('music_albums', 'music_songs',('album_id',)),  #2
+                    ('music_genres', 'music_songs',('genre_id',)))  #4
+        if key in ('name','track','disc_number','rating',
+                        'format','sample_rate','bitrate'):
+            return ('music_songs.%s=%%s' % key, value, 0)
+        if key == 'artist':
+            return ('music_artists.artist_name=%s', value, 1)
+        if key == 'album':
+            return ('music_albums.album_name=%s', value, 2)
+        if key == 'year':
+            return ('music_albums.year=%s', value, 2)
+        if key == 'genre':
+            return ('music_genres.genre=%s', value, 4)
Index: python/MythTV/connections.py
===================================================================
--- python/MythTV/connections.py	(revision 25163)
+++ python/MythTV/connections.py	(working copy)
@@ -12,8 +12,9 @@
 
 from select import select
 from urllib import urlopen
-from thread import start_new_thread, allocate_lock
+from thread import start_new_thread, allocate_lock, get_ident
 from time import sleep, time
+import traceback
 import socket
 import re
 import weakref
@@ -28,18 +29,34 @@
     """
     def __init__(self, connection):
         self.log = None
+        self._releaseCallback = None
+        self.id = id(connection)
         MySQLdb.cursors.Cursor.__init__(self, connection)
         self.ping = self._ping121
         if MySQLdb.__version__ >= ('1','2','2'):
             self.ping = self._ping122
         self.ping()
-        
+
+    def __del__(self):
+        if self._releaseCallback is not None:
+            self._releaseCallback(self.id)
+        MySQLdb.cursors.Cursor.__del__(self)
+
+    def close(self):
+        if self._releaseCallback is not None:
+            self._releaseCallback(self.id)
+        MySQLdb.cursors.Cursor.close(self)
+
     def _ping121(self): self.connection.ping(True)
     def _ping122(self): self.connection.ping()
 
     def log_query(self, query, args):
         self.log(self.log.DATABASE, ' '.join(query.split()), str(args))
 
+    def __enter__(self): return self
+
+    def __exit__(self, type, value, traceback): self.close()
+
     def execute(self, query, args=None):
         self.ping()
         self.log_query(query, args)
@@ -63,33 +80,79 @@
     This is the basic database connection object.
     You dont want to use this directly.
     """
+    _poolsize = 2
+    @classmethod
+    def setPoolSize(cls, size):
+        cls._poolsize = size
 
     def __init__(self, dbconn):
         self.log = MythLog('Python Database Connection')
-        self.tablefields = None
-        self.settings = None
+        self._pool = []
+        self._inuse = {}
+        self._stack = {}
+        self.dbconn = dbconn
+
         try:
             self.log(MythLog.DATABASE, "Attempting connection", 
                                                 str(dbconn))
-            self.db = MySQLdb.connect(  user=   dbconn['DBUserName'],
-                                        host=   dbconn['DBHostName'],
-                                        passwd= dbconn['DBPassword'],
-                                        db=     dbconn['DBName'],
-                                        port=   dbconn['DBPort'],
-                                        use_unicode=True,
-                                        charset='utf8')
+            for i in range(self._poolsize):
+                self._pool.append(self.connect())
         except:
             raise MythDBError(MythError.DB_CONNECTION, dbconn)
-        self.db.autocommit(True)
 
+    def connect(self):
+        dbconn = self.dbconn
+        db = MySQLdb.connect( 
+                         user=   dbconn['DBUserName'],
+                         host=   dbconn['DBHostName'],
+                         passwd= dbconn['DBPassword'],
+                         db=     dbconn['DBName'],
+                         port=   dbconn['DBPort'],
+                         use_unicode=True,
+                         charset='utf8')
+        db.autocommit(True)
+        return db
+
     def cursor(self, log=None, type=LoggedCursor):
-        c = self.db.cursor(type)
-        if log:
-            c.log = log
-        else:
-            c.log = self.log
-        return c
+        cursor = self.acquire().cursor(type)
+        cursor._releaseCallback = self.release
+        if log is None:
+            log = self.log
+        cursor.log = log
+        return cursor
 
+    def acquire(self):
+        try:
+            conn = self._pool.pop(0)
+            self._inuse[id(conn)] = conn
+        except IndexError:
+            # TODO: throw error or block if self.expandable==False
+            conn = self.connect()
+        return conn
+
+    def release(self, id):
+        try:
+            conn = self._inuse.pop(id)
+            self._pool.append(conn)
+        except KeyError:
+            pass
+
+    def __enter__(self):
+        cursor = self.cursor()
+        ident = get_ident()
+
+        if ident not in self._stack:
+            self._stack[ident] = []
+        self._stack[ident].append(cursor)
+        return cursor
+
+    def __exit__(self, type, value, traceback):
+        ident = get_ident()
+        if ident not in self._stack:
+            raise MythError('Missing Context stack in DBConnection')
+        cursor = self._stack[ident].pop()
+        cursor.close()
+
 class BEConnection( object ):
     """
     This is the basic backend connection object.
@@ -177,12 +240,16 @@
     def disconnect(self):
         if not self.connected:
             return
-        self.log(MythLog.SOCKET|MythLog.NETWORK,
+        try:
+            self.log(MythLog.SOCKET|MythLog.NETWORK,
                 "Terminating connection to %s:%d" % (self.host, self.port))
-        self.backendCommand('DONE',0)
-        self.connected = False
-        self.socket.shutdown(1)
-        self.socket.close()
+            self.backendCommand('DONE',0)
+            self.connected = False
+            self.socket.shutdown(1)
+            self.socket.close()
+        except:
+            traceback.print_exc()
+            raise
 
     def reconnect(self, force=False):
         # compute new connection options
@@ -473,3 +540,5 @@
             if 'DBPort' in dbconn:
                 dbconn['DBPort'] = int(dbconn['DBPort'])
         return dbconn
+
+
Index: python/MythTV/static.py
===================================================================
--- python/MythTV/static.py	(revision 25163)
+++ python/MythTV/static.py	(working copy)
@@ -4,10 +4,11 @@
 Contains any static and global variables for MythTV Python Bindings
 """
 
-OWN_VERSION = (0,23,0,12)
+OWN_VERSION = (0,23,0,14)
 SCHEMA_VERSION = 1259
 MVSCHEMA_VERSION = 1036
 NVSCHEMA_VERSION = 1007
+MUSICSCHEMA_VERSION = 1017
 PROTO_VERSION = 57
 BACKEND_SEP = '[]:[]'