Upload 8 files

README.md

@@ -11,30 +11,95 @@ license: mit
 ---
 
 
-# 🎵 BOB Processor
+# 🎵 BOB Processor - Version Hugging Face
 
-Application de transcription et d'analyse automatique de fichiers audio.
+Application de transcription et d'analyse automatique de fichiers audio utilisant Hugging Face Transformers.
+
+## 🚀 Nouveautés (Mise à jour depuis EXE)
+
+### Améliorations intégrées :
+- ✅ **portable_env.py** : Bootstrap environnement portable avec gestion PyInstaller
+- ✅ **Extraction auteur améliorée** : Support des formats "1 DEMARIA Philippe" → "DEMARIA Philippe"
+- ✅ **Interface GUI avancée** : Suppression automatique des fenêtres console
+- ✅ **Gestion durées audio** : Calcul automatique avec pydub + correction auto P+S/SON
+- ✅ **Variables d'environnement** : Lecture dynamique des modèles depuis l'environnement
+- ✅ **Gestion d'erreurs améliorée** : Encodage UTF-8 robuste
+- ✅ **API factorisée** : Callbacks pour log/progress/cancel dans l'analyse
+
+### Modèles Hugging Face supportés :
+- **Qwen/Qwen2-7B-Instruct** (recommandé) - Excellent pour l'analyse
+- **microsoft/DialoGPT-medium** (plus léger) - Pour PC avec peu de RAM
+- **google/flan-t5-base** (très léger) - Pour tests rapides
 
 ## Fonctionnalités
 
-- 🎵 Transcription audio avec Whisper
-- 🤖 Analyse de contenu avec Hugging Face
-- 📋 Classification automatique des formats (P/P+S/QR/MT)
-- 📝 Extraction d'informations structurées
+- 🎵 **Transcription audio** avec Whisper (Small/Medium)
+- 🤖 **Analyse de contenu** avec Hugging Face Transformers
+- 📋 **Classification automatique** des formats :
+  - **P** = Papier seul (lecture continue)
+  - **P+S** = Papier + Son (avec témoignages/interviews)
+  - **QR** = Questions-Réponses (dialogue en direct)
+  - **MT** = Micro-Trottoir (opinions publiques)
+- 📝 **Extraction d'informations** : Auteur, Qualification, Titre, Durée
+- 🔍 **Détection automatique** des patterns de contenu
 
 ## Utilisation
 
+### Interface Gradio (Web)
 1. Téléchargez un fichier audio (MP3, WAV, etc.)
 2. Cliquez sur "Traiter le fichier"
 3. Obtenez la transcription et l'analyse automatique
 
-## Modèles utilisés
+### Interface GUI (Desktop)
+```bash
+python bob_gui_hf.py
+```
+
+### Script en ligne de commande
+```bash
+python process_bob_hf.py
+```
+
+## Installation
 
-- **Transcription** : Whisper small
-- **Analyse** : Modèles Hugging Face (OPT-350M)
+```bash
+pip install -r requirements.txt
+```
+
+## Architecture
+
+```
+HUGIN PORTABLE BOB/
+├── portable_env.py      # 🆕 Bootstrap environnement portable
+├── transcribe_audio.py  # Transcription Whisper
+├── analyze_bob_hf.py    # 🆕 Analyse Hugging Face (mis à jour)
+├── bob_gui_hf.py        # 🆕 Interface graphique (améliorée)
+├── process_bob_hf.py    # Orchestrateur principal
+├── app.py               # Interface Gradio pour Hugging Face Spaces
+└── requirements.txt     # 🆕 Dépendances nettoyées
+```
+
+## Configuration
+
+Variables d'environnement supportées :
+- `HF_MODEL` : Modèle Hugging Face à utiliser
+- `WHISPER_MODEL` : Modèle Whisper (small/medium/large)
+- `BOB_INPUT_DIR` : Dossier d'entrée des fichiers audio
+- `BOB_TRANSCRIPTIONS_DIR` : Dossier de sortie des transcriptions
+- `BOB_OUTPUT_FILE` : Fichier de résumé final
+- `HF_TOKEN` : Token Hugging Face pour modèles privés
 
 ## Développement
 
