csc-cia-stne 0.0.30__py3-none-any.whl → 0.0.31__py3-none-any.whl

csc_cia_stne/__init__.py

@@ -1,36 +1,16 @@
 import os
 from dotenv import load_dotenv
-
-# Carrega .env
-load_dotenv()
-logger = None  # Inicializa como None
-#if os.getenv('ambiente_de_execucao') is not None and os.getenv('ambiente_de_execucao') == "karavela":
-#    from .logger_json import logger
-#else:
-#    from .logger_rich import logger
-
-
-if os.getenv('ambiente_de_execucao') is not None and os.getenv('ambiente_de_execucao') == "karavela":
-    from .logger_json import get_logger as get_logger_json
-    def logger():
-        return get_logger_json()
-else:
-    from .logger_rich import get_logger as get_logger_rich
-    def logger():
-        return get_logger_rich()
-
-
-
-
+from .logger_json import get_logger as get_logger_json
+from .logger_rich import get_logger as get_logger_rich
 from .karavela import Karavela
-#from .utilitarios.classes import Util
 from .servicenow import ServiceNow
 from .stne_admin import StoneAdmin
 from .bc_sta import BC_STA
 from .bc_correios import BC_Correios
 from .gcp_bigquery import BigQuery
 from .email import Email
-#from .utilitarios.functions import titulo
+from .provio import Provio
+
 # Define os itens disponíveis para importação
 __all__ = [
     "titulo",
@@ -41,5 +21,49 @@ __all__ = [
     "ServiceNow",
     "Util",
     "logger",
+    "Provio",
     "Email"
-]
+]
+
+diretorio_inicial = os.getcwd()
+caminho_env = os.path.join(diretorio_inicial, ".env")
+
+# Carrega .env
+load_dotenv(caminho_env)
+logger = None  # Inicializa como None
+
+def running_in_container():
+
+    if os.environ.get("KUBERNETES_SERVICE_HOST") or os.path.exists("/.dockerenv"):
+        
+        return True
+    
+    try:
+    
+        with open("/proc/1/cgroup", "rt") as file:
+    
+            for line in file:
+    
+                if "docker" in line or "kubepods" in line:
+    
+                    return True
+    
+    except FileNotFoundError as e:
+    
+        return False
+    
+    return False
+    
+def logger():
+    
+    if os.getenv('ambiente_de_execucao') is not None and os.getenv('ambiente_de_execucao') == "karavela":
+        
+        return get_logger_json()
+    
+    elif running_in_container():
+        
+        return get_logger_json()
+    
+    else:
+        
+        return get_logger_rich()

csc_cia_stne/gcp_bigquery.py

@@ -1,99 +1,7 @@
 from google.cloud import bigquery
-import json
-import os
 from google.oauth2 import service_account
-from pydantic import BaseModel, ValidationError, field_validator,model_validator
-
-class InitParamsValidator(BaseModel):
-    limit:int
-    id_project:str
-    creds_dict:dict
-    creds_file:str
-
-    @field_validator('limit')
-    def check_input_basic(cls, value, info):
-        if not isinstance(value, int):
-            raise ValueError(f"O parametro 'limit' deve ser um inteiro e não um {type(value)}")
-        
-        return value
-
-    @field_validator('id_project')
-    def check_str_input(cls, value, info):
-        if not isinstance(value, str) or not value.strip():
-            raise ValueError(f"O parametro 'id_project' deve ser uma string e não um {type(value)} e não vazio")
-        return value
-    
-    @model_validator(mode="after")
-    def check_others_input(cls, model):
-        creds_dict = model.creds_dict
-        creds_file = model.creds_file
-
-        if isinstance(creds_dict, dict):
-            return model
-
-        elif isinstance(creds_file, str) and creds_file.strip():
-            return model
-
-        else:
-            raise ValueError("Pelo menos um dos parâmetros 'creds_dict' ou 'creds_file' deve ser fornecido.")
-        
-
-class tryQueryValidator(BaseModel):
-
-    query_to_execute:str
-    organize:bool
-    use_legacy:bool
-    use_cache:bool
-    query_parameters:list
-
-    @field_validator('query_to_execute')
-    def check_str_input(cls, value, info):
-        if not isinstance(value, str) or not value.strip():
-            raise ValueError(f"O parametro '{info.field_name}' deve ser uma string não vazia")
-        
-        return value
-    
-    @field_validator('organize','use_legacy','use_cache')
-    def check_bool_input(cls, value, info):
-        if not isinstance(value, bool):
-            raise ValueError(f"O parametro '{info.field_name}' deve ser um boleano")
-        
-        return value
-    
-    @field_validator('query_parameters')
-    def check_list_input(cls, value, info):
-        if not isinstance(value, list):
-            raise ValueError(f"O parametro '{info.field_name}' deve ser uma lista")
-        
-        return value
-
-
-class tryInsertListValidator(BaseModel):
-
-    insert_limit:int
-    list_to_insert:list
-    table:str
-
-    @field_validator('list_to_insert')
-    def check_list_input(cls, value, info):
-        if not isinstance(value, list) and len(value) > 0:
-            raise ValueError(f"O parametro '{info.field_name}' deve ser uma lista e não estar vazia")
-        
-        return value
-    
-    @field_validator('table')
-    def check_str_input(cls, value, info):
-        if not isinstance(value, str) or not value.strip():
-            raise ValueError(f"O parametro '{info.field_name}' deve ser uma string não vazia")
-        
-        return value
-    
-    @field_validator('insert_limit')
-    def check_int_input(cls, value, info):
-        if not isinstance(value, int) or value > 10000:
-            raise ValueError(f"O parametro '{info.field_name}' deve ser um inteiro não maior que 10000")
-        
-        return value
+from pydantic import ValidationError
+from .utilitarios.validations.GcpBigQueryValidator import tryQueryValidator, InitParamsValidator, tryInsertListValidator
 
 class BigQuery():
 

