adstoolbox 0.1.0__py3-none-any.whl

adsToolBox/__init__.py

@@ -0,0 +1,12 @@
+from .logger import Logger
+from .timer import timer, get_timer
+from .global_config import set_timer
+from .dbPgsql import dbPgsql
+from .dbMssql import dbMssql
+from .pipeline import pipeline
+from .wait_file import wait_for_file
+
+
+__all__ = [
+    "Logger", "timer", "set_timer", "get_timer", "dbPgsql", "dbMssql", "pipeline", "wait_for_file"
+]

adsToolBox/dataFactory.py

@@ -0,0 +1,22 @@
+from abc import ABC, abstractmethod
+
+
+class data_factory(ABC):
+
+    @abstractmethod
+    def connect(self):
+        pass
+    @abstractmethod
+    def insert(self,table,cols=[],rows=[]):
+        pass
+
+    @abstractmethod
+    def insertBulk(self,table,cols=[],rows=[]):
+        pass
+    @abstractmethod
+    def sqlQuery(self,query):
+        pass
+
+    @abstractmethod
+    def sqlExec(self, query: str, params=None):
+        pass

adsToolBox/dbMssql.py

@@ -0,0 +1,119 @@
+from datetime import datetime
+import pymssql
+import timeit
+from .timer import timer, get_timer
+from .dataFactory import data_factory
+
+class dbMssql(data_factory):
+
+    def __init__(self, dictionnary: dict, logger, batch_size=10_000):
+        self.connection = None
+        self.logger = logger
+        self.__database = dictionnary['database']
+        self.__user = dictionnary['user']
+        self.__password = dictionnary['password']
+        self.__port = dictionnary['port']
+        self.__host = dictionnary['host']
+        self.__batch_size = batch_size
+
+    @timer
+    def connect(self):
+        if self.logger is not None: self.logger.info("Tentative de connexion avec la base de données.")
+        try:
+            self.connection = pymssql.connect(
+                server=f"{self.__host}:{self.__port}",
+                user=self.__user,
+                password=self.__password,
+                database=self.__database
+            )
+            if self.logger is not None: self.logger.info(f"Connexion établie avec la base de données.")
+            return self.connection
+        except Exception as e:
+            if self.logger is not None: self.logger.error(f"Échec de la connexion à la base de données: {e}")
+            raise
+
+    def sqlQuery(self, query):
+        self.logger.debug(f"Exécution de la requête de lecture : {query}")
+        start_time = datetime.now()
+        try:
+            timer_start = timeit.default_timer()
+            with self.connection.cursor() as cursor:
+                cursor.execute(query)
+                cols = [desc[0] for desc in cursor.description]
+                self.logger.info("Requête exécutée avec succès, début de la lecture des résultats.")
+                while True:
+                    rows = cursor.fetchmany(self.__batch_size)
+                    if not rows:
+                        break
+                    yield from rows
+                    self.logger.info(f"{len(rows)} lignes lues.")
+            end_time = datetime.now()
+            self.logger.log_to_db(start_time, end_time, status='success', message="Requête de lecture exécutée.")
+            if get_timer():
+                elapsed_time = timeit.default_timer() - timer_start
+                self.logger.info(f"Temps d'exécution de sqlQuery: {elapsed_time:.4f} secondes")
+        except Exception as e:
+            end_time = datetime.now()
+            self.logger.error(f"Échec de la lecture des données: {e}")
+            self.logger.log_to_db(start_time, end_time, status="failure", message=str(e))
+            raise
+
+    @timer
+    def sqlExec(self, query):
+        try:
+            with self.connection.cursor() as cursor:
+                cursor.execute(query)
+                self.logger.info(f"Requête exécutée avec succès.")
+                self.connection.commit()
+        except Exception as e:
+            self.logger.error(f"Échec de l'exécution de la requête: {e}")
+            raise
+
+    @timer
+    def sqlScalaire(self, query):
+        try:
+            with self.connection.cursor() as cursor:
+                cursor.execute(query)
+                self.logger.info(f"Requête exécutée avec succès.")
+                data = cursor.fetchone()
+                return data
+        except Exception as e:
+            self.logger.error(f"Échec de l'exécution de la requête: {e}")
+            raise
+
+
+    @timer
+    def insert(self, table, cols=[], rows=[]):
+        start_time = datetime.now()
+        try:
+            with self.connection.cursor() as cursor:
+                placeholders = ", ".join(["%s"] * len(cols))
+                query = f"INSERT INTO {table} ({', '.join(cols)}) VALUES ({placeholders})"
+                cursor.execute(query, rows)
+                self.connection.commit()
+                self.logger.info(f"{cursor.rowcount} lignes insérées avec succès dans la table {table}.")
+                self.logger.log_to_db(start_time, datetime.now(), status='success', message="Insertion réussie.")
+                return ["SUCCESS"]
+        except Exception as e:
+            self.logger.error(f"Échec de l'insertion des données: {e}")
+            self.logger.log_to_db(start_time, datetime.now(), status='failure', message=str(e))
+            self.connection.rollback()
+            return "ERROR", str(e), rows
+
+    @timer
+    def insertBulk(self, table, cols=[], rows=[]):
+        start_time = datetime.now()
+        try:
+            with self.connection.cursor() as cursor:
+                placeholders = ", ".join(["%s"] * len(cols))
+                query = f"INSERT INTO {table} ({', '.join(cols)}) VALUES ({placeholders})"
+                cursor.executemany(query, rows)
+                self.connection.commit()
+                self.logger.info(f"{cursor.rowcount} lignes insérées avec succès dans la table {table}.")
+                self.logger.log_to_db(start_time, datetime.now(), status='success', message="Insertion réussie.")
+                return ["SUCCESS"]
+        except Exception as e:
+            self.logger.error(f"Échec de l'insertion des données: {e}")
+            self.logger.log_to_db(start_time, datetime.now(), status='failure', message=str(e))
+            self.connection.rollback()
+            return "ERROR", str(e), rows