-Ce projet est conçu pour fonctionner sur Hugging Face Spaces.
+### Test des améliorations
+```bash
+python test_ameliorations.py
+```
+
+### Compatibilité
+- ✅ Hugging Face Spaces
+- ✅ Environnement portable (PyInstaller)
+- ✅ Windows/Linux/macOS
+- ✅ CPU et GPU (détection automatique)
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

analyze_bob_hf.py

@@ -11,6 +11,7 @@ from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
 from datetime import datetime
 import re
 import traceback
+from dotenv import load_dotenv
 
 # Bootstrap environnement portable
 try:
@@ -19,28 +20,39 @@ try:
 except Exception:
     pass
 
+# Charger les variables d'environnement
+try:
+    load_dotenv(Path(__file__).parent.parent / ".env")
+except Exception:
+    pass
+
 # Configuration (via env, avec fallback local)
 BASE_DIR = Path(os.environ.get("BOB_BASE_DIR", Path(__file__).parent.parent))
 TRANSCRIPTIONS_DIR = Path(os.environ.get("BOB_TRANSCRIPTIONS_DIR", BASE_DIR / "output" / "transcriptions"))
 OUTPUT_FILE = Path(os.environ.get("BOB_OUTPUT_FILE", BASE_DIR / "output" / "resume_bob.txt"))
 HF_MODEL = os.environ.get("HF_MODEL", "Qwen/Qwen2-7B-Instruct")  # Qwen 7B par défaut
 
+def get_hf_model():
+    """Récupère le modèle Hugging Face depuis la variable d'environnement"""
+    return os.environ.get("HF_MODEL", "Qwen/Qwen2-7B-Instruct")
+
 
 def load_hf_model():
     """Charge un modèle Hugging Face"""
     try:
-        print(f"Chargement du modèle Hugging Face: {HF_MODEL}")
+        hf_model = get_hf_model()  # Lire dynamiquement
+        print(f"Chargement du modèle Hugging Face: {hf_model}")
         
         # Utiliser pipeline pour plus de simplicité
         generator = pipeline(
             "text-generation",
-            model=HF_MODEL,
+            model=hf_model,
             torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
             device_map="auto" if torch.cuda.is_available() else "cpu",
             token=os.environ.get("HF_TOKEN")  # Pour les modèles privés
         )
         
-        print(f"✅ Modèle {HF_MODEL} chargé avec succès")
+        print(f"✅ Modèle {hf_model} chargé avec succès")
         return generator
     except Exception as e:
         print(f"❌ Erreur lors du chargement du modèle Hugging Face: {e}")
@@ -351,44 +363,29 @@ def apply_duration_correction(result, duration_seconds, format_indicators=None):
 def extract_author_from_filename(filename):
     """Extrait le nom du journaliste depuis le nom du fichier"""
     try:
+        import re
+        
         # Nettoyer le nom du fichier
         clean_name = filename.replace('_transcription.txt', '').replace('.mp3', '').replace('.MP3', '')
         
-        # Patterns courants pour extraire un nom (prénom + nom)
-        words = clean_name.split()
-        
-        # Chercher une séquence de 2 mots qui commencent par une majuscule
-        for i in range(len(words) - 1):
-            word1 = words[i].strip('()[]{}.,;:!?-_')
-            word2 = words[i + 1].strip('()[]{}.,;:!?-_')
-            
-            # Vérifier si les deux mots ressemblent à un prénom + nom
-            if (len(word1) >= 2 and len(word2) >= 2 and 
-                word1[0].isupper() and word2[0].isupper() and
-                word1.isalpha() and word2.isalpha()):
-                return f"{word1} {word2}"
+        # Pattern spécifique pour "1 DEMARIA Philippe" -> "DEMARIA Philippe"
+        # Supprimer les numéros au début
+        clean_name = re.sub(r'^\d+\s+', '', clean_name).strip()
         
