DE-Lib 0.0.20__py3-none-any.whl → 0.0.35.4__py3-none-any.whl

DE_Lib/DataBase/Azure.py

@@ -1,31 +1,42 @@
-import redshift_connector as DB
+"""
+Faltam testes mais conclusivos
+"""
+import redshift_connector as redshift
+from azure.storage.filedatalake import DataLakeServiceClient
+import os
+import json
 
+from DE_Lib.Utils import Generic
 
-class Azure:
+gen = Generic.GENERIC()
+
+
+class AZURE:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
         self._cnn = None
         self.__database_error = None
 
-    def AZURE(self, string_connect: dict):
-        conn = None
+    def Connect(self, string_connect: dict):
+        conn, result = None, None
         try:
-            from azure.storage.filedatalake import DataLakeServiceClient as az
-
-            conn = az.connect(host=string_connect["host"],
+            conn = DataLakeServiceClient(host=string_connect["host"],
                               database=string_connect["instance"],
                               user=string_connect["username"],
                               password=string_connect["password"]
                               )
             self._connection_is_valid = True
-            self._nome_database = string_connect["database"]
+            self._cnn = result
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
+            self._nome_database = gen.nvl(string_connect["database"], "")
         except Exception as error:
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados AZURE\nException Error: {error} """
+            result = msg
             self._connection_is_valid = False
-            self.__database_error = conn.DatabaseError
-            conn = error
+            self.__database_error = msg
         finally:
-            return conn
+            return result
 
     @property
     def CONNECTION(self):

DE_Lib/DataBase/Cache.py

@@ -3,7 +3,11 @@ import jpype as jp
 import os
 import json
 
-class Cache:
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class CACHE:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
@@ -48,7 +52,7 @@ class Cache:
             self._connection_is_valid = True
             self._cnn = result
             self._database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["pwd"], "******")}\nConexao bem sucedida!"""
-            self._nome_database = string_connect["database"]
+            self._nome_database = gen.nvl(string_connect["database"], "")
         except Exception as error:
             msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["pwd"], "******")}\nFalha ao tentar se conectar com o banco de dados CACHÉ (intersystem)\nException Error: {error} """
             result = msg
@@ -57,6 +61,8 @@ class Cache:
         finally:
             return result
 
+
+
     @property
     def CONNECTION(self):
         return self._cnn

DE_Lib/DataBase/Firebird.py

@@ -1,6 +1,12 @@
 import fbd
+import os
+import json
 
-class Firebird:
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class FIREBIRD:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
@@ -10,7 +16,7 @@ class Firebird:
     # ----------------------------------------------------------------
     # Falta driver - maquina local não permite
     def Connect(self, string_connect: dict):
-        msg, conn = None, None
+        msg, conn, result = None, None, None
         try:
             user = string_connect["username"]
             pwd = string_connect["password"]
@@ -19,13 +25,16 @@ class Firebird:
             instance = string_connect["instance"]
             conn = fbd.connect(host=host, database=instance, user=user, password=pwd, port=port)
             self._connection_is_valid = True
-            self._nome_database = string_connect["database"]
-            self._cnn = conn
+            self._nome_database = gen.nvl(string_connect["database"], "")
+            self._cnn = result
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
         except Exception as error:
-            conn = error
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados ORACLE\nException Error: {error} """
+            result = msg
             self._connection_is_valid = False
-            self._DATABASE_ERROR = conn.DatabaseError
+            self.__database_error = msg
         finally:
+            return result
             return conn
 
     @property

DE_Lib/DataBase/Informix.py

@@ -1,6 +1,11 @@
+import os
+import json
 
+from DE_Lib.Utils import Generic
 
-class Informix:
+gen = Generic.GENERIC()
+
+class INFORMIX:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
@@ -10,15 +15,20 @@ class Informix:
     # ----------------------------------------------------------------
     # Falta tudo (Instalar driver ODBC) Maquina local não permite
     def Connect(self, string_connect: dict):
+        msg, result = None, None
         try:
             pass
             self._connection_is_valid = True
