nia-etl-utils 0.1.0__py3-none-any.whl

nia_etl_utils/__init__.py

@@ -0,0 +1,126 @@
+"""Utilitários compartilhados para pipelines ETL do NIA/MPRJ.
+
+Este pacote fornece funções reutilizáveis para:
+- Configuração de ambiente (env_config)
+- Envio de emails via SMTP (email_smtp)
+- Conexões com bancos de dados Oracle e PostgreSQL (database)
+- Configuração de logging padronizado (logger_config)
+- Processamento e exportação de CSV (processa_csv)
+- Manipulação de arquivos e diretórios (limpeza_pastas)
+
+Exemplo de uso:
+    from nia_etl_utils import obter_variavel_env, configurar_logger_padrao_nia
+    from nia_etl_utils import conectar_postgresql_nia, exportar_para_csv
+
+    # Configuração
+    configurar_logger_padrao_nia("meu_pipeline")
+    db_host = obter_variavel_env('DB_POSTGRESQL_HOST')
+
+    # Conexão e processamento
+    cur, conn = conectar_postgresql_nia()
+    # ... processar dados ...
+    exportar_para_csv(df, "resultado", "2025_01_19", "/dados")
+"""
+
+__version__ = "0.1.0"
+__author__ = "Nícolas Galdino Esmael"
+
+# ============================================================================
+# IMPORTS PRINCIPAIS - Funções mais usadas exportadas diretamente
+# ============================================================================
+
+# Configuração de ambiente
+from .env_config import obter_variavel_env
+
+# Email
+from .email_smtp import enviar_email_smtp, obter_destinatarios_padrao
+
+# Database - PostgreSQL
+from .database import (
+    conectar_postgresql,
+    conectar_postgresql_nia,
+    conectar_postgresql_opengeo,
+    obter_engine_postgresql,
+    obter_engine_postgresql_nia,
+    obter_engine_postgresql_opengeo,
+)
+
+# Database - Oracle
+from .database import (
+    conectar_oracle,
+    conectar_oracle_ouvidorias,
+    fechar_conexao,
+)
+
+# Logging
+from .logger_config import (
+    configurar_logger,
+    configurar_logger_padrao_nia,
+    remover_handlers_existentes,
+)
+
+# Processamento CSV
+from .processa_csv import (
+    exportar_para_csv,
+    extrair_e_exportar_csv,
+    exportar_multiplos_csv,
+)
+
+# Processamento CSV Paralelo
+from .processa_csv_paralelo import (
+    processar_csv_paralelo,
+    calcular_chunksize,
+)
+
+# Manipulação de arquivos
+from .limpeza_pastas import (
+    limpar_pasta,
+    remover_pasta_recursivamente,
+    criar_pasta_se_nao_existir,
+)
+
+
+__all__ = [
+    # Metadata
+    "__version__",
+    "__author__",
+
+    # Env config
+    "obter_variavel_env",
+
+    # Email
+    "enviar_email_smtp",
+    "obter_destinatarios_padrao",
+
+    # Database - PostgreSQL
+    "conectar_postgresql",
+    "conectar_postgresql_nia",
+    "conectar_postgresql_opengeo",
+    "obter_engine_postgresql",
+    "obter_engine_postgresql_nia",
+    "obter_engine_postgresql_opengeo",
+
+    # Database - Oracle
+    "conectar_oracle",
+    "conectar_oracle_ouvidorias",
+    "fechar_conexao",
+
+    # Logging
+    "configurar_logger",
+    "configurar_logger_padrao_nia",
+    "remover_handlers_existentes",
+
+    # CSV
+    "exportar_para_csv",
+    "extrair_e_exportar_csv",
+    "exportar_multiplos_csv",
+
+    # CSV Paralelo
+    "processar_csv_paralelo",
+    "calcular_chunksize",
+
+    # Arquivos
+    "limpar_pasta",
+    "remover_pasta_recursivamente",
+    "criar_pasta_se_nao_existir",
+]

nia_etl_utils/database.py

