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

csc_cia_stne/__init__.py

@@ -1,3 +1,8 @@
+import os
+if os.getenv('ambiente_de_execucao') == "karavela":
+    from .logger_json import logger
+else:
+    from .logger_rich import logger
 from .karavela import Karavela
 from .utilitarios import Util
 from .servicenow import ServiceNow

csc_cia_stne/gcp_bigquery.py

@@ -34,7 +34,7 @@ class BigQuery():
 
         try:
 
-            if(creds_dict not None):
+            if(creds_dict is not None):
 
                 credentials = service_account.Credentials.from_service_account_info(
                     creds_dict,

csc_cia_stne/logger_json.py

@@ -0,0 +1,36 @@
+import logging
+from pythonjsonlogger import jsonlogger
+
+def setup_json_logger():
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+
+    # 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)
+
+    # Capturando logs da biblioteca FastAPI/Uvicorn
+    #uvicorn_logger = logging.getLogger("uvicorn")
+    #uvicorn_logger.handlers = logger.handlers
+    #uvicorn_logger.setLevel(logging.INFO)
+
+    #uvicorn_error_logger = logging.getLogger("uvicorn.error")
+    #uvicorn_error_logger.handlers = logger.handlers
+    #uvicorn_error_logger.setLevel(logging.INFO)
+
+    #uvicorn_access_logger = logging.getLogger("uvicorn.access")
+    #uvicorn_access_logger.handlers = logger.handlers
+    #uvicorn_access_logger.setLevel(logging.INFO)
+
+    return logger
+
+# Chama a função para configurar o logger
+logger = setup_json_logger()

csc_cia_stne/logger_rich.py

@@ -0,0 +1,105 @@
+import logging
+from rich.logging import RichHandler
+from rich.theme import Theme
+from rich.console import Console
+import re
+import traceback
+import os
+
+# Definindo o nível de log baseado nas configurações
+if os.getenv('log_level') == "DEBUG":
+
+    log_config_level = logging.DEBUG
+
+elif os.getenv('log_level') == "INFO":
+
+    log_config_level = logging.INFO
+
+else:
+
+    log_config_level = logging.WARNING  # ou outro nível padrão
+
+# 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, omit_repeated_times=True, **kwargs):
+        super().__init__(rich_tracebacks=rich_tracebacks, show_time=show_time, show_level=show_level, show_path=show_path, console=console, omit_repeated_times=omit_repeated_times, *args, **kwargs)
+        self.show_time = show_time
+
+
+    def format(self, record: logging.LogRecord) -> str:
+        try:
+            msg = f"| {record.getMessage()}"
+            #msg = f"{record.getMessage()}"
+
+            return(str(msg))
+        except Exception as e:
+            print("FALHA AO FORMATAR O LOG")
+            print(e)
+
+# Configurando o logging com o CustomRichHandler
+logging.basicConfig(
+    level=log_config_level,
+    handlers=[CustomRichHandler()],
+    datefmt="%d/%m/%Y %H:%M:%S |",
+    format="| %(message)s"
+)
+
+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)
+
+logger = logging.getLogger()

csc_cia_stne/servicenow.py

@@ -1,7 +1,7 @@
 import requests
 import base64, json
 import os
-from .logger import logger
+import logging
 
 class ServiceNow:
     
@@ -59,17 +59,17 @@ class ServiceNow:
             if "result" in result:
                 return result["result"]
             else:
-                logger.warning("A resposta não contém o campo 'result'.")
+                logging.warning("A resposta não contém o campo 'result'.")
                 return {}
 
         except requests.exceptions.HTTPError as http_err:
-            logger.error(f"Erro HTTP ao buscar os detalhes do ticket: {http_err}")
+            logging.error(f"Erro HTTP ao buscar os detalhes do ticket: {http_err}")
             raise
         except requests.exceptions.RequestException as req_err:
-            logger.error(f"Erro ao buscar os detalhes do ticket: {req_err}")
+            logging.error(f"Erro ao buscar os detalhes do ticket: {req_err}")
             raise
         except Exception as e:
