bob_gui_hf.py

#!/usr/bin/env python3
"""
BOB Processor - Interface graphique (Hugging Face version)
Application GUI pour traiter automatiquement les fichiers audio BOB
"""

import sys
import os
import threading
import time
from pathlib import Path
from PyQt5.QtWidgets import (QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, 
                            QWidget, QPushButton, QLabel, QProgressBar, QTextEdit,
                            QFileDialog, QMessageBox, QFrame, QGridLayout, QCheckBox,
                            QComboBox, QGroupBox)
from PyQt5.QtCore import QThread, pyqtSignal, Qt, QTimer
from PyQt5.QtGui import QFont, QPixmap, QIcon

# Imports des modules de traitement
# Bootstrap environnement portable avant toute importation lourde
try:
    from portable_env import setup_portable_env
    setup_portable_env()
except Exception as _e:
    # En cas d'échec du bootstrap, continuer mais loguer plus tard
    pass

from transcribe_audio import transcribe_file, load_whisper_model, get_audio_files
from analyze_bob_hf import analyze_files_hf  # Version Hugging Face

# Masquer la console Windows si présente (exe console) pour n'afficher que le GUI
def _hide_windows_console():
    if os.name == 'nt':
        try:
            import ctypes
            hwnd = ctypes.windll.kernel32.GetConsoleWindow()
            if hwnd:
                # 0 = SW_HIDE
                ctypes.windll.user32.ShowWindow(hwnd, 0)
        except Exception:
            pass

def _suppress_console_windows():
    """Supprime toutes les fenêtres console qui pourraient s'ouvrir pendant l'exécution"""
    if os.name == 'nt':
        try:
            import subprocess
            import ctypes
            from ctypes import wintypes
            
            # Forcer tous les subprocess à ne pas créer de fenêtre
            original_popen_init = subprocess.Popen.__init__
            def _hidden_popen_init(self, *args, **kwargs):
                # Forcer la suppression de toutes les fenêtres
                if 'startupinfo' not in kwargs:
                    kwargs['startupinfo'] = subprocess.STARTUPINFO()
                kwargs['startupinfo'].dwFlags |= subprocess.STARTF_USESHOWWINDOW  
                kwargs['startupinfo'].wShowWindow = subprocess.SW_HIDE
                if 'creationflags' not in kwargs:
                    kwargs['creationflags'] = 0
                kwargs['creationflags'] |= subprocess.CREATE_NO_WINDOW | 0x08000000  # CREATE_NO_WINDOW + DETACHED_PROCESS
                return original_popen_init(self, *args, **kwargs)
            subprocess.Popen.__init__ = _hidden_popen_init
            
            # Aussi pour os.system et os.popen
            original_system = os.system
            def hidden_system(cmd):
                return subprocess.call(cmd, shell=True, creationflags=subprocess.CREATE_NO_WINDOW)
            os.system = hidden_system
            
            # Patch global pour tous les appels système
            import atexit
            def hide_all_console_windows():
                try:
                    # Enum toutes les fenêtres et cache celles qui sont des consoles
                    def enum_windows_proc(hwnd, lParam):
                        try:
                            class_name = ctypes.create_unicode_buffer(256)
                            ctypes.windll.user32.GetClassNameW(hwnd, class_name, 256)
                            if class_name.value == "ConsoleWindowClass":
                                ctypes.windll.user32.ShowWindow(hwnd, 0)  # SW_HIDE
                        except:
                            pass
                        return True
                    
                    EnumWindowsProc = ctypes.WINFUNCTYPE(ctypes.c_bool, wintypes.HWND, wintypes.LPARAM)
                    enum_proc = EnumWindowsProc(enum_windows_proc)
                    ctypes.windll.user32.EnumWindows(enum_proc, 0)
                except:
                    pass
            
            # Démarrer un timer pour cacher les fenêtres en continu
            import threading
            def console_hider():
                while True:
                    hide_all_console_windows()
                    time.sleep(0.1)  # Vérifier toutes les 100ms
            
            timer_thread = threading.Thread(target=console_hider, daemon=True)
            timer_thread.start()
            
        except Exception:
            pass

