David Castex
c9bfc721d3
La partie 'analyse' du programme est fonctionnelle Ajout de fichiers intentionellement erronés dans le repertoire de test
442 lines
18 KiB
Python
442 lines
18 KiB
Python
# ~~ Script DORY Digitanie ~~
|
|
|
|
# Voir algorithme.txt pour plus de détails et commentaires
|
|
|
|
|
|
|
|
import os # getcwd(),
|
|
|
|
|
|
## TODO : voir le pb des dicos qui auraient plusieurs fois les memes clés (se qui n'est pas possible) à cause de plusieurs fichiers qui auraient la meme extension
|
|
|
|
|
|
|
|
# - une liste des extensions nécessaires
|
|
NECESSAIRES = ["cpg", "dbf", "prj", "shp", "shx"]
|
|
|
|
# - une liste des extentions auxiliaires
|
|
AUXILIAIRES = ["qix", "qmd", "qml"]
|
|
|
|
# - la configuration de la feuille Excel
|
|
CONFIG = {"NOM" : "A5",
|
|
"TYPE" : "B5",
|
|
"NB_FICHIERS" : "C5",
|
|
"ENCODAGE" : "D5",
|
|
"PROJECTION" : "E5",
|
|
"VALIDITE" : "F5"}
|
|
|
|
|
|
|
|
# REPRESENTATION DES DONNEES
|
|
|
|
class _Fichier:
|
|
def __init__(self,
|
|
nom_original="Pas de nom original",
|
|
chemin="Pas de chemin",
|
|
extension="Pas d'extension",
|
|
nom= "Pas de nom",
|
|
implication="Non-conforme"):
|
|
self.nom_original = nom_original # - son nom original - string
|
|
self.chemin = chemin # - son chemin - string
|
|
self.extension = extension # - son extension - string
|
|
self.nom = nom # - son nom formaté - string
|
|
self.implication = implication # - son implication - enum
|
|
# {"Nécessaire",
|
|
# "Auxiliaire",
|
|
# "Non-conforme",
|
|
# "A-ignorer"}
|
|
def afficher(self):
|
|
"""Affiche dans la sortie standard les éléments du fichier
|
|
"""
|
|
print("nom : ".center(16), self.nom)
|
|
print("nom orig : ".center(16), self.nom_original)
|
|
print("ext : ".center(16), self.extension)
|
|
print("chemin : ".center(16), self.chemin)
|
|
print("implication :".center(16), self.implication)
|
|
|
|
def impliquer(self):
|
|
"""Définir l'implication d'un fichier
|
|
|
|
Les fichiers nécessaires sont indispensables sinon l'importation
|
|
de la couche échoue.
|
|
Les fichiers optionels (ou auxiliaires) contiennent des données
|
|
supplémentaires lors de l'importation.
|
|
Les fichiers non conformes pourraient être importer dans QGIS. Mais,
|
|
ne sont pas conformes au cahier des charges.
|
|
Les fichiers ignorés ne fonctionnent pas dans QGIS.
|
|
L'implication est définie en fonction de l'extension du fichier.
|
|
"""
|
|
match self.extension:
|
|
case "dbf" | "cpg" | "prj" | "shx" | "shp":
|
|
self.implication = "Necessaire"
|
|
case "qix" | "qmd" | "qml":
|
|
self.implication = "Auxiliaire"
|
|
case "gpkg" | "sqlite":
|
|
self.implication = "Non-conforme"
|
|
case _:
|
|
self.implication = "A-ignorer"
|
|
# TODO : gerer la casse des extensions pour que le controle se fasse
|
|
|
|
|
|
|
|
## TODO Mettre les init de dico à vide {} plutot ??
|
|
class _Catalogue:
|
|
def __init__(self,
|
|
necessaires,
|
|
auxiliaires,
|
|
non_conformes
|
|
):
|
|
self.necessaires = necessaires # - son dictionnaire de fichiers nécessaires avec pour clé l'extention
|
|
# de chaque fichier - dico de paire string : _Fichier
|
|
self.auxiliaires = auxiliaires # - son dictionnaire de fichiers auxiliaires avec pour clé l'extention
|
|
# de chaque fichier - dico de paire string : _Fichier
|
|
self.non_conformes = non_conformes # - son dictionnaire de fichiers non-conformes avec pour clé l'extention
|
|
# de chaque fichier - dico de paire string : _Fichier
|
|
# PB : Pour le moment cette facon de representer des groupes de fichiers
|
|
# ne gèrent pas le fait qu'il y ai plusieurs fichiers avec la meme extension,
|
|
# en effet, je ne peux pas avoir plusieurs clés avec la meme extension
|
|
|
|
def afficher(self):
|
|
"""Affiche le catalogue dans la sortie standard
|
|
|
|
Affiche aussi un message si pour chaque dictionnaire vide
|
|
"""
|
|
if self.necessaires: # TODO renvoie False si dico = {} ou alors dois je écrire if necessaires == {}
|
|
print("fichiers nécessaires :".center(28))
|
|
for fichier in self.necessaires.values():
|
|
print(" ", fichier.nom, fichier.extension)
|
|
else:
|
|
print("Pas de Nécessaires".center(28))
|
|
if self.auxiliaires:
|
|
print("fichiers auxiliaires :".center(28))
|
|
for fichier in self.auxiliaires.values():
|
|
print(" ", fichier.nom, fichier.extension)
|
|
else:
|
|
print("Pas d'Auxiliaires".center(28))
|
|
if self.non_conformes:
|
|
print("fichiers non conformes :".center(28))
|
|
for fichier in self.non_conformes.values():
|
|
print(" ", fichier.non_conformes)
|
|
else:
|
|
print("Pas de Non-conformes".center(28))
|
|
|
|
|
|
|
|
class _Projet:
|
|
def __init__(self,
|
|
nom="Pas de nom",
|
|
necessaires = {},
|
|
auxiliaires = {},
|
|
non_conformes = {},
|
|
nb_fichiers=0,
|
|
conformite="Non conforme",
|
|
projection="Pas de projection",
|
|
encodage="Pas d'encodage"):
|
|
self.nom = nom # - son nom - string
|
|
self.necessaires = necessaires
|
|
self.auxiliaires = auxiliaires
|
|
self.non_conformes = non_conformes
|
|
self.nb_fichiers = nb_fichiers # - son nombre de fichiers - entier
|
|
self.conformite = conformite # - sa conformité - bool
|
|
self.projection = projection # - sa projection géodésique - string // ou énumération --> voir Constantes
|
|
self.encodage = encodage # - son type d'encodage prévu dans QGIS string
|
|
# /* pour ce script, ce devrait être forcement "UTF8" */
|
|
|
|
def afficher(self):
|
|
"""Affiche dans la sortie standard le contenu d'un projet
|
|
"""
|
|
print("nom : ".center(16), self.nom)
|
|
print("nb fichiers :".center(16), self.nb_fichiers)
|
|
print("conformité :".center(16), self.conformite)
|
|
print("projection :".center(16), self.projection)
|
|
print("encodage :".center(16), self.encodage)
|
|
print("necessaires :".center(16), self.necessaires)
|
|
print("auxiliaires :".center(16), self.auxiliaires)
|
|
print("non_conformes :".center(16), self.non_conformes)
|
|
#self.catalogue.afficher()
|
|
|
|
def cataloguer(self, fichier):
|
|
"""Catalogue le fichier dans le projet
|
|
|
|
La méthode ajoute le fichier suivant son extension
|
|
dans un des dictionnaires du catalogue
|
|
"""
|
|
match fichier.implication:
|
|
case "Necessaire":
|
|
self.necessaires[fichier.extension] = fichier
|
|
case "Auxiliaire":
|
|
self.auxiliaires[fichier.extension] = fichier
|
|
case "Non-conforme":
|
|
self.non_conformes[fichier.extension] = fichier
|
|
|
|
def lire_projection(self):
|
|
"""Récupère la projection des données géomatiques définie.
|
|
|
|
Lis la première ligne du fichier *.PRJ du projet
|
|
et controle la présence de la chaine "RGF_1993_Lambert_93"
|
|
"""
|
|
if "prj" in self.necessaires:
|
|
df = open(self.necessaires["prj"].chemin)
|
|
chaine = df.readline()
|
|
df.close()
|
|
if "RGF_1993_Lambert_93" in chaine:
|
|
self.projection = "LAMBERT93"
|
|
else:
|
|
print(projet.nom, " : pas de PRJ trouvé --> pas de projection définie")
|
|
|
|
def lire_encodage(self):
|
|
"""Récupère l'encodage prévu pour les fichiers dans QGIS
|
|
|
|
Lis la première ligne du fichier *.CPG du projet
|
|
et controle la présence de la chaine "UTF-8"
|
|
"""
|
|
if "cpg" in self.necessaires:
|
|
df = open(self.necessaires["cpg"].chemin)
|
|
chaine = df.readline()
|
|
#print("encod lu : ", chaine)
|
|
df.close()
|
|
if "UTF-8" in chaine:
|
|
self.encodage = "UTF8"
|
|
else:
|
|
print(projet.nom, " : pas de CPG trouvé --> pas d'encodage définie")
|
|
|
|
def valider(self):
|
|
"""Valide la conformité du projet
|
|
|
|
Controle si les 5 fichiers differents nécessaires sont présents.
|
|
Controle si la projection est correcte (pour le moment Lambert93).
|
|
Controle si l'encodage défini pour l'import dans QGIS est bien UTF8.
|
|
Si ces 3 controles sont OK, alors le projet est défini comme valide.
|
|
"""
|
|
nb_controles_OK = 0
|
|
# Controle présences fichiers
|
|
valide = [False, False, False, False, False]
|
|
for extension in self.necessaires.keys():
|
|
match extension:
|
|
case "dbf":
|
|
valide[0] = True
|
|
case "cpg":
|
|
valide[1] = True
|
|
case "prj" :
|
|
valide[2] = True
|
|
case "shx" :
|
|
valide[3] = True
|
|
case "shp" :
|
|
valide[4] = True
|
|
if valide[0] and valide[1] and valide[2] and valide[3] and valide[4]:
|
|
nb_controles_OK += 1
|
|
|
|
# Controle projection
|
|
if self.projection == "LAMBERT93":
|
|
nb_controles_OK += 1
|
|
|
|
# Controle encodage
|
|
if self.encodage == "UTF8":
|
|
nb_controles_OK += 1
|
|
|
|
# Si les 3 controles sont OK ALors le projet est conforme
|
|
if nb_controles_OK == 3:
|
|
self.conformite = "Conforme"
|
|
|
|
|
|
|
|
# DEFINITIONS DE FONCTIONS
|
|
|
|
def formatter(chaine):
|
|
"""Formate selon nomenclature.
|
|
|
|
Formate la chaine de caractères passée en paramètre :
|
|
Enlève tous les accents français. Enlève la cédille du C.
|
|
Remplace les espaces ' ' et les traits d'union '-' par
|
|
des tirets bas '_'.
|
|
Ne traite pas pour le moment le AE et OE ligaturé.
|
|
"""
|
|
#TODO : gérer les accents sur majuscules
|
|
#TODO : amélioration ou exercice, utiliser la méthode str.translate() et maketrans
|
|
resultat = ""
|
|
for c in chaine:
|
|
match c:
|
|
case "à" | "â" | "ä":
|
|
resultat+= "a"
|
|
case "é" | "è" | "ê" | "ë":
|
|
resultat+= "e"
|
|
case "î" | "ï":
|
|
resultat+= "i"
|
|
case "ô" | "ö":
|
|
resultat+= "o"
|
|
case "ù" | "û" | "ü":
|
|
resultat+= "u"
|
|
case "ÿ":
|
|
resultat+= "y"
|
|
case "ç":
|
|
resultat+= "c"
|
|
case " " | "-":
|
|
resultat+= "_"
|
|
case _:
|
|
resultat+= c
|
|
return resultat
|
|
|
|
|
|
|
|
|
|
# DEBUT DU PROGRAMME
|
|
|
|
liste = [] # - une liste des fichiers list _Fichier
|
|
dico = {} # - un dictionnaire des projets avec pour clé le nom de chaque projet
|
|
# dico de paire string : Entité Projet
|
|
racine = os.getcwd() # - un chemin absolue vers le repertoire racine à traiter string
|
|
print("Racine : ".center(18), racine)
|
|
|
|
|
|
|
|
# --recupérer le chemin du dossier à traiter
|
|
# Si il y a PAS un dossier de traitement dans le working directory Alors
|
|
pas_de_dossier = True
|
|
|
|
for a in os.scandir():
|
|
if a.is_dir():
|
|
#il y a un dossier
|
|
pas_de_dossier = False
|
|
if pas_de_dossier:
|
|
print("Pas de dossier trouvé...\nFin de programme\n")
|
|
os.system("pause")
|
|
# fin du programme
|
|
exit()
|
|
else:
|
|
print(f"Dossier à Traiter trouvé : {a.name}")
|
|
racine = a
|
|
|
|
|
|
# --analyser le dossier
|
|
# initialiser une liste de _Fichiers
|
|
liste = []
|
|
# Pour Chaque fichier des dossiers et sous dossiers à explorer Faire
|
|
for dossier_courant, list_sousdossiers, list_fichiers in os.walk(racine): ##TODO voir la fonction fwalk qui renvoie un 4-tuple(dirpath, dirnames, filenames, dirfd), and it supports dir_fd
|
|
for fichier_courant in list_fichiers:
|
|
# --lire, analyser chaque fichier et peupler la liste
|
|
# initialiser un _Fichier
|
|
ce_Fichier = _Fichier()
|
|
# lire son chemin
|
|
ce_Fichier.chemin = dossier_courant + "\\" + fichier_courant
|
|
# déterminer son nom original et son extension
|
|
# lire le nom original
|
|
# lire son extension
|
|
ce_Fichier.nom_original, ce_Fichier.extension = fichier_courant.split(".")
|
|
# formatter et écrire le nom
|
|
ce_Fichier.nom = formatter(ce_Fichier.nom_original)
|
|
# déterminer son implication
|
|
ce_Fichier.impliquer()
|
|
# ajouter le _Fichier à la liste
|
|
liste.append(ce_Fichier)
|
|
# Fin Pour
|
|
|
|
# /* Ici la liste des _Fichiers doit être correctement remplie */
|
|
#TEST affichage de la liste de fichier
|
|
|
|
# initialiser un dictionnaire de _Projets avec comme clé leurs noms respectifs
|
|
print("Init Dico\n")
|
|
dico = {}
|
|
# Pour Chaque fichier de la liste Faire
|
|
for fichier_courant in liste:
|
|
if fichier_courant.implication not in "A-ignorer":
|
|
# --associer le fichier courant à un projet du dictionnaire
|
|
# /* Vérifier que le projet existe déjà dans le dico */
|
|
# Si le nom du fichier courant n'est pas dans le dico Alors
|
|
if fichier_courant.nom not in dico:
|
|
# initialiser un _Projet
|
|
projet = _Projet()
|
|
projet.necessaires = {}
|
|
projet.auxiliaires = {}
|
|
projet.non_conformes = {}
|
|
projet.nom = fichier_courant.nom
|
|
print("création clé : ", projet.nom)
|
|
# ajouter le nom comme clé dans le dictionnaire
|
|
# associer le projet à cette clé
|
|
dico[projet.nom] = projet
|
|
|
|
#test contenu du dico
|
|
|
|
# Fin Si
|
|
# cataloguer le fichier dans le projet concerné
|
|
projet.cataloguer(fichier_courant)
|
|
# il y a un fichier de plus au projet
|
|
projet.nb_fichiers += 1
|
|
else:
|
|
# sinon le fichier est a ignorer
|
|
print("Ignoré : ".center(16), fichier_courant.nom_original)
|
|
# Fin Pour
|
|
|
|
# Pour Chaque projet du dictionnaire Faire
|
|
for projet in dico.values():
|
|
# --analyser et completer les infos du projet courant
|
|
# /* conformité, projection, encodage etc */
|
|
# lire la projection du projet courant
|
|
projet.lire_projection()
|
|
# lire l'encodage du projet courant
|
|
projet.lire_encodage()
|
|
# Si tous les fichiers nécessaires sont présents ET
|
|
# la projection est correcte ET
|
|
# l'encodage est correct Alors
|
|
# passer le projet à conforme
|
|
projet.valider()
|
|
# Fin Si
|
|
# Fin Pour
|
|
|
|
# /* Ici le dictionnaire des _Projets doit être correctement remplie */
|
|
|
|
|
|
os.system("pause")
|
|
|
|
# --produire le rapport
|
|
# créer un classeur Excel
|
|
# /* Note : peut être utiliser un modèle pré-config */
|
|
# --mettre en page la première feuille du classeur
|
|
# inserer une image
|
|
# écrire les nom des colonnes
|
|
# écrire les formules de colorations auto des colonnes
|
|
|
|
# Pour chaque projet du dictionnaire Faire
|
|
# --completer la feuille avec les infos du projet courant
|
|
# /* Note : Chaque ligne de la feuille correspond à un projet */
|
|
# /* Utiliser la config fournie en Constante */
|
|
# écrire le nom du projet
|
|
# écrire le type d'extention
|
|
# /* Note : ce sera "SHP" pour les projets conformes et le type
|
|
# natif pour les non-conformes */
|
|
# écrire le nombre de fichiers du projet
|
|
# écrire l'encodage
|
|
# écrire la projection
|
|
# écrire la validité (conformité)
|
|
# encadrer le "tout" pour délimiter le tableau de la feuille
|
|
# Fin Pour
|
|
|
|
# /* Ici le rapport doit être correctement produit et remplie */
|
|
|
|
# --produire le dossier de mise à disposition
|
|
# créer un dossier "Travail" et un dossier "Livraison"
|
|
# --créer l'arborescence du dossier "Travail"
|
|
# le dossier Travail devient le working directory
|
|
# créer un dossier "00-Cadastre"
|
|
# créer un dossier "01-Donnees_Valides"
|
|
# créer un dossier "02-Donnees_Invalides
|
|
# créer un dossier "03-Production"
|
|
# créer un dossier "04-Verif_Geometrie"
|
|
# --peupler le dossier "Travail"
|
|
# Pour Chaque projet du dictionnaire Faire
|
|
# copier les fichiers des projets conforme dans le dossier "01"
|
|
# copier les fichiers des projets non-conformes dans le dossier "02"
|
|
# Fin Pour
|
|
|
|
# /* Ici les dossiers doivent être correctement produit et remplie */
|
|
|
|
# ARRET DU PROGRAMME
|
|
|
|
|
|
|
|
# /* TODO Controler qu'il y a bien les 5 necessaires par projet sinon FAIL
|
|
# --> a faire dans le controle de conformité de chaque projet */
|
|
|
|
# /* TODO S'assurer que les GPKG et autres non conformes peuplent correctement
|
|
# les infos dans les projets --> géré si l'initialisation des
|
|
# projets est correctement fait */
|