build_executable.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Build Executable - Script para gerar executável do projeto
Gera um arquivo .exe profissional para Windows
"""

import os
import sys
import shutil
import subprocess
from datetime import datetime

# Cores para terminal
class Colors:
    HEADER = '\033[95m'
    OKBLUE = '\033[94m'
    OKCYAN = '\033[96m'
    OKGREEN = '\033[92m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'

def print_header(text):
    """Imprimir cabeçalho colorido"""
    print(f"\n{Colors.HEADER}{Colors.BOLD}{'='*70}{Colors.ENDC}")
    print(f"{Colors.HEADER}{Colors.BOLD}{text.center(70)}{Colors.ENDC}")
    print(f"{Colors.HEADER}{Colors.BOLD}{'='*70}{Colors.ENDC}\n")

def print_success(text):
    """Imprimir mensagem de sucesso"""
    print(f"{Colors.OKGREEN}✓ {text}{Colors.ENDC}")

def print_info(text):
    """Imprimir mensagem informativa"""
    print(f"{Colors.OKCYAN}ℹ {text}{Colors.ENDC}")

def print_warning(text):
    """Imprimir mensagem de aviso"""
    print(f"{Colors.WARNING}⚠ {text}{Colors.ENDC}")

def print_error(text):
    """Imprimir mensagem de erro"""
    print(f"{Colors.FAIL}✗ {text}{Colors.ENDC}")

def check_pyinstaller():
    """Verificar se PyInstaller está instalado"""
    try:
        import PyInstaller
        print_success(f"PyInstaller encontrado: versão {PyInstaller.__version__}")
        return True
    except ImportError:
        print_error("PyInstaller não está instalado!")
        print_info("Instalando PyInstaller...")
        try:
            subprocess.check_call([sys.executable, "-m", "pip", "install", "pyinstaller"])
            print_success("PyInstaller instalado com sucesso!")
            return True
        except:
            print_error("Falha ao instalar PyInstaller")
            return False

def clean_build_dirs():
    """Limpar diretórios de build anteriores"""
    dirs_to_clean = ['build', 'dist', '__pycache__']

    print_info("Limpando diretórios de build anteriores...")

    for dir_name in dirs_to_clean:
        if os.path.exists(dir_name):
            try:
                shutil.rmtree(dir_name)
                print_success(f"Removido: {dir_name}/")
            except Exception as e:
                print_warning(f"Não foi possível remover {dir_name}/: {e}")

    # Limpar arquivos .spec antigos
    for file in os.listdir('.'):
        if file.endswith('.spec') and file != 'app.spec':
            try:
                os.remove(file)
                print_success(f"Removido: {file}")
            except Exception as e:
                print_warning(f"Não foi possível remover {file}: {e}")

def create_spec_file():
    """Criar arquivo .spec customizado para PyInstaller"""
    print_info("Criando arquivo de configuração .spec...")

    spec_content = """# -*- mode: python ; coding: utf-8 -*-

block_cipher = None

# Análise do script principal
a = Analysis(
    ['main.py'],
    pathex=[],
    binaries=[],
    datas=[
        ('data', 'data'),
        ('src', 'src'),
        ('*.md', '.'),
    ],
    hiddenimports=[
        'tkinter',
        'tkinter.ttk',
        'tkinter.scrolledtext',
        'tkinter.filedialog',
        'tkinter.messagebox',
        'selenium',
        'selenium.webdriver',
        'selenium.webdriver.chrome',
        'selenium.webdriver.chrome.service',
        'pandas',
        'matplotlib',
        'matplotlib.pyplot',
        'matplotlib.backends.backend_tkagg',
        'seaborn',
        'reportlab',
        'reportlab.pdfgen',
        'reportlab.lib',
        'reportlab.platypus',
        'google.generativeai',
        'PIL',
        'numpy',
        'openpyxl',
        'xlsxwriter',
    ],
    hookspath=[],
    hooksconfig={},
    runtime_hooks=[],
    excludes=[
        'pytest',
        'unittest',
        'test',
        '_pytest',
    ],
    win_no_prefer_redirects=False,
    win_private_assemblies=False,
    cipher=block_cipher,
    noarchive=False,
)

# PYZ - Arquivo Python compactado
pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)

