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

csc_cia_stne/utilitarios/functions/func_recriar_pastas.py

@@ -0,0 +1,29 @@
+import os
+import shutil
+
+def recriar_pasta(caminho_pasta):
+    """
+    Remove a pasta existente, se houver, e cria uma nova pasta no caminho especificado.
+    Args:
+        caminho_pasta (str): O caminho da pasta a ser recriada.
+    Returns:
+        tuple: Uma tupla contendo um valor booleano indicando se a operação foi bem-sucedida e uma mensagem de erro em caso de falha.
+    Examples:
+        >>> recriar_pasta('/caminho/para/pasta')
+        (True, None)
+    """
+
+    try:
+
+        # Se a pasta já existir, remove-a
+        if os.path.exists(caminho_pasta) and os.path.isdir(caminho_pasta):
+            shutil.rmtree(caminho_pasta)  # Deleta a pasta e todo o conteúdo
+
+        # Cria a pasta novamente
+        os.makedirs(caminho_pasta)
+        return True, None
+
+    except Exception as e:
+
+        return False, e
+

csc_cia_stne/utilitarios/functions/func_settings.py

@@ -0,0 +1,66 @@
+import yaml
+import os
+import sys
+
+
+def get_config(file_path:str="settings.yaml",file_path_local:str=None,prod:bool=False) -> dict:
+    """
+    Retorna as configurações carregadas a partir de um arquivo YAML.
+    Parâmetros:
+    - file_path (str): O caminho do arquivo YAML.
+    - file_path_local (str, opcional): O caminho local do arquivo YAML, caso exista.
+    - prod (bool, opcional): Indica se as configurações de produção devem ser carregadas.
+    Retorna:
+    - dict: Um dicionário contendo as configurações carregadas do arquivo YAML.
+    Lança:
+    - FileNotFoundError: Caso o arquivo especificado não seja encontrado.
+    - Exception: Caso ocorra algum erro ao carregar as configurações.
+    Exemplo de uso:
+    config = get_config('/path/to/config.yaml', prod=True)
+    """
+
+    # Essa validação serve apenas para que continue funcionando mesmo se for dentro de um executavel
+
+    file_path = os.path.join(os.getcwd(), file_path)
+
+    try:
+
+        base_path = sys._MEIPASS
+
+    except:
+
+        base_path = os.path.abspath(".")
+
+    if os.path.exists(file_path):
+
+        file_place = os.path.join(base_path, file_path)
+
+    elif file_path_local is not None:
+
+        file_path_local = os.path.join(os.getcwd(), file_path_local)
+
+        file_place = os.path.join(base_path, file_path_local)
+
+    else:
+
+        raise FileNotFoundError(f"Arquivo '{file_path}' não encontrado.")
+    
+    try:
+
+        with open(file_place, 'r', encoding='utf-8') as f:
+
+            config = yaml.safe_load(f)
+
+        if prod:
+
+            config['env'] = config['prod']
+
+        else:
+
+            config['env'] = config['prod']
+
+        return config
+
+    except Exception as e:
+
+        raise(e)

csc_cia_stne/utilitarios/functions/func_titulo.py