-            self._cnn = None
+            self._nome_database = gen.nvl(string_connect["database"], "")
+            self._cnn = result
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
         except Exception as error:
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados ORACLE\nException Error: {error} """
+            result = msg
             self._connection_is_valid = False
-            self._DATABASE_ERROR = True
+            self.__database_error = msg
         finally:
-            pass
+            return result
 
     @property
     def CONNECTION(self):

DE_Lib/DataBase/Metadata.py

@@ -1,6 +1,6 @@
 import pandas as pd
 
-class Metadata:
+class METADATA:
     def __init__(self):
         ...
 

DE_Lib/DataBase/MsSql.py

@@ -1,6 +1,10 @@
 import pymssql as mssql
 
-class MsSql:
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class MSSQL:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
@@ -13,14 +17,16 @@ class MsSql:
             # Efetuando a conexao com a instancia do BANCO
             conn = mssql.connect(user=string_connect["username"], password=string_connect["password"], database=string_connect["instance"], server=string_connect["host"])
             self._connection_is_valid = True
-            self._nome_database = string_connect["database"]
-            self._cnn = conn
+            self._cnn = result
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
+            self._nome_database = gen.nvl(string_connect["database"], "")
         except Exception as error:
-            conn = error
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados MSSQL (SqlAlchemy)\nException Error: {error} """
+            result = msg
             self._connection_is_valid = False
-            self._DATABASE_ERROR = conn.DatabaseError
+            self.__database_error = msg
         finally:
-            return conn
+            return result
 
     @property
     def CONNECTION(self):

DE_Lib/DataBase/MySql.py

@@ -1,27 +1,45 @@
 import mysql.connector as mysql
+import pymysql
+import sqlalchemy as sqa
 import json
 
-class MySql:
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class MYSQL:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
+        self.__database_driver = None
         self._cnn = None
         self.__database_error = None
 
-    def Connect(self, string_connect: dict):
-        msg, conn = None, None
+    def Connect(self, conn: dict):
+        msg, result = None, True
         try:
             # Efetuando a conexao com a instancia do BANCO
-            result = mysql.connect(user=string_connect["username"], password=string_connect["password"], database=string_connect["instance"], host=string_connect["host"])
+            __conn = None
+            if conn["driver_conexao"].upper() == "SQLALCHEMY":
+                __dns = f"""{conn["database"].lower()}+pymysql://{conn["username"]}:{conn["password"]}@{conn["host"]}:{conn["port"]}/{conn["instance"]}"""
+                __engine = sqa.create_engine(url=__dns)
+                __conn = __engine.connect().connection
+                #__conn = __conn.connection
+            elif conn["driver_conexao"].upper() == "MYSQL":
+                __conn = mysql.connect(user=conn["username"], password=conn["password"], database=conn["instance"], host=conn["host"])
+            elif conn["driver_conexao"].upper() == "PYMYSQL":
+                __conn = pymysql.connect(user=conn["username"], password=conn["password"], database=conn["instance"], host=conn["host"])#, cursorclass=pymysql.cursors.DictCursor)
             self._connection_is_valid = True
-            self._cnn = result
-            self._DATABASE_ERROR = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
-            self._nome_database = string_connect["database"]
+            self._nome_database = gen.nvl(conn["database"], "")
+            self.__database_driver = conn["driver_conexao"]
+            self._cnn = __conn
+            self.__database_error = result
+            result = True
         except Exception as error:
