build_exe_ci.py

#!/usr/bin/env python3
"""
Script de build optimisé pour CI/CD GitHub Actions.
Version multi-plateforme compatible Windows, Linux et macOS.
"""

import sys
import subprocess
import shutil
import platform
import os
from pathlib import Path

# Configuration de l'encoding UTF-8 pour Windows
if platform.system() == "Windows":
    import codecs
    import locale
    
    # Force UTF-8 encoding pour stdout
    if hasattr(sys.stdout, 'reconfigure'):
        sys.stdout.reconfigure(encoding='utf-8')
    if hasattr(sys.stderr, 'reconfigure'):
        sys.stderr.reconfigure(encoding='utf-8')
    
    # Variables d'environnement pour forcer UTF-8
    os.environ['PYTHONIOENCODING'] = 'utf-8'
    os.environ['PYTHONUTF8'] = '1'

def get_platform_info():
    """Détecte les informations de la plateforme."""
    system = platform.system().lower()
    
    if system == "windows":
        return {
            "name": "windows",
            "exe_ext": ".exe", 
            "separator": ";",
            "executable_name": "Minuteur.exe"
        }
    elif system == "darwin":
        return {
            "name": "macos",
            "exe_ext": "",
            "separator": ":",
            "executable_name": "Minuteur"
        }
    else:  # Linux et autres Unix
        return {
            "name": "linux", 
            "exe_ext": "",
            "separator": ":",
            "executable_name": "Minuteur"
        }

def log(message, level="INFO"):
    """Logging avec couleurs pour CI, compatible Windows encoding."""
    colors = {
        "INFO": "\033[94m",    # Bleu
        "SUCCESS": "\033[92m", # Vert
        "WARNING": "\033[93m", # Jaune
        "ERROR": "\033[91m",   # Rouge
        "RESET": "\033[0m"     # Reset
    }
    
    color = colors.get(level, colors["INFO"])
    reset = colors["RESET"]
    
    # Tentative d'affichage avec emojis
    try:
        print(f"{color}[{level}]{reset} {message}")
    except UnicodeEncodeError:
        # Fallback: remplacer les emojis par des équivalents ASCII
        safe_message = message
        emoji_replacements = {
            "🚀": "[BUILD]",
            "🔍": "[CHECK]", 
            "✅": "[OK]",
            "❌": "[FAIL]",
            "🔨": "[COMPILE]",
            "🧹": "[CLEAN]",
            "📦": "[PACKAGE]",
            "🎯": "[TARGET]",
            "📊": "[SIZE]",
            "🖥️": "[OS]",
            "🐍": "[PYTHON]",
            "📁": "[DIR]",
            "🔧": "[CONFIG]",
            "🎉": "[SUCCESS]",
            "💥": "[ERROR]"
        }
        
        for emoji, replacement in emoji_replacements.items():
            safe_message = safe_message.replace(emoji, replacement)
        
        print(f"{color}[{level}]{reset} {safe_message}")

def check_dependencies():
    """Vérifie les dépendances nécessaires."""
    log("🔍 Vérification des dépendances...")
    
    try:
        import customtkinter
        log(f"✅ CustomTkinter: {customtkinter.__version__}")
    except ImportError:
        log("❌ CustomTkinter non trouvé", "ERROR")
        return False
        
    try:
        import pystray
        log(f"✅ pystray: OK")
    except ImportError:
        log("❌ pystray non trouvé", "ERROR")
        return False
        
    try:
        import PIL
        log(f"✅ Pillow: {PIL.__version__}")
    except ImportError:
        log("❌ Pillow non trouvé", "ERROR")
        return False
        
    try:
        import PyInstaller
        log(f"✅ PyInstaller: {PyInstaller.__version__}")
    except ImportError:
        log("❌ PyInstaller non trouvé", "ERROR")
        return False
        
    return True