# EXE - Executável
exe = EXE(
    pyz,
    a.scripts,
    a.binaries,
    a.zipfiles,
    a.datas,
    [],
    name='Microsoft_Forms_Automation_Tool',
    debug=False,
    bootloader_ignore_signals=False,
    strip=False,
    upx=True,
    upx_exclude=[],
    runtime_tmpdir=None,
    console=False,  # Não mostrar console em aplicações GUI
    disable_windowed_traceback=False,
    argv_emulation=False,
    target_arch=None,
    codesign_identity=None,
    entitlements_file=None,
    icon=None,  # Adicione caminho do ícone aqui se tiver: icon='icon.ico'
)
"""

    with open('app.spec', 'w', encoding='utf-8') as f:
        f.write(spec_content)

    print_success("Arquivo app.spec criado com sucesso!")

def build_executable():
    """Construir o executável usando PyInstaller"""
    print_info("Iniciando construção do executável...")
    print_info("Isso pode levar alguns minutos...")

    try:
        # Executar PyInstaller
        cmd = [
            'pyinstaller',
            '--clean',
            '--noconfirm',
            'app.spec'
        ]

        result = subprocess.run(cmd, capture_output=True, text=True)

        if result.returncode == 0:
            print_success("Executável construído com sucesso!")
            return True
        else:
            print_error("Erro ao construir executável")
            print(result.stderr)
            return False

    except Exception as e:
        print_error(f"Erro durante a construção: {e}")
        return False

def create_readme():
    """Criar README para o executável"""
    print_info("Criando documentação...")

    readme_content = """
# Microsoft Forms Automation Tool - Executável

## 📦 Versão Standalone

Este é o executável standalone do Microsoft Forms Automation Tool.
Não requer instalação de Python ou dependências.

## 🚀 Como Usar

1. Execute o arquivo `Microsoft_Forms_Automation_Tool.exe`
2. A interface gráfica será aberta automaticamente
3. Siga as instruções na tela

## 📋 Requisitos do Sistema

- **Sistema Operacional**: Windows 7/8/10/11 (64-bit)
- **Memória RAM**: Mínimo 4GB (Recomendado 8GB)
- **Espaço em Disco**: 500MB livres
- **Resolução de Tela**: Mínimo 1280x720

## ⚠️ Importante

### Primeira Execução
- Na primeira execução, o Windows Defender pode mostrar um aviso
- Isso é normal para executáveis não assinados digitalmente
- Clique em "Mais informações" e depois "Executar assim mesmo"

### Antivírus
- Alguns antivírus podem sinalizar o arquivo como suspeito
- Adicione uma exceção ou permissão para o executável
- O arquivo é 100% seguro e não contém malware

### Dependências
- Para automação web, você precisa ter o Google Chrome instalado
- O ChromeDriver será baixado automaticamente pelo sistema

## 📊 Funcionalidades

✓ Automação de formulários Microsoft Forms
✓ Banco de dados SQLite3 integrado
✓ Geração de relatórios PDF profissionais
✓ 15+ tipos de gráficos estatísticos
✓ Envio de e-mails com SMTP
✓ Assistente de IA com Google Gemini
✓ Sistema de logs e histórico
✓ Tutorial interativo completo

## 🆘 Suporte

Se encontrar problemas:
1. Verifique se todos os requisitos estão atendidos
2. Execute como Administrador
3. Verifique permissões de firewall/antivírus
4. Consulte o tutorial integrado no software

## 📝 Logs

Os logs do sistema são salvos em:
- `logs/` - Pasta de logs da aplicação

## 💾 Dados

Os dados do banco são salvos em:
- `data/form_data.db` - Banco de dados SQLite3

## 🔄 Atualizações

Para atualizar:
1. Baixe a nova versão do executável
2. Substitua o arquivo antigo
3. Seus dados serão preservados (banco de dados)

## 📧 Contato

Para dúvidas ou sugestões, consulte a documentação completa
na pasta do projeto original.