adsToolBox/dbPgsql.py

@@ -0,0 +1,119 @@
+from datetime import datetime
+import psycopg2
+import timeit
+from .timer import timer, get_timer
+from .dataFactory import data_factory
+
+class dbPgsql(data_factory):
+
+    def __init__(self, dictionnary: dict, logger, batch_size=10_000):
+        self.connection = None
+        self.logger = logger
+        self.__database = dictionnary['database']
+        self.__user = dictionnary['user']
+        self.__password = dictionnary['password']
+        self.__port = dictionnary['port']
+        self.__host = dictionnary['host']
+        self.__batch_size = batch_size
+
+    @timer
+    def connect(self):
+        if self.logger is not None: self.logger.info("Tentative de connexion avec la base de données.")
+        try:
+            self.connection = psycopg2.connect(
+                database=self.__database,
+                user=self.__user,
+                password=self.__password,
+                port=self.__port,
+                host=self.__host
+            )
+            if self.logger is not None: self.logger.info(f"Connexion établie avec la base de données.")
+            return self.connection
+        except Exception as e:
+            if self.logger is not None: self.logger.error(f"Échec de la connexion à la base de données.")
+            raise
+
+    def sqlQuery(self, query: str):
+        self.logger.debug(f"Exécution de la requête de lecture: {query}")
+        start_time = datetime.now()
+        try:
+            timer_start = timeit.default_timer()
+            with self.connection.cursor() as cursor:
+                cursor.execute(query)
+                cols = [desc for desc in cursor.description]
+                self.logger.info("Requête exécutée avec succès, début de la lecture des résultats.")
+                while True:
+                    rows = cursor.fetchmany(self.__batch_size)
+                    if not rows:
+                        break
+                    yield rows
+                    self.logger.info(f"{len(rows)} ligne(s) lue(s).")
+            end_time = datetime.now()
+            self.logger.log_to_db(start_time, end_time, status='success', message='Requête de lecture exécutée')
+            if get_timer():
+                elapsed_time = timeit.default_timer() - timer_start
+                self.logger.info(f"Temps d'exécution de sqlQuery: {elapsed_time:.4f} secondes")
+        except Exception as e:
+            end_time = datetime.now()
+            self.logger.error(f"Échec de la lecture des données: {e}")
+            self.logger.log_to_db(start_time, end_time, status="failure", message=str(e))
+            raise
+
+    @timer
+    def sqlExec(self, query):
+        try:
+            with self.connection.cursor() as cursor:
+                cursor.execute(query)
+                self.logger.info(f"Requête exécutée avec succès.")
+                self.connection.commit()
+        except Exception as e:
+            self.logger.error(f"Échec de l'exécution de la requête: {e}")
+            raise
+
+    @timer
+    def sqlScalaire(self, query):
+        try:
+            with self.connection.cursor() as cursor:
+                cursor.execute(query)
+                self.logger.info(f"Requête exécutée avec succès.")
+                data = cursor.fetchone()
+                return data
+        except Exception as e:
+            self.logger.error(f"Échec de l'exécution de la requête: {e}")
+            raise
+
+    @timer
+    def insert(self, table, cols=[], rows=[]):
+        start_time = datetime.now()
+        try:
+            with self.connection.cursor() as cursor:
+                placeholders = ", ".join(["%s"] * len(cols))
+                query = f"INSERT INTO {table} ({', '.join(cols)}) VALUES ({placeholders})"
+                cursor.execute(query, rows)
+                self.connection.commit()
+                self.logger.info(f"{cursor.rowcount} ligne insérée avec succès dans la table {table}.")
+                self.logger.log_to_db(start_time, datetime.now(), status='success', message="Insertion réussie.")
+                return ["SUCCESS"]
+        except Exception as e:
+            self.logger.error(f"Échec de l'insertion des données: {e}")
+            self.logger.log_to_db(start_time, datetime.now(), status='failure', message=str(e))
+            self.connection.rollback()
+            return "ERROR", str(e), rows
+
+    @timer
+    def insertBulk(self, table, cols=[], rows=[]):
+        start_time = datetime.now()
+        try:
+            with self.connection.cursor() as cursor:
+                placeholders = ", ".join(["%s"] * len(cols))
+                query = f"INSERT INTO {table} ({', '.join(cols)}) VALUES ({placeholders})"
+                cursor.executemany(query, rows)
+                self.connection.commit()
+                self.logger.info(f"{cursor.rowcount} lignes insérées avec succès dans la table {table}.")
+                self.logger.log_to_db(start_time, datetime.now(), status="success", message="Insertion(s) réussie(s)")
+                return ["SUCCESS"]
+        except Exception as e:
+            self.logger.error(f"Échec de l'insertion des données: {e}")
+            self.logger.log_to_db(start_time, datetime.now(), status="failure", message=str(e))
+            self.connection.rollback()
+            return "ERROR", str(e), rows

