DE-Lib 0.0.20__tar.gz

de_lib-0.0.20/DE_LIB.egg-info/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.2
+Name: DE_Lib
+Version: 0.0.20
+Summary: Biblioteca de funcionalidades
+Home-page: https://github.com/DE-DATAx/DAX_DB.git
+Author: Almir J Gomes
+Author-email: almir.jg@hotmail.com
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: fbd
+Requires-Dist: cx_Oracle
+Requires-Dist: JayDeBeApi
+Requires-Dist: mysql.connector
+Requires-Dist: psycopg2
+Requires-Dist: pymssql
+Requires-Dist: redshift-connector
+Requires-Dist: SQLAlchemy==2.0.38
+Requires-Dist: bcrypt==4.3.0
+Requires-Dist: argon2-cffi==23.1.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
+
+<h1>DAX_UTIL</h1>
+
+## **Biblioteca de funcionalidades**
+
+## Conteudo
+
+Os pacotes que compoem esta biblioteca sao:<br>
+- Cipher<br>
+- DateUtils<br>
+- Generic<br>
+- SQL<br>
+- System<br>
+- WebHook<br>
+
+<h3>Descricao dos pacotes...</h3>
+<h2>Cipher:</h2>
+
+Pacote responsavel por criptografar e descriptografar conteudos, composta 
+por tres classes: RSA, AES e B64.
+Peculiaridades de cada uma destas classes:<br>
+- <b>RSA</b>: Criptografa textos curtos
+- <b>AES</b>: Criptografa textos longos (faz uso tambem da RSA)
+- <b>B64</b>: Criptografia mais vulneravel
+
+<b><u>from Utils.Cipher import RSA, AES, B64</b></u>
+
+Apesar de criptografar qualquer tipo de valor, nao e recomendada utilizar 
+para senhas ou informacoes sensiveis pois sua vulnerabilidade e grande.<br>
+***Em breve sera disponibilizadas funcionalidades para este fim neste pacote
+
+<h2>DateUtils</h2> Pacote responsavel por manipulacao de datas e horas
+<h2>Generic</h2>Funcionalidades de utilizacao generica. Principal foco e facilitar e 
+diminuir aqueles codigos que ocupam varias linhas suprimindo-os em apenas uma linha,
+quando possivel. Ex.:<br> 
+- NVL() --> Equivalente ao NVL do ORACLE. nvl(None, "a")<br>
+- IIF() --> If de uma linha so IF(value_boolean, value_True, value_False)<br>
+- entre outras funconalidades<br>
+
+<h2>SQL</h2>Ainda em desenvolvimento. Com objetivo de facilitar obtencao de valores de cursores, etc.
+<h2>System</h2>Obtem informacoes do sistema operacional
+<h2>WebHook</h2>Funcionalidades para conversar com TEAMS e SLACK

de_lib-0.0.20/DE_LIB.egg-info/SOURCES.txt