class WorkerThread(QThread):
    """Thread pour le traitement en arrière-plan"""
    progress = pyqtSignal(int)
    log = pyqtSignal(str)
    finished = pyqtSignal(str)
    
    def __init__(self, input_dir, output_dir, whisper_model, hf_model_name: str, fast_mode: bool):
        super().__init__()
        self.input_dir = Path(input_dir)
        self.output_dir = Path(output_dir)
        self.whisper_model = whisper_model
        self.hf_model_name = hf_model_name
        self.fast_mode = fast_mode
        self.is_cancelled = False
    
    def run(self):
        try:
            # Créer les dossiers de sortie
            transcriptions_dir = self.output_dir / "transcriptions"
            transcriptions_dir.mkdir(parents=True, exist_ok=True)
            
            self.log.emit("🚀 Début du traitement BOB...")
            self.log.emit(f"📁 Dossier d'entrée: {self.input_dir}")
            self.log.emit(f"📁 Dossier de sortie: {self.output_dir}")
            
            # Étape 1: Récupérer les fichiers audio
            audio_files = get_audio_files(self.input_dir)
            if not audio_files:
                self.log.emit("❌ Aucun fichier audio trouvé!")
                self.finished.emit("Aucun fichier audio trouvé dans le dossier sélectionné.")
                return
            
            total_files = len(audio_files)
            self.log.emit(f"📊 {total_files} fichier(s) audio trouvé(s)")
            
            # Étape 2: Chargement du modèle Whisper
            self.log.emit(f"🧠 Chargement du modèle Whisper ({self.whisper_model})...")
            model = load_whisper_model(self.whisper_model)
            self.log.emit("✅ Modèle Whisper chargé avec succès!")
            
            # Étape 3: Transcription des fichiers
            self.log.emit("🎵 Début de la transcription...")
            for i, audio_file in enumerate(audio_files):
                if self.is_cancelled:
                    break
                
                self.log.emit(f"📝 [{i+1}/{total_files}] Transcription: {audio_file.name}")
                
                # Transcription
                success = transcribe_file(model, audio_file, transcriptions_dir)
                
                if success:
                    self.log.emit(f"✅ Transcrit: {audio_file.name}")
                else:
                    self.log.emit(f"❌ Erreur: {audio_file.name}")
                
                # Mise à jour du progrès (70% pour transcription)
                progress = int(((i + 1) / total_files) * 70)
                self.progress.emit(progress)
            
            if self.is_cancelled:
                self.finished.emit("Traitement annulé par l'utilisateur.")
                return
            
            # Étape 4: Analyse avec Hugging Face
            self.log.emit("🤖 Début de l'analyse avec Hugging Face...")
            self.log.emit(f"🤖 Modèle HF sélectionné: {self.hf_model_name} | Mode rapide: {'ON' if self.fast_mode else 'OFF'}")
            
            # Rediriger temporairement les prints vers notre log
            import io
            import contextlib
            
            # Capturer les sorties
            captured_output = io.StringIO()
            with contextlib.redirect_stdout(captured_output):
                try:
                    # Configurer les variables d'environnement
                    os.environ["HF_MODEL"] = self.hf_model_name
                    
                    # Exécuter l'analyse avec progression
                    def prog(cur, total):
                        base = 70
                        span = 30
                        val = base + int((cur / total) * span)
                        self.progress.emit(min(99, val))
                    def cancelled():
                        return self.is_cancelled
                    def logger(*args, **kwargs):
                        msg = " ".join(str(a) for a in args)
                        print(msg)
                    
                    result = analyze_files_hf(
                        transcriptions_dir=transcriptions_dir,
                        input_dir=Path(self.input_dir),
                        output_file=Path(self.output_dir) / "resume_bob.txt",
                        log_fn=logger,
                        progress_fn=prog,
                        cancel_fn=cancelled,
                    )
                    
                except Exception as e:
                    self.log.emit(f"❌ Erreur lors de l'analyse: {e}")
            
            # Récupérer et afficher les logs d'analyse
            analysis_output = captured_output.getvalue()
            for line in analysis_output.split('\n'):
                if line.strip():
                    self.log.emit(line)
            
            self.progress.emit(100)
            self.log.emit("🎉 Traitement terminé avec succès!")
            
            # Vérifier le fichier de résultat
            result_file = self.output_dir / "resume_bob.txt"
            if result_file.exists():
                self.finished.emit(f"Traitement terminé! Résultats sauvegardés dans:\n{result_file}")
            else:
                self.finished.emit("Traitement terminé mais fichier de résultat introuvable.")
                
        except Exception as e:
            self.log.emit(f"❌ Erreur critique: {e}")
            self.finished.emit(f"Erreur lors du traitement: {e}")
    
    def cancel(self):
        self.is_cancelled = True