adsToolBox/demo/_demo.py

@@ -0,0 +1,63 @@
+import adsToolBox as ads
+from to_sort.env import *
+import os
+
+ads.set_timer(True) # active les timer
+
+#--------------------------------------------------------------------------------------
+#---------------------         DATA PIPELINE DB to DB         -------------------------
+#--------------------------------------------------------------------------------------
+
+def pipeline():
+    pg_source=ads.dbPgsql({'database':pg_dwh_db
+                            , 'user':pg_dwh_user
+                            , 'password':pg_dwh_pwd
+                            , 'port':pg_dwh_port
+                            , 'host':pg_dwh_host})
+
+    mssql_destination=ads.dbMssql({'database': mssql_dwh_db
+                            , 'user':mssql_dwh_user
+                            , 'password':mssql_dwh_pwd
+                            , 'port':mssql_dwh_port
+                            , 'host':mssql_dwh_host})
+
+
+    mypipeline=ads.pipelineBulk({'db_source':pg_source
+                         ,'query_source':'''SELECT tenantname, taille, unite, fichier FROM onyx_qs."diskcheck" LIMIT 10'''
+                         ,'db_destination':mssql_destination
+                         ,'table':'ONYX.diskcheck'
+                         ,'cols':['tenantname', 'taille', 'unite', 'fichier']})
+
+
+    mssql_destination=ads.dbMssql({'database': mssql_dwh_db
+                            , 'user':mssql_dwh_user
+                            , 'password':mssql_dwh_pwd
+                            , 'port':mssql_dwh_port
+                            , 'host':mssql_dwh_host})
+
+
+    mypipeline=ads.pipeline({'db_source':pg_source
+                         ,'query_source':'''SELECT tenantname, taille, unite, fichier FROM onyx_qs."diskcheck" LIMIT 10'''
+                         ,'db_destination':mssql_destination
+                         ,'table':'ONYX.diskcheck'
+                         ,'cols':['tenantname', 'taille', 'unite', 'fichier']})
+
+    mypipeline.run()
+
+#--------------------------------------------------------------------------------------
+#----------------------------         FICHIERS         --------------------------------
+#--------------------------------------------------------------------------------------
+
+def fichier():
+    # lister un dossier
+    os.listdir()
+
+    # Copier un fichier
+    #shutil.copy("trashcan.py", "../factory")
+
+    #shutil.copy2() #--> conserve les metadata
+
+    # Vérifier l'existance d'un fichier
+    #os.path.isfile("")
+
+pipeline()