@@ -0,0 +1,246 @@
+"""Módulo de conexão com bancos de dados PostgreSQL e Oracle.
+
+Fornece funções genéricas e wrappers de conveniência para estabelecer conexões
+com diferentes bancos de dados usando credenciais de variáveis de ambiente.
+"""
+import sys
+import cx_Oracle
+import psycopg2
+from loguru import logger
+from psycopg2 import Error, OperationalError
+from sqlalchemy import create_engine
+from sqlalchemy.engine import Engine
+
+from .env_config import obter_variavel_env
+
+
+def conectar_postgresql(sufixo_env: str = "") -> tuple:
+    """Estabelece conexão genérica com banco de dados PostgreSQL usando psycopg2.
+
+    Args:
+        sufixo_env: Sufixo das variáveis de ambiente para conexão.
+                   Vazio ("") para banco padrão (DB_POSTGRESQL_*).
+                   "_OPENGEO" para OpenGeo (DB_POSTGRESQL_HOST_OPENGEO, etc).
+
+    Returns:
+        tuple: (cursor, connection) — cursor e objeto de conexão ativa.
+
+    Raises:
+        SystemExit: Se houver erro ao estabelecer a conexão.
+
+    Examples:
+        >>> # Conecta usando variáveis DB_POSTGRESQL_HOST, DB_POSTGRESQL_PORT, etc
+        >>> cur, conn = conectar_postgresql()
+        >>> cur.execute("SELECT * FROM tabela")
+        >>> resultados = cur.fetchall()
+        >>> cur.close()
+        >>> conn.close()
+
+        >>> # Conecta em OpenGeo usando DB_POSTGRESQL_HOST_OPENGEO, etc
+        >>> cur, conn = conectar_postgresql("_OPENGEO")
+    """
+    try:
+        host = obter_variavel_env(f"DB_POSTGRESQL_HOST{sufixo_env}")
+        port = obter_variavel_env(f"DB_POSTGRESQL_PORT{sufixo_env}")
+        database = obter_variavel_env(f"DB_POSTGRESQL_DATABASE{sufixo_env}")
+        user = obter_variavel_env(f"DB_POSTGRESQL_USER{sufixo_env}")
+        password = obter_variavel_env(f"DB_POSTGRESQL_PASSWORD{sufixo_env}")
+
+        logger.info(f"Iniciando conexão PostgreSQL em {host}:{port}, database '{database}'...")
+
+        connection = psycopg2.connect(
+            host=host,
+            port=port,
+            database=database,
+            user=user,
+            password=password
+        )
+        cursor = connection.cursor()
+
+        logger.success(f"Conexão PostgreSQL estabelecida: '{database}' em '{host}:{port}'")
+        return cursor, connection
+
+    except OperationalError as error:
+        logger.error(f"Erro operacional PostgreSQL (sufixo: '{sufixo_env}'): {error}")
+        sys.exit(1)
+    except Error as error:
+        logger.error(f"Erro PostgreSQL (sufixo: '{sufixo_env}'): {error}")
+        sys.exit(1)
+    except Exception as error:
+        logger.error(f"Erro inesperado PostgreSQL (sufixo: '{sufixo_env}'): {error}")
+        sys.exit(1)
+
+
+def obter_engine_postgresql(sufixo_env: str = "") -> Engine:
+    """Cria uma engine SQLAlchemy genérica para PostgreSQL.
+
+    Args:
+        sufixo_env: Sufixo das variáveis de ambiente para conexão.
+                   Vazio ("") para banco padrão, "_OPENGEO" para OpenGeo.
+
+    Returns:
+        Engine configurada para PostgreSQL.
+
+    Raises:
+        SystemExit: Se houver erro na criação da conexão.
+
+    Examples:
+        >>> import pandas as pd
+        >>> engine = obter_engine_postgresql()
+        >>> df = pd.read_sql("SELECT * FROM tabela", engine)
+
+        >>> # Engine para OpenGeo
+        >>> engine = obter_engine_postgresql("_OPENGEO")
+    """
+    try:
+        host = obter_variavel_env(f"DB_POSTGRESQL_HOST{sufixo_env}")
+        port = obter_variavel_env(f"DB_POSTGRESQL_PORT{sufixo_env}")
+        database = obter_variavel_env(f"DB_POSTGRESQL_DATABASE{sufixo_env}")
+        user = obter_variavel_env(f"DB_POSTGRESQL_USER{sufixo_env}")
+        password = obter_variavel_env(f"DB_POSTGRESQL_PASSWORD{sufixo_env}")
+
+        connection_string = f"postgresql+psycopg2://{user}:{password}@{host}:{port}/{database}"
+        engine = create_engine(connection_string)
+
+        # Testa a conexão
+        with engine.connect() as conn:
+            conn.execute("SELECT 1") # type: ignore
+
+        logger.success(f"Engine PostgreSQL criada: '{database}' em '{host}:{port}'")
+        return engine
+
+    except OperationalError as error:
+        logger.error(f"Erro operacional ao criar engine PostgreSQL (sufixo: '{sufixo_env}'): {error}")
+        sys.exit(1)
+    except Exception as error:
+        logger.error(f"Erro inesperado ao criar engine PostgreSQL (sufixo: '{sufixo_env}'): {error}")
+        sys.exit(1)
+
+
+def conectar_oracle() -> tuple:
+    """Estabelece conexão com banco de dados Oracle.
+
+    Usa variáveis de ambiente: DB_ORACLE_HOST, DB_ORACLE_PORT, DB_ORACLE_SERVICE_NAME,
+    DB_ORACLE_USER, DB_ORACLE_PASSWORD.
+
+    Returns:
+        tuple: (cursor, connection) — cursor e objeto de conexão ativa.
+
+    Raises:
+        SystemExit: Se houver erro ao estabelecer a conexão.
+
+    Examples:
+        >>> cur, conn = conectar_oracle()
+        >>> cur.execute("SELECT * FROM tabela WHERE ROWNUM <= 10")
+        >>> resultados = cur.fetchall()
+        >>> fechar_conexao(cur, conn)
+    """
+    try:
+        host = obter_variavel_env("DB_ORACLE_HOST")
+        port = obter_variavel_env("DB_ORACLE_PORT")
+        service_name = obter_variavel_env("DB_ORACLE_SERVICE_NAME")
+        user = obter_variavel_env("DB_ORACLE_USER")
+        password = obter_variavel_env("DB_ORACLE_PASSWORD")
+
+        logger.info(f"Iniciando conexão Oracle em {host}:{port}, service '{service_name}'...")
+
+        dsn = cx_Oracle.makedsn(host, port, service_name=service_name)
+        connection = cx_Oracle.connect(user=user, password=password, dsn=dsn)
+        cursor = connection.cursor()
+
+        logger.success(f"Conexão Oracle estabelecida: '{service_name}' em '{host}:{port}'")
+        return cursor, connection
+
+    except cx_Oracle.DatabaseError as error:
+        logger.error(f"Erro de banco Oracle: {error}")
+        sys.exit(1)
+    except cx_Oracle.InterfaceError as error:
+        logger.error(f"Erro de interface Oracle: {error}")
+        sys.exit(1)
+    except Exception as error:
+        logger.error(f"Erro inesperado Oracle: {error}")
+        sys.exit(1)
+
+
+def fechar_conexao(cursor, connection) -> None:
+    """Encerra cursor e conexão de banco de dados de forma segura.
+
+    Funciona para conexões PostgreSQL (psycopg2) e Oracle (cx_Oracle).
+
+    Args:
+        cursor: Cursor ativo que será fechado.
+        connection: Conexão ativa que será encerrada.
+
+    Examples:
+        >>> cur, conn = conectar_postgresql()
+        >>> # ... usar cursor ...
+        >>> fechar_conexao(cur, conn)
+    """
+    try:
+        if cursor:
+            cursor.close()
+            logger.debug("Cursor fechado com sucesso.")
+
+        if connection:
+            connection.close()
+            logger.debug("Conexão encerrada com sucesso.")
+
+    except Exception as error:
+        logger.warning(f"Erro ao fechar conexão: {error}")
+        # Não usa sys.exit(1) porque fechar conexão é cleanup
+
+
+# =============================================================================
+# WRAPPERS DE CONVENIÊNCIA - APIs específicas para bancos conhecidos
+# =============================================================================
+
+def conectar_postgresql_nia() -> tuple:
+    """Conecta no PostgreSQL do NIA.
+
+    Usa variáveis de ambiente: DB_POSTGRESQL_HOST, DB_POSTGRESQL_PORT, etc.
+
+    Returns:
+        tuple: (cursor, connection)
+    """
+    return conectar_postgresql("")
+
+
+def obter_engine_postgresql_nia() -> Engine:
+    """Cria engine SQLAlchemy para PostgreSQL do NIA.
+
+    Returns:
+        Engine configurada para o banco NIA.
+    """
+    return obter_engine_postgresql("")
+
+
+def conectar_postgresql_opengeo() -> tuple:
+    """Conecta no PostgreSQL OpenGeo.
+
+    Usa variáveis de ambiente: DB_POSTGRESQL_HOST_OPENGEO, DB_POSTGRESQL_PORT_OPENGEO, etc.
+
+    Returns:
+        tuple: (cursor, connection)
+    """
+    return conectar_postgresql("_OPENGEO")
+
+
+def obter_engine_postgresql_opengeo() -> Engine:
+    """Cria engine SQLAlchemy para PostgreSQL OpenGeo.
+
+    Returns:
+        Engine configurada para o banco OpenGeo.
+    """
+    return obter_engine_postgresql("_OPENGEO")
+
+
+def conectar_oracle_ouvidorias() -> tuple:
+    """Conecta no Oracle de Ouvidorias.
+
+    Alias para conectar_oracle() — mantido para compatibilidade semântica.
+    Usa variáveis de ambiente: DB_ORACLE_HOST, DB_ORACLE_PORT, etc.
+
+    Returns:
+        tuple: (cursor, connection)
+    """
+    return conectar_oracle()