@@ -0,0 +1,55 @@
+LICENCE
+README.md
+setup.py
+DE_LIB.egg-info/PKG-INFO
+DE_LIB.egg-info/SOURCES.txt
+DE_LIB.egg-info/dependency_links.txt
+DE_LIB.egg-info/requires.txt
+DE_LIB.egg-info/top_level.txt
+DE_Lib/__init__.py
+DE_Lib.egg-info/PKG-INFO
+DE_Lib.egg-info/SOURCES.txt
+DE_Lib.egg-info/dependency_links.txt
+DE_Lib.egg-info/requires.txt
+DE_Lib.egg-info/top_level.txt
+DE_Lib/Cloud/__init__.py
+DE_Lib/DataBase/Azure.py
+DE_Lib/DataBase/Cache.py
+DE_Lib/DataBase/Firebird.py
+DE_Lib/DataBase/Informix.py
+DE_Lib/DataBase/Metadata.py
+DE_Lib/DataBase/MsSql.py
+DE_Lib/DataBase/MySql.py
+DE_Lib/DataBase/Oracle.py
+DE_Lib/DataBase/Postgres.py
+DE_Lib/DataBase/RedShift.py
+DE_Lib/DataBase/SQCipher.py
+DE_Lib/DataBase/SQLite.py
+DE_Lib/DataBase/__init__.py
+DE_Lib/Files/Avro.py
+DE_Lib/Files/Csv.py
+DE_Lib/Files/JSon.py
+DE_Lib/Files/Parquet.py
+DE_Lib/Files/Txt.py
+DE_Lib/Files/Xlsx.py
+DE_Lib/Files/__init__.py
+DE_Lib/Log/DE_LogEventos.py
+DE_Lib/Log/Level.py
+DE_Lib/Log/Log.py
+DE_Lib/Log/__init__.py
+DE_Lib/Utils/Colors.py
+DE_Lib/Utils/DateUtils.py
+DE_Lib/Utils/Generic.py
+DE_Lib/Utils/SQL.py
+DE_Lib/Utils/System.py
+DE_Lib/Utils/WebHook.py
+DE_Lib/Utils/__init__.py
+DE_Lib/Utils/Cipher/Aes.py
+DE_Lib/Utils/Cipher/Argon.py
+DE_Lib/Utils/Cipher/Base64.py
+DE_Lib/Utils/Cipher/Cipher.py
+DE_Lib/Utils/Cipher/Fernet.py
+DE_Lib/Utils/Cipher/Gcm.py
+DE_Lib/Utils/Cipher/Pbkdf2.py
+DE_Lib/Utils/Cipher/Rsa.py
+DE_Lib/Utils/Cipher/__init__.py

de_lib-0.0.20/DE_LIB.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

de_lib-0.0.20/DE_LIB.egg-info/requires.txt

@@ -0,0 +1,10 @@
+fbd
+cx_Oracle
+JayDeBeApi
+mysql.connector
+psycopg2
+pymssql
+redshift-connector
+SQLAlchemy==2.0.38
+bcrypt==4.3.0
+argon2-cffi==23.1.0

de_lib-0.0.20/DE_LIB.egg-info/top_level.txt

@@ -0,0 +1 @@
+DE_Lib

de_lib-0.0.20/DE_Lib/DataBase/Azure.py