-            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados MYSQL\nException Error: {error} """
+            msg = f"""{json.dumps(conn, indent=4).replace(conn["password"], "******")}\nFalha ao tentar se conectar com o banco de dados MYSQL\nException Error: {error} """
             result = msg
             self._connection_is_valid = False
-            self._DATABASE_ERROR = msg
+            self.__database_error = msg
         finally:
             return result
 
@@ -35,8 +53,16 @@ class MySql:
 
     @property
     def NOME_DATABASE(self):
-        return self._nome_database.upper()
+        return self._nome_database
 
     @property
     def DATABASE_ERROR(self):
-        return self._DATABASE_ERROR
+        return self.__database_error
+
+    @property
+    def DATABASE_DRIVER(self):
+        return self.__database_driver
+
+    @DATABASE_DRIVER.setter
+    def DATABASE_DRIVER(self, value):
+        self._DATABASE_DRIVER = value

DE_Lib/DataBase/Oracle.py

@@ -1,15 +1,100 @@
 import os
 import cx_Oracle as ora
+import oracledb as odb
 import sqlalchemy as sqa
 import json
 
-class Oracle:
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class ORACLE:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
         self._cnn = None
         self.__database_error = None
 
+    # ---------------------------------
+    def Connect(self, conn: dict):
+        msg, result = None, True
+        try:
+
+            #region Definindo o tipo de instancia SID/SERVICE_NAME
+            if conn["type_conection"].upper() == "SID":
+                __dnsName = odb.makedsn(host=conn["host"], port=conn["port"],
+                                        sid=conn["instance"])
+            else:
+                __dnsName = odb.makedsn(host=conn["host"], port=conn["port"],
+                                        service_name=conn["instance"])
+            #endregion
+
+            #region Tipo de driver de conexao
+            """
+            Oracle Thin Mode vs Thick Mode no oracledb
+            O driver oracledb do Python pode operar em dois modos de conexão com o Oracle Database:            
+            . Thin Mode (Padrão) → Conexão nativa, sem necessidade do Oracle Client.
+            . Thick Mode → Usa o Oracle Client para recursos avançados e maior desempenho.
+            🔹 Comparação Geral
+                Característica	                    Thin Mode (Padrão)	Thick Mode
+                Requer Oracle Client?	            ❌ Não	            ✅ Sim
+                Performance	                           Média	        Alta
+                Suporta TNS (tnsnames.ora)?	        ❌ Não   	        ✅ Sim
+                Suporta Connection Pooling?	        ❌ Limitado	        ✅ Sim
+                Suporte a Banco de Dados Antigos?	❌ Não	            ✅ Sim
+                Uso recomendado	                    Ambientes simples	Produção, conexões complexas
+                                                    ,Cloud, Containers
+            """
+            if conn["driver_mode"].upper() == "THICK":
+                try:
+                    # region LIBRARY
+                    if conn["path_library"] is None:
+                        __pathlib = os.getenv("ORACLE_LIB")
+                    else:
+                        __pathlib = conn["path_library"]
+                    # endregion
+                    ora.init_oracle_client(lib_dir=__pathlib)
+                except  Exception as error:
+                    ...
+                    # Modo THIN apenas do banco 12 em diante
+            #endregion
+
+            #region Conexao via SQLALCHEMY | CX_ORACLE | ORACLEDB
+            __conn = None
+            if conn["driver_conexao"].upper() == "SQLALCHEMY":
+                # driver oracledb compativel com banco 12 em diante
+                if not conn["driver_library"]:
+                    # driver default caso não seja explicitado
+                    # para versões do oracle anterior a 12, este driver é o mais recomendado.
+                    __driver = "cx_oracle"
+                else:
+                    __driver = conn["driver_library"].lower()
+                conn_cnn = f"""{conn["database"].lower()}+{__driver}://{conn["username"]}:{conn["password"]}@{__dnsName}"""
+                __engine = sqa.create_engine(conn_cnn)
+                __conn = __engine.connect().connection
+            elif conn["driver_conexao"].upper() == "CX_ORACLE":
+                __conn = ora.connect(conn["username"], conn["password"], __dnsName, threaded=True)
+            elif conn["driver_conexao"].upper() == "ORACLEDB" or conn  is None:
+                # Conexao via ORACLEDB (Novo driver em substituicao do CX_ORACLE)
+                __conn = ora.connect(conn["username"], conn["password"], __dnsName, threaded=True)
+            #endregion
+
+            #region Populando propriedadas da classe
+            self.__connection_is_valid = True
+            self.__nome_database = gen.nvl(conn["database"], "")
+            self.__database_driver = conn["driver_conexao"]
+            self.__cnn = __conn
+            self.__database_error = result
+            #endregion
+        except Exception as error:
+            msg = f"""{json.dumps(conn, indent=4).replace(conn["password"], "******")}\nFalha ao tentar se conectar com o banco de dados ORACLE (SqlAlchemy)\nException Error: {error} """
+            self._connection_is_valid = False
+            self.__database_error = msg
+            result = self._connection_is_valid
+        finally:
+            return result
+
+    #region METODOS qQUE FICARÃO DEPRECIADOS A PARTIR DE 18/03/2025
     def Connect_ORA(self, string_connect: dict):
         pathlib, msg, result = None, None, None
         try:
@@ -38,7 +123,7 @@ class Oracle:
             # Efetuando a conexao com a instancia do BANCO
             result = ora.connect(string_connect["username"], string_connect["password"], dnsName, threaded=True)
             self._connection_is_valid = True
-            self._nome_database = string_connect["database"]
+            self._nome_database = gen.nvl(string_connect["database"], "")
             self._cnn = result
             self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
         except Exception as error:
@@ -46,7 +131,6 @@ class Oracle:
             result = msg
             self._connection_is_valid = False
             self.__database_error = msg
-
         finally:
             return result
 
@@ -55,6 +139,7 @@ class Oracle:
         try:
             # Definindo a Library ORACLE
             if string_connect["path_library"] is None:
+                # ORACLE_LIB tem que estar previamente criada
                 pathlib = os.getenv("ORACLE_LIB")
             else:
                 pathlib = string_connect["path_library"]
@@ -85,7 +170,7 @@ class Oracle:
             self._connection_is_valid = True
             self._cnn = result
             self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
-            self._nome_database = string_connect["database"]
+            self._nome_database = gen.nvl(string_connect["database"], "")
         except Exception as error:
             msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados ORACLE (SqlAlchemy)\nException Error: {error} """
             result = msg
@@ -93,19 +178,31 @@ class Oracle:
             self.__database_error = msg
         finally:
             return result
+    #endregion
 
+    #region PROPRIEDADES
     @property
     def CONNECTION(self):
-        return self._cnn
+        return self.__cnn
 
     @property
     def CONNECTION_VALID(self):
-        return self._connection_is_valid
+        return self.__connection_is_valid
 
     @property
     def NOME_DATABASE(self):
-        return self._nome_database.upper()
+        return self.__nome_database.upper()
 
     @property
     def DATABASE_ERROR(self):
-        return self.__database_error
+        return self.__database_error
+
+    @property
+    def DATABASE_DRIVER(self):
+        return self.__database_driver
+
+    @DATABASE_DRIVER.setter
+    def DATABASE_DRIVER(self, value):
+        self._DATABASE_DRIVER = value
+
+    #endregion

DE_Lib/DataBase/Postgres.py

@@ -1,6 +1,12 @@
 import psycopg2 as ps2
+import os
+import json
 
-class Postgres:
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class POSTGRES:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
@@ -8,19 +14,21 @@ class Postgres:
         self.__database_error = None
 
     def Connect(self, string_connect: dict):
-        msg, conn = None, None
+        msg, conn, result = None, None, None
         try:
             # Efetuando a conexao com a instancia do BANCO
             conn = ps2.connect(user=string_connect["username"], password=string_connect["password"], database=string_connect["instance"], host=string_connect["host"])
             self._connection_is_valid = True
-            self._nome_database = string_connect["database"]
-            self._cnn = conn
+            self._cnn = result
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
+            self._nome_database = gen.nvl(string_connect["database"], "")
         except Exception as error:
-            conn = f"""Falha ao tentar se conectar com o banco de dados POSTGRES.\n """
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados POSTGRES\nException Error: {error} """
+            result = msg
             self._connection_is_valid = False
-            self._DATABASE_ERROR = conn.DatabaseError
+            self.__database_error = msg
         finally:
-            return conn
+            return result
 
     @property
     def CONNECTION(self):

DE_Lib/DataBase/RedShift.py

@@ -1,6 +1,12 @@
+import redshift_connector as reds
+import os
+import json
 
+from DE_Lib.Utils import Generic
 
-class RedShift:
+gen = Generic.GENERIC()
+
+class REDSHIFT:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
@@ -8,7 +14,7 @@ class RedShift:
         self.__database_error = None
 
     def Connect(self, string_connect: dict):
-        conn = None
+        conn, result = None, None
         try:
             conn = reds.connect(host=string_connect["host"],
                                 database=string_connect["instance"],
@@ -16,14 +22,16 @@ class RedShift:
                                 password=string_connect["password"]
                             )
             self._connection_is_valid = True