nia_etl_utils/email_smtp.py

@@ -0,0 +1,126 @@
+"""Módulo responsável por enviar e-mails com ou sem anexo via SMTP."""
+import os
+import smtplib
+import sys
+from email import encoders
+from email.mime.base import MIMEBase
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from loguru import logger
+
+from .env_config import obter_variavel_env
+
+
+def obter_destinatarios_padrao() -> list[str]:
+    """Obtém lista de destinatários da variável de ambiente EMAIL_DESTINATARIOS.
+
+    Returns:
+        Lista de emails extraída da env var.
+
+    Raises:
+        SystemExit: Se EMAIL_DESTINATARIOS estiver vazia ou contiver apenas valores inválidos.
+    """
+    destinatarios_str = obter_variavel_env("EMAIL_DESTINATARIOS").strip()
+    destinatarios = [email.strip() for email in destinatarios_str.split(',') if email.strip()]
+
+    if not destinatarios:
+        logger.error(
+            "EMAIL_DESTINATARIOS está vazia ou contém apenas valores inválidos. "
+            "Configure a variável com destinatários separados por vírgula."
+        )
+        sys.exit(1)
+
+    return destinatarios
+
+
+def enviar_email_smtp(
+    corpo_do_email: str,
+    assunto: str,
+    destinatarios: list[str] | None = None,
+    anexo: str | None = None
+) -> None:
+    """Envia um e-mail com ou sem anexo via SMTP.
+
+    Args:
+        corpo_do_email: Texto que será enviado no corpo do e-mail.
+        assunto: Assunto da mensagem.
+        destinatarios: Lista de endereços de e-mail. Se None, usa EMAIL_DESTINATARIOS da env var.
+        anexo: Caminho para arquivo anexo. Defaults to None.
+
+    Raises:
+        SystemExit: Se destinatários não forem fornecidos e EMAIL_DESTINATARIOS não existir,
+                   ou se ocorrer qualquer erro durante o envio do email.
+
+    Examples:
+        >>> # Uso padrão (destinatários da env var)
+        >>> enviar_email_smtp(
+        ...     corpo_do_email="Pipeline concluído",
+        ...     assunto="[PROD] ETL Finalizado"
+        ... )
+
+        >>> # Com destinatários específicos
+        >>> enviar_email_smtp(
+        ...     corpo_do_email="Relatório executivo",
+        ...     assunto="Relatório Mensal",
+        ...     destinatarios=["diretor@mprj.mp.br"],
+        ...     anexo="/tmp/relatorio.pdf"
+        ... )
+    """
+    if destinatarios is None:
+        destinatarios = obter_destinatarios_padrao()
+
+    if not destinatarios:
+        logger.error("Nenhum destinatário fornecido. E-mail não pode ser enviado.")
+        sys.exit(1)
+
+    try:
+        email_msg = MIMEMultipart()
+        email_msg['From'] = obter_variavel_env('MAIL_SENDER')
+        email_msg['To'] = ", ".join(destinatarios)
+        email_msg['Cc'] = 'gadg.etl@mprj.mp.br'
+        email_msg['Subject'] = assunto
+
+        corpo_da_mensagem = MIMEText(corpo_do_email, 'plain')
+        email_msg.attach(corpo_da_mensagem)
+
+        if anexo:
+            attachment = MIMEBase('application', 'octet-stream')
+            with open(anexo, 'rb') as attachment_file:
+                attachment.set_payload(attachment_file.read())
+            encoders.encode_base64(attachment)
+            attachment.add_header(
+                'Content-Disposition',
+                f'attachment; filename={os.path.basename(anexo)}'
+            )
+            email_msg.attach(attachment)
+
+        logger.info("Iniciando conexão com o servidor SMTP...")
+        with smtplib.SMTP(
+            obter_variavel_env('MAIL_SMTP_SERVER'),
+            int(obter_variavel_env('MAIL_SMTP_PORT'))
+        ) as server:
+            server.sendmail(
+                obter_variavel_env('MAIL_SENDER'),
+                destinatarios,
+                email_msg.as_string()
+            )
+            logger.info(f"E-mail enviado com sucesso para {destinatarios}")
+
+    except smtplib.SMTPRecipientsRefused as error:
+        logger.error(f"Destinatários recusaram o e-mail: {error}")
+        sys.exit(1)
+    except smtplib.SMTPDataError as error:
+        logger.error(f"Erro durante a transferência de dados: {error}")
+        sys.exit(1)
+    except smtplib.SMTPException as error:
+        logger.error(f"Erro ao enviar o e-mail: {error}")
+        sys.exit(1)
+    except ConnectionError as error:
+        logger.error(f"Erro de conexão com servidor SMTP: {error}")
+        sys.exit(1)
+    except FileNotFoundError as error:
+        logger.error(f"Arquivo de anexo não encontrado: {error}")
+        sys.exit(1)
+    except Exception as error:
+        logger.error(f"Erro inesperado ao enviar e-mail: {error}")
+        sys.exit(1)

