csc-cia-stne 0.0.13__py3-none-any.whl

csc_cia_stne/bc_sta.py

@@ -0,0 +1,301 @@
+from requests.auth import HTTPBasicAuth
+import sys
+from pydantic import BaseModel
+import requests
+import xml.etree.ElementTree as ET
+import hashlib
+from pydantic import BaseModel, StrictStr, StrictInt, ValidationError, field_validator, FieldValidationInfo
+from typing import Literal, Dict, Union, Optional
+
+# Validações dos inputs
+class InitParamsValidator(BaseModel):
+    usuario: str
+    senha: str
+    ambiente: Literal["prd", "hml"]  # Aceita apenas "prd" ou "sdx"
+
+    # Validação para garantir que cada parâmetro é uma string não vazia
+    @field_validator('usuario', 'senha')
+    def check_non_empty_string(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            
+            raise ValueError(f"O parâmetro '{info.field_name}' deve ser uma string não vazia.")
+        
+        return value
+
+class EnviarArquivoValidator(BaseModel):
+    tipo_arquivo:str
+    file_content:bytes
+    nome_arquivo:str
+    observacao:str
+    destinatarios:Optional[Union[Dict[str, str], str]] = None  # Aceita um dicionário
+    
+    @field_validator("tipo_arquivo")
+    def check_tipo_arquivo(cls, value):
+        if not isinstance(value, str) or not value.strip():
+    
+            raise ValueError("O parâmetro 'tipo_arquivo' deve ser uma string não vazia, com o código do tipo de envio a ser utilizado para o STA, verificar codigos disponíveis na documentação STA")
+    
+        return value
+    
+    # Validador para file_content: deve ter conteúdo em bytes
+    @field_validator("file_content")
+    def check_file_content(cls, value):
+        if not isinstance(value, bytes) or len(value) == 0:
+            raise ValueError("O parâmetro 'file_content' deve ser um byte array não vazio.")
+        return value
+    
+    # Validador para nome_arquivo: deve ser uma string não vazia e terminar com uma extensão de arquivo comum
+    @field_validator("nome_arquivo")
+    def check_nome_arquivo(cls, value):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError("O nome do arquivo deve ser uma string não vazia.")
+        if not value.lower().endswith(('.zip', '.xpto')):
+            raise ValueError("O nome do arquivo deve ter uma extensão válida.")
+        return value
+    
+    @field_validator("observacao")
+    def check_observacao(cls, value):
+        if not isinstance(value, str) or not value.strip():
+    
+            raise ValueError("O parâmetro 'observacao' deve ser uma string não vazia")
+    
+        return value
+
+    # Validador para destinatarios: aceita um dicionário ou uma string XML opcional
+    @field_validator("destinatarios")
+    def check_destinatarios(cls, value):
+        if value is not None:
+            
+            if not isinstance(value, list):
+            
+                raise ValueError("O parâmetro 'destinatarios' deve ser uma lista de dicionários.")
+            
+            for item in value:
+            
+                if not isinstance(item, dict):
+            
+                    raise ValueError("Cada destinatário deve ser um dicionário.")
+            
+                required_keys = {"unidade", "dependencia", "operador"}
+            
+                if not required_keys.issubset(item.keys()):
+            
+                    raise ValueError("Cada destinatário deve conter as chaves 'unidade', 'dependencia' e 'operador'. Verifique a documentação da API BC STA para entender o que colocar cada campo")
+        
+        return value
+    
+class BC_STA:
+    
+    def __init__(self, usuario:str, senha:str, ambiente:str):
+
+        try:
+            
+            InitParamsValidator(usuario=usuario, senha=senha, ambiente=ambiente)
+        
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input da inicialização da instância 'BC_STA':", e.errors())
+        
+        if ambiente == 'prd':
+            
+            self.base_url = "https://sta.bcb.gov.br/staws"
+        
+        else:
+            
+            self.base_url = "https://sta-h.bcb.gov.br/staws"
+        
+        try:
+
+            self.auth = HTTPBasicAuth(usuario,senha)
+            self.error = None
+            self.headers = {'Content-Type': 'application/xml'}
+            self.is_connected = self.verifica_conexao()
+
+        except Exception as e:
+
+            self.is_connected = False
+            self.error = e
+    
+    def verifica_conexao(self):
+        try:
+
+            response = requests.get("https://sta.bcb.gov.br/staws/arquivos?tipoConsulta=AVANC&nivelDetalhe=RES", auth=self.auth)
+            
+            # Verificando o status e retornando a resposta
+            if response.status_code == 200:
+
+                return True
+
+            else:
+
+                return False
+
+
+        except Exception as e:
+
+            raise e
+
+    def enviar_arquivo(self, tipo_arquivo:str, file_content:bytes, nome_arquivo:str, observacao:str, destinatarios:dict=None):
+
+        try:
+            
+            EnviarArquivoValidator(tipo_arquivo=tipo_arquivo, file_content=file_content, nome_arquivo=nome_arquivo, observacao=observacao, destinatarios=destinatarios)
+        
+        except ValidationError as e:
+        
+            raise ValueError("Erro na validação dos dados de input do método 'enviar_arquivo':", e.errors())
+
+        def generate_sha256_hash(file_content):
+            
+            # Gera o hash SHA-256 do arquivo
+            sha256_hash = hashlib.sha256()
+            sha256_hash.update(file_content)
+            return sha256_hash.hexdigest()
+
+        def process_response(xml_content):
+
+            try:
+
+                root = ET.fromstring(xml_content)
+
+                # Verifica se há um elemento <Erro> no XML
+                erro = None
+                erro_elem = root.find('Erro')
+                
+                if erro_elem is not None:
+                
+                    codigo_erro = erro_elem.find('Codigo').text
+                    descricao_erro = erro_elem.find('Descricao').text
+                    erro = f"Erro {codigo_erro}: {descricao_erro}"
+                    resposta = {
+                        'enviado':False,
+                        'protocolo': None,
+                        'link': None,
+                        'erro': erro
+                        }                                    
+
+                else:
+
+                    protocolo = root.find('Protocolo').text
+                    link = root.find('.//atom:link', namespaces={'atom': 'http://www.w3.org/2005/Atom'}).attrib['href']
+                    resposta = {
+                        'enviado':True,
+                        'protocolo': protocolo,
+                        'link': link,
+                        'erro': None
+                        }
+
+                return resposta
+
+            except ET.ParseError as e:
+
+                resposta = {
+                    'enviado': False,
+                    'protocolo': None,
+                    'link': None,
+                    'erro': f"Error processing XML: {str(e)}"
+                }
+                return resposta
+        
+        url = self.base_url + '/arquivos'
+
+        # Calcula o hash SHA-256 do conteúdo do arquivo
+        hash_sha256 = generate_sha256_hash(file_content)
+        tamanho_arquivo = len(file_content)  # Tamanho do arquivo em bytes
+
+        # Constrói o XML de requisição
+        parametros = ET.Element('Parametros')
+        ET.SubElement(parametros, 'IdentificadorDocumento').text = tipo_arquivo
+        ET.SubElement(parametros, 'Hash').text = hash_sha256
+        ET.SubElement(parametros, 'Tamanho').text = str(tamanho_arquivo)
+        ET.SubElement(parametros, 'NomeArquivo').text = nome_arquivo
+        
+        # Campo observação é opcional
+        if observacao:
+            ET.SubElement(parametros, 'Observacao').text = observacao
+
+        # Campo destinatários é opcional
+        if destinatarios:
+
+            destinatarios_elem = ET.SubElement(parametros, 'Destinatarios')
+
+            for dest in destinatarios:
+
+                destinatario_elem = ET.SubElement(destinatarios_elem, 'Destinatario')
+                ET.SubElement(destinatario_elem, 'Unidade').text = dest['unidade']
+
+                if 'dependencia' in dest:
+
+                    ET.SubElement(destinatario_elem, 'Dependencia').text = dest['dependencia']
+
+                if 'operador' in dest:
+
+                    ET.SubElement(destinatario_elem, 'Operador').text = dest['operador']
+
+        # Converte o XML para string
+        xml_data = ET.tostring(parametros, encoding='utf-8', method='xml')
+
+        # Envia a requisição POST
+        response = requests.post(url, headers=self.headers, data=xml_data, auth=self.auth, timeout=60)
+
+        if response.status_code == 201:  # Verifica se o protocolo foi criado com sucesso
+            
+            resultado_protocolo = process_response(response.text)
+            
+            # Protocolo gerado, prosseguir com envio do arquivo
+            if resultado_protocolo["enviado"]:
+                
+                try:
+                    
+                    # Solicita o envio
+                    protocolo = resultado_protocolo["protocolo"]
+                    # URL do endpoint, incluindo o protocolo
+                    url = url + f"/{protocolo}/conteudo"
+
+                    # Envia a requisição PUT com o conteúdo binário do arquivo
+                    response = requests.put(url, data=file_content, auth=self.auth, timeout=60)
+                    
+                    if response.status_code == 200:
+                    
+                        return resultado_protocolo
+                    
+                    else:
+                    
+                        resposta = {
+                            'enviado':False,
+                            'protocolo': None,
+                            'link': None,
+                            'erro': f"Falha ao enviar arquivo. Status code: {response.status_code}, Text: {response.text}, Reason: {response.reason}"
+                            }
+                        return resposta
+
+                except Exception as e:
+                    
+                    erro = str(e)
+                    resposta = {
+                        'enviado':False,
+                        'protocolo': None,
+                        'link': None,
+                        'erro': erro
+                        }
+                    return resposta
+
+
+
+            # Protocolo não foi gerado, retornar erro
+            else:
+            
+                return resultado_protocolo
+
+        else:
+
+            print(response.text)
+            resposta = {
+                'enviado': False,
+                'protocolo': None,
+                'link': None,
+                'erro': f"Failed to create protocol. Status code: {response.status_code}, Reason: {response.reason}"
+            }
+            #return f"Failed to create protocol. Status code: {response.status_code}, Reason: {response.reason}"
+            return resposta
+

csc_cia_stne/cia_logging.py

@@ -0,0 +1,149 @@
+import logging
+from rich.logging import RichHandler
+from rich.theme import Theme
+from rich.console import Console
+import re
+from pythonjsonlogger import jsonlogger
+from rich.traceback import install
+
+def logger(env:str = "local", log_level:str = "DEBUG"):
+    
+    def get_log_level(log_level):
+        if log_level.upper().strip() == "DEBUG":
+
+            log_config_level = logging.DEBUG
+
+        elif log_level.upper().strip() == "INFO":
+
+            log_config_level = logging.INFO
+
+        elif log_level.upper().strip() == "WARNING":
+
+            log_config_level = logging.WARNING
+
+        elif log_level.upper().strip() == "ERROR":
+
+            log_config_level = logging.ERROR
+        
+        elif log_level.upper().strip() == "CRITICAL":
+
+            log_config_level = logging.CRITICAL
+
+        else:
+
+            log_config_level = logging.INFO  # ou outro nível padrão
+        
+        return log_config_level
+
+    def add_log_level(level_name, level_num, method_name=None):
+        """
+        Adiciona um log level
+
+        Parâmetros:
+            level_name (str): Nome do level
+            level_num (int): Número do level
+        """
+        if not method_name:
+        
+            method_name = level_name.lower()
+
+        if hasattr(logging, level_name):
+        
+            raise AttributeError('{} already defined in logging module'.format(level_name))
+        
+        if hasattr(logging, method_name):
+        
+            raise AttributeError('{} already defined in logging module'.format(method_name))
+        
+        if hasattr(logging.getLoggerClass(), method_name):
+        
+            raise AttributeError('{} already defined in logger class'.format(method_name))
+
+        def log_for_level(self, message, *args, **kwargs):
+            
+            if self.isEnabledFor(level_num):
+
+                self._log(level_num, message, args, **kwargs)
+                
+        def log_to_root(message, *args, **kwargs):
+            
+            logging.log(level_num, message, *args, **kwargs)
+
+        logging.addLevelName(level_num, level_name)
+        setattr(logging, level_name, level_num)
+        setattr(logging.getLoggerClass(), method_name, log_for_level)
+        setattr(logging, method_name, log_to_root)
+
+    add_log_level("SUCCESS",21)
+
+    if env.upper().strip() != "KARAVELA":
+        
+        install()
+
+        # Definindo o tema customizado
+        custom_theme = Theme({
+            # python -m rich.color - cores
+            # python -m rich.default_styles - item + cor padrão
+            "logging.level.debug": "bold bright_cyan",
+            "logging.level.info": "bold bright_white",
+            "logging.level.warning": "bold orange1",
+            "logging.level.error": "bold red blink",
+            "logging.level.critical": "bold white on red blink",
+            "logging.level.success": "bold bright_green",
+            "log.time":"bold white",
+            "log.message":"bold gray70",
+            "repr.str":"dark_olive_green3",
+            "inspect.value.border":"blue",
+        })
+
+        console = Console(theme=custom_theme)
+
+        class CustomRichHandler(RichHandler):
+            def __init__(self, *args, rich_tracebacks=True, show_time=True, show_level=True, show_path=True, console=console, **kwargs):
+                super().__init__(rich_tracebacks=rich_tracebacks, show_time=show_time, show_level=show_level, show_path=show_path, console=console, *args, **kwargs)
+                self.show_time = show_time
+
+            def format(self, record: logging.LogRecord) -> str:
+                
+                def remover_prefixo_log(mensagem):
+                    # Expressão regular que encontra o padrão 'log_level:nivel: '
+                    padrao = r'^(ERROR|WARNING|INFO|DEBUG|SUCCESS|CRITICAL):[^:]*:'
+                    
+                    # Substitui o padrão encontrado por uma string vazia
+                    return re.sub(padrao, '', mensagem).strip()
+                
+                msg = f"| {record.getMessage()}"
+
+                return(str(msg))
+            
+        # Configurando o logging com o CustomRichHandler
+        logging.basicConfig(
+            level=get_log_level(log_level),
+            handlers=[CustomRichHandler()],
+            datefmt="%d/%m/%Y %H:%M:%S |",
+        )
+
+        return logging.getLogger()
+    
+    else:
+
+        def setup_json_logger():
+            logger = logging.getLogger()
+            logger.setLevel(get_log_level(log_level))
+
+            # Remove handlers anteriores, se houver
+            if logger.hasHandlers():
+                logger.handlers.clear()
+
+            log_handler = logging.StreamHandler()
+            formatter = jsonlogger.JsonFormatter(
+                fmt='%(asctime)s %(levelname)s %(name)s %(message)s %(pathname)s %(lineno)d %(exc_info)s %(stack_info)s %(funcName)s %(module)s',
+                json_ensure_ascii=False
+            )
+            log_handler.setFormatter(formatter)
+            logger.addHandler(log_handler)
+
+            return logger
+
+        # Chama a função para configurar o logger
+        return setup_json_logger()

csc_cia_stne/gcp_bigquery.py

@@ -0,0 +1,182 @@
+from google.cloud import bigquery
+import json
+import os
+from google.oauth2 import service_account
+
+class BigQuery():
+
+    def __init__(self, client: bigquery.Client, limit: int = 3):
+        """
+        Inicializa a classe BigQuery.
+        Parâmetros:
+        limit (int): O limite de resultados a serem retornados. O valor padrão é 3.
+        client (bigquery.Client): O cliente BigQuery a ser utilizado.
+        """
+
+        self.limit = limit
+        self.client = client
+
+    def create_client(id_project: str, creds_dict: dict = None, creds_file: str = "") -> bigquery.Client:
+        """
+        Cria um cliente BigQuery com base nas credenciais fornecidas.
+        Parâmetros:
+        - creds_dict (dict): Dicionário contendo as informações das credenciais. Opcional se creds_file for fornecido.
+        - creds_file (str): Caminho do arquivo de credenciais. Opcional se creds_dict for fornecido.
+        - id_project (str): ID do projeto BigQuery.
+        Retorna:
+        - client (bigquery.Client): Cliente BigQuery criado com base nas credenciais fornecidas.
+        Exceções:
+        - Retorna um dicionário com as seguintes chaves em caso de erro:
+            - 'status' (bool): False
+            - 'error' (str): Mensagem de erro
+            - 'details' (str): Detalhes do erro
+        """
+
+        try:
+
+            if(creds_dict not None):
+
+                credentials = service_account.Credentials.from_service_account_info(
+                    creds_dict,
+                    scopes=["https://www.googleapis.com/auth/cloud-platform"],
+                )
+
+                client = bigquery.Client(credentials=credentials, project=id_project)
+
+            elif(str(creds_file) > 0):
+
+                credentials = service_account.Credentials.from_service_account_file(
+                    creds_file,
+                    scopes=["https://www.googleapis.com/auth/cloud-platform"],
+                )
+
+            else:
+
+                return {
+                    'status':False,
+                    'error':"Credenciais não fornecidas"
+                }
+
+            return client
+        
+        except Exception as e:
+
+            return {
+                'status':False,
+                'error':'Problema ao tentar gerar o client do big query',
+                'details':str(e)
+            }
+
+    def try_query(self, query_to_execute:str,organize:bool=True) -> dict:
+        """
+        Executa uma consulta no BigQuery e retorna o resultado.
+        Args:
+            query_to_execute (str): A consulta a ser executada.
+            organize (bool, optional): Indica se o resultado deve ser organizado em um formato específico. 
+                O padrão é True.
+        Returns:
+            dict: Um dicionário contendo o status da consulta e o resultado, se houver.
+                Exemplo:
+                {
+                    'status': True,
+                    'resultado': result_query
+                Se ocorrer um erro durante a execução da consulta, o dicionário de retorno terá o seguinte formato:
+                {
+                    'status': False,
+        """
+        
+        error = ""
+
+        for try_out in range(self.limit):
+
+            try:
+
+                result_query = self.client.query(query_to_execute).result()
+
+                error = False
+
+                if organize:
+
+                    result_rows = [dict(row) for row in result_query['resultado']]
+
+                    result_query = result_rows
+
+                break
+
+            except Exception as e:
+
+                error = e
+
+        if not error:
+
+            return {
+                'status':True,
+                'resultado':result_query
+            }
+
+        else:
+
+            return {
+                'status':False,
+                'error': str(error)
+            }
+
+    def insert_list(self,table:str,dict_to_insert:dict=[]) -> dict:
+        
+        """
+        Insere uma lista de dicionários em uma tabela do BigQuery.
+        Args:
+            client (bigquery.Client): Cliente do BigQuery.
+            table (str): Nome da tabela onde os dados serão inseridos.
+            dict_to_insert (dict, optional): Lista de dicionários a serem inseridos. O padrão é [].
+            limit_trys (int, optional): Número máximo de tentativas de inserção. O padrão é 3.
+        Returns:
+            dict: Dicionário contendo o status da inserção e informações adicionais.
+                - Se a inserção for bem-sucedida:
+                    {'status': True, 'inserted': inserted}
+                - Se ocorrer um erro durante a inserção:
+                    {'status': False, 'error': error, 'last_try': list_to_insert, 'inserted': inserted}
+        """
+
+        table_ref = self.client.get_table(table)
+
+        error = ""
+
+        inserted = []
+
+        for data in range(0, len(dict_to_insert), 10000):
+
+            # listagem que será inserida no big query
+            list_to_insert = dict_to_insert[data:data+10000]
+
+            for try_out in range(self.limit):
+
+                try:
+
+                    self.client.insert_rows(table_ref, list_to_insert)
+
+                    error = False
+
+                except Exception as e:
+
+                    error = e
+
+            if not error:
+
+                inserted.extend(list_to_insert)
+
+                continue
+
+            else:
+
+                return{
+                    'status':False,
+                    'error':str(error),
+                    'last_try':list_to_insert,
+                    'inserted':inserted
+                }
+            
+        return {
+            'status':True,
+            'inserted':inserted
+        }