Here I am sending a slightly updated version of the script. The minor
changes include:

  * using args instead of sys.argv.
  * describe export/import as the arguments.

In the future I might include support for XSPF. In essence I would have to
create a Zip file with two directories, playlists and crates, which would
include an XSPF for each one.
#!/usr/bin/env python
#
# Import and Export Crates.

import sys
import os
import sqlite3
import xml.dom.minidom
from optparse import OptionParser


def ExportCrates(db, fp):
	doc = xml.dom.minidom.Document()
	
	cur = db.cursor()
	cur.execute("SELECT * FROM crates")
	
	crates = doc.createElement("mixxx-crates")
	crates.setAttribute('version', '0.1')
	doc.appendChild(crates)
	
	row = cur.fetchone()
	
	
	while row != None:
		
		crate = doc.createElement('mixxx-crate')
		crate.setAttribute('name', row['name'])
		crates.appendChild(crate)
		
		c2 = db.cursor()
		c2.execute("""
			SELECT 
				track_locations.location AS location,
				track_locations.filename AS filename,
				library.artist,
				library.title
			FROM library
				INNER JOIN track_locations
					ON (track_locations.id=library.location)
				INNER JOIN crate_tracks
					ON (crate_tracks.track_id=library.id)
			WHERE
				crate_tracks.crate_id = %d
			""" % row['id'])
		
		rt = c2.fetchone()
		while rt != None:
			
			try:
				track = doc.createElement('track')
				for key in rt.keys():
					if rt[key] == None:
						continue
					
					track.setAttribute(key, rt[key])
				
			except:
				print "ERROR"
			else:
				crate.appendChild(track)
			
			rt = c2.fetchone()
		
		
		row = cur.fetchone()
		
	fp.write(doc.toprettyxml("\t", "\n", "utf-8"))


def ImportCrates(db, crates):
	
	doc = xml.dom.minidom.parse(crates)
	crates = doc.getElementsByTagName('mixxx-crate')
	
	
	for dcrate in crates:
		crate = {}
		crate['name'] = str(dcrate.getAttribute('name'))
		
		
		try:
			cur = db.cursor()
			cur.execute("SELECT id FROM crates WHERE name = :name", crate)
			
			cr = cur.fetchone()
			crate['id'] = cr['id']
			
			cur.close()
			
		except Exception as e:
			
			cur.execute("INSERT INTO crates ( name ) VALUES ( :name )", crate)
			cur.execute("SELECT id FROM crates WHERE name = :name", crate)
			
			cr = cur.fetchone()
			crate['id'] = cr['id']
			
			cur.close()
		
		
		tracks = dcrate.getElementsByTagName('track')
		for track in tracks:
			
			trackAttr = {
				'filename': None,
				'location': None,
				'artist': None,
				'title': None
			}
			
			for key in trackAttr.keys():
				if track.hasAttribute(key):
					trackAttr[key] = track.getAttribute(key)
			
			cur = db.cursor()
			cur.execute("""
				SELECT 
					library.id AS id
				FROM library 
					INNER JOIN track_locations
					ON (track_locations.id = library.location)
				WHERE
					track_locations.location = :location
					OR track_locations.filename = :filename
					OR (
						:artist IS NOT NULL AND
						:title IS NOT NULL AND
						library.artist = :artist AND 
						library.title = :title
					)
				""", trackAttr)
			
			row = cur.fetchone()
			if row == None:
				 continue
			
			crateTrack = {
				'cid' : crate['id'],
				'tid' : row['id']
			}
			
			cur.execute("""
				SELECT COUNT(*) AS count
				FROM crate_tracks
				WHERE
					crate_id = :cid
					AND track_id = :tid
				""", crateTrack)
			
			row = cur.fetchone()
			
			if row['count'] <= 0:
				cur.execute("""
					INSERT INTO crate_tracks (crate_id, track_id)
					VALUES (:cid, :tid)
					""", crateTrack)


if __name__ == '__main__':
	
	parser = OptionParser(usage="usage: %prog [options] <export|import>")
	
	parser.add_option("-f", "--file", dest="filename",
		help="file to import from/export to, defaults to STDIN/STDOUT", 
		metavar="FILE")
	parser.add_option("-d", "--database", dest="database",
		help="The Mixxx SQLite database to import to/export from, defaults to the default Mixxxx Database",
		default=os.environ['HOME'] + '/.mixxx/mixxxdb.sqlite')
	
	(options, args) = parser.parse_args()
	
	
	db = sqlite3.connect(options.database)
	db.row_factory = sqlite3.Row
	
	
	if args[0] == 'export':
		if options.filename != None:
			fp = open(options.filename, "w+")
		else:
			fp = sys.stdout
		
		ExportCrates(db, fp)
		
	elif args[0] == 'import':
		if options.filename != None:
			fp = open(options.filename, "r+")
		else:
			fp = sys.stdin
		
		ImportCrates(db, fp)
	
	db.commit()

------------------------------------------------------------------------------
Download new Adobe(R) Flash(R) Builder(TM) 4
The new Adobe(R) Flex(R) 4 and Flash(R) Builder(TM) 4 (formerly 
Flex(R) Builder(TM)) enable the development of rich applications that run
across multiple browsers and platforms. Download your free trials today!
http://p.sf.net/sfu/adobe-dev2dev
_______________________________________________
Mixxx-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/mixxx-devel

Reply via email to