Create bob_gui_hf.py

bob_gui_hf.py

@@ -0,0 +1,450 @@
+#!/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
+def _hide_windows_console():
+    if os.name == 'nt':
+        try:
+            import ctypes
+            hwnd = ctypes.windll.kernel32.GetConsoleWindow()
+            if hwnd:
+                ctypes.windll.user32.ShowWindow(hwnd, 0)
+        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 Whisper:")
+        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([
+            "medium (recommandé)",
+            "small (plus rapide mais moins précis)",
+            "large (plus précis mais plus lent)",
+        ])
+        self.model_combo.setCurrentText("medium (recommandé)")
+        self.model_combo.setStyleSheet("font-size: 11pt; padding: 5px;")
+        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()
+        whisper_model = model_text.split()[0]  # Prendre le premier mot (small/medium/large)
+        
+        # HF selection -> nom de modèle Hugging Face
+        hf_choice = self.hf_combo.currentText()
+        if "Llama-3.2-1B" in hf_choice:
+            hf_model_name = "meta-llama/Llama-3.2-1B-Instruct"
+            fast_mode = True
+        elif "Phi-3" in hf_choice:
+            hf_model_name = "microsoft/Phi-3-mini-4k-instruct"
+            fast_mode = True
+        else:
+            hf_model_name = "mistralai/Mistral-7B-Instruct-v0.3"
+            fast_mode = False
+
+        # 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()
+    app = QApplication(sys.argv)
+    app.setStyle('Fusion')
+    
+    window = BOBProcessorGUI()
+    window.show()
+    
+    sys.exit(app.exec_())
+
+if __name__ == "__main__":
+    main()