adsToolBox/demo/dataset_deduplicate.py

@@ -0,0 +1,15 @@
+import polars as pl
+
+tbl = [
+    ("A", "1"),
+    ("B", "2"),
+    ("C", "3"),
+    ("C", "3"),
+    ("C", "3")
+]
+
+df = pl.DataFrame(tbl, schema=["key", "value"], orient="row")
+
+df = df.unique()
+
+print(df)

adsToolBox/demo/dataset_file.py

@@ -0,0 +1,50 @@
+import shutil
+import polars as pl
+import os
+
+data = [
+    ("A", 1, 10.5, 'He said "Hello"'),
+    ("B", 2, 20.1, "NA"),
+    ("C", 3, 30.7, "NA"),
+    ("D", "NA", 40.6, "NA")
+]
+df = pl.DataFrame(data, schema=["key", "value1", "value2", "value3"], orient="row")
+
+# Écriture dans un fichier csv
+csv_file = "example_data.csv"
+df.write_csv(csv_file, separator=";", quote_char='"', include_header=True)
+
+# Lecture à partir d'un fichier csv
+df_csv = pl.read_csv(
+    "example_data.csv",
+    separator=";",  #Utiliser un séparateur précis, par défaut ","
+    has_header=True,  #Indique si le fichier a une ligne d'en-tête
+    null_values=["NA"],  #Interpréter ces valeurs comme nulles
+    columns=["key", "value1", "value3"],  #Lire uniquement certaines colonnes
+    quote_char='"'  #Le caractère utilisé pour entourer les valeurs est le double guillemet
+)
+print(df_csv)
+
+# Lister les fichiers du répertoire courant
+print(os.listdir())
+
+# Créer et écrire dans un fichier txt
+with open("file.txt", "w") as file:
+    file.write("Your text goes here")
+
+# Copier un fichier
+shutil.copy("file.txt", "copy.txt")
+
+# Copier les métadonnées
+shutil.copy2("file.txt", "copy2.txt")
+
+# Vérifier si un fichier est présent ou non
+if os.path.isfile("copy.txt"):
+    print("Le fichier est bien présent.")
+else:
+    print("Le fichier n'est pas présent.")
+
+# Supprime un fichier
+os.remove("copy.txt")
+os.remove("copy2.txt")
+os.remove("file.txt")

adsToolBox/demo/dataset_join.py

