def __init__(self):
db_path = os.path.join(xdg.get_data_home(), "data.db")
if os.path.exists(db_path):
self.conn = sqlite3.connect(db_path)
self.conn.row_factory = sqlite3.Row
self.c = self.conn.cursor()
else:
self.conn = sqlite3.connect(db_path)
self.conn.row_factory = sqlite3.Row
self.c = self.conn.cursor()
self.creer_tables()
# self.scanner_dossier("/home/piccolo/Musique")
# xdg.make_missing_dirs()
BDD.initNetwork()
# Abonnement à certains types de messages auprès du messager
messager.inscrire(self.charger_playlist, "ID_playlist")
# messager.inscrire(self.fill_library_browser, 'TS_bibliotheque')
# messager.inscrire(self.remplir_liste_sections, 'liste_sections')
messager.inscrire(self.get_tracks_data, "need_tracks")
messager.inscrire(self.get_track_data, "queue_add_track")
# messager.inscrire(self.get_data_of, 'need_data_of')
messager.inscrire(self.add_file_in, "fileIN")
messager.inscrire(self.add_file_in, "fileINuniverse", None, "univers_ID")
messager.inscrire(self.ajouter_section, "new_category", None, "categorie")
messager.inscrire(self.ajouter_section, "new_universe", None, "univers")
# messager.inscrire(self.create_intelligent_playlist, 'intelligent_playlist_request')
print ("BDD initialisée")
def initNetwork():
BDD.network_is_connected = threading.Event()
BDD.network_cache = []
try:
f = open(os.path.join(xdg.get_data_home(), "network_cache.txt"), "r")
queue = f.readlines()
f.close()
for e in queue:
BDD.network_cache.append(eval(e))
except IOError:
logger.debug("No network cache file")
try:
API_KEY = "04537e40b5501f85610cf4e4bbf1d97a" # this is a sample key
API_SECRET = "b36376228a6e72314ffd503b8e3c9f5e"
# In order to perform a write operation you need to authenticate yourself
username = settings.get_option("music/audioscrobbler_login", "")
password_hash = md5(settings.get_option("music/audioscrobbler_password", ""))
BDD.network = LastFMNetwork(
api_key=API_KEY, api_secret=API_SECRET, username=username, password_hash=password_hash
)
logger.debug("Connection successfuly established with Last.fm")
BDD.network_is_connected.set()
except NetworkError:
logger.debug("Connection to Last.fm failed")
def saveCache():
try:
f = open(os.path.join(xdg.get_data_home(), "network_cache.txt"), "w")
for e in BDD.network_cache:
f.write(str(e) + "\n")
f.close()
except:
logger.debug("Error saving scrobbling cache")
def add_playlist(self, button):
DN = gtk.Dialog()
Entry = gtk.Entry()
hbox = gtk.HBox()
hbox.pack_start(gtk.Label(_("Name") + " : "), False, 5, 5)
hbox.pack_end(Entry)
DN.vbox.add(hbox)
DN.add_button("OK", 1)
DN.add_button(_("Cancel"), 0)
DN.show_all()
action = DN.run()
name = Entry.get_text()
DN.destroy()
if action == 1:
fichier = open(os.path.join(xdg.get_data_home(), "playlists" + os.sep) + name, "w")
fichier.close()
messager.diffuser("playlist_ajoutee", self, ["personalised", name])
def quit(self):
f = open(os.path.join(xdg.get_data_home(), "network_cache.txt"), "w")
for e in BDD.network_cache:
f.write(str(e) + "\n")
f.close()
def check_for_new_files(self, progressWidget, folders=None):
"""
Méthode principale pour remplir la base
- Est executée dans un thread secondaire
@param dossier : le dossier père qui sera scanné
@param progressWidget : la barre de progrès pour informer de l'état d'avancement du scan
TODO walk + list (see Bluemindo)
TODO use trigger to check existence - not needed with current process
TODO PERF trick : essayer de checker l'existence avec un trigger mais sans récupérer les tags
TODO prompter les fichiers mal nommés
"""
if folders is None:
folders = settings.get_option("music/folders", [])
# Redéfinition d'une connexion puisque cette fonction tourne dans un thread secondaire :
conn = sqlite3.connect(os.path.join(xdg.get_data_home(), "data.db"))
conn.row_factory = sqlite3.Row
c = conn.cursor()
recovered_paths = []
error_paths = []
def add_files(files):
"""
Ajoute des nouveaux fichiers à la BDD
@param files : liste de tuples(type, dossier, fichier, extension)
@param progressWidget : barre de progrès représentant l'avancement
"""
registered_paths = []
c.execute("SELECT path FROM tracks")
for row in c:
registered_paths.append(row[0])
c.execute("SELECT folder, filename, folder FROM pictures")
for row in c:
registered_paths.append(row[0] + os.sep + row[1])
c.execute("SELECT folder, filename, folder FROM videos")
for row in c:
registered_paths.append(row[0] + os.sep + row[1])
new_paths = list(set(recovered_paths) - set(registered_paths))
new_files = {"music": [], "picture": [], "video": []}
# *** REQUETE PARAMETREE AVEC CLAUSE IN -> for row in conn.execute('SELECT path FROM tracks WHERE path IN (%s)' % ("?," * len(tracks_path))[:-1], tracks_path):
longueur = float(len(files["music_files"]))
progressWidget.setFraction(0)
i = 0
for track in files["music_files"]:
path = track[0] + os.sep + track[1]
if path in new_paths:
new_files["music"].append(get_track_data(path, track[2]))
i += 1
progressWidget.setFraction((float(i) / longueur))
longueur = float(len(files["picture_files"]))
progressWidget.setFraction(0)
i = 0
for element in files["picture_files"]:
path = element[0] + os.sep + element[1]
if path in new_paths:
new_files["picture"].append(get_UC_element_data("picture", element[0], element[1]))
i += 1
progressWidget.setFraction((float(i) / longueur))
longueur = float(len(files["video_files"]))
progressWidget.setFraction(0)
i = 0
for element in files["video_files"]:
path = element[0] + os.sep + element[1]
if path in new_paths:
new_files["video"].append(get_UC_element_data("video", element[0], element[1]))
i += 1
progressWidget.setFraction((float(i) / longueur))
for section in new_files.iterkeys():
if section == "music":
conn.executemany(
"INSERT INTO tracks (path, title, album, artist, genre, length, rating, playcount, year, performer) VALUES (?,?,?,?,?, ?, ?, ?, ?, ?)",
new_files[section],
)
else:
conn.executemany(
"INSERT INTO "
+ section
+ "s (folder, filename, rating, categorie_ID, univers_ID, size) VALUES (?, ?, ?, ?, ?, ?)",
new_files[section],
)
progressWidget.setFraction(0)
conn.commit()
def get_UC_element_data(type, dossier, fichier):
t = (unicode(dossier), unicode(fichier), 0, 1, 1, os.path.getsize(os.path.join(dossier, fichier)))
return t
def get_track_data(fichier, extension):
tags = Tags.fromPath(fichier)
fichier = unicode(fichier)
t = (
fichier,
tags["title"],
tags["album"],
tags["artist"],
tags["genre"],
tags["length"],
0,
0,
tags["year"],
tags["performer"],
)
# conn.execute('INSERT INTO tracks (path, title, album, artist, genre, length, note, compteur, year) VALUES (?,?,?,?,?, ?, ?, ?, ?)', t)
return t
def scanner_dossier(dossier, dig=False, files={"music_files": [], "picture_files": [], "video_files": []}):
"""
Scanne récursivement un dossier et ses sous-dossiers pour repérer les fichiers intéressants
@param dossier : le dossier qui sera scanné
@param files : un dictionnaire contenant des listes de tuples contenant les infos des nouveaux fichiers
"""
def add_new_CU(type, dossier, fichier, extension):
try:
t = (unicode(dossier), unicode(fichier))
c.execute("SELECT COUNT(" + type + "_ID) FROM " + type + "s WHERE folder = ? AND filename = ?", t)
if c.fetchone()[0] == 0: # Si le fichier n'est pas déjà dans la base
files.append((type, dossier, fichier, extension))
except UnicodeDecodeError:
logger.debug("Fichier avec nom foireux : " + dossier + fichier)
def check_interest(dossier, fichier, extension):
if extension == ".mp3" or extension == ".ogg":
try:
t = (unicode(dossier + os.sep + fichier),)
# c.execute('SELECT COUNT(track_ID) FROM tracks WHERE path = ?', t)
# if(c.fetchone()[0] == 0): #Si le fichier n'est pas déjà dans la base
files["music_files"].append((dossier, fichier, extension))
recovered_paths.append(unicode(dossier + os.sep + fichier))
except UnicodeDecodeError:
error_paths.append(dossier + os.sep + fichier)
elif extension == ".flv" or extension == ".mkv" or extension == ".avi":
try:
files["video_files"].append((dossier, fichier))
recovered_paths.append(unicode(dossier + os.sep + fichier))
except UnicodeDecodeError:
error_paths.append(dossier + os.sep + fichier)
elif extension in (".jpg", ".gif", ".png", ".bmp"):
try:
if dossier != "thumbnails/images": # *** A COMPLETER ***
files["picture_files"].append((dossier, fichier))
recovered_paths.append(unicode(dossier + os.sep + fichier))
except UnicodeDecodeError:
error_paths.append(dossier + os.sep + fichier)
# elif extension == '.pdf':
# add_new_CU('document', dossier, fichier, extension)
progressWidget.pulse()
for f in os.listdir(dossier):
if f[0] != ".":
if os.path.isfile(os.path.join(dossier, f)):
(shortname, extension) = os.path.splitext(f)
check_interest(dossier, f, extension)
else:
if dig:
scanner_dossier(dossier + os.sep + f, files)
return files
for folder in folders:
new_files = scanner_dossier(folder[0], folder[1])
add_files(new_files)
for path in error_paths:
logging.debug("Chemin foireux : " + path)
progressWidget.emitDone()
def __init__(self):
db_path = os.path.join(xdg.get_data_home(), "data.db")
if os.path.exists(db_path):
self.conn = sqlite3.connect(db_path)
self.conn.row_factory = sqlite3.Row
self.c = self.conn.cursor()
def save(self): f = open(os.path.join(xdg.get_data_home(), 'playlists') + os.sep + self.label, 'w') for track in self.model.tracks: f.write(str(track.ID) + "\n") f.close()