nia_etl_utils/env_config.py

@@ -0,0 +1,43 @@
+"""Módulo utilitário para buscar variáveis de ambiente com suporte a valor padrão e log de erro."""
+import os
+import sys
+from dotenv import load_dotenv
+from loguru import logger
+
+load_dotenv()
+
+
+def obter_variavel_env(nome_env: str, default=None):
+    """Retorna o valor de uma variável de ambiente, com fallback opcional.
+
+    Se a variável não existir e nenhum valor padrão for fornecido, o processo
+    é encerrado com código de saída 1 (falha), garantindo que pipelines no
+    Airflow detectem o erro corretamente.
+
+    Args:
+        nome_env: Nome da variável de ambiente a ser buscada.
+        default: Valor a ser retornado caso a variável não esteja definida. Defaults to None.
+
+    Returns:
+        str: Valor da variável de ambiente ou valor padrão.
+
+    Raises:
+        SystemExit: Se a variável não for encontrada e nenhum valor padrão for fornecido.
+
+    Examples:
+        >>> # Variável obrigatória (falha se não existir)
+        >>> db_host = obter_variavel_env('DB_HOST')
+
+        >>> # Variável opcional com fallback
+        >>> porta = obter_variavel_env('DB_PORT', default='5432')
+    """
+    value = os.getenv(nome_env, default)
+
+    if value is None:
+        logger.error(
+            f"Variável de ambiente '{nome_env}' não encontrada e nenhum valor padrão foi fornecido. "
+            f"Configure esta variável antes de executar o script."
+        )
+        sys.exit(1)
+
+    return value