csc_cia_stne/google_drive.py

@@ -0,0 +1,238 @@
+import os, time, logging, json
+from .karavela import Karavela
+from googleapiclient.discovery import build
+from googleapiclient.http import MediaFileUpload
+from googleapiclient.errors import HttpError
+from io import BytesIO
+from googleapiclient.discovery import build
+from google.oauth2 import service_account
+from .utilitarios.validations.GoogleDriveValidator import InitParamsValidator, CreateFolderValidator, ListFolderValidator
+from pydantic import ValidationError
+
+
+
+class GoogleDrive():
+    
+    """
+        Classe responsável por gerenciar operações no Google Drive, como upload de arquivos, criação de pastas
+        e listagem de conteúdo. Utiliza a API do Google Drive para realizar essas operações.
+
+        Args:
+            key (str): Chave de autenticação para acessar a API do Google Drive.
+    """
+    
+    def __init__(self, key, with_subject : str, scopes : list = ["https://www.googleapis.com/auth/drive"], version : str = "v3"):
+        """
+            Inicializa a classe GoogleDrive e autentica o serviço usando a chave fornecida.
+
+            Args:
+                key (str): Chave de autenticação do Google Drive.
+        """
+        try:
+            InitParamsValidator(key=key, with_subject=with_subject, scopes=scopes)
+        except ValidationError as e:
+            raise ValueError("Erro na validação dos dados de input da inicialização da instância:", e.errors())
+
+        self.__token = json.loads(Karavela.get_secret(key))
+        self.version = version
+        self.scopes = scopes
+        self.__auth = self.__autentica(with_subject)
+        self.page_size = 1000
+        self.service = self.create_service()
+
+    def timer_decorator(func):
+        """
+            Classe reponsável por calcular qualquer execução que ela seja chamada.        
+        """
+        def wrapper(*args, **kwargs):
+            inicio = time.time()
+            resultado = func(*args, **kwargs)
+            fim = time.time()
+            logging.debug(f"Tempo de execução de {func.__name__}: {fim - inicio:.2f} segundos")
+            return resultado
+        return wrapper
+    
+    def create_service(self):
+        """
+            Cria um serviço para a plataforma Google especificada.
+
+            Args:
+                platform (str): O nome da plataforma Google para a qual o serviço será criado (por exemplo, 'drive', 'sheets').
+
+            Returns:
+                googleapiclient.discovery.Resource: Serviço do Google para a plataforma especificada.
+                bool: Retorna False se houver um erro ao criar o serviço.
+        """
+        try:
+            
+            cred = build(f"drive", f"{self.version}", credentials=self.__auth)
+            logging.debug(f"Serviço do Google drive criado")
+            return cred
+        except Exception as e:
+            logging.debug(f"Erro ao criar o serviço do Google drive: Error: {e}")
+            return False
+    
+    def __autentica(self, with_subject : str):
+        """
+            Autentica o serviço do Google utilizando um token e escopos fornecidos.
+
+            Args:
+                token (dict): As credenciais de autenticação.
+                scopes (list): A lista de escopos para o acesso aos serviços do Google.
+
+            Returns:
+                google.oauth2.service_account.Credentials: Objeto de credenciais autenticado.
+                bool: Retorna False em caso de erro.
+        """
+
+        try:
+            credentials = service_account.Credentials.from_service_account_info(self.__token, scopes=self.scopes)
+            delegated_credencial = credentials.with_subject(with_subject)
+            return delegated_credencial
+
+        except Exception as e:
+            logging.debug(f"Erro ao tentar autenticar. Verifique o erro: {e}")
+            return False
+
+    @timer_decorator
+    def upload(self, folder_id: str, name: str, file_path: str, mimetype: str):
+        """
+            Faz o upload de um arquivo para o Google Drive em uma pasta especificada.
+
+            Args:
+                folder_id (str): ID da pasta no Google Drive onde o arquivo será armazenado.
+                name (str): Nome do arquivo que será carregado.
+                file_path (str): Caminho completo do arquivo no sistema local.
+                mimetype (str): Tipo MIME do arquivo a ser carregado.
+
+            Returns:
+                dict: Informações sobre o arquivo carregado, incluindo o ID do arquivo.
+                None: Caso o caminho do arquivo não seja encontrado.
+        """
+        file_metadata = {"name": name, "parents": [folder_id]}
+        if not os.path.exists(file_path):
+            logging.debug(f"Pasta {file_path} não encontrada")           
+            return {"success" : False, "result" : None, "error" : "Diretório ou arquivo não encontrado"}
+        
+        try:
+            logging.debug(f"Realizando o upload do arquivo")
+            media = MediaFileUpload(file_path, mimetype=mimetype, resumable=True)
+            file = (
+                self.service.files()
+                .create(body=file_metadata, media_body=media, fields="id", supportsAllDrives=True)
+                .execute()
+            )
+
+            logging.debug(f"Upload realizado com sucesso")
+            return {"success" : True, "result" : file}
+        except Exception as e:
+            logging.debug(f"Erro ao realizar o upload do arquivo {name} no google drive. Erro: {e}")
+            return {"success" : False, "result" : None, "error" : str(e)}
+   
+    def create_folder(self, name: str, parent_folder_id: str):
+        """
+            Cria uma pasta no Google Drive dentro de uma pasta existente.
+
+            Args:
+                name (str): Nome da pasta a ser criada.
+                parent_folder_id (int): ID da pasta pai onde a nova pasta será criada.
+
+            Returns:
+                str: ID da pasta criada.
+        """
+        try:
+            CreateFolderValidator(name=name, parent_folder_id=parent_folder_id)
+        except ValidationError as e:
+            raise ValueError("Erro na validação dos dados de input da inicialização da instância:", e.errors())
+            
+        try:
+            folder_metadata = {
+                "name": name,
+                "parents": [parent_folder_id],
+                "mimeType": "application/vnd.google-apps.folder",
+            }
+            folder = (
+                self.service.files().create(body=folder_metadata, fields="id", supportsAllDrives=True).execute()
+            )
+            return {"success" : True, "result": folder}
+        except Exception as e:
+            logging.debug(f"Não foi possível criar a pasta {name}")
+            return {"success" : False, "result": None, "error" : str(e)}
+    
+    def list(self, query: str = "", spaces: str = "drive", fields: str = "nextPageToken, files(id, name)"):
+        """
+            Lista os arquivos e pastas no Google Drive com base nos critérios fornecidos.
+
+            Args:
+                query (str, optional): Critério de busca para os arquivos ou pastas no Google Drive. 
+                                    Consulte https://developers.google.com/drive/api/v3/ref-search-terms.
+                                    Defaults to "".
+                spaces (str, optional): Especifica os locais de armazenamento a serem consultados. Pode ser 'drive', 
+                                        'appDataFolder', ou 'photos'. Defaults to 'drive'.
+                fields (str, optional): Campos a serem retornados na resposta. Consulte a documentação para os campos disponíveis.
+                                        Defaults to "nextPageToken, files(id, name)".
+
+            Returns:
+                dict: Dicionário contendo o resultado da busca.
+        """
+        try:
+            ListFolderValidator(query=query, fields=fields, spaces=spaces)
+        except ValidationError as e:
+            raise ValueError("Erro na validação dos dados de input da lista:", e.errors())
+        try: 
+            results = (
+                self.service.files()
+                .list(q=query,
+                      spaces=spaces,
+                      pageSize=self.page_size,
+                      fields=fields,
+                      supportsAllDrives=True,
+                      includeItemsFromAllDrives=True)
+                .execute()
+            )
+            return {"success" : True, "result" : results}
+        except HttpError as hr:
+            logging.debug(f"Ocorreu um de http. Erro: {hr}")
+            return {"success" : False, "result" : None, "error" : str(hr)}
+    
+    @timer_decorator
+    def get_file(self, file : str, ):
+        """
+            Obtém o conteúdo de um arquivo armazenado no Google Drive.
+
+            Esta função acessa o Google Drive usando a API e lê os dados do arquivo especificado, retornando-os como um objeto binário de memória (`BytesIO`).
+
+            Parâmetros:
+                - file (str): Dicionário contendo informações do arquivo no Google Drive, incluindo as chaves:
+                    - `"name"`: Nome do arquivo.
+                    - `"id"`: ID do arquivo.
+
+            Retorna:
+                - BytesIO: Objeto em memória contendo os dados do arquivo.
+                - None: Caso ocorra um erro ao tentar abrir ou ler o arquivo.
+
+            Logs:
+                - Registra mensagens indicando o início e o término da leitura do arquivo.
+                - Em caso de falha, registra o erro ocorrido.
+
+            Exceções:
+                - Qualquer erro durante o processo será capturado e registrado no log. A função retornará `None` nesses casos.
+
+            Dependências:
+                - A função assume a existência de um atributo `self.service` configurado para interagir com a API do Google Drive.
+        """
+        try:
+            # file_metadata = self.service.files().get(fileId=file_id, fields="name, mimeType").execute()
+            logging.debug(f"Lendo o arquivo {file.get("name")}")
+            request = self.service.files().get_media(fileId=file.get("id"))
+            file_data = BytesIO(request.execute())
+            logging.debug("Leitura do arquivo finalizada")
+
+            return {"success" : True, "result" : file_data}
+    
+        except Exception as e:
+            logging.debug(f"Erro ao tentar abrir o arquivo. Erro {e}")
+            return {"success" : False, "result" : None}
+
+        
+