@@ -0,0 +1,141 @@
+import os
+from datetime import datetime
+from rich import print
+from rich.panel import Panel
+from rich.style import Style
+import logging
+from pydantic import BaseModel
+from pydantic import ValidationError, field_validator
+
+# Classe para validar - titulo
+class TituloSettings(BaseModel):
+    """
+    Classe que define as configurações do título do projeto.
+    Atributos:
+    - project_name (str): O nome do projeto.
+    - project_version (str): A versão do projeto.
+    - project_dev_name (str): O nome do desenvolvedor do projeto.
+    - project_dev_mail (str): O e-mail do desenvolvedor do projeto.
+    Métodos:
+    - check_non_empty_string(value, info): Método de validação para garantir que nenhum campo seja uma string vazia.
+    """
+    
+    # Titulo
+    project_name: str
+    project_version: str
+    project_dev_name: str
+    project_dev_mail: str
+    # Validador para garantir que nenhum campo seja uma string vazia
+    """
+    Método de validação para garantir que nenhum campo seja uma string vazia.
+    Parâmetros:
+    - value: O valor do campo a ser validado.
+    - info: Informações sobre o campo a ser validado.
+    Retorna:
+    - O valor do campo se for uma string não vazia.
+    Lança:
+    - ValueError: Se o valor do campo for uma string vazia.
+    Exemplo de uso:
+    ```
+    settings = TituloSettings()
+    settings.check_non_empty_string("GitHub Copilot", "project_name")
+    ```
+    """
+    @field_validator('project_name', 'project_version', 'project_dev_name', 'project_dev_mail')
+    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
+
+
+# Retorna data de modificação
+def last_modified()->datetime:
+    """
+    Retorna a data da última atualização do script
+
+    """
+    base_dir = os.path.abspath(os.getcwd())
+
+    newest_date = None
+
+    for root, _, files in os.walk(base_dir):
+        
+        for file in files:
+        
+            if file.endswith('.py'):
+        
+                file_path = os.path.join(root, file)
+                file_modification_date = os.path.getmtime(file_path)
+                
+                if newest_date is None or file_modification_date > newest_date:
+        
+                    newest_date = file_modification_date
+
+    # Converter o timestamp para um objeto datetime
+    last_modified_date = datetime.fromtimestamp(newest_date)
+    last_modified_date = last_modified_date.strftime("%Y%m%d")
+    
+    return last_modified_date
+
+def titulo(project_name:str,project_version:str,project_dev_name:str,project_dev_mail:str):
+    """
+    Gera um título formatado para exibição do projeto.
+    Args:
+        project_name (str): Nome do projeto.
+        project_version (str): Versão do projeto.
+        project_dev_name (str): Nome do desenvolvedor do projeto.
+        project_dev_mail (str): E-mail do desenvolvedor do projeto.
+    Raises:
+        ValueError: Caso alguma variável obrigatória esteja ausente no arquivo .env ou nas variáveis de ambiente da máquina.
+    Example:
+        >>> titulo("Meu Projeto", "1.0", "João", "joao@example.com")
+        [Exemplo de saída]
+    """
+
+    try:
+        settings = TituloSettings(project_name=project_name,project_version=project_version,project_dev_name=project_dev_name,project_dev_mail=project_dev_mail)
+        #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, impossibi: {missing_vars_str}"
+            )
+
+
+    if os.getenv('ambiente_de_execucao') is None or os.getenv('ambiente_de_execucao') != "karavela":
+
+        estilo_box = Style(bold=True)
+        print(
+            Panel(
+                f"""
+                    [bold chartreuse3]CIA [bold white]| [bold chartreuse3]Centro de Inteligência e Automação [bold white]([bold chartreuse3]cia@stone.com.br[bold white])[bold green]\n
+                    Projeto[bold white]: [bold green]{project_name}\n
+                    Versão[bold white]: [bold green]{project_version}\n
+                    Dev[bold white]: [bold green]{project_dev_name} [bold white]([bold green]{project_dev_mail}[bold white])[bold green]\n
+                    Última atualização[bold white]: [bold green]{last_modified()}
+                """, 
+                title="Stone", 
+                subtitle="CSC-CIA", 
+                style=estilo_box, 
+                border_style="bold chartreuse3"
+            )   
+        )
+
+    else:
+
+        logging.info("CSC | CIA - Centro de Inteligência e Automação")
+        logging.info(f"Projeto: {project_name}")
+        logging.info(f"\tVersão: {project_version} (Última modificação: {last_modified()})")
+        logging.info("\tTime: CIA <cia@stone.com.br>")
+        logging.info(f"\tDesenvolvedor: {project_dev_name} <{project_dev_mail}>")
+        logging.info("-")
+

csc_cia_stne/utilitarios/validations/GcpBigQueryValidator.py

@@ -0,0 +1,133 @@
+from pydantic import BaseModel, 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):
+    """
+    Classe de validação para o modelo tryInsertListValidator.
+    Atributos:
+    - insert_limit (int): Limite de inserção.
+    - list_to_insert (list): Lista a ser inserida.
+    - table (str): Nome da tabela.
+    Métodos:
+    - check_list_input(value, info): Valida se o valor fornecido para 'list_to_insert' é uma lista não vazia.
+    - check_str_input(value, info): Valida se o valor fornecido para 'table' é uma string não vazia.
+    - check_int_input(value, info): Valida se o valor fornecido para 'insert_limit' é um inteiro não maior que 10000.
+    """
+        
+    insert_limit:int
+    list_to_insert:list
+    table:str
+
+    """
+    Valida se o valor fornecido para 'list_to_insert' é uma lista não vazia.
+    Parâmetros:
+    - value: O valor a ser validado.
+    - info: Informações adicionais sobre o campo.
+    Retorna:
+    - O valor fornecido, se for uma lista não vazia.
+    Lança:
+    - ValueError: Se o valor não for uma lista ou estiver vazio.
+    """
+    @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
+    
+    """
+    Valida se o valor fornecido para 'table' é uma string não vazia.
+    Parâmetros:
+    - value: O valor a ser validado.
+    - info: Informações adicionais sobre o campo.
+    Retorna:
+    - O valor fornecido, se for uma string não vazia.
+    Lança:
+    - ValueError: Se o valor não for uma string ou estiver vazio.
+    """
+    @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
+    
+    """
+    Valida se o valor fornecido para 'insert_limit' é um inteiro não maior que 10000.
+    Parâmetros:
+    - value: O valor a ser validado.
+    - info: Informações adicionais sobre o campo.
+    Retorna:
+    - O valor fornecido, se for um inteiro não maior que 10000.
+    Lança:
+    - ValueError: Se o valor não for um inteiro ou for maior que 10000.
+    """
+    @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

