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'