@@ -0,0 +1,25 @@
+import polars as pl
+
+tbl1 = [
+    ("A", "1"),
+    ("B", "2"),
+    ("C", "3"),
+    ("D", "4")
+]
+
+df1 = pl.DataFrame(tbl1, schema=["key", "value1"], orient="row")
+tbl2 = [
+    ("A", "10"),
+    ("B", "20"),
+    ("C", "40"),
+]
+
+df2 = pl.DataFrame(tbl2, schema=["key", "value2"], orient="row")
+
+# Inner join
+df_joined = df1.join(df2, on="key", how="inner")
+print(df_joined)
+
+# Left join
+df_left_joined = df1.join(df2, on="key", how="left")
+print(df_left_joined)

adsToolBox/demo/dataset_sort.py

@@ -0,0 +1,16 @@
+import polars as pl
+
+tbl = [
+    ("A", "5"),
+    ("C", "3"),
+    ("E", "1"),
+    ("D", "2"),
+    ("B", "4")
+]
+df = pl.DataFrame(tbl, schema=["key", "value"], orient="row")
+
+df = df.sort("key")
+print(df)
+
+df = df.sort("value")
+print(df)

adsToolBox/demo/dataset_transform.py

@@ -0,0 +1,19 @@
+import polars as pl
+
+tbl = [
+    ("A A A A", "1"),
+    ("B   V", "2"),
+    ("CZZ  ZDQS", "3"),
+    ("CQSD d", "4"),
+    ("CDAS   AZDASD", "5")
+]
+df = pl.DataFrame(tbl, schema=["key", "value"], orient="row")
+print(df)
+
+#Suppression des espaces sur une colonne
+df = df.with_columns(pl.col("key").str.replace_all(" ", ""))
+print(df)
+
+#Concaténation de 2 champs
+df = df.with_columns(pl.concat_str(["key", "value"], separator="-").alias("value2"))
+print(df)

adsToolBox/demo/demo_logger_timer.py

@@ -0,0 +1,62 @@
+from adsToolBox import timer
+from adsToolBox.dbPgsql import dbPgsql
+from adsToolBox.logger import Logger
+from adsToolBox.global_config import set_timer
+import time
+
+from to_sort.env import *
+import logging
+
+# Établit une connexion pour que le logger puisse écrire en base
+logger_connection = dbPgsql({'database': pg_dwh_db
+                          , 'user': pg_dwh_user
+                          , 'password': pg_dwh_pwd
+                          , 'port': pg_dwh_port
+                          , 'host': pg_dwh_host},
+                      None)
+# Ne pas oublier de lancer la connection
+logger_connection.connect()
+
+logger = Logger(logger_connection, logging.INFO, "AdsLogger", "LOGS", "LOGS_details")
+logger.info("Début de la démonstration.")
+
+# Active le timer, les requêtes seront chronométrées, si le logger n'est pas activé, les temps d'exécutions ne seront pas affichés
+set_timer(True)
+
+# On définit une source de connexion à laquelle on affecte notre logger
+source = dbPgsql({'database': pg_dwh_db
+                          , 'user': pg_dwh_user
+                          , 'password': pg_dwh_pwd
+                          , 'port': pg_dwh_port
+                          , 'host': pg_dwh_host},
+                      logger)
+
+# Cette opération sera loguée et chronométrée
+source.connect()
+
+# Celle-ci le sera dès que le flux (générateur) renvoyé par sqlQuery sera consommé
+data1 = source.sqlQuery('''SELECT tenantname, fichier FROM onyx_qs."diskcheck" LIMIT 10''')
+print(f"Première requête: {list(data1)}")
+# Après ce print viennent les notifications d'insertions des logs en base et le temps d'eéxuction
+
+# Voici comment désactiver les logs
+logger.disable()
+logger.info("Ceci est un message d'information qui n'est pas censé s'afficher.")
+
+data2 = source.sqlQuery('''SELECT tenantname, fichier FROM onyx_qs."diskcheck" LIMIT 10''')
+print(f"Seconde requête: {list(data2)}")
+# Ici pas d'insertions en base de logs non plus, et pas de temps d'exécutions affiché
+
+# On peut aussi affecter le décorateur timer à n'importe quelle méthode
+@timer
+def sample_function(duration, logger=None):
+    """ Une fonction d'exemple qui simule une tâche en attendant un certain temps. """
+    time.sleep(duration)
+    return "Done"
+
+# Par contre, il faut absolument un argument 'logger' dans la fonction en question
+logger.enable()
+sample_function(0.1, logger=logger)
+
+
+logger.info("Fin de la démonstration !")