csc_cia_stne/logger_json.py

@@ -2,7 +2,49 @@ import logging
 from pythonjsonlogger import jsonlogger
 
 def setup_json_logger():
-    logger = logging.getLogger()
+    
+    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(__name__)
     logger.setLevel(logging.INFO)
 
     # Remove handlers anteriores, se houver

csc_cia_stne/logger_rich.py

@@ -120,21 +120,30 @@ def get_logger():
     install()
 
     # Definindo o nível de log baseado nas configurações
-    if os.getenv('log_level') is None:
+    if os.getenv('log_level') is None or os.getenv('log_level') == "DEBUG":
         
-        log_config_level = logging.DEBUG
-
-    elif os.getenv('log_level') == "DEBUG":
-
-        log_config_level = logging.DEBUG
+        log_config_level = logging.INFO
 
     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.WARNING  # ou outro nível padrão
+        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({
@@ -220,6 +229,6 @@ def get_logger():
 
     add_log_level("SUCCESS",21)
 
-    logger = logging.getLogger()
+    logger = logging.getLogger(__name__)
 
     return logger

csc_cia_stne/provio.py

@@ -0,0 +1,66 @@
+import logging
+import requests
+from requests.auth import HTTPBasicAuth
+from pydantic import BaseModel, Field, ValidationError
+
+# Validadores
+class ProvioModel(BaseModel):
+    username: str = Field(..., strip_whitespace=True, min_length=1)
+    password: str = Field(..., strip_whitespace=True, min_length=1)
+
+class ExportarRelatorioParams(BaseModel):
+    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")
+
+# Classe provio
+class Provio:
+    
+    def __init__(self,username:str,password:str):
+        
+        # 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):
+        
+        # Validação dos parâmetros
+        params = ExportarRelatorioParams(ano=ano, mes=mes)
+        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
+                    logging.info(f"Exportando relatório: Requisição #{str(requisicao).zfill(3)} - {len(todos_os_dados)} registros exportados")
+            
+                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)}