def addtracks(self):
sb_dir = qc.query('scatterbrainz_dir')
music_lib = qc.query('music_lib')
tracks_dir = os.path.join(music_lib,'tracks')
dbfile = qc.query('music_dbfile')
sqw = swrap.sqliteWrapper(dbfile)
gidlist = []
if not os.path.isdir(tracks_dir): os.mkdir(tracks_dir)
for (base, dirs, files) in os.walk(music_lib,followlinks = True):
for f in files:
ext = os.path.splitext(f)[-1]
if ext == '.mp3':
f_abs = os.path.join(base,f)
mutagen = MP3(f_abs)
##for some reason that nobody will probably ever
##understand, this does not work with EasyID3
tkey = u'TXXX:MusicBrainz Track Id'
if tkey in mutagen.tags.keys():
gid =mutagen[tkey].text[0]
link = os.path.join(tracks_dir,gid)
if not gid in gidlist: gidlist.append(gid)
if not os.path.isfile(link):
os.link(f_abs,link)
else:
print 'no musicbrainz id for' + f_abs
for gid in gidlist:
sqw.query("""INSERT OR IGNORE INTO tracklist(gid) values('"""+gid+"""');""")
sqw.commit()
sqw.close()
n = len(gidlist)
return sjson.dumps('moved '+str(n)+' tracks to '+tracks_dir+' , indexed in '+dbfile)
def index(self):
# Return a rendered template
#return render('/init.mako')
# or, return a response
#qc.autoset('sb_address')
c.sb_address=qc.query('sb_address')
c.sb_port=qc.query('sb_port')
return render('init_index.mako')
def __init__(self):
self.port = int(qc.query('mbport'))
self.host = str(qc.query('mbhost'))
self.user = str(qc.query('mbuser'))
self.db = qc.query('mbdb')
self.cxn = None
self._openCXN()
print 'opened mbrainz cxn with host'+self.host
def mbrainz():
mbhost = qc.query('mbhost')
mbport = qc.query('mbport')
mbdb = qc.query('mbdb')
mbuser = qc.query('mbuser')
pgw = pgwrap.postgresWrapper(host = mbhost,
port = mbport,
db = mbdb,
user = mbuser)
return pgw
def listUsers():
import sqliteWrapper as sqw
db = sqw.sqliteWrapper(qc.query('config_dbfile'))
d = db.queryToDict('select name from user;');
db.close
return d
def register():
print 'registering what.cd plugin'
sb_dir = qc.query('scatterbrainz_dir')
what_dir =os.path.join(sb_dir,'external/dbs/what')
if not os.path.isdir(what_dir):
os.mkdir(what_dir)
print "Register what.cd for which SB user?"
sb_user = raw_input('username: '******'what',sb_user):
print "Plugin already registered for " + sb_user
print "... exiting"
exit(1)
print "\nWhat.cd username?"
what_user = raw_input('username: '******'password: '******'...configuring'
wc.configure(what_user,what_pass,what_dir,sb_user)
print '...initializing'
wc.init(sb_user)
import dbs.config.prefs as prefs
w_user = prefs.readPref('what_user',sb_user)
print 'Success! set up what.cd pluging for ' +sb_user+' with what.cd account: ' + w_user
pc.register('what',sb_user)
exit(0)
def friendAddressesJSON(self):
sqw = swrap.sqliteWrapper(qc.query('friends_dbfile'))
knows = sqw.queryToDict("SELECT address, sb_port FROM known, friends WHERE known.id = friends.known")
sqw.close
urls = []
for k in knows:
urls.append("http://"+k['address']+':'+str(k['sb_port']))
return sjson.dumps(urls)
def userID(username):
import sqliteWrapper as sqw
db = sqw.sqliteWrapper(qc.query('config_dbfile'))
d = db.queryToDict('select id from user where name = :username;',params = {'username':username});
db.close
if len(d) == 0:
return None
else:
return d[0]['id']
def getAllTracks(self):
d = sw.queryOnce(qc.query("music_dbfile"),"""
SELECT
track.gid as track_mbid,
track.name as track_name
FROM track
LIMIT 20;
""")
for item in d: item['name']= item['track_name']
return d
def getAllAlbums(self):
d = sw.queryOnce(qc.query("music_dbfile"),"""
SELECT
album.gid as album_mbid,
album.name as album_name
FROM album
LIMIT 20;
""")
for item in d: item['name']= item['album_name']
return d
def getAllArtists(self):
d = sw.queryOnce(qc.query("music_dbfile"),"""
SELECT
artist.name as artist_name, artist.gid as artist_gid
FROM artist
""")
for item in d:
item['name'] = item['artist_name']
item['artist_mbid']= item['artist_gid']
return d
def addknown(self):
fdb = qc.query('friends_dbfile')
sqw = swrap.sqliteWrapper(fdb)
sw_address = "94.100.21.250"
sw_port = "5554"
sw_pg = "64077"
sqw.query("INSERT OR IGNORE into known(address, pg_port,sb_port) values(:address,:pg_port,:sb_port);",params={'address':sw_address,'pg_port':sw_pg,'sb_port':sw_port})
sqw.commit()
sqw.close()
return sjson.dumps("Added the default friend at swiftway")
def friendallknown(self):
sqw = swrap.sqliteWrapper(qc.query('friends_dbfile'))
knows = sqw.queryToDict("SELECT id FROM known")
for k in knows:
sqw.query("""
INSERT OR IGNORE INTO friends(known) values(:kid);
"""
,params={'kid':k['id']})
sqw.commit()
sqw.close()
return sjson.dumps("friended each known server, Total: "+str(len(knows)))
def listPrefs(username = None):
import sqliteWrapper as sqw
db = sqw.sqliteWrapper(qc.query('config_dbfile'))
if username:
uid = userID(username);
if not uid : return None
d = db.queryToDict('select name, value from user_prefs where user = :uid;',params = {'uid':uid});
else:
d = db.queryToDict('select name, value from global;')
db.close
return d
def getMBIDAlbumMembers(self,gid):
d = sw.queryOnce(qc.query("music_dbfile"),"""SELECT
track.name as track_name, artist2.name as artist_name
from album,albumjoin , artist as artist2, track, l_artist_track as art_track
where album.gid = :gid
AND albumjoin.album = album.id
AND albumjoin.track = track.id
AND art_track.link0 = artist2.id
AND art_track.link1 = track.id
LIMIT 20;
""",params = {'gid':gid})
for item in d: item['name']= item['artist_name']
return d
def getMBIDAlbumInfo(self,gid):
d = sw.queryOnce(qc.query("music_dbfile"),"""
SELECT
album.gid as album_mbid,
album.name as album_name,
artist.name as artist_name
FROM artist, album
WHERE album.gid = :gid
AND album.artist = artist.id
""",params={'gid':gid})
for item in d:
item['name'] = item['album_name']
return d
def getMBIDArtistTracks(self,gid):
d = sw.queryOnce(qc.query("music_dbfile"),"""
SELECT
track.gid as track_mbid,
track.name as track_name,
artist.name as artist_name
FROM artist, track
WHERE artist.gid = :gid
AND track.artist = artist.id
LIMIT 20;
""",params = {"gid":gid})
for item in d:
item['name']= item['track_name']
return d
def hearabout(self):
p = request.params;
address = p['address']
sb_port = p['sb_port']
pg_port = p['pg_port']
sqw = swrap.sqliteWrapper(qc.query('friends_dbfile'))
sqw.query("""
INSERT OR IGNORE INTO
known(address,pg_port,sb_port)
values(:address,:pg_port,:sb_port)
"""
,params={'address':address,'sb_port':sb_port,'pg_port':pg_port})
sqw.commit()
sqw.close()
def getMBIDAlbumTracks(self,gid):
d = sw.queryOnce(qc.query("music_dbfile"),"""
SELECT
track.gid as track_mbid,
track.name as track_name,
album.name as album_name,
track.number as track_number,
track.length as track_length
FROM album, albumjoin, track
WHERE album.gid = :gid
AND albumjoin.album = album.id
AND track.id = albumjoin.track
ORDER BY track_number
""",params = {"gid":gid})
for item in d: item['name']= item['track_name']
return d
def readPref(name, username=None):
db = sqw.sqliteWrapper(qc.query("config_dbfile"))
if not username:
d = db.queryToDict("""select value from global where name = :name""", params={"name": name})
else:
d = db.queryToDict(
"""
select value
from user_prefs, user
where user_prefs.name = :name
and user.name = :username
and user_prefs.user = user.id;
""",
params={"username": username, "name": name},
)
db.close()
if len(d) == 0:
return None
else:
return d[0]["value"]
def deletePref(name, username=None):
db = sqw.sqliteWrapper(qc.query("config_dbfile"))
if not username:
db.query(
"""
DELETE FROM global
WHERE name =:name;
""",
params={"name": name},
)
else:
uid = db.queryToDict("""SELECT id FROM user WHERE name = :username;""", params={"username": username})[0]["id"]
d = db.query(
"""
DELETE FROM user_prefs
WHERE name = :name
AND user = :user;
""",
params={"name": name, "user": uid},
)
db.commit()
db.close()
def writePref(name, value, username=None):
db = sqw.sqliteWrapper(qc.query("config_dbfile"))
if not username:
db.query(
"""
INSERT OR REPLACE INTO
global(name, value)
values(:name,:value) ;
""",
params={"name": name, "value": value},
)
else:
uid = db.queryToDict("""SELECT id FROM user WHERE name = :username;""", params={"username": username})[0]["id"]
d = db.query(
"""
INSERT OR REPLACE INTO
user_prefs(name, value, user)
values(:name,:value,:user);
""",
params={"name": name, "value": value, "user": uid},
)
db.commit()
db.close()
def wrap(dbname):
import sqliteWrapper as sqw
dbfile = qc.query(dbname+'_dbfile')
db = sqw.sqliteWrapper(dbfile)
return db
def userPassword(uname):
dbf = qc.query('config_dbfile')
pw = sqw.sqliteWrapper(dbf).queryToDict("select password from user where user.name = :uname",{'uname':uname})[0]['password']
return pw
def list(self):
fdb = qc.query('friends_dbfile')
sqw = swrap.sqliteWrapper(fdb)
d = sqw.queryToDict("select * from friends;")
sqw.close()
return sjson.dumps(d)
def sb_root_url():
addr = qc.query('sb_address')
port = qc.query('sb_port')
url ="http://"+str(addr)+":"+str(port)
return url
def getFriends(self):
sqw = swrap.sqliteWrapper(qc.query('friends_dbfile'))
d = sqw.queryToDict("select address, sb_port, pg_port from friends")
sqw.close()
return sjson.dumps(d)
def tagDir():
music_dir = qc.query('music_lib')
pgw = mbrainz()
ask_certain = True
ask_maybe = True
for base, dirs, files in os.walk(music_dir,followlinks = True):
#automatically treat each directory as a cluster
mut = []
for f in files:
ext = os.path.splitext(f)[-1]
if ext == '.mp3': mut.append(MP3(os.path.join(base,f)))
artist_names = []
album_names = []
tracks = []
if mut == []: continue
for m in mut:
album_name = m['TALB'].text[0]
artist_name = m['TPE1'].text[0]
print artist_name
if not album_name in album_names: album_names.append(album_name)
if not artist_name in artist_names: artist_names.append(artist_name)
if not m.has_key('TRCK') or not m.has_key('TIT2'):
print "MP3's in the current directory lack track or title data.\n ... Continuing to next dir"
break
track_num = m['TRCK'].text[0]
num_re = re.compile('^\W*\d*')
num = re.search(num_re,unicode(track_num)).group()
title = m['TIT2'].text[0]
length = m.info.length*1000
tracks.append({'mut':m,'number':num,'name':title,'length':length})
if tracks == []: continue
ds = []
print '\n\n\nTagging: ' + unicode(base) + '\n'
print 'found artists:'
pprint.pprint(artist_names)
print 'and albums:'
pprint.pprint(album_names)
print '\n'
for a in artist_names:
for alb in album_names:
print a, alb
d = pgw.queryToDict("""
select set_limit(.6);
select
artist.name as artist_name,
release_group.name as rg_name,
album.name as album_name,
album.gid as album_mbid,
release_group.gid as rg_mbid,
artist.gid as artist_mbid,
track.gid as track_mbid,
track.name as name,
albumjoin.sequence as number,
track.length as length
from artist, album, track, albumjoin, release_group
where artist.name %% %s
and release_group.artist = artist.id
and album.name %% %s
and release_group.id = album.release_group
and albumjoin.album = album.id
and albumjoin.track = track.id
limit 100;
""",params = (a,alb))
ds.extend(d)
#for each appearance of an artist or album in the current directory,
#all possible matching releases have been accumulated into ds.
#now, assume that each song in the current dwells within
#the same release group and try to parse everything.
if ds == []:
print '\n\nUh oh. \n \n Found no musicbrainz info....\n Continuing\n\n'
continue
rgs = []
albs = []
for k, g in itertools.groupby(ds, key = lambda x: x['rg_mbid']):
items = list(g)
rgs.append(items)
for k2, g2 in itertools.groupby(items, key = lambda x:x['album_mbid']):
i2 = list(g2)
albs.append(i2)
#the easiest case: finding an album match
outcome = matchAlbum(tracks, albs)
pgw.close()
def addmeta(self):
mdb = swrap.sqliteWrapper(qc.query('music_dbfile'))
tracks = mdb.queryToDict("""
SELECT gid, id from tracklist
""")
mbw = mbwrap.mbrainzWrapper()
#meta fields:
#list, gid, name, number, length, album, artist
out =[]
for t in tracks:
#METADATA GATHERING LOOP!
d = mbw.queryToDict("""
SELECT
track.name as track_name,
track.length as track_length,
albumjoin.sequence as track_number,
artist.name as artist_name,
album.name as album_name,
artist.gid as artist_gid,
album.gid as album_gid
FROM
album, artist, track, albumjoin
WHERE
track.artist=artist.id AND
albumjoin.track=track.id AND
albumjoin.album=album.id AND
track.gid= %(track_gid)s
LIMIT 1;
"""
, params={'track_gid':t['gid']} )
r = d[0]
mdb.query('INSERT OR IGNORE INTO artist(name,gid) values( :artist_name, :artist_gid);',params = {'artist_name':r['artist_name'],
'artist_gid':r['artist_gid']})
ans=mdb.queryToDict('select id from artist where gid= :artist_gid;' ,params = {'artist_gid':r['artist_gid']})
artist_id = ans[0]['id']
mdb.query('INSERT OR IGNORE INTO album(name,gid,artist) values( :album_name, :album_gid,:artist_id);'
,params = {'album_name':r['album_name'],
'artist_id':artist_id,
'album_gid':r['album_gid']})
album_id = mdb.queryToDict('SELECT id FROM album WHERE gid = :album_gid',params = {'album_gid':r['album_gid']})[0]['id']
artist_id = mdb.queryToDict('''
SELECT id
FROM artist
WHERE gid = :artist_gid''',params = {'artist_gid':r['artist_gid']})[0]['id']
mdb.query("""
INSERT OR IGNORE INTO
track(listing, gid, name, number, length, album, artist)
values(:track_id, :track_gid,:track_name, :track_number, :track_length, :album_id, :artist_id)"""
,params={'album_id':album_id,
'artist_id':artist_id,
'track_number':r['track_number'],
'track_length':r['track_length'],
'track_name':r['track_name'],
'track_gid':t['gid'],
'track_id':t['id']})
mdb.query("""
INSERT OR IGNORE INTO
albumjoin(track, album, artist)
values(:track_id, :album_id, :artist_id)
""",
params = {'album_id':album_id,
'artist_id':artist_id,
'track_id':t['id']})
mdb.commit()
d = mdb.queryToDict("SELECT name FROM artist")
mdb.close()
mbw.close()
strout = ''
for i in d:
strout = strout + i['name']
return sjson.dumps(strout)
try:
opts, args = getopt.getopt(argv, '',['reset-all','reset-meta','help'])
except getopt.GetoptError, e:
print e
usage()
sys.exit(2)
for opt, arg in opts:
if opt in ("-h", "--help"):
usage()
sys.exit()
elif opt == '--reset-all':
do_reset = True
elif opt == '--reset-meta':
do_reset_meta = True
sb_dir = qc.query('scatterbrainz_dir')
music_dir = qc.query('music_dir')
tracks_dir = os.path.join(music_dir,'tracks')
dbfile = qc.query('music_dbfile')
sqw = swrap.sqliteWrapper(dbfile)
if do_reset:
d = sqw.queryToDict('''select name from sqlite_master where type = 'table';''')
print 'Resetting all music tables'
for table in d:
sqw.query("""drop table '""" + table['name'] + """';""")
if do_reset_meta:
d = sqw.queryToDict('''select name from sqlite_master where type = 'table';''')
print 'Resetting music meta tables'