@@ -0,0 +1,44 @@
+import redshift_connector as DB
+
+
+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
+        try:
+            from azure.storage.filedatalake import DataLakeServiceClient as az
+
+            conn = az.connect(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"]
+        except Exception as error:
+            self._connection_is_valid = False
+            self.__database_error = conn.DatabaseError
+            conn = error
+        finally:
+            return conn
+
+    @property
+    def CONNECTION(self):
+        return self._cnn
+
+    @property
+    def CONNECTION_VALID(self):
+        return self._connection_is_valid
+
+    @property
+    def NOME_DATABASE(self):
+        return self._nome_database.upper()
+
+    @property
+    def DATABASE_ERROR(self):
+        return self.__database_error

de_lib-0.0.20/DE_Lib/DataBase/Cache.py

@@ -0,0 +1,74 @@
+import jaydebeapi as jdb
+import jpype as jp
+import os
+import json
+
+class Cache:
+    def __init__(self):
+        self._connection_is_valid = None
+        self._nome_database = None
+        self._cnn = None
+        self.__database_error = None
+
+    def Connect(self, string_connect):
+        """
+        Conexao com a base CACHÉ (Intersystem)
+        O arquivo "CacheDB.jar" --> Tem que estar na mesma pasta de da lib ou ter o seu
+        caminho completo declarado na chamada da funcao
+        :param string_connect:
+                    "database": "cache",
+                    "name_conection": "Nome da conexão para melhor identicacao",
+                    "driver": str: default = "CacheDB.jar",
+                    "user": str: Nome do usuario,
+                    "pwd": str: senha do usuario,
+                    "host": str: Nome do host (Url ou IP),
+                    "port": str: Numero da porta --> default = "1972",
+                    "instance": str: <Nome da instanciaa ser conectada>
+        :return:
+        """
+        msg, result = None, None
+        try:
+            if string_connect["database"] == "":
+                string_connect["database"] = "cache"
+            if string_connect["driver_conexao"] == "":
+                string_connect["driver_conexao"] = "CacheDB.jar"
+            if string_connect["port"] == "":
+                string_connect["port"] = "1972"
+            jarODBC = os.path.join(string_connect["driver_library"], string_connect["driver_conexao"])
+            JHOME = jp.getDefaultJVMPath()
+            jp.startJVM(JHOME, f"""-Djava.class.path={jarODBC}""")
+            __driver = "com.intersys.jdbc.CacheDriver"
+            __usr = string_connect["user"]
+            __pwd = string_connect["pwd"]
+            __host = string_connect["host"]
+            __port = string_connect["port"]
+            __namespace = string_connect["instance"]
+            __url = f"""jdbc:Cache://{__host}:{__port}/{__namespace}"""
+            result = jdb.connect(__driver, __url, [__usr, __pwd])
+            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"]
+        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
+            self._connection_is_valid = False
+            self._database_error = msg
+        finally:
+            return result
+
+    @property
+    def CONNECTION(self):
+        return self._cnn
+
+    @property
+    def CONNECTION_VALID(self):
+        return self._connection_is_valid
+
+    @property
+    def NOME_DATABASE(self):
+        return self._nome_database.upper()
+
+    @property
+    def DATABASE_ERROR(self):
+        return self._database_error

de_lib-0.0.20/DE_Lib/DataBase/Firebird.py

@@ -0,0 +1,45 @@
+import fbd
+
+class Firebird:
+    def __init__(self):
+        self._connection_is_valid = None
+        self._nome_database = None
+        self._cnn = None
+        self.__database_error = None
+
+    # ----------------------------------------------------------------
+    # Falta driver - maquina local não permite
+    def Connect(self, string_connect: dict):
+        msg, conn = None, None
+        try:
+            user = string_connect["username"]
+            pwd = string_connect["password"]
+            host = string_connect["host"]
+            port = string_connect["port"]
+            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
+        except Exception as error:
+            conn = error
+            self._connection_is_valid = False
+            self._DATABASE_ERROR = conn.DatabaseError
+        finally:
+            return conn
+
+    @property
+    def CONNECTION(self):
+        return self._cnn
+
+    @property
+    def CONNECTION_VALID(self):
+        return self._connection_is_valid
+
+    @property
+    def NOME_DATABASE(self):
+        return self._nome_database.upper()
+
+    @property
+    def DATABASE_ERROR(self):
+        return self._DATABASE_ERROR

de_lib-0.0.20/DE_Lib/DataBase/Informix.py

@@ -0,0 +1,37 @@
+
+
+class Informix:
+    def __init__(self):
+        self._connection_is_valid = None
+        self._nome_database = None
+        self._cnn = None
+        self.__database_error = None
+
+    # ----------------------------------------------------------------
+    # Falta tudo (Instalar driver ODBC) Maquina local não permite
+    def Connect(self, string_connect: dict):
+        try:
+            pass
+            self._connection_is_valid = True
+            self._cnn = None
+        except Exception as error:
+            self._connection_is_valid = False
+            self._DATABASE_ERROR = True
+        finally:
+            pass
+
+    @property
+    def CONNECTION(self):
+        return self._cnn
+
+    @property
+    def CONNECTION_VALID(self):
+        return self._connection_is_valid
+
+    @property
+    def NOME_DATABASE(self):
+        return self._nome_database.upper()
+
+    @property
+    def DATABASE_ERROR(self):
+        return self.__database_error

de_lib-0.0.20/DE_Lib/DataBase/Metadata.py

@@ -0,0 +1,62 @@
+import pandas as pd
+
+class Metadata:
+    def __init__(self):
+        ...
+
+    def getMetadados(self, table, owner: str = '', con=None, database: str = 'ORACLE', driver: str = "SQLALCHEMY"):
+        msg, result = None, None
+        try:
+            self._owner = owner
+            self._table = table
+            self._qry = self.QUERYS_METADADOS[database.upper()]
+            #cur = con.connection.cursor()
+            if driver.upper() == "SQLALCHEMY":
+                result = pd.read_sql(con=con.connection, sql=self.QUERY)
+            else:
+                result = pd.read_sql(con=con, sql=self.QUERY)
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    @property
+    def QUERYS_METADADOS(self):
+        value = {
+            "ORACLE": f"""Select * from all_tab_columns where owner = '{self._owner}' and table_name = '{self._table}' order by column_id"""
+            ,
+            "POSTGRES": f"""Select * from information_schema.columns where table_schema = '{self._owner}' and table_name = '{self._table}' order by ordinal_position"""
+            , "SQLITE": f"""Select * from pragma_table_info('{self._table}') order by cid"""
+            ,
+            "MYSQL": f"""Select * from information_schema.columns where table_name = '{self._table}' order by ordinal_position"""
+            ,
+            "REDSHIFT": f"""Select column_name from information_schema.columns where table_schema ='{self._owner}' and table_name = '{self._table}' order by ordinal_position"""
+            ,
+            "CACHE": f"""SELECT * FROM INFORMATION_SCHEMA.COLUMNS where table_schema = '{self._owner}' and table_name = '{self._table}' order by ordinal_position"""
+            , "MSSQL": f"""select t.name Tabela
+                                                ,ac.name Coluna
+                                                ,ac.column_id
+                                                ,sep.value Comment
+                                                ,t2.name Data_Type
+                                            from sys.schemas s
+                                            join sys.tables t
+                                              on t.schema_id = s.schema_id
+                                            join sys.all_columns ac
+                                              on ac.object_id = t.object_id
+                                            join sys.types t2
+                                              on t2.system_type_id = ac.system_type_id
+                                            left join sys.extended_properties sep
+                                              on sep.major_id = t.object_id
+                                                 and sep.minor_id = ac.column_id
+                                                 and sep.name = 'MS_Description'
+                                           where s.name = ISNULL('{self._owner}', 'dbo')
+                                             and t.name = '{self._table}'
+                                           order by t.name, ac.column_id
+                                """
+        }
+        return value
+
+    @property
+    def QUERY(self):
+        return self._qry

de_lib-0.0.20/DE_Lib/DataBase/MsSql.py

@@ -0,0 +1,39 @@
+import pymssql as mssql
+
+class MsSql:
+    def __init__(self):
+        self._connection_is_valid = None
+        self._nome_database = None
+        self._cnn = None
+        self.__database_error = None
+
+    def Connect(self, string_connect: dict):
+        msg, conn = None, None
+        try:
+            # 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
+        except Exception as error:
+            conn = error
+            self._connection_is_valid = False
+            self._DATABASE_ERROR = conn.DatabaseError
+        finally:
+            return conn
+
+    @property
+    def CONNECTION(self):
+        return self._cnn
+
+    @property
+    def CONNECTION_VALID(self):
+        return self._connection_is_valid
+
+    @property
+    def NOME_DATABASE(self):
+        return self._nome_database.upper()
+
+    @property
+    def DATABASE_ERROR(self):
+        return self._DATABASE_ERROR

de_lib-0.0.20/DE_Lib/DataBase/MySql.py

@@ -0,0 +1,42 @@
+import mysql.connector as mysql
+import json
+
+class MySql:
+    def __init__(self):
+        self._connection_is_valid = None
+        self._nome_database = None
+        self._cnn = None
+        self.__database_error = None
+
+    def Connect(self, string_connect: dict):
+        msg, conn = None, None
+        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"])
+            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"]
+        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} """
+            result = msg
+            self._connection_is_valid = False
+            self._DATABASE_ERROR = msg
+        finally:
+            return result
+
+    @property
+    def CONNECTION(self):
+        return self._cnn
+
+    @property
+    def CONNECTION_VALID(self):
+        return self._connection_is_valid
+
+    @property
+    def NOME_DATABASE(self):
+        return self._nome_database.upper()
+
+    @property
+    def DATABASE_ERROR(self):
+        return self._DATABASE_ERROR

de_lib-0.0.20/DE_Lib/DataBase/Oracle.py

@@ -0,0 +1,111 @@
+import os
+import cx_Oracle as ora
+import sqlalchemy as sqa
+import json
+
+class Oracle:
+    def __init__(self):
+        self._connection_is_valid = None
+        self._nome_database = None
+        self._cnn = None
+        self.__database_error = None
+
+    def Connect_ORA(self, string_connect: dict):
+        pathlib, msg, result = None, None, None
+        try:
+            # Definindo a Library ORACLE
+            if "library" in string_connect.keys():
+                if string_connect["library"] is None:
+                    pathlib = os.getenv("ORACLE_LIB")
+                else:
+                    pathlib = string_connect["library"]
+            else:
+                pathlib = os.getenv("ORACLE_LIB")
+
+            # Consistindo se a biblioteca do oracle ja esta iniciada
+            try:
+                ora.init_oracle_client(lib_dir=pathlib)
+            except:
+                pass
+                # não faz nada (e para deixar assim se nao da erro)
+
+            # Definindo o tipo de instancia SID/SERVICE_NAME
+            if string_connect["type_conection"].upper() == "SID":
+                dnsName = ora.makedsn(host=string_connect["host"], port=string_connect["port"], sid=string_connect["instance"])
+            else:
+                dnsName = ora.makedsn(host=string_connect["host"], port=string_connect["port"], service_name=string_connect["instance"])
+
+            # 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._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 = msg
+
+        finally:
+            return result
+
+    def Connect_SQLA(self, string_connect: dict):
+        conn = None
+        try:
+            # Definindo a Library ORACLE
+            if string_connect["path_library"] is None:
+                pathlib = os.getenv("ORACLE_LIB")
+            else:
+                pathlib = string_connect["path_library"]
+
+            # Consistindo se a biblioteca do oracle ja esta iniciada
+            try:
+                ora.init_oracle_client(lib_dir=pathlib)
+            except:
+                pass
+                # não faz nada (e para deixar assim se nao da erro)
+            # Validando se foi passado um driver para conexao
+            if string_connect["driver_conexao"] is None:
+                string_connect["driver_conexao"] = "cx_oracle"
+            database = string_connect["database"]
+            driver = string_connect["driver_conexao"]
+            user = string_connect["username"]
+            pwd = string_connect["password"]
+            host = string_connect["host"]
+            port = string_connect["port"]
+            string_connect["instance"] = ora.makedsn(host, port, string_connect["instance"])
+            # Validando o tipo de conexao (SID ou SERVICE_NAME) apenas oracle
+            if string_connect["type_conection"].upper() == "SERVICE_NAME":
+                string_connect["instance"] = string_connect["instance"].replace("SID", "SERVICE_NAME")
+            dnsName = string_connect["instance"]
+            str_cnn = f"""{database.lower()}{driver}://{user}:{pwd}@{dnsName}"""
+            engine = sqa.create_engine(str_cnn)
+            result = engine.connect()
+            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"]
+        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
+            self._connection_is_valid = False
+            self.__database_error = msg
+        finally:
+            return result
+
+    @property
+    def CONNECTION(self):
+        return self._cnn
+
+    @property
+    def CONNECTION_VALID(self):
+        return self._connection_is_valid
+
+    @property
+    def NOME_DATABASE(self):
+        return self._nome_database.upper()
+
+    @property
+    def DATABASE_ERROR(self):
+        return self.__database_error

de_lib-0.0.20/DE_Lib/DataBase/Postgres.py

@@ -0,0 +1,39 @@
+import psycopg2 as ps2
+
+class Postgres:
+    def __init__(self):
+        self._connection_is_valid = None
+        self._nome_database = None
+        self._cnn = None
+        self.__database_error = None
+
+    def Connect(self, string_connect: dict):
+        msg, conn = 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
+        except Exception as error:
+            conn = f"""Falha ao tentar se conectar com o banco de dados POSTGRES.\n """
+            self._connection_is_valid = False
+            self._DATABASE_ERROR = conn.DatabaseError
+        finally:
+            return conn
+
+    @property
+    def CONNECTION(self):
+        return self._cnn
+
+    @property
+    def CONNECTION_VALID(self):
+        return self._connection_is_valid
+
+    @property
+    def NOME_DATABASE(self):
+        return self._nome_database.upper()
+
+    @property
+    def DATABASE_ERROR(self):
+        return self.__database_error