-            logger.error(f"Erro inesperado: {e}")
+            logging.error(f"Erro inesperado: {e}")
             raise
 
     def put(self, url, payload):
@@ -93,21 +93,21 @@ class ServiceNow:
             result = response.json()
             if "result" in result:
                 update = result["result"]
-                logger.info(f"Atualização concluída com sucesso. Registro atualizado: {update["sys_id"]} | Alterações: {payload}")
+                logging.info(f"Atualização concluída com sucesso. Registro atualizado: {update["sys_id"]} | Alterações: {payload}")
             else:
-                logger.warning(f"A Resposta da sua requisição não contém o campo 'Result'. Segue o retorno: \n {result} | Alterações: {payload}")
+                logging.warning(f"A Resposta da sua requisição não contém o campo 'Result'. Segue o retorno: \n {result} | Alterações: {payload}")
         
         #TRATAMENTOS DE ERRO 
         except requests.exceptions.HTTPError as http_err:
 
-            logger.error(f"Erro HTTP ao tentar atualizar o ticket: {http_err} \n Reposta da solicitação: {response.json().get("error").get("message")}")
+            logging.error(f"Erro HTTP ao tentar atualizar o ticket: {http_err} \n Reposta da solicitação: {response.json().get("error").get("message")}")
             raise
         except requests.exceptions.RequestException as req_err:
             
-            logger.error(f"Erro ao tentar atualizar o ticket: \n {req_err}")
+            logging.error(f"Erro ao tentar atualizar o ticket: \n {req_err}")
             raise
         except Exception as e:
-            logger.error(f"Erro inesperado: \n {e}")
+            logging.error(f"Erro inesperado: \n {e}")
             raise
     
     def post(self, url, variables, header_content_type = ""):
@@ -148,22 +148,22 @@ class ServiceNow:
             if "result" in result:
                 ticket_number = result["result"].get("number")
                 ticket_sys_id = result["result"].get("sys_id")
-                logger.info(f"Ticket registrado com sucesso. Número: {ticket_number} | SYS_ID: {ticket_sys_id}")
+                logging.info(f"Ticket registrado com sucesso. Número: {ticket_number} | SYS_ID: {ticket_sys_id}")
                 return result["result"]
             else:
-                logger.warning(f"A Resposta da sua requisição não contém o campo 'Result'. Segue o retorno: \n {result}")
+                logging.warning(f"A Resposta da sua requisição não contém o campo 'Result'. Segue o retorno: \n {result}")
         
         #TRATAMENTOS DE ERRO 
         except requests.exceptions.HTTPError as http_err:
 
-            logger.error(f"Erro HTTP ao tentar registrar o ticket: {http_err} \n Reposta da solicitação: {response.json().get("error").get("message")}")
+            logging.error(f"Erro HTTP ao tentar registrar o ticket: {http_err} \n Reposta da solicitação: {response.json().get("error").get("message")}")
             raise
         except requests.exceptions.RequestException as req_err:
             
-            logger.error(f"Erro ao tentar registrar o ticket: \n {req_err}")
+            logging.error(f"Erro ao tentar registrar o ticket: \n {req_err}")
             raise
         except Exception as e:
-            logger.error(f"Erro inesperado: \n {e}")
+            logging.error(f"Erro inesperado: \n {e}")
             raise
     
     def listar_tickets(self, tabela: str = None, campos: list = None, query: str = None, limite: int = 50, timeout:int=15)->dict:

csc_cia_stne/settings.py

