ChatGPT - Template Avançado Python para Scripts com Banco de Dados e Logs

---

@CanalQb no YouTube

---

✅ Prompt Genérico Aprimorado para Criação de Scripts em Python

---

Sempre crie uma frase de segurança única para jogos, testnets ou airdrops e evite usar sua carteira principal.

---

Este modelo de script foi desenvolvido para facilitar a criação de aplicações Python com suporte a banco de dados local ou remoto, registro de progresso em caso de falha, exportação de resultados e tratamento robusto de erros. Ideal para tarefas automatizadas, ETLs simples ou consultas técnicas com grande volume de dados.

🎯 Objetivo do Script

Criar um script limpo, resiliente, legível e de fácil manutenção, com suporte completo para SQLite, PostgreSQL e MySQL.

⚙️ Funcionalidades Principais

1. Acesso a banco de dados (online ou offline): Suporte para SQLite, PostgreSQL e MySQL, com entrada interativa para credenciais e caminhos.
2. Recuperação de progresso: Salva o ponto de parada em arquivo JSON legível para retomar após falhas ou encerramento manual.
3. Exportação de dados: Geração de arquivos CSV ou TXT com base em entrada do usuário. Nome do arquivo dinâmico com base no nome do script e assunto escolhido.
4. Mínimo de dependências: Utiliza módulos da biblioteca padrão sempre que possível. Para bancos remotos, é necessário instalar psycopg2-binary e mysql-connector-python.
5. Precisão numérica: Usa o módulo decimal.Decimal para trabalhar com números grandes com alta precisão.
6. Tratamento robusto de erros: Geração automática de log com linha exata, tipo e mensagem de erro, além do contexto do código.
7. Boas práticas: Código organizado por funções, com comentários explicativos e suporte a execução parcial.

💡 Extras Incluídos

• Modo silencioso vs interativo
• Validação de arquivos antes da execução
• Validação de dados antes da exportação
• Suporte a múltiplos bancos de dados

📦 Dependências para Bancos Online

Para utilizar com bancos PostgreSQL ou MySQL, instale os módulos:

pip install psycopg2-binary mysql-connector-python

📁 Estrutura de Arquivos Gerados

• nome_do_script_error_log.txt: logs de erros
• nome_do_script_progress.txt: progresso da execução
• nome_do_script_assunto.csv ou .txt: exportação de resultados

🔧 Script Python Base

O código abaixo representa o template completo com suporte a SQLite, PostgreSQL e MySQL, exportação, e salvamento de progresso:

import os
import sys
import json
import csv
import logging
import traceback
from decimal import Decimal, getcontext

# Conexões dinâmicas
try:
    import sqlite3
except ImportError:
    sqlite3 = None

try:
    import psycopg2
except ImportError:
    psycopg2 = None

try:
    import mysql.connector
except ImportError:
    mysql = None

SCRIPT_NAME = os.path.splitext(os.path.basename(__file__))[0]
LOG_FILE = f"{SCRIPT_NAME}_error_log.txt"
PROGRESS_FILE = f"{SCRIPT_NAME}_progress.txt"

getcontext().prec = 100

logging.basicConfig(filename=LOG_FILE, level=logging.ERROR, format='%(asctime)s - %(levelname)s - %(message)s')

def log_error():
    exc_type, exc_value, exc_traceback = sys.exc_info()
    tb_lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
    context_line = traceback.extract_tb(exc_traceback)[-1]
    logging.error("Erro na linha %s: %s\nContexto: %s\nTraceback:\n%s",
                  context_line.lineno,
                  exc_value,
                  context_line.line,
                  "".join(tb_lines))

def solicitar_dados_banco():
    print("\n=== Configuração do banco de dados ===")
    tipo = input("Tipo de banco (sqlite/postgres/mysql): ").strip().lower()

    if tipo == "sqlite":
        caminho = input("Caminho do arquivo .db: ").strip()
        return tipo, {'path': caminho}

    host = input("Host: ").strip()
    porta = input("Porta: ").strip()
    usuario = input("Usuário: ").strip()
    senha = input("Senha: ").strip()
    db = input("Nome do banco: ").strip()

    return tipo, {
        'host': host,
        'port': int(porta),
        'user': usuario,
        'password': senha,
        'database': db
    }

