pyThtoBD

Data/Z510/.xtherion.dat

@@ -0,0 +1,15 @@
+set xth(ctrl,cp,datlist) {}
+xth_cp_data_tree_insert 1 {} 0   "" "" "length: 742.22m (surface 0.00m, duplicated 13.46m)\nvertical range: 237.20m (from Z_510@Z510.Z510 at 1644.00m to 2023.0@Z510.Z510 at 1406.80m)\nnorth-south range: 70.37m (from Z_510@Z510.Z510 at 4758093.00m to 2023.AC@Z510.Z510 at 4758022.63m)\neast-west range: 60.82m (from 8.2@Z510.Z510 at 679299.28m to 2023.AC@Z510.Z510 at 679238.46m)\nnumber of shots: 573\nnumber of stations: 574"
+xth_cp_data_tree_insert 66 1 1 Z510 Z510 "Z510" "Z510" "length: 742.22m (surface 0.00m, duplicated 13.46m)\nvertical range: 237.20m (from Z_510@Z510.Z510 at 1644.00m to 2023.0@Z510.Z510 at 1406.80m)\nnorth-south range: 70.37m (from Z_510@Z510.Z510 at 4758093.00m to 2023.AC@Z510.Z510 at 4758022.63m)\neast-west range: 60.82m (from 8.2@Z510.Z510 at 679299.28m to 2023.AC@Z510.Z510 at 679238.46m)\nnumber of shots: 573\nnumber of stations: 574"
+xth_cp_data_tree_insert 68 66 2 Z510 Z510.Z510 "Gouffre Z510" "Gouffre Z510" "length: 742.22m (surface 0.00m, duplicated 13.46m)\nvertical range: 237.20m (from Z_510@Z510.Z510 at 1644.00m to 2023.0@Z510.Z510 at 1406.80m)\nnorth-south range: 70.37m (from Z_510@Z510.Z510 at 4758093.00m to 2023.AC@Z510.Z510 at 4758022.63m)\neast-west range: 60.82m (from 8.2@Z510.Z510 at 679299.28m to 2023.AC@Z510.Z510 at 679238.46m)\nnumber of shots: 573\nnumber of stations: 574"
+xth_cp_data_tree_create
+set xth(ctrl,cp,maplist) {}
+xth_cp_map_tree_insert projection 0 p1 {} 0 plan {} {} {}
+xth_cp_map_tree_insert projection 0 p2 {} 0 extended {} {} {}
+xth_cp_map_tree_insert map 1 947X1 p1 1 MP-Z510-plan-tot MP-Z510-plan-tot@Z510 "Z510" "Z510"
+xth_cp_map_tree_insert map 1 948X1 p2 1 MC-Z510-coupe-tot MC-Z510-coupe-tot@Z510 "Z510" "Z510"
+xth_cp_map_tree_create
+xth_cp_comp_stat 742 14
+set xth(th_exit_state) 1
+set xth(th_exit_number) 1746719589
+

Data/Z510/therion.log

@@ -91,7 +91,7 @@ processing projection extended ... done
 average distortion: 0.02%
 done
 ####################### metapost log file ########################