class BOBProcessorGUI(QMainWindow):
    def __init__(self):
        super().__init__()
        self.worker_thread = None
        self.input_dir = None
        self.output_dir = None
        # Chrono
        self.elapsed_seconds = 0
        self.timer = QTimer(self)
        self.timer.timeout.connect(self._tick_elapsed)
        self.init_ui()
    
    def init_ui(self):
        self.setWindowTitle("BOB Processor - Hugging Face Version")
        self.setGeometry(100, 100, 800, 600)
        
        # Widget central
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        # Layout principal
        layout = QVBoxLayout(central_widget)
        
        # Titre
        title = QLabel("🎵 BOB 🤖 (Hugging Face)")
        title.setAlignment(Qt.AlignCenter)
        title.setFont(QFont("Arial", 18, QFont.Bold))
        title.setStyleSheet("color: #2c3e50; margin: 10px;")
        layout.addWidget(title)
        
        subtitle = QLabel("Transcription automatique et analyse intelligente des sujets")
        subtitle.setAlignment(Qt.AlignCenter)
        subtitle.setFont(QFont("Arial", 10))
        subtitle.setStyleSheet("color: #7f8c8d; margin-bottom: 20px;")
        layout.addWidget(subtitle)
        
        # Séparateur
        line = QFrame()
        line.setFrameShape(QFrame.HLine)
        line.setFrameShadow(QFrame.Sunken)
        layout.addWidget(line)
        
        # Configuration
        config_group = QGroupBox("⚙️ Configuration")
        config_group.setFont(QFont("Arial", 12, QFont.Bold))
        config_layout = QGridLayout(config_group)
        
        # Sélection des dossiers
        self.input_label = QLabel("📁 Dossier d'entrée (MP3): Aucun dossier sélectionné")
        self.input_label.setFont(QFont("Arial", 11))
        self.input_label.setStyleSheet("padding: 8px; background-color: #ecf0f1; border-radius: 3px; font-size: 11pt;")
        config_layout.addWidget(self.input_label, 0, 0, 1, 2)
        
        self.input_btn = QPushButton("Choisir dossier MP3")
        self.input_btn.setFont(QFont("Arial", 11, QFont.Bold))
        self.input_btn.clicked.connect(self.select_input_dir)
        self.input_btn.setStyleSheet("padding: 10px; background-color: #3498db; color: white; border-radius: 3px; font-size: 11pt; font-weight: bold;")
        config_layout.addWidget(self.input_btn, 0, 2)
        
        self.output_label = QLabel("📁 Dossier de sortie: Aucun dossier sélectionné")
        self.output_label.setFont(QFont("Arial", 11))
        self.output_label.setStyleSheet("padding: 8px; background-color: #ecf0f1; border-radius: 3px; font-size: 11pt;")
        config_layout.addWidget(self.output_label, 1, 0, 1, 2)
        
        self.output_btn = QPushButton("Choisir dossier de sortie")
        self.output_btn.setFont(QFont("Arial", 11, QFont.Bold))
        self.output_btn.clicked.connect(self.select_output_dir)
        self.output_btn.setStyleSheet("padding: 10px; background-color: #3498db; color: white; border-radius: 3px; font-size: 11pt; font-weight: bold;")
        config_layout.addWidget(self.output_btn, 1, 2)
        
        # Options
        model_label = QLabel("� Modèle de transcription:")
        model_label.setFont(QFont("Arial", 11, QFont.Bold))
        config_layout.addWidget(model_label, 2, 0)
        self.model_combo = QComboBox()
        self.model_combo.setFont(QFont("Arial", 11))
        self.model_combo.addItems([
            "Whisper Small : 2x plus rapide (recommandé)",
            "Whisper Medium : utile si qualité audio faible",
        ])
        self.model_combo.setCurrentText("Whisper Small : 2x plus rapide (recommandé)")
        self.model_combo.setStyleSheet("font-size: 11pt; padding: 5px;")
        # Tooltip explicative pour le choix du modèle Whisper
        self.model_combo.setToolTip(
            "🎙️ Choix du modèle de transcription audio :\n\n"
            "• Small : Recommandé dans la plupart des cas\n"
            "  - 2x plus rapide que Medium\n"
            "  - Bonne précision pour un audio de qualité correcte\n"
            "  - Utilise moins de ressources\n\n"
            "• Medium : Pour audio de mauvaise qualité\n"
            "  - Plus précis mais 2x plus lent\n"
            "  - Utilisez si Small donne de mauvais résultats\n"
            "  - Recommandé pour enregistrements bruyants"
        )
        config_layout.addWidget(self.model_combo, 2, 1)

        # Sélecteur de modèle HF pour l'analyse
        hf_label = QLabel("🧠 Modèle HF (analyse textuelle):")
        hf_label.setFont(QFont("Arial", 11, QFont.Bold))
        config_layout.addWidget(hf_label, 3, 0)
        self.hf_combo = QComboBox()
        self.hf_combo.setFont(QFont("Arial", 11))
        self.hf_combo.addItems([
            "google/gemma-3-4b-pt (Gemma 3 4B FORCÉ)",
        ])
        self.hf_combo.setCurrentText("google/gemma-3-4b-pt (Gemma 3 4B FORCÉ)")
        self.hf_combo.setStyleSheet("font-size: 11pt; padding: 5px;")
        # Tooltip explicative pour le choix du modèle
        self.hf_combo.setToolTip(
            "💡 Modèle Gemma 3 4B (Google) :\n\n"
            "• Gemma 3 4B FORCÉ\n"
            "• Modèle 4B comme demandé\n"
            "• Optimisé pour Hugging Face Spaces"
        )
        config_layout.addWidget(self.hf_combo, 3, 1)

        # Aide: format des noms de fichiers MP3
        hint = QLabel("ℹ️ Les fichiers MP3 doivent contenir le nom du journaliste pour extraire l'auteur (ex: 'Marie Dupont.mp3').")
        hint.setWordWrap(True)
        hint.setFont(QFont("Arial", 9))
        hint.setStyleSheet("color: #8c0000; padding-top: 6px;")
        config_layout.addWidget(hint, 4, 0, 1, 3)
        config_layout.addWidget(self.model_combo, 2, 1)

        # Sélecteur de modèle HF pour l'analyse
        hf_label = QLabel("🤖 Modèle HF (analyse):")
        hf_label.setFont(QFont("Arial", 11, QFont.Bold))
        config_layout.addWidget(hf_label, 3, 0)
        self.hf_combo = QComboBox()
        self.hf_combo.setFont(QFont("Arial", 11))
        self.hf_combo.addItems([
            "meta-llama/Llama-3.2-1B-Instruct (meilleur compromis)",
            "microsoft/Phi-3-mini-4k-instruct (rapide)",
            "mistralai/Mistral-7B-Instruct-v0.3 (meilleure qualité)",
        ])
        self.hf_combo.setCurrentText("meta-llama/Llama-3.2-1B-Instruct (meilleur compromis)")
        self.hf_combo.setStyleSheet("font-size: 11pt; padding: 5px;")
        config_layout.addWidget(self.hf_combo, 3, 1)

        # Aide: format des noms de fichiers MP3
        hint = QLabel("ℹ️ Les fichiers MP3 doivent contenir le nom du journaliste pour extraire l’auteur (ex: ‘Marie Dupont.mp3’).")
        hint.setWordWrap(True)
        hint.setFont(QFont("Arial", 9))
        hint.setStyleSheet("color: #8c0000; padding-top: 6px;")
        config_layout.addWidget(hint, 4, 0, 1, 3)
            
        layout.addWidget(config_group)
        
        # Contrôles
        controls_layout = QHBoxLayout()
        
        self.start_btn = QPushButton("▶️ DÉMARRER LE TRAITEMENT")
        self.start_btn.setFont(QFont("Arial", 12, QFont.Bold))
        self.start_btn.clicked.connect(self.start_processing)
        self.start_btn.setEnabled(False)
        self.start_btn.setStyleSheet("padding: 15px; background-color: #27ae60; color: white; font-weight: bold; border-radius: 5px; font-size: 12pt;")
        
        self.cancel_btn = QPushButton("⏹️ ANNULER")
        self.cancel_btn.setFont(QFont("Arial", 12, QFont.Bold))
        self.cancel_btn.clicked.connect(self.cancel_processing)
        self.cancel_btn.setEnabled(False)
        self.cancel_btn.setStyleSheet("padding: 15px; background-color: #e74c3c; color: white; font-weight: bold; border-radius: 5px; font-size: 12pt;")
        
        controls_layout.addWidget(self.start_btn)
        controls_layout.addWidget(self.cancel_btn)
        layout.addLayout(controls_layout)
        
        # Barre de progression
        self.progress_bar = QProgressBar()
        self.progress_bar.setStyleSheet("QProgressBar { border: 2px solid grey; border-radius: 5px; text-align: center; } QProgressBar::chunk { background-color: #3498db; }")
        layout.addWidget(self.progress_bar)
        
        # Chrono
        self.elapsed_label = QLabel("⏱️ Temps écoulé: 00:00")
        self.elapsed_label.setAlignment(Qt.AlignCenter)
        self.elapsed_label.setFont(QFont("Arial", 10, QFont.Bold))
        self.elapsed_label.setStyleSheet("color: #2c3e50; margin-bottom: 10px;")
        layout.addWidget(self.elapsed_label)
        
        # Zone de log
        log_group = QGroupBox("📋 Journal d'exécution")
        log_group.setFont(QFont("Arial", 12, QFont.Bold))
        log_layout = QVBoxLayout(log_group)
        
        self.log_text = QTextEdit()
        self.log_text.setReadOnly(True)
        self.log_text.setFont(QFont("Courier New", 10))
        self.log_text.setStyleSheet("background-color: #2c3e50; color: #ecf0f1; font-family: 'Courier New'; font-size: 10pt;")
        self.log_text.append("📝 Prêt à traiter vos fichiers BOB...")
        log_layout.addWidget(self.log_text)
        
        layout.addWidget(log_group)
        
        # Vérifier les conditions initiales
        self.check_start_conditions()
    
    def select_input_dir(self):
        dir_path = QFileDialog.getExistingDirectory(self, "Sélectionner le dossier contenant les fichiers MP3")
        if dir_path:
            self.input_dir = dir_path
            # Tronquer le chemin s'il est trop long pour l'affichage
            display_path = dir_path if len(dir_path) < 60 else "..." + dir_path[-57:]
            self.input_label.setText(f"📁 Dossier d'entrée: {display_path}")
            self.check_start_conditions()
    
    def select_output_dir(self):
        dir_path = QFileDialog.getExistingDirectory(self, "Sélectionner le dossier de sortie")
        if dir_path:
            self.output_dir = dir_path
            # Tronquer le chemin s'il est trop long pour l'affichage
            display_path = dir_path if len(dir_path) < 60 else "..." + dir_path[-57:]
            self.output_label.setText(f"📁 Dossier de sortie: {display_path}")
            self.check_start_conditions()
    
    def check_start_conditions(self):
        """Vérifie si toutes les conditions sont remplies pour démarrer"""
        can_start = bool(self.input_dir and self.output_dir)
        self.start_btn.setEnabled(can_start)
    
    def start_processing(self):
        """Démarre le traitement"""
        if not self.input_dir or not self.output_dir:
            QMessageBox.warning(self, "Erreur", "Veuillez sélectionner les dossiers d'entrée et de sortie.")
            return
        
        # Configuration du thread de traitement
        model_text = self.model_combo.currentText()
        if "Small" in model_text:
            whisper_model = "small"
        elif "Medium" in model_text:
            whisper_model = "medium"
        else:
            whisper_model = "small"  # défaut
        
        # HF selection -> nom de modèle Hugging Face (Gemma 3 4B FORCÉ)
        hf_choice = self.hf_combo.currentText()
        hf_model_name = "google/gemma-3-4b-pt"  # Gemma 3 4B FORCÉ
        fast_mode = True  # 4B est rapide

        # Configuration des variables d'environnement
        os.environ["BOB_INPUT_DIR"] = str(self.input_dir)
        os.environ["BOB_TRANSCRIPTIONS_DIR"] = str(Path(self.output_dir) / "transcriptions")
        os.environ["BOB_OUTPUT_FILE"] = str(Path(self.output_dir) / "resume_bob.txt")
        os.environ["WHISPER_MODEL"] = whisper_model
        os.environ["HF_MODEL"] = hf_model_name

        self.worker_thread = WorkerThread(self.input_dir, self.output_dir, whisper_model, hf_model_name, fast_mode)
        self.worker_thread.progress.connect(self.update_progress)
        self.worker_thread.log.connect(self.add_log)
        self.worker_thread.finished.connect(self.processing_finished)
        
        # Interface en mode traitement
        self.start_btn.setEnabled(False)
        self.cancel_btn.setEnabled(True)
        self.progress_bar.setValue(0)
        self.log_text.clear()
        
        # Démarrer le traitement
        # Chrono: démarrer
        self.elapsed_seconds = 0
        self._update_elapsed_label()
        self.timer.start(1000)

        self.worker_thread.start()
    
    def cancel_processing(self):
        """Annule le traitement en cours"""
        if self.worker_thread and self.worker_thread.isRunning():
            self.worker_thread.cancel()
            self.add_log("⏹️ Annulation en cours...")
    
    def update_progress(self, value):
        """Met à jour la barre de progression"""
        self.progress_bar.setValue(value)
    
    def add_log(self, message):
        """Ajoute un message au journal"""
        timestamp = time.strftime("%H:%M:%S")
        self.log_text.append(f"[{timestamp}] {message}")
        
        # Auto-scroll vers le bas
        scrollbar = self.log_text.verticalScrollBar()
        scrollbar.setValue(scrollbar.maximum())
    
    def processing_finished(self, message):
        """Traitement terminé"""
        self.start_btn.setEnabled(True)
        self.cancel_btn.setEnabled(False)
        # Arrêter le chrono
        if self.timer.isActive():
            self.timer.stop()
        
        # Afficher le message de fin
        if "Erreur" in message or "annulé" in message:
            QMessageBox.warning(self, "Traitement terminé", message)
        else:
            QMessageBox.information(self, "Succès!", message)

    # Chrono helpers
    def _tick_elapsed(self):
        self.elapsed_seconds += 1
        self._update_elapsed_label()

    def _update_elapsed_label(self):
        m = self.elapsed_seconds // 60
        s = self.elapsed_seconds % 60
        self.elapsed_label.setText(f"⏱️ Temps écoulé: {m:02d}:{s:02d}")

def main():
    _hide_windows_console()
    _suppress_console_windows()  # Suppression avancée des consoles
    app = QApplication(sys.argv)
    app.setStyle('Fusion')
    
    window = BOBProcessorGUI()
    window.show()
    
    sys.exit(app.exec_())

if __name__ == "__main__":
    main()