@@ -0,0 +1,47 @@
+from pydantic_settings import BaseSettings
+from pydantic import ValidationError
+from rich.traceback import install
+from dotenv import load_dotenv
+
+# Instala formatações de exception da biblioteca Rich
+install()
+
+# Carrega .env
+load_dotenv()
+
+# Classe para armazenar configurações
+class Settings(BaseSettings):
+    # Ambiente de Execução
+    ambiente_de_execucao: str = "local"
+    log_level: str = "DEBUG"
+    
+    # Titulo
+    project_name: str
+    project_version: str
+    project_dev_name: str
+    project_dev_mail: str
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = 'utf-8'  # Defina a codificação se necessário
+
+# Carrega as configurações do arquivo .env ou retorna exception com os campos obrigatórios que não foram preenchidos
+def load_settings():
+    try:
+        settings = Settings()
+        return settings
+
+    except ValidationError as e:
+        # Extrair os detalhes da exceção
+        errors = e.errors()
+        missing_vars = [error['loc'][0] for error in errors if error['type'] == 'missing']
+        
+        # Criar uma mensagem personalizada
+        if missing_vars:
+            missing_vars_str = ', '.join(missing_vars)
+            raise ValueError(
+                f"As seguintes variáveis obrigatórias estão ausentes no arquivo .env ou nas variáveis de ambiente da máquina: {missing_vars_str}\n"
+                "Outras variáveis, não obrigatórias: 'ambiente_de_execução' ('local' ou 'karavela') e 'log_level' ('DEBUG', 'INFO', etc)"
+            )
+        
+settings = load_settings()