-            self._nome_database = string_connect["database"]
-            self._cnn = conn
+            self._cnn = result
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
+            self._nome_database = gen.nvl(string_connect["database"], "")
         except Exception as error:
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados RedShift\nException Error: {error} """
+            result = msg
             self._connection_is_valid = False
-            self._DATABASE_ERROR = conn.DatabaseError
-            conn = error
+            self.__database_error = msg
         finally:
-            return conn
+            return result
 
     @property
     def CONNECTION(self):

DE_Lib/DataBase/SQCipher.py

@@ -1,29 +1,33 @@
+import os
+import json
 
+from DE_Lib.Utils import Generic
 
-class SQCipher:
+gen = Generic.GENERIC()
+
+class SQCIPHER:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
         self._cnn = None
         self.__database_error = None
 
-    def Connect(self, database, password):
+    def Connect(self, string_connect:dict, password):
         DATABASE_NAME, result, msg, conn = None, False, None, None
         try:
-            if os.path.isfile(database):
+            if os.path.isfile(os.path.join(string_connect["host"], string_connect["instance"])):
                 #conn = sqch.connect(database, password=password)
                 self._connection_is_valid = True
-                self._nome_database = 'SQLCIPHER'
-                self._cnn = conn
-            else:
-                msg = f"""SQLITE [{database}]- Não existe no local informado!"""
-                raise Exception(msg)
+                self._nome_database = gen.nvl(string_connect["database"], "")
+                self._cnn = result
+                self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
         except Exception as error:
-            conn = error
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados ORACLE\nException Error: {error} """
+            result = msg
             self._connection_is_valid = False
-            self._DATABASE_ERROR = True
+            self.__database_error = msg
         finally:
-            return conn
+            return result
 
     @property
     def CONNECTION(self):

DE_Lib/DataBase/SQLite.py

@@ -1,33 +1,49 @@
 import sqlite3 as sq3
+import sqlalchemy as sqa
 import os
+import json
 
-class SQLite:
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class SQLITE:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
         self._cnn = None
         self.__database_error = None
 
-    def Connect(self, database, **kwargs):
-        result, msg, conn = False, None, None
+    def Connect(self, conn: dict, **kwargs):
+        msg, result = None, True
         try:
-            if os.path.isfile(database):
+            __file = os.path.join(conn["host"], conn["instance"])
+            if os.path.isfile(__file):
                 if "check_same_thread" in kwargs.keys():
                     __check_same_thread = kwargs.get("check_same_thread")
                 else:
                     __check_same_thread = True
-                result = sq3.connect(database, check_same_thread=__check_same_thread)
-                self._connection_is_valid = True
-                self._cnn = result
-                self.__database_error = f"""SQLITE database: {database}\nConexao bem sucedida!"""
-            else:
-                raise Exception("File NOT FOUND!")
-            self._nome_database = 'SQLITE'
+
+                __conn = None
+                if not conn["driver_conexao"]:
+                    __conn = sq3.connect(__file, check_same_thread=__check_same_thread)
+                elif conn["driver_conexao"].upper() == "SQLALCHEMY":
+                    engine = sqa.create_engine(f"""sqlite:///{__file}""")
+                    __conn = engine.connect()
+                else:
+                    ...
+                    # driver nativo sqlite
+
+            self._connection_is_valid = True
+            self._cnn = __conn
+            self._nome_database = gen.nvl(conn["database"], "SQLite")
+            self.__database_driver = conn["driver_conexao"]
+            self.__database_error = result
         except Exception as error:
-            msg = f"""SQLITE database: {database}\nFalha ao tentar se conectar com o banco de dados SQLITE\nException Error: {error} """
+            msg = f"""{json.dumps(conn, indent=4).replace(conn["password"], "******")}\nFalha ao tentar se conectar com o banco de dados SQLite\nException Error: {error} """
             result = msg
             self._connection_is_valid = False
-            self.__database_error = msg + "\n" + error
+            self.__database_error = msg
         finally:
             return result
 
@@ -45,4 +61,12 @@ class SQLite:
 
     @property
     def DATABASE_ERROR(self):
-        return self.__database_error
+        return self.__database_error
+
+    @property
+    def DATABASE_DRIVER(self):
+        return self.__database_driver
+
+    @DATABASE_DRIVER.setter
+    def DATABASE_DRIVER(self, value):
+        self._DATABASE_DRIVER = value