-This is MetaPost, version 2.01 (TeX Live 2021/W32TeX) (kpathsea version 6.3.3)  24 APR 2025 22:32
+This is MetaPost, version 2.01 (TeX Live 2021/W32TeX) (kpathsea version 6.3.3)  8 MAY 2025 17:53
 **data.mp
 (c:/Program Files/Therion/texmf/mpost/mpost.mp
 (c:/Program Files/Therion/texmf/mpost/plain.mp
@@ -112,6 +112,7 @@ writing Outputs/Z510-Cave-list.kml ... done
 writing Outputs/Z510-Surveys.kml ... 
 C:\Program Files\Therion\therion.exe: warning -- geographical reference is not associated with table
 done
+writing xtherion file ... done
 compilation time: 1 sec
 
 

Scripts/README.en.md

@@ -51,7 +51,7 @@ Script to export therion data base to an other like Karsteau
 
 Usage:
     - Place Export_bd.ini files in each of the cave directories to be exported.
-    - Run python pyThtoDB.py, then select the Therion folder to export.
+    - Run python pyThtoBD.py, then select the Therion folder to export.
     - Results for Karsteau will be in the /Outputs/Export_bd/ directory.
     - Coming soon – Import the export results into Karsteau.
 	   

Scripts/README.md

@@ -54,7 +54,7 @@ Script pour exporter une base Therion vers une base de données type Karsteau
 
 Utilisation:
 	- Placer des fichiers Export_bd.ini dans chacun des dossiers des cavités à exporter                                    
-	- Lancer python pyThtoDB.py, sélectionner le dossier therion à exporter                                                 
+	- Lancer python pyThtoBD.py, sélectionner le dossier therion à exporter                                                 
 	- Résultats pour Karsteau dans le dossier /Outputs/Export_bd/                                                             
 	- A venir - Importer le résultat de l'importation dans Karsteau    
 

Scripts/pyThtoBD/README.rst

@@ -13,6 +13,7 @@ Résultats dans le dossier /Outputs/Export_bd de la db Therion :
 	- Export_bd.zip	: archive brute des données Therion
 	- Export_bd_data.zip : archive des documents à exporter vers Karsteau
 	
+Commande : python pyToBD.py --help
 
 ==============================
 Table des données exportées :

Scripts/pyThtoBD/pyThtoBD.py

@@ -6,9 +6,10 @@
 #                                                                                                                                      #                                           
 #                                         By Alexandre PONT  alexandre.pont@yahoo.fr                                                   # 
 #                                                                                                                                      #
+# Commande : python pyThtoBD.py --help                                                                                                 #
 # Utilisation:                                                                                                                         #
 #   1 : Placer des fichiers Export_bd.ini dans chacun des dossiers des cavités à exporter                                              #
-#   2 : Lancer python pyThtoDB.py, sélectionner le dossier therion à exporter                                                          # 
+#   2 : Lancer python pyThtoBD.py, sélectionner le dossier therion à exporter                                                          # 
 #   3 : Résultats pour Karsteau dans le dossier /Outputs/Export_bd/                                                                    #    
 #   4 : (A venir - Importer le résultat de l'importation dans Karsteau )                                                               #   
 #                                                                                                                                      #   
@@ -16,20 +17,17 @@
 ########################################################################################################################################
 
 '''
-To do liste :
+To do list :
 
-A gérer le cas de données supprimées dans th... les supprimer de la BD
+- A gérer le cas de données supprimées dans th... les supprimer de la BD
-Ajouter une compteur d'erreur global
+- Fonction pour importer les clés Karsteau
-produire un zip avec les fichiers à exporter
-fonction d'importation des clés Karsteau
 
 '''
 
 import sqlite3, sys, os, re, argparse
-import numpy as np
 import pandas as pd
 import configparser
-import matplotlib.pyplot as plt
+import hashlib
 import tkinter as tk
 import zipfile
 from tkinter import filedialog
@@ -44,7 +42,7 @@ from openpyxl import load_workbook
 from openpyxl.styles import PatternFill, Border, Side, Alignment, Font
 from openpyxl.utils import get_column_letter
 
-Version ="2025.05.05"  
+Version ="2025.05.12"  
 
 export_file ="Export_bd.ini"
 export_folder = "/Outputs/Export_bd/"
@@ -55,7 +53,18 @@ debug_log = False
 
 
 #####################################################################################################################################
-#                              Fonction pour importer un fichier SQL dans une base de données SQLite                                #
+#         Fonction calculer le hash d'un fichier                                                                                    #
+#####################################################################################################################################
+def hash_file(filepath, algo='sha256', chunk_size=8192):
+    hasher = hashlib.new(algo)
+    with open(filepath, 'rb') as f:
+        for chunk in iter(lambda: f.read(chunk_size), b''):
+            hasher.update(chunk)
+    return hasher.hexdigest()
+
+
+#####################################################################################################################################
+#         Fonction pour importer un fichier SQL dans une base de données SQLite                                                     #
 #####################################################################################################################################
 def importation_sql_db(fichier_sql, fichier_db):
     """
@@ -69,7 +78,7 @@ def importation_sql_db(fichier_sql, fichier_db):
     
     try:
         # Si la base de données existe, supprimez-la pour forcer l'écriture
-        log.info(f"Importation de la base de données Therion {Colors.MAGENTA}{fichier_sql}{Colors.GREEN} dans: {Colors.MAGENTA}{fichier_db}")
+        
         if os.path.exists(fichier_db):
             #print("Suppression de la Bd existante: " + imported_database)
             os.remove(fichier_db)
@@ -96,19 +105,22 @@ def importation_sql_db(fichier_sql, fichier_db):
 
         connection.close()
         
+        log.info(f"Importation réussie de la base de données Therion : {Colors.MAGENTA}{fichier_db}")
+        
     except sqlite3.Error as e:
         log.error(f"Erreur lors de l'exécution de la requête importation_sql_data code:{Colors.CYAN}{e}") 
         error_count  += 1
-        sys.exit(1)  # Arrête le programme en cas d'erreur
+        # sys.exit(1)  # Arrête le programme en cas d'erreur
         
     return
 
 
 #####################################################################################################################################
-#        # Requête : Table des entrées  (Liste des entrées avec coordonnées)                                                       #
+#        Requête : Table des entrées  (Liste des entrées avec coordonnées)                                                          #
 #####################################################################################################################################
-def sql_liste_entree(cursor):
+def sql_liste_entree(cursor, ID_CAVITE, NAME):
-    global error_count
+    global error_count, warning_fix
+    
     
     """
     Retour une table avec en ligne :
@@ -119,7 +131,7 @@ def sql_liste_entree(cursor):
         Z
     """
          
-    sql_query=  ("""
+    sql_query_ent=  ("""
                     select 
                         STATION.ID, 
                         STATION.NAME, 
@@ -133,16 +145,49 @@ def sql_liste_entree(cursor):
                     from STATION 
                     join STATION_FLAG on STATION_FLAG.STATION_ID = STATION.ID
                     join SURVEY on SURVEY.ID = STATION.SURVEY_ID
-                    where  STATION_FLAG.FLAG='ent'  -- or STATION_FLAG.FLAG='fix' --and STATION.ID = 28548 
+                    where  STATION_FLAG.FLAG='ent' -- or STATION_FLAG.FLAG='fix' --and STATION.ID = 28548 
                     group by STATION.NAME , STATION.Y, STATION.Z 
                     order by STATION.NAME ASC 
                 """)
     
+    sql_query_fix=  ("""
+                        SELECT 
+                            STATION.ID, 
+                            STATION.NAME, 
+                            ROUND(STATION.X, 1), 
+                            ROUND(STATION.Y, 1), 
+                            ROUND(STATION.Z, 1),
+                            SURVEY.NAME,
+                            SURVEY.TITLE
+                        FROM STATION
+                        JOIN STATION_FLAG ON STATION_FLAG.STATION_ID = STATION.ID
+                        JOIN SURVEY ON SURVEY.ID = STATION.SURVEY_ID
+                        WHERE STATION.ID IN (
+                            SELECT STATION_ID
+                            FROM STATION_FLAG
+                            WHERE FLAG = 'fix'
+                        )
+                        AND STATION.ID NOT IN (
+                            SELECT STATION_ID
+                            FROM STATION_FLAG
+                            WHERE FLAG = 'ent'
+                        )
+                        GROUP BY STATION.ID, STATION.NAME, STATION.X, STATION.Y, STATION.Z, SURVEY.NAME, SURVEY.TITLE
+                        ORDER BY STATION.NAME ASC;
+            """)
+    
     try:
-        cursor.execute(sql_query)    
+        
+        cursor.execute(sql_query_fix)    
+        result_fix = cursor.fetchall()
+        
+        if len(result_fix) > 0 :
+            log.warning(f"{Colors.CYAN}{len(result_fix)}{Colors.YELLOW} point(s) fixe trouvées pour la cavité ID : {Colors.CYAN}[{ID_CAVITE}] {Colors.WHITE}{NAME}")
+            warning_fix += len(result_fix)
+                
+        cursor.execute(sql_query_ent)    
         result_ent = cursor.fetchall()
-        # cursor.execute(sql_query)    
+
-        # result_fix = cursor.fetchall()
         if len(result_ent) == 0 :
             error_count  += 1 
             log.error(f"\tAttention aucune entrée ou point fix trouvé")
@@ -184,6 +229,7 @@ def create_new_db(db_path):
         PATH TEXT CHECK(LENGTH(PATH) <= 128),
         TH_VALIDE BOOLEAN DEFAULT FALSE,
         KEY_KARSTEAU INTEGER,
+        HASH_SQL_FILE,
         DATE_UPDATE -- format attendu : 'YYYY-MM-DD HH:MM:SS'
     );
     '''
@@ -233,6 +279,7 @@ def create_new_db(db_path):
         TEXT TEXT CHECK(LENGTH(TEXT) <= 128),
         CAT INTERGER,
         FILE TEXT CHECK(LENGTH(FILE) <= 128),
+        HASH_FILE TEXT CHECK(LENGTH(HASH_FILE) <= 128),
         TH_VALIDE BOOLEAN DEFAULT FALSE, 
         KEY_KARSTEAU INTEGER,
         DATE_UPDATE -- format attendu : 'YYYY-MM-DD HH:MM:SS'
@@ -245,7 +292,7 @@ def create_new_db(db_path):
 
 
 #####################################################################################################################################
-#            initialisation de la BD  (pour la détection des données supprimées dans Therion                                        #                                                                                   #
+#            Initialisation de la BD  (pour la détection des données supprimées dans Therion                                        #                                                                                   #
 #####################################################################################################################################  
 def init_th_valide(conn):
     cursor = conn.cursor()      
@@ -257,10 +304,12 @@ def init_th_valide(conn):
 
         
 #####################################################################################################################################
-#            nom de la cavité                                                                                                       #
+#            Nom de la cavité                                                                                                       #
 #####################################################################################################################################      
 # extrait du champs -title du fichier -tot.th
 def cave_name(_path_name):  
+    global error_count
+
     tot_files = []
     for file_name in os.listdir(_path_name):
         if file_name.endswith("-tot.th") and os.path.isfile(os.path.join(_path_name, file_name)):
@@ -268,10 +317,12 @@ def cave_name(_path_name):
     
     if len(tot_files) > 1 :
         log.error(f"Erreur plusieurs fichiers -tot.th : {Colors.MAGENTA}{tot_files}")
-        return "Erreur"
+        error_count += 1
+        return 
     elif  tot_files == [] :
         log.error(f"Erreur pas de fichiers -tot.th : {Colors.MAGENTA}{_path_name}")
-        return "Erreur"
+        error_count += 1
+        return
     
     with open(tot_files[0], 'r', encoding='utf-8') as f:
         for line in f:
@@ -288,6 +339,7 @@ def cave_name(_path_name):
 #            Execution du fichier thconfig                                                                                          #
 #####################################################################################################################################      
 def exe_therion_cave(_path_name):
+    global error_count
     
     ligne_export_db = "export database "
     
@@ -298,10 +350,12 @@ def exe_therion_cave(_path_name):
     
     if len(tot_files) > 1 :
         log.error(f"Erreur plusieurs fichiers .thconfig : {Colors.MAGENTA}{tot_files}")
-        return "Erreur"
+        error_count += 1
+        return
     elif  tot_files == [] :
         log.error(f"Erreur pas de fichiers .thconfig : {Colors.MAGENTA}{_path_name}")
-        return "Erreur"
+        error_count += 1
+        return 
     
     with open(tot_files[0], 'r+', encoding='utf-8') as f:
         lignes = f.readlines()
@@ -326,6 +380,7 @@ def cave_dev(_path_name):
     Extrait les données de développement et dénivelé depuis le fichier log de therion 
     
     """
+    global error_count
     
     tot_files = []
     for file_name in os.listdir(_path_name):
@@ -334,10 +389,12 @@ def cave_dev(_path_name):
     
     if len(tot_files) > 1 :
         log.error(f"Erreur plusieurs fichiers therion.log : {Colors.MAGENTA}{tot_files}")
-        return "Erreur"
+        error_count += 1
+        return
     elif  tot_files == [] :
         log.error(f"Erreur pas de fichiers therion.log : {Colors.MAGENTA}{_path_name}")
-        return "Erreur"
+        error_count += 1
+        return
     
     # print("fichiers log.log" + tot_files[0])
     with open(tot_files[0], "r") as f:
@@ -355,6 +412,7 @@ def cave_sys(_path_name):
     Extrait les données de coordonnées log de therion 
     
     """
+    global error_count
     
     tot_files = []
     for file_name in os.listdir(_path_name):
@@ -363,10 +421,12 @@ def cave_sys(_path_name):
     
     if len(tot_files) > 1 :
         log.error(f"Erreur plusieurs fichiers therion.log : {Colors.MAGENTA}{tot_files}")
-        return "Erreur"
+        error_count += 1
+        return None
     elif  tot_files == [] :
         log.error(f"Erreur pas de fichiers therion.log : {Colors.MAGENTA}{_path_name}")
-        return "Erreur"
+        error_count += 1
+        return None
     
     # print("fichiers log.log" + tot_files[0])
     with open(tot_files[0], "r") as f:
@@ -386,6 +446,8 @@ def pdf_exif(file):
     :param file: Chemin du fichier PDF
     :return: Tuple (auteur, titre, sujet, date_creation) avec date au format 'YYYY-MM-DD HH:MM:SS'
     """
+    global error_count
+    
     try:
         reader = PdfReader(file)
         info = reader.metadata
@@ -409,6 +471,7 @@ def pdf_exif(file):
 
     except Exception as e:
         log.error(f"Erreur lors de la lecture exif du fichier pdf : {Colors.MAGENTA}{file} {Colors.ERROR}Code : {Colors.MAGENTA}{e}")
+        error_count += 1
         return None, None, None, None
 
 
@@ -436,7 +499,10 @@ def pdf_update(conn, base_path, path_name, _update, ID_CAVITE, NAME):
 
     for file in tot_files:
         _file = os.path.relpath(file, base_path).replace("\\", "/")
-        cursor.execute("SELECT 1 FROM DOCUMENT WHERE ID_CAVITE = ? AND FILE = ?", (ID_CAVITE, _file,))
+        
+        _hash_file = hash_file(file)
+         
+        cursor.execute("SELECT HASH_FILE FROM DOCUMENT WHERE ID_CAVITE = ? AND FILE = ?", (ID_CAVITE, _file,))
         _document = cursor.fetchone()
         
         auteur, titre, sujet, date  = pdf_exif(file.replace("\\", "/"))
@@ -457,16 +523,17 @@ def pdf_update(conn, base_path, path_name, _update, ID_CAVITE, NAME):
                            DESCRIPTION = ?, 
                            DATE_UPDATE = ?, 
                            CAT = ?, 
+                           HASH_FILE = ?,
                            TH_VALIDE = TRUE 
                            WHERE ID = ?
                         """,
-                    (ID_CAVITE, _Lie,_file, _Nature, auteur, titre, date, sujet, _update, _Cat, ID_DOCUMENT))
+                    (ID_CAVITE, _Lie,_file, _Nature, auteur, titre, date, sujet, _update, _Cat, _hash_file, ID_DOCUMENT))
             log.info(f"Création du document : {Colors.WHITE}{_file}{Colors.GREEN} de la cavité : {Colors.WHITE}{NAME}{Colors.GREEN}")
         else :
-            cursor.execute("SELECT ID, AUTEUR, TITRE, DATE, DESCRIPTION FROM DOCUMENT WHERE ID_CAVITE = ? AND FILE = ?", (ID_CAVITE, _file,))
+            cursor.execute("SELECT ID, AUTEUR, TITRE, DESCRIPTION, HASH_FILE FROM DOCUMENT WHERE ID_CAVITE = ? AND FILE = ?", (ID_CAVITE, _file,))
             row = cursor.fetchone()
-            ID_DOCUMENT_DB, auteur_db, titre_db, date_db, sujet_db = row
+            ID_DOCUMENT_DB, auteur_db, titre_db, sujet_db, hash_file_db = row
-            if (auteur != auteur_db) or (titre != titre_db) or (date != date_db) or (sujet != sujet_db):
+            if (auteur != auteur_db) or (titre != titre_db) or (sujet != sujet_db)  or (_hash_file != hash_file_db):
                 cursor.execute("""
                     UPDATE DOCUMENT 
                     SET LIE = ?, 
@@ -476,10 +543,11 @@ def pdf_update(conn, base_path, path_name, _update, ID_CAVITE, NAME):
                     DESCRIPTION = ?, 
                     DATE_UPDATE = ?, 
                     CAT = ?, 
+                    HASH_FILE = ?,
                     TH_VALIDE = TRUE
                     WHERE ID = ?
                 """, 
-                (_Lie, auteur, titre, date, sujet, _update, _Cat, ID_DOCUMENT_DB))
+                (_Lie, auteur, titre, date, sujet, _update, _Cat, _hash_file, ID_DOCUMENT_DB))
                 log.info(f"Mise à jour pdf : {Colors.WHITE}{_file}{Colors.GREEN} de la cavité : {Colors.WHITE}{NAME}{Colors.GREEN}")
             else:
                 cursor.execute("UPDATE DOCUMENT SET TH_VALIDE = TRUE WHERE ID = ?", (ID_DOCUMENT_DB,))
@@ -496,6 +564,8 @@ def pdf_update(conn, base_path, path_name, _update, ID_CAVITE, NAME):
 #####################################################################################################################################  
 def kml_update(conn, base_path, path_name, _update, ID_CAVITE, NAME):
     
+    global error_count
+
     _path_name = path_name + "/Outputs"
     _Nature = "kml"
     _Lie = "cavité"
@@ -511,11 +581,15 @@ def kml_update(conn, base_path, path_name, _update, ID_CAVITE, NAME):
         log.debug(f"Cavité: {Colors.WHITE}{NAME}{Colors.GREEN}, fichiers kml à exporter : {Colors.WHITE}{len(tot_files)}")
     elif  tot_files == [] :
         log.error(f"Erreur cavité: {Colors.WHITE}{NAME}{Colors.ERROR}, pas de fichiers kml à exporter : {Colors.MAGENTA}{_path_name}")
-        return "Erreur"
+        error_count += 1
+        return
 
     for file in tot_files:
         _file = os.path.relpath(file, base_path).replace("\\", "/")
-        cursor.execute("SELECT 1 FROM DOCUMENT WHERE ID_CAVITE = ? AND FILE = ?", (ID_CAVITE, _file,))
+        
+        _hash_file = hash_file(file)
+                 
+        cursor.execute("SELECT HASH_FILE FROM DOCUMENT WHERE ID_CAVITE = ? AND FILE = ?", (ID_CAVITE, _file,))
         _document = cursor.fetchone()
         
         auteur = " "
@@ -523,7 +597,6 @@ def kml_update(conn, base_path, path_name, _update, ID_CAVITE, NAME):
         sujet = f"Polygonale de {NAME} au format google earth"
         date = _update
        
-            
         if _document is None :     
             cursor.execute("INSERT INTO DOCUMENT (FILE) VALUES (?)", (_file,))
             ID_DOCUMENT = cursor.lastrowid
@@ -539,16 +612,18 @@ def kml_update(conn, base_path, path_name, _update, ID_CAVITE, NAME):
                         DESCRIPTION = ?, 
                         DATE_UPDATE = ?, 
                         CAT = ?, 
+                        HASH_FILE = ?,
                         TH_VALIDE = TRUE 
                         WHERE ID = ?
                         """,
-                    (ID_CAVITE, _Lie,_file, _Nature, auteur, titre, date, sujet, _update, _Cat, ID_DOCUMENT))
+                    (ID_CAVITE, _Lie,_file, _Nature, auteur, titre, date, sujet, _update, _Cat, _hash_file, ID_DOCUMENT))
             log.info(f"Création du document : {Colors.WHITE}{_file}{Colors.GREEN} de la cavité : {Colors.WHITE}{NAME}{Colors.GREEN}")
         else :
-            cursor.execute("SELECT ID, AUTEUR, TITRE, DATE, DESCRIPTION FROM DOCUMENT WHERE ID_CAVITE = ? AND FILE = ?", (ID_CAVITE, _file,))
+            cursor.execute("SELECT ID, AUTEUR, TITRE, DESCRIPTION, HASH_FILE FROM DOCUMENT WHERE ID_CAVITE = ? AND FILE = ?", (ID_CAVITE, _file,))
             row = cursor.fetchone()
-            ID_DOCUMENT_DB, auteur_db, titre_db, date_db, sujet_db = row
+            ID_DOCUMENT_DB, auteur_db, titre_db, sujet_db, hash_file_db = row
-            if (auteur != auteur_db) or (titre != titre_db) or (date != date_db) or (sujet != sujet_db):
+            
+            if (auteur != auteur_db) or (titre != titre_db) or (sujet != sujet_db) or (_hash_file != hash_file_db):
                 cursor.execute("""
                     UPDATE DOCUMENT 
                     SET LIE = ?, 
@@ -558,10 +633,11 @@ def kml_update(conn, base_path, path_name, _update, ID_CAVITE, NAME):
                     DESCRIPTION = ?, 
                     DATE_UPDATE = ?, 
                     CAT = ?, 
+                    HASH_FILE = ?,
                     TH_VALIDE = TRUE
                     WHERE ID = ?
                 """, 
-                (_Lie, auteur, titre, date, sujet, _update, _Cat, ID_DOCUMENT_DB))
+                (_Lie, auteur, titre, date, sujet, _update, _Cat, _hash_file, ID_DOCUMENT_DB))
                 log.info(f"Mise à jour kml : {Colors.WHITE}{_file}{Colors.GREEN} de la cavité : {Colors.WHITE}{NAME}{Colors.GREEN}")
             else:
                 cursor.execute("UPDATE DOCUMENT SET TH_VALIDE = TRUE WHERE ID = ?", (ID_DOCUMENT_DB,))
@@ -574,7 +650,7 @@ def kml_update(conn, base_path, path_name, _update, ID_CAVITE, NAME):
 
 
 #####################################################################################################################################
-#            création des fichiers zip                                                                                              #
+#            Création des fichiers zip                                                                                              #
 ##################################################################################################################################### 
 def zip_file(path_source, path_dest, _name_zip):
     
@@ -632,10 +708,12 @@ def zip_file(path_source, path_dest, _name_zip):
 
 
 #####################################################################################################################################
-#            création du fichier zip avec les données à exporter                                                                    #
+#            Création du fichier zip avec les données à exporter                                                                    #
 ##################################################################################################################################### 
 def zip_data(conn, path_dest, base_path, _name_zip):
     
+    global error_count
+    
     cursor = conn.cursor()
     
     cursor.execute("""
@@ -654,6 +732,7 @@ def zip_data(conn, path_dest, base_path, _name_zip):
                     zipf.write(_file, str(file[0]).replace("\\", "/"))
                 else:
                     log.error(f"Erreur d'export des fichiers : {Colors.CYAN}{file[0]}{Colors.ERROR} non trouvé ou invalide")
+                    error_count += 1
                 bar()
 
     log.info(f"Archive des fichiers exportés créée : {Colors.WHITE}{zip_path}{Colors.GREEN}, {Colors.WHITE}{os.path.getsize(zip_path)} {Colors.GREEN}octets")
@@ -664,6 +743,8 @@ def zip_data(conn, path_dest, base_path, _name_zip):
 #####################################################################################################################################  
 def zip_update(conn, base_path, path_name, _update, ID_CAVITE, Name) :
     
+    global error_count
+    
     _path_name = path_name + "/Outputs"
     _Nature = "autre"
     _Lie = "cavité"
@@ -681,11 +762,15 @@ def zip_update(conn, base_path, path_name, _update, ID_CAVITE, Name) :
         log.info(f"{Colors.WHITE}{len(tot_files)}{Colors.GREEN} Fichiers .zip à exporter : {Colors.MAGENTA}{tot_files}")
     elif  tot_files == [] :
         log.error(f"Erreur pas de fichiers .zip : {Colors.MAGENTA}{_path_name}")
-        return "Erreur"
+        error_count += 1
+        return
 
     for file in tot_files:
         _file = os.path.relpath(file, base_path).replace("\\", "/")
-        cursor.execute("SELECT 1 FROM DOCUMENT WHERE ID_CAVITE = ? AND FILE = ?", (ID_CAVITE, _file,))
+        
+        _hash_file = hash_file(file)
+        
+        cursor.execute("SELECT HASH_FILE FROM DOCUMENT WHERE ID_CAVITE = ? AND FILE = ?", (ID_CAVITE, _file,))
         _document = cursor.fetchone()
         
         auteur = " "
@@ -708,16 +793,17 @@ def zip_update(conn, base_path, path_name, _update, ID_CAVITE, Name) :
                         DESCRIPTION = ?, 
                         DATE_UPDATE = ?, 
                         CAT = ?,
+                        HASH_FILE = ?, 
                         TH_VALIDE = TRUE    
                         WHERE ID = ?
                     """,
-                    (ID_CAVITE, _Lie,_file, _Nature, auteur, titre, date, sujet, _update, _Cat, ID_DOCUMENT))
+                    (ID_CAVITE, _Lie,_file, _Nature, auteur, titre, date, sujet, _update, _Cat, _hash_file, ID_DOCUMENT))
             log.info(f"Création du zip : {Colors.WHITE}{_file}{Colors.GREEN} de la cavité : {Colors.WHITE}{Name}{Colors.GREEN}")
         else :
-            cursor.execute("SELECT ID, AUTEUR, TITRE, DATE, DESCRIPTION FROM DOCUMENT WHERE ID_CAVITE = ? AND FILE = ?", (ID_CAVITE, _file,))
+            cursor.execute("SELECT ID, AUTEUR, TITRE, DESCRIPTION, HASH_FILE FROM DOCUMENT WHERE ID_CAVITE = ? AND FILE = ?", (ID_CAVITE, _file,))
             row = cursor.fetchone()
-            ID_DOCUMENT_DB, auteur_db, titre_db, date_db, sujet_db = row
+            ID_DOCUMENT_DB, auteur_db, titre_db, sujet_db, hash_file_db = row
-            if (auteur != auteur_db) or (titre != titre_db) or (date != date_db) or (sujet != sujet_db):
+            if (auteur != auteur_db) or (titre != titre_db) or (sujet != sujet_db)  or (_hash_file != hash_file_db):
                 cursor.execute("""
                     UPDATE DOCUMENT 
                     SET LIE = ?, 
@@ -727,10 +813,11 @@ def zip_update(conn, base_path, path_name, _update, ID_CAVITE, Name) :
                     DESCRIPTION = ?, 
                     DATE_UPDATE = ?, 
                     CAT = ?, 
+                    HASH_FILE = ?,
                     TH_VALIDE = TRUE
                     WHERE ID = ?
                 """, 
-                (_Lie, auteur, titre, date, sujet, _update, _Cat, ID_DOCUMENT_DB))
+                (_Lie, auteur, titre, date, sujet, _update, _Cat, _hash_file, ID_DOCUMENT_DB))
                 log.info(f"Mise à jour zip : {Colors.WHITE}{_file}{Colors.GREEN} de la cavité : {Colors.WHITE}{Name}{Colors.GREEN}")
             else:
                 cursor.execute("UPDATE DOCUMENT SET TH_VALIDE = TRUE WHERE ID = ?", (ID_DOCUMENT_DB,))
@@ -748,6 +835,8 @@ def zip_update(conn, base_path, path_name, _update, ID_CAVITE, Name) :
 #####################################################################################################################################  
 def entrance_update(conn, base_path, path_name, _update, ID_CAVITE, NAME, syscoord):
     
+    global error_count
+    
     _path_name = path_name + "/Outputs"
     
     tot_files = []
@@ -757,26 +846,40 @@ def entrance_update(conn, base_path, path_name, _update, ID_CAVITE, NAME, syscoo
     
     if len(tot_files) > 1 :
         log.error(f"Erreur plusieurs fichiers sql : {Colors.MAGENTA}{tot_files}")
-        return "Erreur"
+        error_count += 1
+        return
     elif  tot_files == [] :
         log.error(f"Erreur pas de fichiers sql : {Colors.MAGENTA}{_path_name}")
-        return "Erreur"
+        error_count += 1
+        return 
+    
+    cursor = conn.cursor()
+    cursor.execute("SELECT HASH_SQL_FILE FROM CAVITE WHERE ID = ?", (ID_CAVITE,))
+    _hash_sql = cursor.fetchone()[0]
       
     imported_database = tot_files[0][:-4]+".db"
-    importation_sql_db(tot_files[0].replace("\\", "/"), imported_database)
+    sql_file = tot_files[0].replace("\\", "/")
+   
+    new_hash_file = hash_file(sql_file)
+    
+    if new_hash_file != _hash_sql :
+        cursor.execute("UPDATE CAVITE SET HASH_SQL_FILE = ? WHERE ID = ?", (new_hash_file, ID_CAVITE,))
+        importation_sql_db(sql_file, imported_database)
+    else : 
+        log.info(f"Aucun changement pour la base sql : {Colors.WHITE}{sql_file}{Colors.GREEN} de la cavité : {Colors.WHITE}{NAME}{Colors.GREEN}")
         
     conn2 = sqlite3.connect(imported_database)  # Connexion à la base de données SQLite
     cursor2 = conn2.cursor()
     
-    resultat = sql_liste_entree(cursor2)
+    resultat = sql_liste_entree(cursor2, ID_CAVITE, NAME)
     # df = pd.DataFrame(resultat, columns=["ID", "Name", "X", "Y", "Z", "Survey"])
     # print(df)
     
-    cursor = conn.cursor()
+    
     cursor.execute("SELECT COUNT(*) FROM ENTREE WHERE ID_CAVITE = ?", (ID_CAVITE,))
     _entree = cursor.fetchone()[0]
     
-    log.info(f"Nombre d'entrées : {Colors.WHITE}{_entree}{Colors.GREEN} trouvées pour la cavité ID : {Colors.CYAN}[{ID_CAVITE}] {Colors.WHITE}{NAME}")
+    log.info(f"Nombre d'entrées existantes : {Colors.WHITE}{_entree}{Colors.GREEN} trouvées pour la cavité ID : {Colors.CYAN}[{ID_CAVITE}] {Colors.WHITE}{NAME}")
 
     for line in resultat:
         Entre_Th = line[1] + "@" + line[5]
@@ -827,6 +930,7 @@ def entrance_update(conn, base_path, path_name, _update, ID_CAVITE, NAME, syscoo
             
         else :
             log.error(f"Erreur, entrée en doublons vérifier la base de données:  {Colors.CYAN}{Entre_Th} Nbe {Entre_Th}")
+            error_count += 1
     
     conn.commit()
         
@@ -889,7 +993,7 @@ def cavite_update(conn, file_list, base_path, _update):
                         WHERE ID = ?
                     """,
                     (rel_path_name, float(cave_Dev['length']), float(cave_Dev['depth']), 0.0, _update, ID_CAVITE))
-            log.info(f"Nouvelle cavité insérée avec ID : {Colors.MAGENTA}{ID_CAVITE}{Colors.YELLOW}, Name : {Colors.MAGENTA}{cave_Name}{Colors.YELLOW}, Dev : {Colors.MAGENTA}{cave_Dev['length']}{Colors.YELLOW}, Prof : {Colors.MAGENTA}{cave_Dev['depth']}{Colors.YELLOW}, Len path : {Colors.MAGENTA}{len(path_name)}")
+            log.info(f"Nouvelle cavité insérée avec ID : {Colors.MAGENTA}{ID_CAVITE}{Colors.YELLOW}, Name : {Colors.MAGENTA}{cave_Name}{Colors.YELLOW}, Dev : {Colors.MAGENTA}{cave_Dev['length']}m{Colors.YELLOW}, Prof : {Colors.MAGENTA}{cave_Dev['depth']}m{Colors.YELLOW}, Len path : {Colors.MAGENTA}{len(path_name)}")
             cave_config['Data_Export'] = {'ID_CAVITE': str(ID_CAVITE)}
             with open(file_path, 'w', encoding='utf-8') as configfile:
                 cave_config.write(configfile)
@@ -1098,6 +1202,10 @@ def adapt_excel(excel_filename, selected_folder, update, max_documents=5):
             fill = gris_low_fill    
         elif str(header_value).endswith("_DATE_UPDATE"):
             fill = gris_fill
+        elif str(header_value).endswith("_HASH_SQL_FILE"):
+            fill = gris_fill
+        elif str(header_value).endswith("_HASH_FILE"):
+            fill = gris_fill          
         else:
             continue
 
@@ -1165,6 +1273,7 @@ def adapt_excel(excel_filename, selected_folder, update, max_documents=5):
 #####################################################################################################################################
 if __name__ == '__main__':
     error_count = 0
+    warning_fix = 0
     outputs_path = "./Test/"
     inputs_path = "./Test/"
 
@@ -1195,7 +1304,7 @@ if __name__ == '__main__':
         input_folder = args.folder
         if os.path.isdir(input_folder) is False :
             print(f"{Colors.ERROR}Erreur : le dossier {Colors.CYAN}{input_folder}{Colors.ERROR} est inexistant")      
-            print(f"{Colors.GREEN}Commande : {Colors.WHITE}python pyThtoDB.py --folder ./chemin/dossier/")
+            print(f"{Colors.GREEN}Commande : {Colors.WHITE}python pyThtoBD.py --folder ./chemin/dossier/")
             sys.exit()  
         else :
             selected_folder = os.path.abspath(input_folder)
@@ -1207,6 +1316,12 @@ if __name__ == '__main__':
     output_db = selected_folder + export_folder + export_db
     update = maintenant.strftime("%Y-%m-%d %H:%M:%S")
       
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+        print(f"Dossier '{output_folder}' créé.")
+    else:
+        print(f"Dossier '{output_folder}' existe déjà.")
+    
     log = setup_logger(output_folder + log_file, debug_log)
     
     # log.debug("Ceci est un message de debug")
@@ -1217,7 +1332,7 @@ if __name__ == '__main__':
        
     _titre =[f'********************************************************************************************************************************************\033[0m', 
              f'* Export d\'une BD Therion',
-             f'*       Script pyThtoDB par :{Colors.MAGENTA} alexandre.pont@yahoo.fr',
+             f'*       Script pyThtoBD par :{Colors.MAGENTA} alexandre.pont@yahoo.fr',
              f'*       Version : {Colors.MAGENTA}' + Version,
              f'*       Dossier source : {Colors.MAGENTA}' + selected_folder,           
              f'*       Dossier destination : {Colors.MAGENTA}' + output_folder,
@@ -1229,9 +1344,6 @@ if __name__ == '__main__':
     
     for i in range(11): log.info(_titre[i])
     
-    if os.path.exists(output_folder) is False :
-        log.debug("Le dossier : " + output_folder + " existe déjà")
-           
     if os.path.isfile(output_db) is False :
         log.info("Le fichier : " + output_db + " n’existe pas, création automatique") 
         conn = create_new_db(output_db)
@@ -1259,6 +1371,11 @@ if __name__ == '__main__':
     
     conn.close()
     
+    if warning_fix > 0 :
+         log.warning(f"""Nbre de point(s) fixe trouvé(s) : {Colors.CYAN}{warning_fix}{Colors.YELLOW}, vérifier : une entrée doit avoir l'attribut type {Colors.CYAN}station 0 "Entrée XXXX" entrance{Colors.YELLOW} lors de sa déclaration""") 
     
-    
+    if error_count > 0 :
+         log.error(f"""Nbre d'erreur(s)  trouvé(s) : {Colors.CYAN}{error_count}{Colors.YELLOW}, à vérifier""")
+    else :         
+        log.info("Aucune d'erreur trouvée, parfait !")
 

Scripts/pyThtoBD/test/Data/Gypse/Cenotes_check-point/Data/Sinkhole1.th

@@ -15,7 +15,7 @@ survey SINKHOLE1 -title "Karabulak Gypsum Collapses 1"
 		
 		cs long-lat
 		fix 0 66.352551  37.618033 351
-		station 0 "Karabulak Gypsum Collapses 1" entrance
+		station 0 "Karabulak Gypsum Collapses 01" entrance
 		
 		units length meters
 		units compass clino degrees

Scripts/pyThtoDat/config.json

@@ -1 +1 @@
-{"prefix": "[Z510]", "outputs_path": "Export_Dat", "input_file": "D:/00 Synology Drive2 [Blade 15]/09_Projets Elec sur [Cloud Drive 2]/14 pyThtoDat/Inputs/Z510_2024_12_31.sql"}
+{"prefix": "[KHAN]", "outputs_path": "Export_Dat", "input_file": "C:/Users/alexa/Desktop/Topo_Copie_Test/Vang_Vieng/Data/Tham_Khan/Outputs/Tham_Khan_Kham.sql"}