-        # Si pas trouvé, chercher le premier mot qui commence par une majuscule
-        for word in words:
-            clean_word = word.strip('()[]{}.,;:!?-_')
-            if len(clean_word) >= 2 and clean_word[0].isupper() and clean_word.isalpha():
-                # Essayer de trouver le mot suivant
-                word_index = words.index(word)
-                if word_index + 1 < len(words):
-                    next_word = words[word_index + 1].strip('()[]{}.,;:!?-_')
-                    if len(next_word) >= 2 and next_word[0].isupper() and next_word.isalpha():
-                        return f"{clean_word} {next_word}"
-                return clean_word
+        # Si on a encore quelque chose, c'est probablement un nom
+        if clean_name:
+            return clean_name
         
         return "Inconnu"
         
     except Exception as e:
-        print(f"Erreur extraction auteur de {filename}: {e}")
+        print(f"Erreur extraction auteur: {e}")
         return "Inconnu"
 
 def get_audio_duration(audio_filename, input_dir):
-    """Calcule la durée d'un fichier audio en secondes totales"""
+    """Calcule la durée d'un fichier audio en secondes totales (version unique)"""
     try:
+        # portable_env a déjà injecté ffmpeg dans le PATH si nécessaire
         from pydub import AudioSegment
         audio_path = None
         audio_extensions = ['.mp3', '.wav', '.m4a', '.flac', '.ogg', '.mp4', '.avi', '.mov']
@@ -415,7 +412,7 @@ def get_audio_duration(audio_filename, input_dir):
         return None
 
 def get_transcription_files(transcriptions_dir):
-    """Récupère tous les fichiers de transcription"""
+    """Récupère tous les fichiers de transcription (unique)"""
     if not transcriptions_dir.exists():
         print(f"Le dossier {transcriptions_dir} n'existe pas")
         return []

bob_gui_hf.py

@@ -28,17 +28,80 @@ except Exception as _e:
 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
+# 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)
@@ -236,18 +299,62 @@ class BOBProcessorGUI(QMainWindow):
         config_layout.addWidget(self.output_btn, 1, 2)
         
         # Options
-        model_label = QLabel("🧠 Modèle Whisper:")
+        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([
-            "medium (recommandé)",
-            "small (plus rapide mais moins précis)",
-            "large (plus précis mais plus lent)",
+            "Whisper Small : 2x plus rapide (recommandé)",
+            "Whisper Medium : utile si qualité audio faible",
         ])
-        self.model_combo.setCurrentText("medium (recommandé)")
+        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([
+            "Qwen/Qwen2-7B-Instruct (recommandé)",
+            "microsoft/DialoGPT-medium (plus léger)",
+            "google/flan-t5-base (très léger)",
+        ])
+        self.hf_combo.setCurrentText("Qwen/Qwen2-7B-Instruct (recommandé)")
+        self.hf_combo.setStyleSheet("font-size: 11pt; padding: 5px;")
+        # Tooltip explicative pour le choix du modèle
+        self.hf_combo.setToolTip(
+            "💡 Choix du modèle d'analyse Hugging Face :\n\n"
+            "• Qwen2-7B : Recommandé, excellent pour l'analyse\n"
+            "  Bonne précision, nécessite plus de ressources\n\n"
+            "• DialoGPT-medium : Modèle plus léger\n"
+            "  Utilisez si vous avez peu de RAM\n\n"
+            "• FLAN-T5-base : Très léger\n"
+            "  Pour PC peu puissants ou tests rapides"
+        )
+        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
@@ -353,18 +460,26 @@ class BOBProcessorGUI(QMainWindow):
         
         # Configuration du thread de traitement
         model_text = self.model_combo.currentText()
-        whisper_model = model_text.split()[0]  # Prendre le premier mot (small/medium/large)
+        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
         hf_choice = self.hf_combo.currentText()
-        if "Llama-3.2-1B" in hf_choice:
-            hf_model_name = "meta-llama/Llama-3.2-1B-Instruct"
+        if "Qwen2-7B" in hf_choice:
+            hf_model_name = "Qwen/Qwen2-7B-Instruct"
+            fast_mode = False
+        elif "DialoGPT" in hf_choice:
+            hf_model_name = "microsoft/DialoGPT-medium"
             fast_mode = True