csc_cia_stne/utilitarios/validations/GoogleDriveValidator.py

@@ -0,0 +1,144 @@
+
+from pydantic import BaseModel, field_validator, EmailStr
+
+class InitParamsValidator(BaseModel):
+    """
+    Classe responsável por validar os parâmetros de inicialização.
+    Atributos:
+    - key (str): A chave de autenticação.
+    - with_subject (str): O assunto da autenticação.
+    - scopes (list): A lista de escopos.
+    - version (str): A versão.
+    Métodos:
+    - check_str_input(cls, value, info): Valida se o valor é uma string não vazia.
+    - check_list_input(cls, value, info): Valida se o valor é uma lista.
+    """
+        
+    token: dict
+    with_subject: EmailStr
+    scopes : list
+    version : str
+
+    """
+    Valida se o valor é uma string não vazia.
+    Parâmetros:
+    - value (Any): O valor a ser validado.
+    - info (FieldInfo): Informações sobre o campo.
+    Retorna:
+    - value (Any): O valor validado.
+    Lança:
+    - ValueError: Se o valor não for uma string ou estiver vazio.
+    """
+    @field_validator("version")
+    def check_str_input(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O campo '{info.field_name}' deve ser strings e não {type(value)}")
+        return value
+    
+    @field_validator('token')
+    def check_dict_input(cls, value, info):
+        if not isinstance(value, dict):
+            raise ValueError(f"O campo '{info.field_name}' deve ser um dicionário e não {type(value)}")
+        return value
+
+    """
+    Valida se o valor é uma lista.
+    Parâmetros:
+    - value (Any): O valor a ser validado.
+    - info (FieldInfo): Informações sobre o campo.
+    Retorna:
+    - value (Any): O valor validado.
+    Lança:
+    - ValueError: Se o valor não for uma lista.
+    """
+    @field_validator('scopes')
+    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 CreateFolderValidator(BaseModel):
+    """
+    Validação para a criação de uma pasta no Google Drive.
+    Atributos:
+    - name (str): O nome da pasta a ser criada.
+    - parent_folder_id (str): O ID da pasta pai onde a nova pasta será criada.
+    Métodos:
+    - check_str_input(value, info): Valida se o valor fornecido é uma string não vazia.
+    """
+    name: str
+    parent_folder_id: str
+
+    """
+    Valida se o valor fornecido é uma string não vazia.
+    Parâmetros:
+    - value: O valor a ser validado.
+    - info: Informações sobre o campo sendo validado.
+    Retorna:
+    - O valor fornecido, se for uma string não vazia.
+    Lança:
+    - ValueError: Se o valor não for uma string ou for uma string vazia.
+    """
+    @field_validator('name','parent_folder_id')
+    def check_str_input(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O campo '{info.field_name}' deve ser strings e não {type(value)}")
+        return value
+
+class ListFolderValidator(BaseModel):
+    """
+    Validação para a classe ListFolderValidator.
+
+    Atributos:
+    - query (str): A consulta a ser realizada.
+    - spaces (str): Os espaços a serem considerados.
+    - fields (str): Os campos a serem retornados.
+
+    Métodos:
+    - check_str_input(cls, value, info): Valida se o valor fornecido é uma string não vazia.
+
+    """
+
+    query: str
+    fields: str
+    spaces: str
+
+    """
+    Valida se o valor fornecido é uma string não vazia.
+
+    Parâmetros:
+    - value (Any): O valor a ser validado.
+    - info (FieldInfo): Informações sobre o campo.
+
+    Retorna:
+    - value (Any): O valor validado.
+
+    Lança:
+    - ValueError: Se o valor não for uma string ou for uma string vazia.
+
+    """
+    @field_validator('query','spaces','fields')
+    def check_str_input(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O campo '{info.field_name}' deve ser strings e não {type(value)}")
+        return value
+    
+class UploadValidator(BaseModel):
+    """
+    Validador para upload de arquivo no Google Drive.
+
+    Atributos:
+    - file_path (str): Caminho do arquivo a ser enviado.
+
+    """
+    folder_id: str
+    name: str
+    file_path: str
+    mimetype: str
+
+    @field_validator('folder_id','name','file_path', 'mimetype')
+    def check_str_input(cls, value, info):
+        if not isinstance(value, str) or not value.strip():
+            raise ValueError(f"O campo '{info.field_name}' deve ser strings e não {type(value)}")
+        return value