def conectar_banco(tipo, dados):
    if tipo == "sqlite":
        if sqlite3 is None:
            raise ImportError("sqlite3 não está disponível neste ambiente.")
        return sqlite3.connect(dados['path'])

    elif tipo == "postgres":
        if psycopg2 is None:
            raise ImportError("psycopg2 não está instalado. Use 'pip install psycopg2-binary'")
        return psycopg2.connect(
            host=dados['host'],
            port=dados['port'],
            user=dados['user'],
            password=dados['password'],
            dbname=dados['database']
        )

    elif tipo == "mysql":
        if mysql is None:
            raise ImportError("mysql-connector-python não está instalado. Use 'pip install mysql-connector-python'")
        return mysql.connector.connect(
            host=dados['host'],
            port=dados['port'],
            user=dados['user'],
            password=dados['password'],
            database=dados['database']
        )

    else:
        raise ValueError("Tipo de banco de dados não suportado.")

def salvar_progresso(dados):
    with open(PROGRESS_FILE, 'w', encoding='utf-8') as f:
        json.dump(dados, f, indent=4)

def carregar_progresso():
    if os.path.exists(PROGRESS_FILE):
        with open(PROGRESS_FILE, 'r', encoding='utf-8') as f:
            return json.load(f)
    return {}

def criar_arquivo_exportacao(dados, assunto, formato='csv'):
    nome_arquivo = f"{SCRIPT_NAME}_{assunto}.{formato}"
    if formato == 'csv':
        with open(nome_arquivo, 'w', newline='', encoding='utf-8') as f:
            writer = csv.DictWriter(f, fieldnames=dados[0].keys())
            writer.writeheader()
            writer.writerows(dados)
    elif formato == 'txt':
        with open(nome_arquivo, 'w', encoding='utf-8') as f:
            for linha in dados:
                f.write(json.dumps(linha, ensure_ascii=False) + '\n')
    print(f"Arquivo exportado: {nome_arquivo}")

def main():
    try:
        tipo_banco, dados_banco = solicitar_dados_banco()
        conn = conectar_banco(tipo_banco, dados_banco)
        cursor = conn.cursor()

        progresso = carregar_progresso()
        ponto = progresso.get('ultimo_id', 0)
        print(f"Retomando do ponto: {ponto}")

        if tipo_banco == "sqlite":
            sql = "SELECT id, valor FROM tabela_exemplo WHERE id > ? ORDER BY id ASC"
            cursor.execute(sql, (ponto,))
        else:
            sql = "SELECT id, valor FROM tabela_exemplo WHERE id > %s ORDER BY id ASC"
            cursor.execute(sql, (ponto,))

        resultados = cursor.fetchall()
        dados_exportar = []

        for row in resultados:
            id_, valor = row
            valor_decimal = Decimal(valor)
            print(f"Processando ID {id_} - Valor: {valor_decimal}")
            resultado = {"id": id_, "valor_processado": valor_decimal * 2}
            dados_exportar.append(resultado)
            salvar_progresso({'ultimo_id': id_})

        if dados_exportar:
            exportar = input("Deseja exportar os resultados? (s/n): ").strip().lower()
            if exportar == 's':
                assunto = input("Informe o assunto do arquivo: ").strip()
                formato = input("Formato (csv/txt): ").strip().lower()
                criar_arquivo_exportacao(dados_exportar, assunto, formato)

        conn.close()

    except Exception:
        log_error()
        print("❌ Ocorreu um erro. Veja os detalhes no log:", LOG_FILE)

if __name__ == '__main__':
    main()

🔎 Considerações Finais

Este template é ideal para desenvolvedores e analistas que desejam criar automações confiáveis com recuperação de progresso e saída estruturada. Basta substituir os campos da consulta e adaptar a lógica de processamento conforme seu caso de uso.

Responsabilidade Individual

Atenção: Para qualquer projeto que envolva investimento, manipulação de dados financeiros ou sensíveis, é essencial realizar uma análise individual. Não execute scripts sem entender totalmente sua função e impactos.

🔗 Links Oficiais dos Módulos Utilizados

• psycopg2 (PostgreSQL)
• mysql-connector-python (MySQL)
• sqlite3 (SQLite)