def build_executable():
    """Génère l'exécutable avec PyInstaller."""
    platform_info = get_platform_info()
    project_root = Path(__file__).parent
    main_script = project_root / "minuteur" / "main.py"
    
    log(f"🔨 Build pour {platform_info['name'].upper()}...")
    
    if not main_script.exists():
        log(f"❌ Script principal non trouvé: {main_script}", "ERROR")
        return False
    
    # Nettoyage préalable
    dist_folder = project_root / "dist"
    build_folder = project_root / "build"
    
    if dist_folder.exists():
        log("🧹 Suppression dist/ existant...")
        shutil.rmtree(dist_folder)
        
    if build_folder.exists():
        log("🧹 Suppression build/ existant...")
        shutil.rmtree(build_folder)
    
    # Configuration PyInstaller adaptée par OS
    base_cmd = [
        sys.executable, "-m", "PyInstaller",
        "--name", "Minuteur",
        "--windowed",
        "--onedir",
        "--collect-all", "customtkinter",
        "--collect-all", "pystray", 
        "--collect-all", "PIL",
        "--optimize", "2",
        "--clean",
        "--noconfirm",
        str(main_script)
    ]
    
    # Ajustements spécifiques par OS
    if platform_info["name"] == "windows":
        # Windows: options spéciales
        base_cmd.extend([
            "--collect-all", "darkdetect",
            "--hidden-import", "tkinter",
            "--hidden-import", "tkinter.ttk"
        ])
    elif platform_info["name"] == "linux":
        # Linux: gestion X11 
        base_cmd.extend([
            "--collect-all", "darkdetect",
            "--hidden-import", "Xlib"
        ])
    elif platform_info["name"] == "macos":
        # macOS: options spéciales
        base_cmd.extend([
            "--collect-all", "darkdetect",
            "--osx-bundle-identifier", "com.minuteur.app"
        ])
    
    log("📦 Commande PyInstaller:")
    log(" ".join(base_cmd))
    
    try:
        # Exécution de PyInstaller
        env = os.environ.copy()
        
        # Variables d'environnement spéciales pour Linux (CI)
        if platform_info["name"] == "linux" and "DISPLAY" not in env:
            env["DISPLAY"] = ":99"
            log("🖥️ Configuration DISPLAY pour Linux CI")
        
        result = subprocess.run(
            base_cmd,
            cwd=project_root,
            env=env,
            capture_output=True,
            text=True,
            timeout=600  # 10 minutes max
        )
        
        if result.returncode == 0:
            log("✅ Build PyInstaller réussi!", "SUCCESS")
            
            # Vérification de la sortie
            exe_folder = dist_folder / "Minuteur"
            if exe_folder.exists():
                executable = exe_folder / platform_info["executable_name"]
                
                if executable.exists():
                    size_mb = executable.stat().st_size / (1024 * 1024)
                    log(f"🎯 Exécutable créé: {executable.name} ({size_mb:.1f} MB)", "SUCCESS")
                    
                    # Calcul taille totale
                    total_size = sum(f.stat().st_size for f in exe_folder.rglob('*') if f.is_file())
                    total_mb = total_size / (1024 * 1024)
                    log(f"📊 Taille totale: {total_mb:.1f} MB", "SUCCESS")
                    
                    return True
                else:
                    log(f"❌ Exécutable non trouvé: {platform_info['executable_name']}", "ERROR")
                    log("📋 Contenu du dossier dist/Minuteur/:")
                    for item in exe_folder.iterdir():
                        log(f"  - {item.name}")
            else:
                log("❌ Dossier de build non créé", "ERROR")
                
        else:
            log("❌ Échec du build PyInstaller", "ERROR")
            log("STDOUT:", "ERROR")
            log(result.stdout, "ERROR")
            log("STDERR:", "ERROR")  
            log(result.stderr, "ERROR")
            
    except subprocess.TimeoutExpired:
        log("❌ Timeout du build (> 10 minutes)", "ERROR")
    except Exception as e:
        log(f"❌ Erreur inattendue: {e}", "ERROR")
        
    return False

def main():
    """Point d'entrée principal."""
    platform_info = get_platform_info()
    
    print("=" * 60)
    log(f"🚀 Build CI/CD - Minuteur pour {platform_info['name'].upper()}")
    print("=" * 60)
    
    # Informations système
    log(f"🖥️ OS: {platform.system()} {platform.release()}")
    log(f"🐍 Python: {sys.version.split()[0]}")
    log(f"📁 Répertoire: {Path.cwd()}")
    
    # Variables d'environnement CI utiles
    ci_vars = ["GITHUB_ACTIONS", "CI", "RUNNER_OS", "DISPLAY"]
    for var in ci_vars:
        if var in os.environ:
            log(f"🔧 {var}: {os.environ[var]}")
    
    # Vérification des dépendances
    if not check_dependencies():
        log("❌ Dépendances manquantes", "ERROR")
        return 1
        
    # Build
    if build_executable():
        log("🎉 Build terminé avec succès!", "SUCCESS")
        return 0
    else:
        log("💥 Échec du build", "ERROR")
        return 1

if __name__ == "__main__":
    sys.exit(main())