adsToolBox/demo/demo_pipeline_1.py

@@ -0,0 +1,88 @@
+from adsToolBox.logger import Logger
+from adsToolBox.dbPgsql import dbPgsql
+from adsToolBox.global_config import set_timer
+from adsToolBox.pipeline import pipeline
+
+from to_sort.env import *
+import logging
+
+logger_connection = dbPgsql({'database': pg_dwh_db
+                          , 'user': pg_dwh_user
+                          , 'password': pg_dwh_pwd
+                          , 'port': pg_dwh_port
+                          , 'host': pg_dwh_host},
+                      None, 10_000)
+logger_connection.connect()
+logger = Logger(logger_connection, logging.INFO, "AdsLogger", "LOGS", "LOGS_details")
+logger.info("Début de la démonstration...")
+logger.disable()
+set_timer(True)
+
+# Déclarons une source base de données
+source = dbPgsql({'database':pg_dwh_db
+                    , 'user':pg_dwh_user
+                    , 'password':pg_dwh_pwd
+                    , 'port':pg_dwh_port
+                    , 'host':pg_dwh_host}, logger, batch_size=1)
+
+# Déclarer une destination, c'est un peu plus complexe
+destination = {
+    'name': 'test',
+    'db': dbPgsql({'database':pg_dwh_db, 'user':pg_dwh_user, 'password':pg_dwh_pwd, 'port':pg_dwh_port
+                    , 'host':pg_dwh_host}, logger),
+    'table': 'demo_pipeline',
+    'cols': ['tenantname', 'taille', 'unite', 'fichier']
+}
+
+# Créons la table de réception de nos données
+destination['db'].connect()
+destination['db'].sqlExec(''' DROP TABLE IF EXISTS demo_pipeline; ''')
+destination['db'].sqlExec('''
+CREATE TABLE IF NOT EXISTS demo_pipeline (
+    id SERIAL PRIMARY KEY,
+    tenantname VARCHAR(255),
+    taille FLOAT(8),
+    unite VARCHAR(10),
+    fichier VARCHAR(255)
+);
+''')
+
+# Voici la requête pour la source
+query = '''
+SELECT tenantname, taille, unite, fichier
+FROM onyx_qs."diskcheck" LIMIT 5
+'''
+logger.enable()
+
+# Premier pipeline
+pipeline_1 = pipeline({
+    'db_source': source, # La source du pipeline
+    'query_source': query, # La requête qui sera exécutée sur cette source
+    'db_destinations': destination, # La destination du pipeline
+    'batch_size': 1
+}, logger)
+
+rejects = pipeline_1.run() # pipeline.run() renvoie les rejets du pipeline, ce sera une liste vide s'il
+# n'y en a pas
+print(f"{len(rejects)} rejets : {rejects}")
+
+# Un batch_size à 1, ce insère les lignes une par une, un batch_size plus grand implique un run plus rapide
+# pour le même nombre de lignes, batch_size est à 10 000 par défaut
+# Second pipeline
+source = dbPgsql({'database':pg_dwh_db
+                    , 'user':pg_dwh_user
+                    , 'password':pg_dwh_pwd
+                    , 'port':pg_dwh_port
+                    , 'host':pg_dwh_host}, logger)
+
+pipeline_2 = pipeline({
+    'db_source': source, # La source du pipeline
+    'query_source': query, # La requête qui sera exécutée sur cette source
+    'db_destinations': destination # La destination du pipeline
+}, logger)
+
+rejects = pipeline_2.run()
+print(f"{len(rejects)} rejets : {rejects}")
+
+
+logger.info("Fin de la démonstration")