{csc_cia_stne-0.0.13.dist-info → csc_cia_stne-0.0.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: csc_cia_stne
-Version: 0.0.13
+Version: 0.0.15
 Summary: Biblioteca do time CSC-CIA utilizada no desenvolvimento de RPAs
 License: MIT
 Keywords: karavela,csc,cia,stone,rpa
@@ -10,11 +10,14 @@ Requires-Dist: python-json-logger
 Requires-Dist: rich
 Requires-Dist: requests
 Requires-Dist: pydantic
+Requires-Dist: pydantic-settings
 Requires-Dist: zeep
 Requires-Dist: google-cloud-bigquery
 Requires-Dist: google-cloud-storage
 Requires-Dist: google-auth-oauthlib
 Requires-Dist: google-auth-httplib2
+Requires-Dist: pyjwt
+Requires-Dist: python-dotenv
 
 Essa biblioteca é desenvolvida e atualizada pelo time **CSC-CIA** da **Stone**
 
@@ -22,4 +25,5 @@ Utilizada no desenvolvimento dos RPAs, possui classes que são utilizadas com fr
 
 O intuito é não precisar desenvolver, novamente, funcionalidades que são utilizadas com frequência
 
+Documentação mais detalhada: [GitHub com acesso restrito](https://github.com/stone-payments/cia-libs)
 Contato: **cia@stone.com.br**

csc_cia_stne-0.0.15.dist-info/RECORD

@@ -0,0 +1,17 @@
+csc_cia_stne/__init__.py,sha256=YfHCQfAdkyKYhN7GXO6obSk3LK1Eg55Byswce8rmIR8,401
+csc_cia_stne/bc_correios.py,sha256=ANsvLyL7wdkM0MvjjBHB2Ih4eyTcyWgt5IqiK0Rv89E,23014
+csc_cia_stne/bc_sta.py,sha256=I9N29wjTbd4ZmoM2yIW-xp3X-dMENZdSb0JhapfCegY,10988
+csc_cia_stne/cia_logging.py,sha256=GbxpcjtF_7tiRez2awIKZJXdo5CvM0n_mo1RKpfvAnU,5100
+csc_cia_stne/gcp_bigquery.py,sha256=f8UEQgr6XyFacYX0bRq4UDmWoH-0XqZF8fA2LsLTtAU,5654
+csc_cia_stne/karavela.py,sha256=Q7MbQXXz_jtrLHM7QeenbSzcro07EpoFk4lKglivJ_I,3564
+csc_cia_stne/logger_json.py,sha256=2G0rm0lyCtHn4o2v7fzn4wMylb0A_nbxiQatnrSZxHs,1212
+csc_cia_stne/logger_rich.py,sha256=IIwTDPfZqsXC0h-lZHgpUqUaXm_t5xH177QEIFZGsBY,3210
+csc_cia_stne/servicenow.py,sha256=vSsNSANFyCZtDu2O7YmdoCbr-_bO1sgMWnOI29mFBOA,23311
+csc_cia_stne/settings.py,sha256=Xr3TPnlGjS_WZ01VeHXUy1p9m1GdA-OUJ8HEA8t_hlU,1561
+csc_cia_stne/stne_admin.py,sha256=G5ozXt18VjKL2BHtROQk4GnfVY1xM14RXSQ-rra_D54,15487
+csc_cia_stne/utilitarios.py,sha256=LU8YrELiRIW4UxqULjiUPYmgbEx79NGenK5QKRdSh_E,2050
+csc_cia_stne-0.0.15.dist-info/LICENCE,sha256=LPGMtgKki2C3KEZP7hDhA1HBrlq5JCHkIeStUCLEMx4,1073
+csc_cia_stne-0.0.15.dist-info/METADATA,sha256=r9Cq_IlIlq8ruqfWOZFx8yIQJGIr0hQSHnTjuBHTaZY,1003
+csc_cia_stne-0.0.15.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+csc_cia_stne-0.0.15.dist-info/top_level.txt,sha256=ldo7GVv3tQx5KJvwBzdZzzQmjPys2NDVVn1rv0BOF2Q,13
+csc_cia_stne-0.0.15.dist-info/RECORD,,

csc_cia_stne/logger.py

@@ -1,155 +0,0 @@
-import os
-import logging
-import colorlog
-from pythonjsonlogger import jsonlogger
-
-
-# Strategy para formatação dos logs
-class LogFormatterStrategy:
-    """
-    Interface para estratégia de formatação de logs.
-    Define o método `format`, que deve ser implementado pelas subclasses.
-    """
-
-    def format(self, log_handler, date_format):
-        """
-        Aplica a formatação do log ao handler fornecido.
-
-        Parâmetros:
-            log_handler (logging.Handler): O handler que receberá a formatação.
-            date_format (str): O formato da data para os logs.
-
-        Retorna:
-            None
-        """
-        raise NotImplementedError("O método format() deve ser implementado")
-
-
-class ColorLogFormatter(LogFormatterStrategy):
-    """
-    Implementação da estratégia de formatação de logs coloridos para uso local.
-    """
-
-    def format(self, log_handler, date_format):
-        """
-        Aplica a formatação colorida ao handler de log.
-
-        Parâmetros:
-            log_handler (logging.Handler): O handler que receberá a formatação.
-            date_format (str): O formato da data para os logs.
-
-        Retorna:
-            None
-        """
-        formatter = colorlog.ColoredFormatter(
-            "%(asctime)s - %(log_color)s%(levelname)s%(reset)s - %(message)s",
-            datefmt=date_format,
-            log_colors={
-                "DEBUG": "reset",
-                "INFO": "green",
-                "WARNING": "yellow",
-                "ERROR": "red",
-                "CRITICAL": "bold_red",
-            },
-        )
-        log_handler.setFormatter(formatter)
-
-
-class JsonLogFormatter(LogFormatterStrategy):
-    """
-    Implementação da estratégia de formatação de logs em JSON, ideal para ambientes como Docker.
-    """
-
-    def format(self, log_handler, date_format):
-        """
-        Aplica a formatação JSON ao handler de log.
-
-        Parâmetros:
-            log_handler (logging.Handler): O handler que receberá a formatação.
-            date_format (str): O formato da data para os logs.
-
-        Retorna:
-            None
-        """
-        formatter = jsonlogger.JsonFormatter(
-            "%(asctime)s - %(levelname)s - %(message)s", datefmt=date_format
-        )
-        log_handler.setFormatter(formatter)
-
-
-# Factory para criar o logger
-class LoggerFactory:
-    """
-    Classe de fábrica responsável por criar e configurar loggers.
-    """
-
-    @staticmethod
-    def create_logger(name):
-        """
-        Cria e retorna um logger configurado com o nome especificado.
-
-        Parâmetros:
-            name (str): O nome do logger.
-
-        Retorna:
-            logging.Logger: O logger configurado.
-        """
-        try:
-            if not os.path.exists("./tmp"):
-                os.makedirs("./tmp")
-        except OSError as e:
-            print(f"Erro ao criar o diretório './tmp': {e}")
-            raise
-
-        logger = logging.getLogger(name)
-        logger.setLevel(logging.INFO)
-        log_handler = logging.StreamHandler()
-        date_format = "%d-%m-%Y %H:%M:%S"
-
-        # Define a estratégia de formatação dependendo do ambiente
-        if LoggerFactory.not_docker():
-            formatter_strategy = ColorLogFormatter()
-
-            # Configura o handler para salvar logs em arquivo
-            file_handler = logging.FileHandler("tmp/log.txt")
-            file_handler.setFormatter(
-                logging.Formatter(
-                    "%(asctime)s - %(levelname)s - %(message)s",
-                    datefmt=date_format,
-                )
-            )
-            logger.addHandler(file_handler)
-        else:
-            formatter_strategy = JsonLogFormatter()
-            print("Rodando em container, logs em JSON")
-
-        # Aplica a estratégia de formatação
-        formatter_strategy.format(log_handler, date_format)
-        logger.addHandler(log_handler)
-
-        return logger
-
-    @staticmethod
-    def not_docker():
-        """
-        Verifica se o código está sendo executado em um container Docker.
-
-        Retorna:
-            bool: False se estiver rodando em um container Docker, True se estiver rodando localmente.
-        """
-        if os.path.exists("/.dockerenv"):
-            return False
-
-        try:
-            with open("/proc/1/cgroup", "rt") as file:
-                for line in file:
-                    if "docker" in line or "kubepods" in line:
-                        return False
-        except Exception:
-            print("Logger sendo executado localmente.")
-
-        return True
-
-
-# Uso do logger
-logger = LoggerFactory.create_logger(__name__)

csc_cia_stne-0.0.13.dist-info/RECORD

@@ -1,15 +0,0 @@
-csc_cia_stne/__init__.py,sha256=VYD8Lj4LgMqM5d3f2dgS5oqThEo9czi-wIDPaw3b3Ec,261
-csc_cia_stne/bc_correios.py,sha256=ANsvLyL7wdkM0MvjjBHB2Ih4eyTcyWgt5IqiK0Rv89E,23014
-csc_cia_stne/bc_sta.py,sha256=I9N29wjTbd4ZmoM2yIW-xp3X-dMENZdSb0JhapfCegY,10988
-csc_cia_stne/cia_logging.py,sha256=GbxpcjtF_7tiRez2awIKZJXdo5CvM0n_mo1RKpfvAnU,5100
-csc_cia_stne/gcp_bigquery.py,sha256=GBI7BDyranwr4IQGzLbbZRgD2Km6tlkqqVCI3R89-bE,5651
-csc_cia_stne/karavela.py,sha256=Q7MbQXXz_jtrLHM7QeenbSzcro07EpoFk4lKglivJ_I,3564
-csc_cia_stne/logger.py,sha256=cadiXHeOv8OaB4o8byznsks4VDTfR0cCccLIWxn2R48,4612
-csc_cia_stne/servicenow.py,sha256=d7HysnJU1Q22hy0e3cIW90S8_5IsQGETiJndnGOI_i8,23309
-csc_cia_stne/stne_admin.py,sha256=G5ozXt18VjKL2BHtROQk4GnfVY1xM14RXSQ-rra_D54,15487
-csc_cia_stne/utilitarios.py,sha256=LU8YrELiRIW4UxqULjiUPYmgbEx79NGenK5QKRdSh_E,2050
-csc_cia_stne-0.0.13.dist-info/LICENCE,sha256=LPGMtgKki2C3KEZP7hDhA1HBrlq5JCHkIeStUCLEMx4,1073
-csc_cia_stne-0.0.13.dist-info/METADATA,sha256=2_oSdzjh5F7344uGFXIxqRxm2xHmCN-TclJVjeurYOY,816
-csc_cia_stne-0.0.13.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-csc_cia_stne-0.0.13.dist-info/top_level.txt,sha256=ldo7GVv3tQx5KJvwBzdZzzQmjPys2NDVVn1rv0BOF2Q,13
-csc_cia_stne-0.0.13.dist-info/RECORD,,