-        elif "Phi-3" in hf_choice:
-            hf_model_name = "microsoft/Phi-3-mini-4k-instruct"
+        elif "flan-t5" in hf_choice:
+            hf_model_name = "google/flan-t5-base"
             fast_mode = True
         else:
-            hf_model_name = "mistralai/Mistral-7B-Instruct-v0.3"
+            hf_model_name = "Qwen/Qwen2-7B-Instruct"
             fast_mode = False
 
         # Configuration des variables d'environnement
@@ -438,6 +553,7 @@ class BOBProcessorGUI(QMainWindow):
 
 def main():
     _hide_windows_console()
+    _suppress_console_windows()  # Suppression avancée des consoles
     app = QApplication(sys.argv)
     app.setStyle('Fusion')
     

portable_env.py

@@ -8,6 +8,7 @@ offre un point unique pour configurer les variables d'environnement.
 from __future__ import annotations
 
 import os
+import sys
 from pathlib import Path
 
 
@@ -30,9 +31,15 @@ def setup_portable_env(base_dir: Path | None = None, force_ollama_portable: bool
     Retourne base_dir normalisé.
     """
     if base_dir is None:
-        # base_dir = racine du projet (.. depuis EXE)
-        here = Path(__file__).resolve().parent
-        base_dir = (here.parent).resolve()
+        # Détection robuste du répertoire de base (compatible PyInstaller)
+        if getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS'):
+            # Application packagée avec PyInstaller
+            # sys.executable pointe vers BOB.exe dans le bon dossier
+            base_dir = Path(sys.executable).parent.resolve()
+        else:
+            # Développement normal
+            here = Path(__file__).resolve().parent
+            base_dir = (here.parent).resolve()
 
     # Expo pour d'autres modules
     os.environ.setdefault("BOB_BASE_DIR", str(base_dir))
@@ -77,8 +84,8 @@ def setup_portable_env(base_dir: Path | None = None, force_ollama_portable: bool
 
     if force_ollama_portable:
         os.environ["BOB_FORCE_PORTABLE_OLLAMA"] = "1"
-        # Permettre override externe, sinon 11435
-        portable_host = os.environ.get("PORTABLE_OLLAMA_HOST", "http://localhost:11435")
+        # Permettre override externe, sinon 11434 (port standard Ollama)
+        portable_host = os.environ.get("PORTABLE_OLLAMA_HOST", "http://localhost:11434")
         os.environ["OLLAMA_HOST"] = portable_host
 
     return base_dir

process_bob_hf.py

@@ -87,7 +87,7 @@ def run_script(script_path, step_name, python_executable=None):
             capture_output=True,
             text=True,
             encoding='utf-8',
-            errors='replace'
+            errors='replace'  # Gérer les erreurs d'encodage
         )
         
         end_time = time.time()
@@ -187,7 +187,7 @@ def main():
     
     print()
     
-    # Déterminer l'exécutable Python
+    # Déterminer l'exécutable Python (le même que celui utilisé actuellement)
     python_exe = sys.executable
     print(f"🐍 Utilisation de Python: {python_exe}")
     print()

requirements.txt

@@ -6,24 +6,16 @@ bitsandbytes>=0.41.0  # Pour quantization 4-bit
 sentencepiece>=0.1.99
 protobuf<=3.20.3  # Pour compatibilité avec certains modèles
 
-# Dépendances existantes
+# Dépendances audio et transcription
 openai-whisper>=20231117
 pydub>=0.25.1
-PyQt5>=5.15.0
-python-dotenv>=1.0.0
-
-# Pour l'environnement portable
-numpy>=1.21.0
-scipy>=1.7.0
 
+# Interface utilisateur
+PyQt5>=5.15.0
 gradio>=4.0.0
-openai-whisper>=20231117
-torch>=2.0.0
-transformers>=4.35.0
-accelerate>=0.20.0
-pydub>=0.25.1
+
+# Utilitaires
+python-dotenv>=1.0.0
 numpy>=1.21.0
 scipy>=1.7.0
-python-dotenv>=1.0.0
-sentencepiece>=0.1.99