---
© 2025 - Microsoft Forms Automation Tool v2.0
Todos os direitos reservados
"""

    os.makedirs('dist', exist_ok=True)
    with open('dist/LEIA-ME.txt', 'w', encoding='utf-8') as f:
        f.write(readme_content.strip())

    print_success("README criado em dist/LEIA-ME.txt")

def copy_essential_files():
    """Copiar arquivos essenciais para o diretório dist"""
    print_info("Copiando arquivos essenciais...")

    essential_dirs = ['data', 'config']

    for dir_name in essential_dirs:
        if os.path.exists(dir_name):
            dest = os.path.join('dist', dir_name)
            if os.path.exists(dest):
                shutil.rmtree(dest)
            shutil.copytree(dir_name, dest)
            print_success(f"Copiado: {dir_name}/ -> dist/{dir_name}/")

    # Criar diretórios necessários
    os.makedirs('dist/logs', exist_ok=True)
    os.makedirs('dist/exports', exist_ok=True)
    print_success("Diretórios necessários criados")

def create_launcher_bat():
    """Criar arquivo .bat para facilitar execução"""
    print_info("Criando launcher...")

    bat_content = """@echo off
title Microsoft Forms Automation Tool
echo.
echo ====================================================
echo    Microsoft Forms Automation Tool v2.0
echo    Iniciando aplicacao...
echo ====================================================
echo.

REM Ir para o diretório do executável
cd /d "%~dp0"

REM Executar o programa
start "" "Microsoft_Forms_Automation_Tool.exe"

REM Aguardar 2 segundos e fechar
timeout /t 2 /nobreak >nul
exit
"""

    with open('dist/Iniciar.bat', 'w', encoding='utf-8') as f:
        f.write(bat_content)

    print_success("Launcher criado: dist/Iniciar.bat")

def show_summary():
    """Mostrar resumo do build"""
    print_header("BUILD CONCLUÍDO COM SUCESSO!")

    print(f"{Colors.BOLD}📦 Localização dos arquivos:{Colors.ENDC}")
    print(f"   • Executável: {Colors.OKGREEN}dist/Microsoft_Forms_Automation_Tool.exe{Colors.ENDC}")
    print(f"   • Launcher: {Colors.OKGREEN}dist/Iniciar.bat{Colors.ENDC}")
    print(f"   • Documentação: {Colors.OKGREEN}dist/LEIA-ME.txt{Colors.ENDC}")

    print(f"\n{Colors.BOLD}📊 Informações:{Colors.ENDC}")

    exe_path = 'dist/Microsoft_Forms_Automation_Tool.exe'
    if os.path.exists(exe_path):
        size_mb = os.path.getsize(exe_path) / (1024 * 1024)
        print(f"   • Tamanho: {Colors.OKCYAN}{size_mb:.2f} MB{Colors.ENDC}")

    print(f"   • Data: {Colors.OKCYAN}{datetime.now().strftime('%d/%m/%Y %H:%M:%S')}{Colors.ENDC}")

    print(f"\n{Colors.BOLD}🚀 Próximos passos:{Colors.ENDC}")
    print(f"   1. Teste o executável: {Colors.OKCYAN}dist/Microsoft_Forms_Automation_Tool.exe{Colors.ENDC}")
    print(f"   2. Distribua a pasta {Colors.OKCYAN}dist/{Colors.ENDC} completa para os usuários")
    print(f"   3. Leia o arquivo {Colors.OKCYAN}LEIA-ME.txt{Colors.ENDC} para instruções")

    print(f"\n{Colors.WARNING}⚠️  Importante:{Colors.ENDC}")
    print(f"   • Distribua toda a pasta {Colors.BOLD}dist/{Colors.ENDC}, não apenas o .exe")
    print(f"   • Os usuários precisam ter o Google Chrome instalado")
    print(f"   • Configure antivírus para não bloquear o executável")

    print()

def main():
    """Função principal"""
    print_header("BUILD DE EXECUTÁVEL - Microsoft Forms Automation Tool")

    # Verificar PyInstaller
    if not check_pyinstaller():
        print_error("Não foi possível instalar PyInstaller. Abortando.")
        return

    # Limpar builds anteriores
    clean_build_dirs()

    # Criar arquivo .spec
    create_spec_file()

    # Construir executável
    if not build_executable():
        print_error("Falha ao construir executável. Verifique os erros acima.")
        return

    # Copiar arquivos essenciais
    copy_essential_files()

    # Criar documentação
    create_readme()

    # Criar launcher
    create_launcher_bat()

    # Mostrar resumo
    show_summary()

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print_warning("\n\nBuild cancelado pelo usuário.")
    except Exception as e:
        print_error(f"\n\nErro inesperado: {e}")
        import traceback
        traceback.print_exc()