lbxtoolkit 2.0.1__py3-none-any.whl

lbxtoolkit/__init__.py

@@ -0,0 +1,664 @@
+import os
+import sys
+import locale
+import time
+import threading
+import logging
+import msal
+import requests
+from requests.auth import HTTPBasicAuth
+from selenium import webdriver
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.chrome.options import Options
+from webdriver_manager.chrome import ChromeDriverManager
+import psycopg2
+from psycopg2.extras import execute_values
+import pandas as pd
+import numpy as np
+from http.server import BaseHTTPRequestHandler, HTTPServer
+import urllib.parse as urlparse
+import validators
+
+locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')
+
+class auth_EntraID: # Classe de autenticação de usuários no Microsoft Entra ID (antiga Azure AD)
+    def __init__(self, client_id, client_secret, tenant_id, grupo, timeout=60, log_file='auth_EntraID.log'):
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.tenant_id = tenant_id
+        self.timeout = timeout
+        self.grupo = grupo
+        self.authority = f"https://login.microsoftonline.com/{self.tenant_id}"
+        self.scope = ["https://graph.microsoft.com/.default"]
+        self.redirect_uri = "http://localhost:8000"
+        self.response = ""
+        self.status_code = 0
+        self.server = None
+        self.log_file = log_file
+
+        # Configura o logger
+        logging.basicConfig(filename=log_file, level=logging.INFO,
+                            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        self.logger = logging.getLogger(__name__)
+
+    def valida_grupo(self): # Valida se o usuário autenticado pertence a grupo de segurança informado
+        # Redireciona stdout e stderr para arquivos de log
+        original_stdout = sys.stdout
+        original_stderr = sys.stderr
+        sys.stdout = open('stdout.log', 'a')
+        sys.stderr = open('stderr.log', 'a')
+
+        # Configurações do Selenium
+        chrome_options = Options()
+        chrome_options.add_argument("--incognito")
+
+        # Inicializa a aplicação MSAL
+        try:        
+            app = msal.ConfidentialClientApplication(
+                self.client_id,
+                authority=self.authority,
+                client_credential=self.client_secret,
+            )
+        except BaseException as err:
+            print(f'Falha ao iniciar aplicação MSAL: {err}')
+            # Restaura saída padrão
+            sys.stdout.close()
+            sys.stderr.close()
+            sys.stdout = original_stdout
+            sys.stderr = original_stderr
+            print(f'Script abortado por falha aplicação MSAL. Verifque logs: {self.log_file}, stdout.log e sterr.log')
+            os._exit(0)
+
+        # Inicia o fluxo de código de autorização
+        try:
+            flow = app.initiate_auth_code_flow(scopes=self.scope, redirect_uri=self.redirect_uri)
+            auth_url = flow["auth_uri"]
+            self.response = f"Acessando a URL de autenticação Microsoft Entra ID (antiga Azure AD): {auth_url}"
+            self.logger.info(self.response)
+        except BaseException as err:
+            print(f'Falha no fluxo de autorização Microsoft Entra ID (antiga Azure AD): {err}')
+            # Restaura saída padrão
+            sys.stdout.close()
+            sys.stderr.close()
+            sys.stdout = original_stdout
+            sys.stderr = original_stderr
+            print(f'Script abortado por falha no fluxo de autorização Microsoft Entra ID (antiga Azure AD). Verifque logs: {self.log_file}, stdout.log e sterr.log')
+            os._exit(0)            
+
+        # Inicializa o ChromeDriver com redirecionamento de saída
+        try:
+            service = Service(ChromeDriverManager().install())
+            service.start()
+            driver = webdriver.Chrome(service=service, options=chrome_options)
+            driver.get(auth_url)
+        except BaseException as err:
+            print(f'Falha na inicialização do Chrome: {err}')
+            # Restaura saída padrão
+            sys.stdout.close()
+            sys.stderr.close()
+            sys.stdout = original_stdout
+            sys.stderr = original_stderr
+            print(f'Script abortado na inicialização do Chrome. Verifque logs: {self.log_file}, stdout.log e sterr.log')
+            os._exit(0)                    
+
+        class AuthHandler(BaseHTTPRequestHandler):
+            def log_message(self, format, *args):
+                self.server.logger.info("%s - - [%s] %s\n" %
+                                        (self.client_address[0],
+                                         self.log_date_time_string(),
+                                         format % args))
+
+            def do_GET(self):
+                parsed_path = urlparse.urlparse(self.path)
+                query_params = urlparse.parse_qs(parsed_path.query)
+                self.send_response(200)
+                self.send_header('Content-type', 'text/html')
+                self.end_headers()
+
+                # Captura o código de autorização e o estado
+                if 'code' in query_params and 'state' in query_params:
+                    self.server.auth_code = query_params['code'][0]
+                    self.server.state = query_params['state'][0]
+                    self.wfile.write(b'''
+                                    <!DOCTYPE html>
+                                    <html lang="pt_BR">
+                                    <head>
+                                        <meta charset="UTF-8">
+                                        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                                        <style>
+                                                body {
+                                                    font-family: 'Arial', sans-serif;
+                                                    background-color: #f8f9fa;
+                                                    margin: 0;
+                                                    font-size: 16px;
+                                                    padding: 30px;
+                                                    display: flex; *
+                                                }
+
+                                                .container {        
+                                                    width: 100%;
+                                                    margin: auto;
+                                                    background-color: #ffffff;
+                                                    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+                                                    padding: 16px;
+                                                    text-align: center;
+                                                    font-size: 16px;
+                                                    border-radius: 8px;
+                                                }
+
+                                                h1 {    
+                                                    font-size: 18px;
+                                                    text-align: center;
+                                                    color: #007bff;
+                                                }
+                                        </style>
+                                     </head>
+                                        <div class="container">
+                                            <h1>Autentica&#231;&#227;o realizada com sucesso!</h1>
+                                            Aguarde que esta p&#225;gina ser&#225; fechada automaticamente.<br>
+                                            Se isto n&#227;o acontecer, pode fech&#225;-la manualmente.
+                                        </div>
+                                     </body></html>
+                                     ''')
+                else:
+                    self.wfile.write(b'''
+                                    <!DOCTYPE html>
+                                    <html lang="pt_BR">
+                                    <head>
+                                        <meta charset="UTF-8">
+                                        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                                        <style>
+                                                body {
+                                                    font-family: 'Arial', sans-serif;
+                                                    background-color: #f8f9fa;
+                                                    margin: 0;
+                                                    font-size: 16px;
+                                                    padding: 30px;
+                                                    display: flex; *
+                                                }
+
+                                                .container {        
+                                                    width: 100%;
+                                                    margin: auto;
+                                                    background-color: #ffffff;
+                                                    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+                                                    padding: 16px;
+                                                    text-align: center;
+                                                    font-size: 16px;
+                                                    border-radius: 8px;
+                                                }
+
+                                                h1 {    
+                                                    font-size: 18px;
+                                                    text-align: center;
+                                                    color: red;
+                                                }
+                                        </style>
+                                     </head>
+                                        <div class="container">
+                                            <h1>Falha na autentica&#231;&#227;o!</h1>
+                                            Esta p&#225;gina ser&#225; fechada automaticamente.<br>
+                                            Se isto n&#227;o acontecer, pode fech&#225;-la manualmente.
+                                        </div>
+                                     </body></html>
+                                     ''')
+
+        # Inicializa o servidor HTTP
+        self.server = HTTPServer(('localhost', 8000), AuthHandler)
+        self.server.logger = self.logger  # Passa o logger para o servidor
+
+        # Função para monitorar o tempo limite
+        def monitor_timeout():
+            time.sleep(self.timeout)
+            if not hasattr(self.server, 'auth_code'):
+                self.response = "tempo limite para autenticação foi excedido"
+                self.status_code = 490
+                self.logger.error(self.response)
+                sys.stdout.close()
+                sys.stderr.close()
+                sys.stdout = original_stdout
+                sys.stderr = original_stderr
+                print(f'Código retorno: {self.status_code} ', end='') ## self.status_code = 200, usuário pertence ao grupo informado. self.status_code = 299, grupo existe mas usuário NÃO pertence à ele. Erros retornam 4xx.
+                print(f'Resposta: {self.response}', end='\n\n')  
+                print('Falha na autenticação! Execução abortada!')
+                driver.quit()
+                self.server.server_close()
+                os._exit(0)       
+
+        # Inicia a thread para monitorar o tempo limite
+        timeout_thread = threading.Thread(target=monitor_timeout)
+        timeout_thread.start()
+
+        # Espera pelo código de autorização
+        self.response = "Esperando pela autenticação..."
+        self.logger.info(self.response)
+        self.server.handle_request()
+
+        # Restaura stdout e stderr
+        sys.stdout.close()
+        sys.stderr.close()
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+
+        # Verifica se o código de autorização foi obtido dentro do tempo limite
+        if not hasattr(self.server, 'auth_code'):
+            return
+
+        # Obtém o código de autorização e o estado capturados pelo servidor HTTP
+        auth_code = self.server.auth_code
+        state = self.server.state
+
+        # Adquire o token usando o código de autorização, verificando o estado
+        try:
+            result = app.acquire_token_by_auth_code_flow(flow, {"code": auth_code, "state": state})
+        except ValueError as e:
+            self.response = f"Erro ao obter o token de acesso: {e}"
+            self.status_code = 401
+            self.logger.error(self.response)
+            driver.quit()
+            return
+
+        if "access_token" in result:
+            access_token = result['access_token']
+            headers = {
+                'Authorization': 'Bearer ' + access_token
+            }
+
+            # Obtém o email do usuário autenticado
+            me_response = requests.get(
+                'https://graph.microsoft.com/v1.0/me',
+                headers=headers
+            )
+            self.status_code = me_response.status_code
+            if me_response.status_code == 200:
+                me_data = me_response.json()
+                user_email = me_data['userPrincipalName']
+                self.response = f"Email do usuário autenticado: {user_email}"
+                self.logger.info(self.response)
+
+                # Verifica se o usuário pertence ao grupo
+                group_name = self.grupo
+
+                # Obtém o ID do usuário
+                user_response = requests.get(
+                    f'https://graph.microsoft.com/v1.0/users/{user_email}',
+                    headers=headers
+                )
+                self.status_code = user_response.status_code
+                if user_response.status_code == 200:
+                    user_data = user_response.json()
+                    user_id = user_data['id']
+
+                    # Pesquisa o grupo pelo nome
+                    group_response = requests.get(
+                        f"https://graph.microsoft.com/v1.0/groups?$filter=displayName eq '{group_name}'",
+                        headers=headers
+                    )
+                    self.status_code = group_response.status_code
+                    if group_response.status_code == 200:
+                        group_data = group_response.json()
+                        if 'value' in group_data and len(group_data['value']) > 0:
+                            group_id = group_data['value'][0]['id']
+
+                            # Verifica se o usuário está no grupo
+                            members_response = requests.get(
+                                f'https://graph.microsoft.com/v1.0/groups/{group_id}/members',
+                                headers=headers
+                            )
+                            self.status_code = members_response.status_code
+                            if members_response.status_code == 200:
+                                members_data = members_response.json()
+                                if 'value' in members_data:
+                                    user_in_group = any(member['id'] == user_id for member in members_data['value'])
+                                    if user_in_group:
+                                        self.response = f"O usuário {user_email} liberado para uso desta aplicação."
+                                    else:
+                                        self.response = f"O usuário {user_email} NÃO liberado para uso desta aplicação. Solicite acesso à TI."
+                                        self.status_code = 299
+                                else:
+                                    self.response = "Resposta da API de membros não contém a chave 'value'."
+                                    self.status_code = 460
+                            else:
+                                self.response = f"Erro na resposta da API de membros: {members_response.status_code}"
+                                self.response += f"\n{members_response.json()}"
+                        else:
+                            self.response = f"Grupo '{group_name}' não encontrado."
+                            self.status_code = 470
+                    else:
+                        self.response = f"Erro na resposta da API de grupos: {group_response.status_code}"
+                        self.response += f"\n{group_response.json()}"
+                else:
+                    self.response = f"Erro na resposta da API de usuário: {user_response.status_code}"
+                    self.response += f"\n{user_response.json()}"
+            else:
+                self.response = f"Erro ao obter informações do usuário: {me_response.status_code}"
+                self.response += f"\n{me_response.json()}"
+        else:
+            self.response = f"Erro ao obter o token de acesso: {result.get('error')}"
+            self.response += f"\n{result.get('error_description')}"
+            self.status_code = 480
+    
+        # Fecha o navegador
+        driver.quit()
+        service.stop()
+
+        # Define o retorno
+        print(f'\nCódigo retorno: {self.status_code} ', end='') ## self.status_code = 200, usuário pertence ao grupo informado. self.status_code = 299, grupo existe mas usuário NÃO pertence à ele. Erros retornam 4xx.
+        print(f'Resposta: {self.response}', end='\n\n')  
+        if self.status_code == 200:
+            print('Acesso autorizado!')
+        else:
+            print('Permissões inválidas! Execução abortada!')
+            os._exit(0)        
+
+    def disclaimer(self): # Mostra o aviso do funcionamento e necessidade de autenticação
+        input(f'''
+              
+        Para ser utilizado de forma adequada e segura, este script requer autenticação no Microsoft Entra ID (antiga Azure AD).
+        Também requer que seu usuário pertença a um grupo de segurança específico. Se você não tem a segurança que tem permissão de uso, solicite previamente à TI.
+        
+        Para continuar, é necessário fornecer suas credenciais, aquelas que costumeiramente utiliza para acessar os serviços de e-mail corporativo.
+        Uma janela de navegador será aberta e você será direcionado à tela de Logon do Microsoft Entra ID.
+        Faça o Logon fornecendo usuário, senha e validação de duplo fator (no autenticador da Microsoft, instalado em seu celular).        
+        Após a autenticação, a janela do navegador será fechada e o script iniciará o processo de execução.
+
+        Você tem {self.timeout} segundos para realizar a autenticação ou a execução será abortada.
+
+        Tecle [ENTER] para continuar ...
+        
+        ''')
+
+class postgreSQL: # Classe de acesso e interação com banco PostgreSQL      
+    def __init__(self, config, logger=None):
+        self.logger = logger if not logger is None else lbx_logger(None, logging.DEBUG, '%(levelname)s: %(message)s') # se não fornecer o logger, vai tudo para o console
+
+        try:
+            self.Conexao = psycopg2.connect(**config)  ## na chamada de uma função/método, o * explode os valores de um dicionário em argumentos posicionais (só valores) e ** explode discionário em argumentos nominais (nome=valor)
+        except Exception as Err:
+            raise
+
+    def csv_df(self, CsvPath, CsvDelim=';'): # Le arquivo CSV e gera Dataframe do Pandas
+        try:
+            DataFrame = pd.read_csv(CsvPath, delimiter=CsvDelim)  # Verifique se o delimitador é ';'
+            DataFrame.replace({np.nan: None}, inplace=True)  ## troca 'NaN' por None (null no postgresql)
+            return DataFrame
+        except Exception as Err:
+            raise
+
+    def db_insert_df(self, DataFrame, Tabela, Schema=None, Colunas=None, OnConflict=None): # Insere os dados de um dataframe em uma tabela equivalente no banco (exige mesma estrutura de colunas)
+        # Essa função exige que os nomes dos cabeçalhos das colunas do CSV sejam os mesmos das colunas da tabela de destino
+        Colunas = Colunas or DataFrame.columns.tolist()     # Caso não seja fornecida a lista de colunas, assume as colunas do DataFrame
+        Valores = [tuple(Linha) for Linha in DataFrame[Colunas].values]    
+        Schema = Schema or 'public'
+        Query = f'insert into {Schema}.{Tabela} ({', '.join(Colunas)}) values %s '
+        if not OnConflict is None:
+            Query = Query + OnConflict
+
+        try:
+            self.Cursor = self.Conexao.cursor() 
+            execute_values(self.Cursor, Query, Valores)  
+            self.Conexao.commit()
+        except Exception as Err:
+            self.Conexao.rollback()
+            raise
+        finally:        
+            self.Cursor.close()
+            #Conexao.close() ## conexão precisa ser fechada explicitamente fora da classe
+
+    def db_select(self, Query): # Retorna um cursor à partir de um select
+        BlackList = ['INSERT ', 'DELETE ', 'UPDATE ', 'CREATE ', 'DROP ', 'MERGE ', 'REPLACE ', 'CALL ', 'EXECUTE ']
+        if any(element in Query.upper() for element in BlackList):
+            BlackListed = [element for element in BlackList if element in Query.upper()]          
+            self.logger.erro(f'{__name__}: Este método permite apenas consultas. A query informada possui as seguintes palavras reservadas não aceitas: {BlackListed} e não foi executada!')
+            return None    
+        else:
+            try:
+                self.Cursor = self.Conexao.cursor()
+                self.Cursor.execute(Query)
+                Dados = self.Cursor.fetchall()
+                Colunas = [Col[0] for Col in self.Cursor.description]
+                self.Conexao.commit()
+                self.Cursor.close()
+                return Dados, Colunas
+            except Exception as Err:
+                self.Conexao.rollback()
+                raise   
+
+    def db_update(self, Query): # Retorna um cursor à partir de um select
+        UpdRows = 0
+        BlackList = ['INSERT ', 'DELETE ', 'SELECT ', 'CREATE ', 'DROP ', 'MERGE ', 'REPLACE ', 'CALL ', 'EXECUTE ']
+        if any(element in Query.upper() for element in BlackList):
+            BlackListed = [element for element in BlackList if element in Query.upper()]          
+            self.logger.erro(f'{__name__}: Este método permite apenas updates. A query informada possui as seguintes palavras reservadas não aceitas: {BlackListed} e não foi executada!')
+            return None            
+        else:
+            try:
+                self.Cursor = self.Conexao.cursor()
+                self.Cursor.execute(Query)
+                UpdRows = self.Cursor.rowcount
+                self.Conexao.commit()
+                self.Cursor.close()
+                return UpdRows
+            except Exception as Err:
+                self.Conexao.rollback()
+                raise  
+
+class api_rest: # Classe para interação com APIs Rest (especialmente Sienge)
+    def __init__(self, url, credenciais, cadencia=3, timeout=6, logger=None, headers={"Content-Type": "application/json"}, verify=True):
+        self.logger = logger if not logger is None else lbx_logger(None, logging.DEBUG, '%(levelname)s: %(message)s') # se não fornecer o logger, vai tudo para o console
+
+        if not validators.url(url):
+            self.logger.critico('URL inválida: {url}. Primeiro parametro precisar uma URL válida. Script abortado', exit=1)
+        if not isinstance(credenciais, dict):
+            self.logger.critico('O segundo parametro posicional precisa ser um dicionário. Script abortado', exit=1)
+
+        self.RetEndPoint = None  # Inicializa self.RetEndPoint como None            
+        self.Headers = headers
+        self.Verify = verify            
+        self.Url = url
+        self.Timeout = timeout
+        self.Credenciais = credenciais
+        self.Cadencia = 1/cadencia  ## candencia corresponde a chamadas por segundo, não minuto
+        self.TempoUltReq = None 
+        self.Intervalo = self.Cadencia + 1     
+
+    def controla_cadencia(self): ## para controle apenas, não deve ser chamada fora da classe
+        # Verificar o tempo atual
+        Agora = time.time()
+        
+        # Calcular intervalo entre requisições
+        if self.TempoUltReq:
+            self.Intervalo = Agora - self.TempoUltReq
+        else:
+            self.Intervalo = float('inf')  # Primeira requisição não espera
+        
+        # Calcular o tempo de espera necessário para respeitar o limite
+        if self.Intervalo < self.Cadencia:
+            self.Espera = self.Cadencia - self.Intervalo
+            time.sleep(self.Espera)
+            return self.Espera
+        else:
+            self.Espera = 0
+            return self.Espera, self.Intervalo
+
+    def auth_basic(self): # Autentica e abre sessão na API 
+        if not self.Credenciais['user'] or not self.Credenciais['password']:
+            self.logger.critico('Dicionário de credenciais não possui chaves "user" e/ou "password". Script abortado', exit=1)             
+        try:          
+            self.Sessao = requests.Session()
+            #Sessao.auth = (ApiUser, ApiPass)
+            self.Sessao.auth = HTTPBasicAuth(self.Credenciais['user'], self.Credenciais['password'])
+            Auth = self.Sessao.post(self.Url)  
+            #print(f'Status: {Auth.status_code}')
+            #print(f'Retorno: {Auth.text}')
+            return self.Sessao
+        except Exception as Err:
+            self.logger.critico(f"Falha ao autenticar API: {Err}. URL: {self.Url}", exit=1)
+
+    def auth_bearer(self): # Autentica e abre sessão na API
+        #self.UrlLogin = UrlLogin if UrlLogin is not None else self.Url
+        try:          
+            self.Sessao = requests.Session()
+            Token = self.Sessao.post(self.Url, headers=self.Headers, json=self.Credenciais, verify=self.Verify)            
+            self.Headers.update({"Authorization": f"Bearer {Token.text}"})
+            if 200 <= Token.status_code <= 299:
+                self.Sessao.status_code = Token.status_code
+                self.Sessao.token = Token.text
+                return self.Sessao
+            else:
+                self.logger.critico(f"Erro ao autenticar API: {Token.status_code} - {Token.text}", exit=1)    
+        except Exception as Err:
+            self.logger.critico(f"Falha ao autenticar API: {Err}. URL: {self.Url}", exit=1)    
+
+    def endpoint_json(self, endpoint, metodo, payload=None): # Interage com End Point
+        self.ult_tempo_req = time.time() 
+        self.Metodo = metodo.lower()
+        #self.EndPoint = self.Url + endpoint
+        self.EndPoint = endpoint
+        self.Payload = payload
+        MetodosAceitos = ['post', 'get', 'patch', 'put']
+        if not any(element in self.Metodo for element in MetodosAceitos):
+            self.logger.critico(f'Método {self.Metodo} não previsto. Abortando chamada!', exit=1)
+        else:
+            ChamadaApi = f'self.Sessao.{self.Metodo}(self.EndPoint, timeout=self.Timeout, headers=self.Headers, verify=self.Verify)' if self.Payload is None else f'self.Sessao.{self.Metodo}(self.EndPoint, timeout=self.Timeout, headers=self.Headers, verify=self.Verify, json=self.Payload)'
+            self.controla_cadencia()
+            self.TempoUltReq = time.time()   
+            try: 
+                self.RetEndPoint = eval(ChamadaApi)
+                if self.RetEndPoint.status_code >= 500:
+                    self.logger.critico(f'Erro {self.RetEndPoint.status_code} na chamada do endpoint: {Err}\nEndpoint: {self.EndPoint}\nResposta: {self.RetEndPoint.text}', exit=1)   
+                self.RetEndPoint.Espera = self.Espera ## adiona o tempo de espera ao retorno da API
+                self.RetEndPoint.Intervalo = self.Intervalo ## adiciona o intervalo entre chamada ao retorno da API                                
+                return self.RetEndPoint
+            except requests.exceptions.ReadTimeout as Err:
+                self.logger.critico(f'Excedido tempo limite {self.Timeout} para retorno do endpoint: {Err}\nEndpoint: {self.EndPoint}', exit=1)            
+            except Exception as Err:
+                self.logger.critico(f'Falha na chamada do endpoint: {Err}\nEndpoint: {self.EndPoint}\nCodigo retorno: {self.RetEndPoint.status_code}\nResposta:{self.RetEndPoint.text}', exit=1)
+
+    def close(self): # Encerra a cessão
+        self.Sessao.close()                   
+
+class lbx_logger: # Classe para gerenciar a saída para log
+    class LevelFilter(logging.Filter):    
+        def __init__(self, levels_to_ignore):
+            self.levels_to_ignore = levels_to_ignore
+        
+        def filter(self, record):
+            return record.levelno not in self.levels_to_ignore
+
+    def __init__(self, log_file_path=None, log_level=logging.DEBUG, formato_log='%(asctime)s - %(levelname)s - %(message)s', modulo=None, ignore_console=None, ignore_file=None):
+        self.ignore_file = [] if ignore_file is None else ignore_file       
+        self.ignore_console = [] if ignore_console is None else ignore_console
+        self.modulo = __name__ if modulo is None else modulo
+        self.logger = logging.getLogger(self.modulo)
+        self.logger.setLevel(log_level)
+        self.msg = ''
+        
+        if log_file_path:
+            # Criando um handler para escrever em um arquivo de log
+            file_handler = logging.FileHandler(log_file_path)
+            file_handler.setLevel(log_level)  # Sempre registrar tudo no arquivo
+            
+            # Criando um handler para exibir no console
+            console_handler = logging.StreamHandler()
+            console_handler.setLevel(log_level)  # Registrar DEBUG e acima no console
+            
+            # Adicionando filtro para ignorar certos níveis no console e no arquivo
+            file_handler.addFilter(self.LevelFilter(self.ignore_file))
+            console_handler.addFilter(self.LevelFilter(self.ignore_console))
+
+            # Definindo o formato das mensagens de log
+            formatter = logging.Formatter(formato_log)
+            file_handler.setFormatter(formatter)
+            console_handler.setFormatter(formatter)
+            
+            # Adicionando os handlers ao logger
+            self.logger.addHandler(file_handler)
+            self.logger.addHandler(console_handler)
+        else:
+            # Tudo direcionado para o console
+            console_handler = logging.StreamHandler()
+            console_handler.setLevel(log_level)  # Registrar no console
+            
+            # Adicionando filtro para ignorar certos níveis no console e no arquivo
+            console_handler.addFilter(self.LevelFilter(self.ignore_console))        
+
+            # Definindo o formato das mensagens de log
+            formatter = logging.Formatter(formato_log)
+            console_handler.setFormatter(formatter)
+            
+            # Adicionando o handler ao logger
+            self.logger.addHandler(console_handler)
+        
+        # Redirecionando exceções para o logger
+        sys.excepthook = self.handle_exception
+        
+        # Redirecionando saída padrão
+        self.original_stdout = sys.stdout
+        sys.stdout = self
+        
+    def handle_exception(self, exc_type, exc_value, exc_traceback):
+        if issubclass(exc_type, KeyboardInterrupt):
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+            return
+        self.logger.error("Exceção não prevista", exc_info=(exc_type, exc_value, exc_traceback))
+
+    def add(self, message, corte=None):
+        message = message[:corte] if corte else message
+        self.msg = self.msg + message if not message is None else self.msg
+    
+    def write(self, message):
+        if message.strip():  # Ignorar mensagens vazias
+            self.logger.info(message.strip())
+    
+    def flush(self):
+        pass  # Método necessário para compatibilidade com sys.stdout
+    
+    def debug(self, message, corte=None, exit=None):
+        self.msg = self.msg + message if not message is None else self.msg
+        msg = self.msg[:corte] if corte else self.msg
+        self.logger.debug(msg)
+        self.msg = ''
+        if exit:
+            os._exit(exit)
+    
+    def info(self, message, corte=None, exit=None):
+        self.msg = self.msg + message if not message is None else self.msg
+        msg = self.msg[:corte] if corte else self.msg
+        self.logger.info(msg)
+        self.msg = ''
+        if exit:
+            os._exit(exit)        
+    
+    def aviso(self, message, corte=None, exit=None):
+        self.msg = self.msg + message if not message is None else self.msg
+        msg = self.msg[:corte] if corte else self.msg
+        self.logger.warning(msg)
+        self.msg = ''
+        if exit:
+            os._exit(exit)
+
+    def erro(self, message, corte=None, exit=None):
+        self.msg = self.msg + message if not message is None else self.msg
+        msg = self.msg[:corte] if corte else self.msg
+        self.logger.error(msg)
+        self.msg = ''
+        if exit:
+            os._exit(exit)
+
+    def critico(self, message, corte=None, exit=None):
+        self.msg = self.msg + message if not message is None else self.msg
+        msg = self.msg[:corte] if corte else self.msg
+        self.logger.critical(msg)
+        self.msg = ''
+        if exit:
+            os._exit(exit)
+
+    def stop_logging(self):
+        # Restaurar o stdout original
+        sys.stdout = self.original_stdout
+        # Remover handlers do logger
+        handlers = self.logger.handlers[:]
+        for handler in handlers:
+            handler.close()
+            self.logger.removeHandler(handler)

lbxtoolkit-2.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 lbx_toolkit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lbxtoolkit-2.0.1.dist-info/METADATA

@@ -0,0 +1,414 @@
+Metadata-Version: 2.1
+Name: lbxtoolkit
+Version: 2.0.1
+Summary: Biblioteca de ferramentas LBX S/A
+Author: Cristiano P. Ferrari
+Author-email: boxferrari@gmail.com
+License: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psycopg2
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: msal
+Requires-Dist: requests
+Requires-Dist: selenium
+Requires-Dist: webdriver-manager
+Requires-Dist: validators
+
+# Biblioteca de ferramentas LBX S/A
+
+Esta biblioteca possui ferramentas de uso recorrente para interação com banco de dados e API, além de autenticação/validação de credenciais de usuário no Microsoft Entra ID
+
+## Classe e funções
+
+**auth_EntraID**:        Usa o Microsoft Entra ID (antiga Azure AD) para evitar execução não autorizada
+  - _.disclaimer_:       Mensagem sobre a necessidade de autenticação
+  - _.valida_grupo_:     Autentica o usuário e aborta se checa não pertencer ao grupo de segurança
+
+
+**postgreSQL**:          Interage com o banco de dados PostgreSQL
+  - _.db_:               Inicia sessão com o banco
+  - _.csv_df_:           Lê arquivo CSV e gera Dataframe (pandas) a partir dele
+  - _.db_insert_df_:     Insere informações de Dataframe em tabela do banco com estrutura equivalente
+  - _.db_select_:        Retorna um cursor a partir de uma query
+  - _.db_update_:        Executa update em tabelas
+
+
+**api_rest**:            Interage com APIs RESTfull, especialmente providas para a plataforma Sienge
+  - _.auth_base_:        Autentica (HTTPBasicAuth) sessão na API
+  - _.auth_bearer_:      Autentica sessão na API pelos métodos: OAuth, JWT, Bearer  
+  - _.endpoint_json_:    Realizad chama ao endpoint. Payload em formato `json` opcional.
+  - _.close_:            Encerra a sessão autenticada
+
+**lbx_logger**:          Manipula e formata as mensagens de saída do script para direcioná-las para tela (stdout) e/ou arquivo de log
+  - _.add_:              Adiciona a mensagem a um _buffer_ sem exibir, acumulando até a próxima chamada em algum dos níveis abaixo.
+  - _.debug, .info, .aviso, .erro, .critico_:
+  Classifica as mensagens por nível de severidade/relevância e rediciona a saída (arquivo, tela, tela+arquivo) conforme a configuração do nível
+  - _.stop_logging_:   Interrompe a manipulação das saídas pelo logger e restaura as saídas padrão (stdout/stderr) para a tela 
+
+
+## Instalação e uso:
+
+### Instalação
+
+```
+pip install lbx_toolkit
+```
+
+### Uso
+```
+from lbx_toolkit import auth_EntraID, PostgreSQL, api_rest, lbx_logger
+```
+
+#### Classe **auth_EntraID**
+
+Este recurso tem o propósito de controlar as permissões de execução do script usando as credencias do ambiente AD em nuvem da Microsoft (Azure AD >> Microsoft Entra ID), abortando se a autentição falhar ou o usuário não pertencer ao grupo.
+
+Essa classe possui apenas dois métodos:
+
+- `auth_EntraID.disclaimer()`: apenas exibe uma tela de informações/instruções ao usuário.
+
+- `auth_EntraID.valida_grupo([client_id], [client_secret], [tenant_id], timeout=60, log_file='auth_EntraID.log')`: efetua a autenticação do usuário e verifica se ele pertence ao grupo informado,  abortando a execução caso não pertença ao grupo ou a autenticação não seja validada no tempo estabelecido. Os argumentos `timeout` e `log_file` são opcionais e, se omitidos, os valores aqui atribuídos serão adotados como padrão.
+
+É necessário obter parametros da plataforma de identidade da Microsoft (AD Azure, agora Microsoft Entra ID), no [*Centro de administração do Microsoft Entra*](https://entra.microsoft.com).
+Sugerimos não armazenar estas ou outras informações sensíveis no script. Considere usar o pacote `dotenv` para isso.
+
+Os argumentos obrigatórios (posicionais) são:
+
+1) `tenant_id` corresponde ao campo *ID do Locatário*, que pode ser obtido na página [visão geral de identidade do domínio](https://entra.microsoft.com/#blade/Microsoft_AAD_IAM/TenantOverview.ReactView)
+
+2) `client_id` corresponde ao *ID do aplicativo (cliente)*, obtido na secção [_Identidade > Aplicativos > Registros de Aplicativo_](https://entra.microsoft.com/#view/Microsoft_AAD_RegisteredApps/ApplicationsListBlade/quickStartType~/null/sourceType/Microsoft_AAD_IAM). Considere não reaproveitar aplicativos e criar um específico para essa finalidade.
+
+3) `secret_id` corresponde ao *Valor* do _ID secreto_ (não ao próprio ID Secreto) do aplicativo. Este token não é passivel de consulta após gerado e para obtê-lo, é necessário criar um novo segredo para o aplicativo na subsecção _"Certificados e Segredos"_, após clicar no nome do aplicativo exibo na indicada no item (2). O token (_Valor do segredo_) deve ser copiado e anotado no ato da criação, pois *não é possível consultá-lo posteriormente*.
+
+
+```
+from lbx_toolkit import auth_EntraID
+
+client_id = 'SEU_CLIENT_ID'
+client_secret = 'SEU_CLIENT_SECRET'
+tenant_id = 'SEU_TENANT_ID'
+
+# inicializa instância
+auth = auth_EntraID(client_id, client_secret, tenant_id, timeout=60, log_file='auth_EntraID.log')  
+
+# exibe a mensagem padrão de aviso
+auth.disclaimer()
+
+auth.valida_grupo('Nome do Grupo de Distribuição') 
+# se usuário não pertencer a grupo informado, a execução do script é abortada.
+```
+
+#### Classe **postgreSQL**
+
+Recursos de interação com o banco de dados relacional PostgreSQL
+
+1) O método `postgreSQl.db()` exige que as credenciais e parametros de acesso sejam fornecidas em um *dicionário* com, ao mínimo, o seguinte formato:
+
+```
+credenciais = {
+                'dbname': 'NOME_BANCO',
+                'user': 'USUARIO'',        
+                'password': 'SENHA',     
+                'host': 'IP_OU_DNS_SERVIDOR',
+                'port': 'PORTA_POSTGRESQL',  ## padrão = 5432
+              }
+
+conexao = postgreSQL.db(credenciais)
+```
+
+O nome do schema é ser declarado no contexto da query, mas se desejar alterar o schema padrão, adicione *`'options' : '-c search_path=[NOME_SCHEMA]',`* ao dicionário.
+
+Qualquer argumento de conexão previsto no pacote *psycopg2* são aceitos como entrada no dicionário acima.
+
+2) O método `postgreSQl.csv_df()` lê arquivo texto do tipo CSV e o converte para o objeto Dataframe do `pandas`. A assinatura da função exige que se forneça o caminho do arquivo CSV e, opcionalmente o caracter delimitador. Se o caracter demilitador não for informado, será assumido `;`. Considere usar a função `Path` para tratar o caminho do arquivo de origem.
+
+```
+from pathlib import Path
+arquivo_csv = Path('./diretorio/arquivo_exemplo.csv')
+dados = postgreSQL.csv_df(arquivo_csv, CsvDelim=',') # usando vírgula como separador. se omisso, assume ";'
+```
+
+3) O método `postgreSQl.db_insert_df()` insere dados a partir de um Dataframe (pandas) em uma tabela do banco com estrutura de colunas equivalente.
+
+A assinatura da função é `postgreSQL.db_insert_df([conexao], [dataframe_origem], [tabela_destino], Schema=None, Colunas=None, OnConflict=None)`
+
+É necessário que os nomes das colunas do dataframe coincidam com o nome das colunas da tabela. 
+Não há como traduzir/compatibilizar (de-para) nomes de colunas entre o dataframe e a tabela.
+
+Os três primeiros parametros são posicionais e correspondem, respectivamente, (1) ao objeto da conexão com o banco, (2) ao objeto que contém o dataframe e (3) ao nome da tabela de destino.
+Assume-se que a tabela pertença ao schema padrão (definido na variável _search_path_ do servidor). Caso a tabela de destino esteja em um _schema_ diferente do padrão, deve-se informar seu nome no parâmetro opcional `Schema`.
+
+O parametro opcional `Colunas` espera um objeto do tipo _lista_ que contenha a relação das colunas a serem importadas. 
+As colunas listadas neste objeto precisam existir nas duas pontas (dataframe e tabela).
+Caso seja omisso, todas as colunas do dataframe serão inseridas na tabela. Neste caso, admite-se que haja colunas na tabela que não exitam no dataframe (serão gravadas como NULL), mas o contrário provocará erro. 
+
+O último parametro opcional `OnConflict` espera uma declaração para tratar o que fazer caso o dado a ser inserido já exista na tabela, baseado na cláusula [*ON CONFLICT*](https://www.postgresql.org/docs/current/sql-insert.html#SQL-ON-CONFLICT) do comando INSERT. A claúsula deve ser declarada explicita e integralmente nessa variável (clausula, _target_ e _action_) e não há crítica/validação desse argumento, podendo gerar erros se declarado inconforme com o padrão SQL.
+
+Exemplo de uso:
+
+```
+from lbx_toolkit import postgreSQL
+from pathlib import Path
+
+credenciais = {
+                'dbname': 'NOME_BANCO',
+                'user': 'USUARIO'',        
+                'password': 'SENHA',     
+                'host': 'IP_OU_DNS_SERVIDOR',
+                'port': 'PORTA_POSTGRESQL',  ## padrão = 5432
+              }
+
+conexao = postgreSQL.db(credenciais)
+
+arquivo_csv = Path('./diretorio/arquivo_exemplo.csv')
+dados = postgreSQL.csv_df(arquivo_csv, CsvDelim=',') # usando vírgula como separador. se omisso, assume ";'
+
+postgreSQL.db_insert_df(conexao, dados, 'teste_table', Schema='meu_esquema', OnConflict='on conflict (coluna_chave_primaria) do nothing')
+
+# conexão com o banco precisa ser fechada explicitamente após a chamada do método, caso não seja mais utilizada:
+conexao.close()
+```
+
+4) O método `postgreSQl.db_select()` executa consultas no banco de dados e retorna um `cursor` com o resultado.
+
+A assinatura da função é `postgreSQL.db_select([conexao], [query])`
+
+São permitidas apenas instruções de consulta (podendo serem complexas, por exemplo, com uso de [CTE](https://www.postgresql.org/docs/current/queries-with.html)). A presença de outras instruções SQL de manipulação de dados e metadados não são permitidas e abortarão a execução da query, se presentes.
+
+O `cursor` é fechado no contexto do método, antes do retorno, *não podendo* ser manipulado após recebido como retorno da função.
+
+A função retorna *dois objetos*, o primeiro contendo os dados do cursor, o segundo, contendo os nomes das respectivas colunas.
+
+Exemplo de uso:
+
+```
+from lbx_toolkit import postgreSQL
+from pathlib import Path
+
+credenciais = {
+                'dbname': 'NOME_BANCO',
+                'user': 'USUARIO'',        
+                'password': 'SENHA',     
+                'host': 'IP_OU_DNS_SERVIDOR',
+                'port': 'PORTA_POSTGRESQL',  ## padrão = 5432
+              }
+
+conexao = postgreSQL.db(credenciais)
+
+query = 'select * from meu_esquema.teste_table'
+
+dados, colunas = postgreSQL.db_select(conexao, query)
+conexao.close()
+```
+
+5) O método `postgreSQl.db_update()` executa updates no banco
+
+A assinatura da função é `postgreSQL.db_update([conexao], [query])`
+
+São permitidas apenas instruções de update. A presença de outras instruções SQL de manipulação de dados e metadados não são permitidas e abortarão a execução da query.
+
+A função retorna *a quantidade de linhas alteradas*.
+
+Exemplo de uso:
+
+```
+from lbx_toolkit import postgreSQL
+from pathlib import Path
+
+credenciais = {
+                'dbname': 'NOME_BANCO',
+                'user': 'USUARIO'',        
+                'password': 'SENHA',     
+                'host': 'IP_OU_DNS_SERVIDOR',
+                'port': 'PORTA_POSTGRESQL',  ## padrão = 5432
+              }
+
+conexao = postgreSQL.db(credenciais)
+
+query = "update meu_esquema.teste_table set coluna='novo_valor' where pk='chave'"
+
+result = postgreSQL.db_update(conexao, query)
+conexao.close()
+```
+
+#### Classe **api_rest**
+
+Destina-se a interatir com APIs RESTfull, em especial as publicadas pela SoftPlan para a [Plataforma Sienge](https://api.sienge.com.br/docs/).
+
+A classe deve ser instanciada conforme sintaxe abaixo:
+
+`api_rest(url, credenciais, cadencia, timeout=6, logger=None, headers={"Content-Type": "application/json"}, verify=True)`
+
+São nessários 2 parâmetros posicionais obrigatórios, e 5 parametros nominais facultativos (valor padrão, se omisso, indicado na sintaxe acima):
+  - `url`: o endereço da URL de autenticação da API
+  - `crednciais`: Dicionário com credenciais de autenticação. 
+  - `cadencia` Número máximo de chamadas *por segudo* à API 
+  - `timeout` Tempo máximo (segundos) para aguardar retorno à chamada. Padrão 6s, se omisso.
+  - `logger` O objeto _log handler_ para lidar com as informações de saída. Se não informado, todas as saídas serão direcionadas para a stdout.
+  - `headers` Cabeçalhos _http_ para a requisição à API.
+  - `verify` Verifica a validade do certificado SSL do servidor de destino da requisição.
+
+Quanto às credenciais de autenticação, assim como a classe de interação com o PostgreSQL, elas precisam ser fornecidas na forma de um *dicionário*. 
+Para o método `api_rest.aut_basic()`, o formato deve ser: 
+```
+credenciais = {
+                'user': 'USUARIO_API',
+                'password': 'TOKEN_USUARIO'
+              }
+```
+Caso a autenticação seja pelo método `api_rest.aut_bearer()`, o dicionário deve corresponder ao formato previsto pelo endpoint e seu conteúdo será enviado como um JSON ao endereço indicado no parametro `url`
+
+
+A classe possui 3 métodos: 
+  - `api_rest.auth_basic()`: instanciamento da sessão autenticando pelo método HTTPBasicAuth
+  - `api_rest.auth_bearer()`: instanciamento da sessão autenticando pelos métodos OAuth, JWT, Bearer    
+  - `api_rest.endpoint_json([endereço], [método], payload=None)`: para a chamada ao endpoint
+  - `close()` para encerra a instância/sessão
+
+O consumo é feito pelo método `api_rest.endpoint_json` que suporta apenas APIs cujo payload (opcional) seja aceito no formato JSON. 
+
+Esse método espera 2 parametros posicionais obrigatórios: o endereço do endpoint e o verbo (get, post, patch ou put), tendo parametro opcional o objeto de 'payload' (json). 
+Note que o endereço do endpoint deve ser informado completo. A URL informada no instanciamento da classe corresponde apenas ao endereço de autenticação. 
+
+O tempo, em segundos, transcorrido entre a chamada a atual e a chamada anterior ao endpoint pode ser consultado pelo argumento `.Intervalo` no objeto recebido do retorno à chamada ao método `.endpoint_json`. 
+
+Da mesma forma, o tempo de espera imposto para respeitar a cadência do webservcie também pode ser consultado pelo argumento `.Espera`.
+
+Exemplo de uso:
+
+```
+from lbx_toolkit import api_rest
+
+UrlBase=r'https://api.sienge.com.br/lbx/public/api/v1'
+Credenciais = {
+                'user': 'USUARIO_API',
+                'password': 'TOKEN_USUARIO'
+              }
+ApiSienge = api_rest(UrlBase,Credenciais,2.5) # limite de 2 requisições/segundo para cadência de chamada ao endpoint
+Auth = ApiSienge.auth_basic()
+
+Nutitulo=input('Numero do título:')
+Nuparcela=input('Numero da parcela:')
+Vencimento=input('Vencimento [AAAA-MM-DD]:')
+Payload = {
+                "dueDate": f"{Vencimento}"
+            }
+EndPoint = f'{UrlBase}/bills/{Nutitulo}/installments/{Nuparcela}'
+
+#chama o endpoint e recebe o retorno no objeto AlteraVcto
+AlteraVcto = ApiSienge.endpoint_json(EndPoint, 'patch', Payload)
+```
+
+No exemplo acima não é esperado que o endpoint retorne nenhum dado (`patch`).
+
+Quando se usa o verbo `get` e se espera o retorno de algum dado, use o método `.json` do pacote `request` para acessar o objeto recebido.
+
+Para uso em APIs com autenticação JWT (JSON Web Token), OAuth, Bearer Token Authentication, a construção é a mesma indicada acima, bastando-se usar `.auth_bearer()` ao invés de _.auth_basic()_, e ajustar o dicionário `credenciais` informado no instanciamento da classe, que deve ser estruturado conforme o padrão fornecido peo mantendor da API e será enviado como payload ao endpoint (`json=credenciais`). 
+
+#### Classe **lbx_logger**
+
+Essa classe tem o propósito de manipular e formatar as mensagens de saída do script, alterando o formato e redirecionando destino padrão (stdout e stderr) para uma combinação de tela e/ou arquivo.
+
+O comportamento padrão é registrar todas as saídas *simultaneamente* em tela e no arquivo com endereço informado no parâmetro `log_file_path`. Se este parametro for omisso no instanciamento da classe, as mensagens serão exibidas apenas na tela.
+
+A mensagens devem ser classificadas por grau de severidade/relevância, da menor para a maior, na seguinte ordem: *debug, info, warning (aviso), error (erro), critical (critico)*
+
+A classificação do nível de serveridade da mensagem se dá pelo método escolhido para invocar a mensagem, correspondente aos níveis de severidade equivalentes.
+
+A classe deve ser instanciada conforme sintaxe abaixo:
+
+`lbx_logger(log_file_path=None, log_level=logging.DEBUG, formato_log='%(asctime)s - %(levelname)s - %(message)s', modulo=None, ignore_console=None, ignore_file=None):`
+
+Todos os parametros são nominativos e facultativos. Em caso de omissão, os valores padrão são assumidos conforme o exemplo acima.
+
+Os parametros para o instanciamento da classe são:
+
+- `log_file_path` Define o caminho e o nome do arquivo de log. Se omisso, as mensagens serão todas direcionadas apenas para a tela.
+- `log_level` Define o nível mínimo de severidade das mensagens a serem manipuladas pelo logger. Se omisso, será assumido o nível mais baixo (_debug_). As mensagens com nível abaixo do especificado são descartadas. Os níveis devem ser informados de acordo com a sintaxe acima (prefixados com _logging._ e com o nome do nível em inglês e maiúsculas). Exemplo: 
+  - `logging.DEBUG` para manipular chamadas do método *.debug()* e acima.
+  - `logging.INFO` para manipular chamadas do método *.info()* e acima.
+  - `logging.WARNING` para manipular chamadas do método *.aviso()* e acima.
+  - `logging.ERROR` para manipular chamadas do método *.erro()* e acima.
+  - `logging.CRITICAL` para manipular chamadas do método *.critico()* e acima.        
+- `formato_log` Define o formato em que a mensagem será apresentada. Se omisso, o padrá é *DATA_HORA - NIVEL - MENSAGEM*. Para maiores opções veja: [Atributos de log](https://docs.python.org/3/library/logging.html#logrecord-attributes)
+- `modulo` Nome do módulo para o qual os logs serão monitorados. Permite instanciar várias vezes a classe para criar manipuladores diferentes para módulos diferente. Informe o nome do módulo para criar um log específico para ele ou simplesmente omita o parametro para criar um log para o script em geral.
+- `ignore_console` Lista com os níveis de severidade a serem ignorados para *apresentação na tela*, registrando *apenas no arquivo* (quando informado no parametro `log_file_path`) e obedecendo ao nível mínimo estabelecido no parametro `log_level`. Note que omitir o parametro `log_file_path` e incluir um nível na lsita `ignore_console` implica em ignorar/suprimir esse nível de mensagem de qualquer apresentação.
+- `ignore_file` Mesma lógica do parametro `ignore_console`, mas com lógica invertida: suprime o registro do nível do arquivo e demonstra *apenas na tela*.
+
+As mensagem são manipuladas substituindo-se o comando `print()` pela chamada a um dos 5 métodos acima (_.add(), .debug(), .info(), .aviso(), .erro(), .critico()_). Exceto o método `.add()`, qualquer um dos demais métodos pode interromper a execução do script, através da passagem do parâmetro `exit`. Ao informar esse parametro na chamadada do método, atribua a ele o código de saída desejado (0 para normal, qualquer outro número para saída com erro). Exemplo:
+
+```
+log.erro('Essa mensagem apenas resulta em uma mensagem de nível ERROR')
+log.erro('Essa mensagem resulta em uma mensagem de nível ERRO e encerra o script com código de retorno -1', exit=-1)
+```
+
+Qualquer chamada ao comando `print()`, uma vez instanciado manipulador de log, será registada como uma chamada ao método _.info()_ e registrada com este nível de severidade. 
+Para retornar ao comportamente padrão do comando print, ou interromper o manipulador, faça chamada ao método `.stop_logging()`
+
+O método _.add()_ não exibe/grava imediatamente a mensagem, mas apenas a diciona a _buffer_. Todas as chamas a _.add()_ irão concatenar a mensagem recebida até a próxima chamada em algum dos níveis _.debug(), .info(), .aviso(), .erro(), .critico()_. Na primeira chama de um destes níveis após uma (ou mais) chamada(s) ao método _.add()_ o *buffer* será concatenado à mensagem recebida por um destes métodos e o resultado será manipulado pelo log conforme os parametros definidos no intanciamento da classe e o método chamado. Essa função é útil para tratar mensagens com retorno condicional. Exemplo:
+
+```
+log.add('Mensagem 1# ') ## não será exibida/registrada
+log.add('Mensagem 2# ') ## não será exibida/registrada
+log.info('Mensagem 3) ## será exibida/registrada como nível "info" e com texto: "Mensagem 1# Mensagem 2# Mensagem 3"
+```
+
+Os métodos que exibem as mensagens (`.debug()`,`.info()`,`.aviso()`, `.erro()`, `.critico()`) possuem 3 parametros: ``message``, `corte=None`, `exit=None`.
+
+ - `message`: posicional e obrigatório. corresponde à mensagem a ser exibida
+ - `corte`: o tamanho máximo da mensagem a ser exibida. opcional e se omitido, exibe a mensagem inteira. se fornecido, corta a mensagem no comprimento informado
+ - `exit`: opcional. se informado (requer um código de retorno), aborta o script com o código informado. se omisso (padrão) a mensagem apenas é minutada pelo log, sem interferir no funcionamento do script
+
+Essa classe requer a importação do módulo `logging` no script em que for instanciada.
+
+Exemplos de uso:
+
+```
+from lbx_toolkit import lbx_logger 
+import logging
+import os
+from pathlib import Path
+
+DirBase = Path('./')  # diretório corrente do script
+BaseName = os.path.splitext(os.path.basename(__file__))[0] # nome do script sem extensão
+LogFile = Path(DirBase, BaseName + '.log') # salva logs no diretório corrente, em um arquivo nomeado com nome do script + extensão ".log"
+
+### instancia o manipulador para tratar todas as mensagens (nível DEBUG acima), 
+#   mas suprime a apresentação em tela das mensagens de nível "DEBUG" na tela, 
+#   apenas registrando-as somente no arquivo
+#   e sumprime o registro no arquivo das mensagens de nível "ERROR", 
+#   mostrando-as apenas na tela
+log = lbx_logger(LogFile, logging.DEBUG, ignore_console=[logging.DEBUG], ignore_file=[logging.ERROR]) 
+
+# Exemplo de mensagens de log
+log.debug('Esta é uma mensagem de debug') 
+log.info('Esta é uma mensagem informativa')
+log.add('Esta mensagem não será exibida agora, mas acumulada no buffer# ')
+log.aviso('Esta é uma mensagem de aviso')
+log.erro('Esta é uma mensagem de erro')
+log.erro('Esta é uma mensagem erro muito comprida e será limitada a 40 caracteres, o restante será cortado e ingorado ao ser manipulado', 40)
+log.critico('Esta é uma mensagem crítica')
+
+# Exemplo de função que gera uma exceção
+def funcao_com_erro():
+    raise ValueError('Este é um erro de exemplo')
+
+# Testando redirecionamento de print e captura de exceção
+print('Mensagem de teste via print')
+try:
+    funcao_com_erro()
+except Exception as e:
+    print(f'Capturado um erro: {e}')
+
+log.erro('Essa é uma mensagem de erro e abortará a execução do script', exit=1)
+
+log.info('Essa mensagem não será exibida pois o script foi abortado na mensagem anterior')
+```
+
+

lbxtoolkit-2.0.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+lbxtoolkit/__init__.py,sha256=GGaV_R8kyui17xL_AYfEI5cHs40d3_pdnjt-dVVzT8g,34349
+lbxtoolkit-2.0.1.dist-info/LICENSE,sha256=oWbIXdrHh8fiZ9xtLg5gloBth4N3LHUxM7REa5mCu4U,1087
+lbxtoolkit-2.0.1.dist-info/METADATA,sha256=paHvj9fu84qZEKcuLLvjEdX66JbU7zvUS7_LlNdzNdw,23925
+lbxtoolkit-2.0.1.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+lbxtoolkit-2.0.1.dist-info/top_level.txt,sha256=2fO2dxZu2kJzx49GALRsptbLdoPOps2mb52zsFFgDaM,11
+lbxtoolkit-2.0.1.dist-info/RECORD,,

lbxtoolkit-2.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (71.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lbxtoolkit-2.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+lbxtoolkit