nia_etl_utils/limpeza_pastas.py

@@ -0,0 +1,137 @@
+"""Funções utilitárias para manipulação de arquivos e diretórios."""
+import sys
+import shutil
+from pathlib import Path
+from loguru import logger
+
+
+def limpar_pasta(pasta: str, log: bool = True) -> None:
+    """Remove todos os arquivos de uma pasta, recriando-a se necessário.
+
+    Se a pasta não existir, ela será criada. Se existir, todos os arquivos
+    dentro dela serão removidos (subdiretórios são preservados).
+
+    Args:
+        pasta: Caminho da pasta que será limpa.
+        log: Se True, emite logs com Loguru. Defaults to True.
+
+    Raises:
+        SystemExit: Se houver erro ao criar ou limpar a pasta.
+
+    Examples:
+        >>> from nia_etl_utils.limpeza_pastas import limpar_pasta
+        >>> limpar_pasta("/tmp/meu_pipeline")
+        >>> # Pasta criada ou limpa com sucesso
+    """
+    try:
+        pasta_path = Path(pasta)
+
+        if not pasta_path.exists():
+            pasta_path.mkdir(parents=True, exist_ok=True)
+            if log:
+                logger.info(f"Pasta criada: {pasta}")
+        else:
+            arquivos_removidos = 0
+
+            for item in pasta_path.iterdir():
+                if item.is_file():
+                    item.unlink()
+                    arquivos_removidos += 1
+                    if log:
+                        logger.debug(f"Arquivo removido: {item}")
+
+            if log:
+                logger.info(f"Pasta '{pasta}' limpa com sucesso. {arquivos_removidos} arquivo(s) removido(s).")
+
+    except PermissionError as error:
+        logger.error(f"Sem permissão para acessar/modificar a pasta '{pasta}': {error}")
+        sys.exit(1)
+    except OSError as error:
+        logger.error(f"Erro do sistema ao manipular a pasta '{pasta}': {error}")
+        sys.exit(1)
+    except Exception as error:
+        logger.error(f"Erro inesperado ao limpar a pasta '{pasta}': {error}")
+        sys.exit(1)
+
+
+def remover_pasta_recursivamente(pasta: str, log: bool = True) -> None:
+    """Remove uma pasta e todo seu conteúdo (arquivos e subpastas).
+
+    ATENÇÃO: Esta função remove TUDO dentro da pasta, incluindo subdiretórios.
+    Use com cautela.
+
+    Args:
+        pasta: Caminho da pasta que será removida completamente.
+        log: Se True, emite logs com Loguru. Defaults to True.
+
+    Raises:
+        SystemExit: Se houver erro ao remover a pasta.
+
+    Examples:
+        >>> from nia_etl_utils.limpeza_pastas import remover_pasta_recursivamente
+        >>> remover_pasta_recursivamente("/tmp/pasta_temporaria")
+    """
+    try:
+        pasta_path = Path(pasta)
+
+        if not pasta_path.exists():
+            if log:
+                logger.warning(f"Pasta '{pasta}' não existe. Nada a remover.")
+            return
+
+        if not pasta_path.is_dir():
+            logger.error(f"'{pasta}' não é um diretório.")
+            sys.exit(1)
+
+        shutil.rmtree(pasta_path)
+
+        if log:
+            logger.info(f"Pasta '{pasta}' removida completamente (incluindo subpastas).")
+
+    except PermissionError as error:
+        logger.error(f"Sem permissão para remover a pasta '{pasta}': {error}")
+        sys.exit(1)
+    except OSError as error:
+        logger.error(f"Erro do sistema ao remover a pasta '{pasta}': {error}")
+        sys.exit(1)
+    except Exception as error:
+        logger.error(f"Erro inesperado ao remover a pasta '{pasta}': {error}")
+        sys.exit(1)
+
+
+def criar_pasta_se_nao_existir(pasta: str, log: bool = True) -> None:
+    """Cria uma pasta se ela não existir (incluindo pastas pai).
+
+    Args:
+        pasta: Caminho da pasta que será criada.
+        log: Se True, emite logs com Loguru. Defaults to True.
+
+    Raises:
+        SystemExit: Se houver erro ao criar a pasta.
+
+    Examples:
+        >>> from nia_etl_utils.limpeza_pastas import criar_pasta_se_nao_existir
+        >>> criar_pasta_se_nao_existir("/tmp/dados/processados/2025")
+    """
+    try:
+        pasta_path = Path(pasta)
+
+        if pasta_path.exists():
+            if log:
+                logger.debug(f"Pasta '{pasta}' já existe.")
+            return
+
+        pasta_path.mkdir(parents=True, exist_ok=True)
+
+        if log:
+            logger.info(f"Pasta criada: {pasta}")
+
+    except PermissionError as error:
+        logger.error(f"Sem permissão para criar a pasta '{pasta}': {error}")
+        sys.exit(1)
+    except OSError as error:
+        logger.error(f"Erro do sistema ao criar a pasta '{pasta}': {error}")
+        sys.exit(1)
+    except Exception as error:
+        logger.error(f"Erro inesperado ao criar a pasta '{pasta}': {error}")
+        sys.exit(1)