def insertCompletion(self, completion):
"""Slot qui insère la completion quand une suggestion est choisie"""
#Le nbr de caractères à rajouter
extra = len(completion) - len(self.completer.completionPrefix())
#On traite le cas où l'user a tapé la suggestion en entier
if extra != 0:
extra_text = completion[-extra:]
else:
extra_text = ""
#On rajoute un espace si on doit le faire
if self.addSpaceAfterCompleting:
extra_text += ' '
#Passage pr gérer la completion indépendamment de la casse
current_comp = self.completer.currentCompletion()
current_text = self.text() + extra_text
current_text = current_text.split(' ')
current_text = [ word for word in current_text if word ]
if current_comp != current_text[-1] and simpleChar(current_text[-1]) == simpleChar(current_comp):
current_text[-1] = current_comp
self.setText(" ".join(current_text) + " ")
def addActor(list_vids, name_actor, logger):
"""Fct pour ajouter un acteur en bdd. Un seul acteur à la fois."""
bdd = sqlite3.connect("fichiers.sqlite") # ouverture de la base
bdd.row_factory = sqlite3.Row # accès aux colonnes par leur nom, pas par leur index
c = bdd.cursor() # obtention d'un curseur
#On vérifie que l'acteur n'est pas déjà en bdd
c.execute("SELECT * FROM actors WHERE name_simple = ? ", (simpleChar(name_actor),))
if c.fetchone() is None:
name_actor = [ each_word.capitalize() for each_word in name_actor.split(" ") ]
name_actor = " ".join(name_actor)
c.execute("INSERT INTO actors (name, name_simple) VALUES (?, ?) ", (name_actor, simpleChar(name_actor)))
bdd.commit()
#À chaque vid s'électionnée, on ajoute l'acteur
for each_video in list_vids:
#On récupère l'id de l'acteur pour s'en servir après
c.execute("SELECT id, name FROM actors WHERE name_simple= ?", (simpleChar(name_actor),))
data = c.fetchone()
id_actor = data["id"]
#On vérifie que l'acteur à stocker n'est pas déjà associé à la vidéo
c.execute("SELECT * FROM videos_actors WHERE id_video = ? AND id_actor = ?", (each_video, id_actor))
if c.fetchone() is None:
logger.info("{0} associé à la vidéo {1}".format(data["name"], each_video))
c.execute("INSERT INTO videos_actors (id_video, id_actor) VALUES (?, ?)", (each_video, id_actor))
else:
print("Cette vidéo est déjà associée à cet acteur")
bdd.commit()
c.close()
bdd.close()
def keyPressEvent(self, event):
"""Méthode qui gère l'appui sur les touches du clavier"""
super(SearchPerso, self).keyPressEvent(event)
#Les propositions valables sont ts les tags et ts les acteurs
self.propositions = listeTags() + listeActors()
#On récupère le texte entré
text = self.text()
#Les propositions valables sont celles qui matchent le texte entré
self.propositions = [ case for case in self.propositions if simpleChar(self.text()) in simpleChar(case) ]
#Si le texte des boutons à droite ne matche pas ds la liste
#des propositions, on cache le bouton, sinon on le montre
for button in self.parent.liste_pressoirs_tags:
if button.text() not in self.propositions:
button.hide()
else:
button.show()
for button in self.parent.liste_pressoirs_actors:
if button.text() not in self.propositions:
button.hide()
else:
button.show()
if event.key() == QtCore.Qt.Key_Return and self.hasFocus() and len(self.propositions) == 1:
for button in self.parent.liste_pressoirs_tags:
if button.text() == self.propositions[0]:
button.setChecked(True)
button.clicked.emit(True)
self.clear()
self.parent.reshowButtons()
for button in self.parent.liste_pressoirs_actors:
if button.text() == self.propositions[0]:
button.setChecked(True)
button.clicked.emit(True)
self.clear()
self.parent.reshowButtons()
def importation(dossier, logger, callback=None):
"""On remplit la bdd avec les listes liste et liste_chemins.
On vérifie que le fichier à ajouter n'est pas déjà en bdd. Sinon, on l'ajoute.
Accepte aussi un callback en option, pour mettre à jour la progress bar du gui
lors de l'import"""
#On récupère la liste des fichiers et leur emplacement
#Uniquement des vidéos avec un type autorisé, la fct de listing
#s'occupe de vérifier
logger.info("Importation du dossier {0}".format(dossier))
liste, liste_chemins = listing(dossier)
bdd = sqlite3.connect("fichiers.sqlite") # ouverture de la base
bdd.row_factory = sqlite3.Row # accès aux colonnes par leur nom, pas par leur index
c = bdd.cursor() # obtention d'un curseur
nbr_videos_added = 0
#On récupère le nbr de fichiers à importer, pr la progress bar
nbr_max = len(liste)
for name, path in zip(liste, liste_chemins):
md4 = md4Function(path)
# On vérifie que le fichier n'existe pas déjà. Plus d'infos :
# http://stackoverflow.com/questions/2440147/how-to-check-the-existence-of-a-row-in-sqlite-with-python
c.execute("SELECT md4 FROM videos WHERE md4= ?", (md4,))
#Si le fichier n'est pas présent, on l'ajoute à la bdd
#avec ttes les opérations qui vont avec
if c.fetchone() is None:
nbr_videos_added += 1
#On génère la miniature et la mosaïque
screen.thumb(path, md4)
screen.caps(path, md4)
#On crée des variables, plus lisibles, pr la requête sql
date_modif = datetime.datetime.fromtimestamp(int(os.path.getmtime(path))).strftime('%Y-%m-%d %H:%M:%S')
path_thumb = os.getcwd() + "/screens/{0}_thumb.png".format(md4)
today = datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S')
size = os.path.getsize(path)
#On insère aussi le nom sans accent, sans majuscule, dans un champ prévu pour faire les recherches
logger.info("Insertion de {0} dans la bdd".format(path))
c.execute("INSERT INTO videos(name, name_simple, path, thumb, date, md4, size, date_add) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
(name, simpleChar(name), path, path_thumb, date_modif, md4, size, today))
else:
logger.debug("Fichier {0} déjà présent en bdd, rien à faire".format(name))
#On appelle le callback pr mettre à jour le pourcentage
#de la progress bar de la gui, au besoin
if callback != None:
callback((liste.index(name) + 1) * 100 / nbr_max, "({0}/{1})".format(liste.index(name) + 1, nbr_max), name, os.path.dirname(path))
# On place le commit en dehors de la boucle, ça va plus vite
#EN TEST, sorti le 18/03/12 de la boucle
bdd.commit()
c.close()
bdd.close()
return nbr_videos_added
def verification(options, logger, callback=None):
"""Vérifie que les fichiers en bdd sont toujours présents dans
le répertoire d'où ils ont été recensés. Sinon, on update le path
en bdd. Si tous les répertoires surveillés existent et qu'un fichier
en bdd n'est stocké nul part, on le supprime."""
#Liste ts les dossiers surveillés dans les préfs
list_to_check = list()
#On se met ds le group de conf 'Watching'
options.beginGroup("Watching")
#On fait la liste de ttes les clés pr les pathes
pathes = options.allKeys()
if pathes:
for each_key in pathes:
#On récupère le path associé à chaque clé, et on l'ajoute à la liste
list_to_check.append(options.value(each_key))
options.endGroup()
#On ne peut effacer que si tous les dossiers
#surveillés existent
effacer = True
nbr_videos_added = 0
for each_dossier in list_to_check:
if not os.path.exists(each_dossier):
effacer = False
logger.info("Un des répertoires surveillés n'est pas accessible")
nbr_videos_added += importation(each_dossier, logger, callback)
liste, liste_chemins = listing(list_to_check)
#On crée un dico ac en clé les md4 des fichiers, en value les paths.
#comme ça, on a pas besoin de parcourir les listes, on peut accéder aux
#nouveaux paths grâce aux noms des fichiers
dico_path = dict()
for each_path in liste_chemins:
dico_path[md4Function(each_path)] = each_path
# On se connecte à la bdd, elle existe forcément
bdd = sqlite3.connect("fichiers.sqlite") # ouverture de la base
bdd.row_factory = sqlite3.Row # accès aux colonnes par leur nom, pas par leur index
c = bdd.cursor() # obtention d'un curseur
c.execute("SELECT md4, path FROM videos")
fichiers_del = 0
fichiers_updated = 0
#Pour chaque ligne de la bdd, on vérifie que le path écrit en bdd correspond
#à un fichier existant. Sinon, on efface l'entrée de la bdd
for ligne_bdd in c.fetchall():
if effacer and ligne_bdd["md4"] not in dico_path.keys():
c.execute("DELETE FROM videos WHERE md4= ?", (ligne_bdd["md4"],))
logger.info("{0} effacé de la bdd".format(ligne_bdd['path']))
fichiers_del += 1
elif ligne_bdd["md4"] in dico_path.keys() and os.path.exists(ligne_bdd["path"]) == False:
new_name = dico_path[ligne_bdd["md4"]].split("/")[-1]
c.execute("UPDATE videos SET name= ?, name_simple = ?, path= ? WHERE md4= ?",
(new_name, simpleChar(new_name), dico_path[ligne_bdd["md4"]], ligne_bdd["md4"]))
logger.info("{0} updaté dans la bdd. Dorénavant localisé: {1}".format(ligne_bdd['path'], dico_path[ligne_bdd["md4"]]))
fichiers_updated += 1
logger.info("{0} fichiers ajoutés à la bdd".format(nbr_videos_added))
logger.info("{0} fichier(s) effacé(s)".format(fichiers_del))
logger.info("{0} fichier(s) updaté(s)".format(fichiers_updated))
bdd.commit()
c.close()
bdd.close()
def renameFile(ancien_nom, nouveau_nom, parent_bdd):
"""Fct qui renomme un fichier, en bdd d'abord, ac la
mise à jour de name, name_simple et du path, puis physiquement
si le fichier est accessible.
ATTENTION : le nom du fichier n'est pas encore mis à jour dans
la bdd à l'appel de la fct."""
#On ferme ici la connexion à la bdd de la fenêtre principale
#car on ne peut pas le faire ailleurs
parent_bdd.close()
bdd = sqlite3.connect("fichiers.sqlite") # ouverture de la base
bdd.row_factory = sqlite3.Row # accès aux colonnes par leur nom, pas par leur index
c = bdd.cursor() # obtention d'un curseur
c.execute("SELECT id, path FROM videos WHERE name = ?", [ancien_nom])
path = c.fetchone()['path']
if path is not None and os.path.exists(path):
#TODO: extension .mpeg
allowed_types = ['avi', 'mkv', 'wmv', 'mov', 'mp4', 'm4v', 'mpeg', 'mpg', 'flv']
if nouveau_nom[-3:] not in allowed_types:
extension = ancien_nom.split(".")[-1]
if extension in allowed_types:
nouveau_nom = nouveau_nom + "." + extension
else:
nouveau_nom = ancien_nom
#On modifie la dernière partie du path, soit le nom du fichier
new_path = path.split("/")[:-1]
new_path = "/".join(new_path) + "/" + nouveau_nom
try:
#On renomme le fichier physiquement
os.renames(path, new_path)
#On change le nom, le nom simple, et le path en bdd
c.execute("UPDATE videos SET name = ?, path = ?, name_simple = ? WHERE name = ?", (nouveau_nom, new_path, simpleChar(nouveau_nom), ancien_nom))
print("Nom modifié dans la bdd")
except:
print("Erreur : aucun changement effectué")
else:
print("Erreur : nom non modifié en bdd")
bdd.commit()
c.close()
bdd.close()
parent_bdd.open()