DE-Lib 0.0.20__py3-none-any.whl

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/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/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/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/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/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/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/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/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

DE_Lib/DataBase/RedShift.py

@@ -0,0 +1,42 @@
+
+
+class RedShift:
+    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):
+        conn = None
+        try:
+            conn = reds.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"]
+            self._cnn = conn
+        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/DataBase/SQCipher.py

@@ -0,0 +1,42 @@
+
+
+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):
+        DATABASE_NAME, result, msg, conn = None, False, None, None
+        try:
+            if os.path.isfile(database):
+                #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)
+        except Exception as error:
+            conn = error
+            self._connection_is_valid = False
+            self._DATABASE_ERROR = True
+        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/DataBase/SQLite.py

@@ -0,0 +1,48 @@
+import sqlite3 as sq3
+import os
+
+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
+        try:
+            if os.path.isfile(database):
+                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'
+        except Exception as error:
+            msg = f"""SQLITE database: {database}\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
+        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/Files/Avro.py

@@ -0,0 +1,23 @@
+import pandas as pd
+import pandavro as pda
+
+
+class AVRO:
+    def __init__(self):
+        ...
+
+    def ExportDataFrame(self,
+             df: pd.DataFrame,
+             file_name: str,
+             file_sufix: str = "",
+             file_path: str = ""
+             ):
+        msg, result = None, True
+        try:
+            pda.to_avro(file_path_or_buffer=file_name, df=df)
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+