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

csc_cia_stne/logger_json.py

@@ -0,0 +1,92 @@
+import logging
+from pythonjsonlogger import jsonlogger
+
+def setup_json_logger():
+    
+    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)
+                self._log(level_num, message, args, **{**kwargs, "stacklevel": 2})
+                
+        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)
+
+    if not 'SUCCESS' in logging._nameToLevel:
+        add_log_level("SUCCESS",21)
+    logger = logging.getLogger(__name__)
+    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()
+
+def get_logger():
+    """
+    logger = logging.getLogger("my_json_logger")
+    if not logger.hasHandlers():  # Evita configurar múltiplas vezes
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(json.dumps({"level": "%(levelname)s", "message": "%(message)s"}))
+        handler.setFormatter(formatter)
+        logger.setLevel(logging.DEBUG)
+        logger.addHandler(handler)
+    """
+    logger = setup_json_logger()
+    return logger

csc_cia_stne/logger_rich.py

@@ -0,0 +1,249 @@
+import logging
+from rich.logging import RichHandler
+from rich.theme import Theme
+from rich.console import Console
+from rich.traceback import install
+import re
+import traceback
+import os
+"""
+# Instala formatações de exception da biblioteca Rich
+install()
+
+# Definindo o nível de log baseado nas configurações
+if os.getenv('log_level') is None:
+    
+    log_config_level = logging.DEBUG
+
+elif 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)
+            self._log(level_num, message, args, **{**kwargs, "stacklevel": 2})
+            
+    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()
+
+"""
+
+def get_logger():
+    """
+    Retorna um objeto logger configurado com base nas variáveis de ambiente.
+    Returns:
+        logging.Logger: Objeto logger configurado.
+    Raises:
+        ValueError: Se o valor da variável de ambiente 'log_level' não for 'DEBUG', 'INFO', 'WARNING', 'ERROR' ou 'CRITICAL'.
+    """
+    # Instala formatações de exception da biblioteca Rich
+    install()
+
+    # Definindo o nível de log baseado nas configurações
+    if os.getenv('log_level') is None or os.getenv('log_level') == "DEBUG":
+        
+        log_config_level = logging.DEBUG
+
+    elif os.getenv('log_level') == "INFO":
+
+        log_config_level = logging.INFO
+    
+    elif os.getenv('log_level') == "WARNING" or os.getenv('log_level') == "WARN":
+        
+        log_config_level = logging.WARNING
+
+    elif os.getenv('log_level') == "ERROR":
+
+        log_config_level = logging.ERROR
+
+    elif os.getenv('log_level') == "CRITICAL":
+
+        log_config_level = logging.CRITICAL
+
+    else:
+
+        log_config_level = logging.INFO  # ou outro nível padrão
+        raise ValueError("'log_level' precisa ser 'DEBUG,'INFO','WARNING','ERROR' ou 'CRITICAL'")
+
+    # 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
+    # Comentado pois estava gerando logs de libs como slack_sdk e big query
+    # 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)
+                self._log(level_num, message, args, **{**kwargs, "stacklevel": 2})
+                
+        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)
+
+    if not 'SUCCESS' in logging._nameToLevel:
+        add_log_level("SUCCESS",21)
+
+    logger = logging.getLogger(__name__)
+
+    # Sendo setado aqui pois no basicConfig estava gerando logs para as libs do slack_sdk e big query
+
+    logger.addHandler(CustomRichHandler())
+
+    logger.setLevel(log_config_level)
+
+    return logger

csc_cia_stne/provio.py

@@ -0,0 +1,103 @@
+import logging
+import requests
+from requests.auth import HTTPBasicAuth
+from pydantic import BaseModel, Field, ValidationError
+from typing import List, Dict, Union
+
+# Validadores
+class ProvioModel(BaseModel):
+    """
+    Modelo para validação das credenciais de autenticação.
+    """
+    username: str = Field(..., strip_whitespace=True, min_length=1)
+    password: str = Field(..., strip_whitespace=True, min_length=1)
+
+class ExportarRelatorioParams(BaseModel):
+    """
+    Modelo para validação dos parâmetros do relatório.
+    """
+    ano: int = Field(..., gt=2015, description="O ano deve ser maior que 2015")
+    mes: int = Field(..., ge=1, le=12, description="O mês deve estar entre 1 e 12")
+    verbose: bool = Field(False, description="Indica se as mensagens detalhadas devem ser exibidas")
+
+# Classe provio
+class Provio:
+    """
+    Classe para interagir com a API do Provio.
+    """
+
+    def __init__(self, username: str, password: str):
+        """
+        Inicializa a classe com as credenciais de autenticação.
+
+        Args:
+            username (str): Nome de usuário para autenticação.
+            password (str): Senha para autenticação.
+
+        Raises:
+            ValidationError: Se as credenciais forem inválidas de acordo com o modelo `ProvioModel`.
+        """        
+        # Validação usando Pydantic
+        data = ProvioModel(username=username, password=password)
+
+        self.api_url = "https://provio.apps.stone.com.br/api/reports"
+        self.auth = HTTPBasicAuth(data.username, data.password)
+
+    def exportar_relatorio_geral(self, ano: int, mes: int, verbose: bool=False) -> Dict[str, Union[bool, str, List[Dict]]]:
+        """
+        Exporta o relatório geral para o período especificado.
+
+        Args:
+            ano (int): Ano do relatório (deve ser maior que 2015).
+            mes (int): Mês do relatório (deve estar entre 1 e 12).
+            verbose (bool): informa se as requisições devem ser expostas na console
+
+        Returns:
+            Dict[str, Union[bool, str, List[Dict]]]: Um dicionário contendo:
+                - `success` (bool): Indica se a exportação foi bem-sucedida.
+                - `error` (str): Mensagem de erro, se houver.
+                - `report` (List[Dict]): Lista de registros exportados, se `success` for `True`.
+
+        Raises:
+            ValidationError: Se os parâmetros `ano` e `mes` forem inválidos.
+        """        
+        # Validação dos parâmetros
+        params = ExportarRelatorioParams(ano=ano, mes=mes, verbose=verbose)
+        periodo = f"{params.ano}-{params.mes:02d}"
+        skip = 0
+        todos_os_dados = []  # Lista para armazenar todos os resultados
+        requisicao = 0
+        try:
+            
+            while True:
+            
+                url = f"{self.api_url}/general/{periodo}/{skip}"
+                response = requests.get(url=url, auth=self.auth)
+
+                if response.status_code == 200:
+            
+                    dados = response.json()
+
+                    # Verifica se há itens na resposta
+                    if not dados:  # Se a resposta for vazia, interrompa o loop
+            
+                        break
+
+                    # Adiciona os dados recebidos à lista total
+                    todos_os_dados.extend(dados)
+
+                    # Incrementa o skip para buscar a próxima página
+                    skip += 500
+                    requisicao += 1
+                    if verbose:
+                        logging.info(f"Exportando relatório: Requisição #{str(requisicao).zfill(3)} - {len(todos_os_dados)} registros no total")
+            
+                else:
+            
+                    return {"success": False, "error": f"{response.status_code} - {response.text}"}
+
+            return {"success": True, "error": None, "report": todos_os_dados}
+
+        except Exception as e:
+            
+            return {"success": False, "error": str(e)}