Update app.py

app.py

@@ -8,26 +8,21 @@ import os
 import tempfile
 from pathlib import Path
 import sys
+import traceback
 
 # Ajouter le dossier courant au path
 sys.path.append(os.path.dirname(__file__))
 
-# Importer les modules nécessaires - avec fonctions de secours
+# Importer les modules nécessaires
 try:
     from transcribe_audio import transcribe_file, load_whisper_model, get_audio_files
     from analyze_bob_hf import analyze_files_hf
     print("✅ Modules importés avec succès")
+    MODULES_AVAILABLE = True
 except Exception as e:
     print(f"❌ Erreur d'import: {e}")
-    # Fonctions de secours pour le test
-    def load_whisper_model(model_name):
-        return "mock_model"
-    
-    def transcribe_file(model, audio_file, output_dir):
-        return True
-        
-    def analyze_files_hf(**kwargs):
-        return {"success": True, "count": 1, "ok": 1}
+    traceback.print_exc()
+    MODULES_AVAILABLE = False
 
 def process_audio_file(audio_file):
     """Traite un fichier audio et retourne les résultats"""
@@ -43,54 +38,90 @@ def process_audio_file(audio_file):
             output_dir.mkdir(parents=True, exist_ok=True)
             transcriptions_dir.mkdir(parents=True, exist_ok=True)
             
+            print(f"📁 Dossiers créés: input={input_dir}, output={output_dir}")
+            
             # Copier le fichier audio
             audio_path = input_dir / os.path.basename(audio_file)
             import shutil
             shutil.copy2(audio_file, audio_path)
+            print(f"📁 Fichier audio copié: {audio_path}")
             
             # Configurer les variables d'environnement
             os.environ["BOB_INPUT_DIR"] = str(input_dir)
             os.environ["BOB_TRANSCRIPTIONS_DIR"] = str(transcriptions_dir)
             os.environ["BOB_OUTPUT_FILE"] = str(output_dir / "resume_bob.txt")
             os.environ["WHISPER_MODEL"] = "small"  # Modèle léger pour le Space
+            os.environ["HF_MODEL"] = "facebook/opt-350m"  # Modèle gratuit et léger
+            
+            print("🔄 Début de la transcription...")
             
             # Transcription
-            print("🔄 Transcription en cours...")
             model = load_whisper_model("small")
             success = transcribe_file(model, audio_path, transcriptions_dir)
             
             if not success:
-                return "❌ Erreur de transcription", ""
+                return "❌ Erreur de transcription", "❌ Erreur de transcription"
             
-            # Analyse
-            print("🤖 Analyse en cours...")
-            result = analyze_files_hf(
-                transcriptions_dir=transcriptions_dir,
-                input_dir=input_dir,
-                output_file=output_dir / "resume_bob.txt",
-                log_fn=print
-            )
+            print("✅ Transcription terminée")
             
-            # Lire les résultats
-            resume_path = output_dir / "resume_bob.txt"
-            if resume_path.exists():
-                with open(resume_path, 'r', encoding='utf-8') as f:
-                    resume_content = f.read()
-            else:
-                resume_content = "❌ Fichier de résultat non trouvé"
-            
-            # Lire la transcription
-            transcription_files = list(transcriptions_dir.glob("*.txt"))
+            # Lire la transcription pour debug
+            transcription_files = list(transcriptions_dir.glob("*_transcription.txt"))
             if transcription_files:
                 with open(transcription_files[0], 'r', encoding='utf-8') as f:
                     transcription_content = f.read()
+                print(f"📝 Transcription lue ({len(transcription_content)} caractères)")
             else:
                 transcription_content = "❌ Transcription non trouvée"
+                return transcription_content, "❌ Pas de transcription générée"
+            
+            print("🤖 Début de l'analyse...")
+            print(f"📁 Transcriptions dir: {transcriptions_dir}")
+            print(f"📁 Input dir: {input_dir}")
+            print(f"📁 Output file: {output_dir / 'resume_bob.txt'}")
+            
+            # Vérifier le contenu du dossier transcriptions
+            print(f"📁 Fichiers dans transcriptions: {list(transcriptions_dir.iterdir())}")
             
-            return transcription_content, resume_content
+            # Analyse - avec les bons chemins
+            try:
+                result = analyze_files_hf(
+                    transcriptions_dir=transcriptions_dir,
+                    input_dir=input_dir,
+                    output_file=output_dir / "resume_bob.txt",
+                    log_fn=print
+                )
+                
+                print(f"✅ Analyse terminée: {result}")
+                
+                # Vérifier si le fichier de résultat existe
+                resume_path = output_dir / "resume_bob.txt"
+                print(f"🔍 Recherche fichier: {resume_path}")
+                print(f"📁 Contenu du dossier output: {list(output_dir.iterdir())}")
+                
+                if resume_path.exists():
+                    with open(resume_path, 'r', encoding='utf-8') as f:
+                        resume_content = f.read()
+                    print("✅ Fichier de résultat trouvé et lu")
+                else:
+                    resume_content = f"❌ Fichier de résultat non trouvé\nChemin attendu: {resume_path}\nContenu du dossier: {list(output_dir.iterdir())}"
+                    print("❌ Fichier de résultat non trouvé")
+                    # Afficher le contenu détaillé pour debug
+                    print("🔍 Contenu détaillé des dossiers:")
+                    print(f"  Input: {list(input_dir.iterdir())}")
+                    print(f"  Transcriptions: {list(transcriptions_dir.iterdir())}")
+                    print(f"  Output: {list(output_dir.iterdir())}")
+                
+                return transcription_content, resume_content
+                
+            except Exception as analyze_error:
+                error_msg = f"❌ Erreur pendant l'analyse:\n{str(analyze_error)}\n\nTraceback:\n{traceback.format_exc()}"
+                print(error_msg)
+                return transcription_content, error_msg
             
     except Exception as e:
-        return f"❌ Erreur: {str(e)}", f"❌ Erreur: {str(e)}"
+        error_msg = f"❌ Erreur générale:\n{str(e)}\n\nTraceback:\n{traceback.format_exc()}"
+        print(error_msg)
+        return error_msg, error_msg
 
 # Interface Gradio
 with gr.Blocks(title="BOB Processor") as demo: