Update app.py

app.py

@@ -6,12 +6,13 @@ import os
 import requests
 import torch
 import numpy
-import torchaudio
-import torchaudio.transforms as T
 from datetime import timedelta
 from pyannote.audio import Pipeline
 from huggingface_hub import login, hf_hub_download
 
+# --- Fix for OMP Error (Critical for T4 Spaces) ---
+os.environ["OMP_NUM_THREADS"] = "1"
+
 # --- Safe Globals for PyTorch 2.6+ ---
 try:
     from pyannote.audio.core.task import Specifications, Problem, Resolution
@@ -43,7 +44,7 @@ ACTIVE_HF_TOKEN = ENV_HF_TOKEN if ENV_HF_TOKEN else HARDCODED_HF_TOKEN
 ACTIVE_GEMINI_KEY = ENV_GEMINI_KEY if ENV_GEMINI_KEY else HARDCODED_GEMINI_KEY
 
 def format_timecode(seconds, fps=25):
-    """Converts seconds to HH:MM:SS:FF for Resolve/Premiere."""
+    """Converts seconds to HH:MM:SS:FF."""
     td = timedelta(seconds=seconds)
     total_seconds = int(td.total_seconds())
     hours = total_seconds // 3600
@@ -129,14 +130,15 @@ if uploaded_file:
             if not ACTIVE_HF_TOKEN or "PASTE_YOUR_HF_TOKEN" in ACTIVE_HF_TOKEN:
                 st.error("Please provide a valid Hugging Face Token.")
             else:
-                with st.spinner("Processing... This may take a moment."):
-                    # Authenticate Globally
-                    login(token=ACTIVE_HF_TOKEN)
+                status_container = st.empty()
+                with status_container.container():
+                    st.write("🔄 **Processing Started...**")
                     
                     with open("temp_input", "wb") as f:
                         f.write(uploaded_file.getbuffer())
                     
-                    # Convert to strict WAV using FFmpeg
+                    st.write("🎵 **Extracting Audio (WAV)...**")
+                    # Strict WAV (PCM)
                     subprocess.run([
                         "ffmpeg", "-i", "temp_input", 
                         "-vn", "-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", 
@@ -144,60 +146,41 @@ if uploaded_file:
                     ])
                     
                     # 1. Diarization
-                    st.write("🗣️ **Running Speaker Diarization (GPU Mode)...**")
+                    st.write("🗣️ **Running Speaker Diarization...**")
                     diarization = None
                     try:
-                        # Load Config Manually
-                        config_path = hf_hub_download(
-                            repo_id="pyannote/speaker-diarization-3.1", 
-                            filename="config.yaml", 
-                            token=ACTIVE_HF_TOKEN
-                        )
-                        pipeline = Pipeline.from_pretrained(config_path)
-                        
-                        # Load Audio into Memory
-                        waveform, sample_rate = torchaudio.load("temp_audio.wav")
+                        # Global Login
+                        login(token=ACTIVE_HF_TOKEN)
                         
-                        # Verify Audio is not silent
-                        max_amp = waveform.abs().max().item()
-                        print(f"DEBUG: Audio Loaded. Shape: {waveform.shape}, Max Amp: {max_amp}")
-                        if max_amp == 0:
-                            st.error("Audio is silent! Check FFmpeg conversion.")
+                        # Load Pipeline Standard Way
+                        pipeline = Pipeline.from_pretrained("pyannote/speaker-diarization-3.1")
                         
-                        # Move Pipeline AND Data to GPU
                         if torch.cuda.is_available():
-                            device = torch.device("cuda")
-                            st.write("🚀 GPU Detected & Active")
-                            pipeline.to(device)
-                            waveform = waveform.to(device)
-                        else:
-                            st.warning("⚠️ No GPU detected. Running slow on CPU.")
-                            
-                        # Run Pipeline on Tensor
-                        # Passing dictionary ensures pyannote doesn't try to reload from disk
-                        diarization_output = pipeline({"waveform": waveform, "sample_rate": sample_rate})
+                            st.write("🚀 Using GPU for Diarization")
+                            pipeline.to(torch.device("cuda"))
                         
-                        # Debug Structure
-                        print(f"DEBUG: Output Type: {type(diarization_output)}")
-                        print(f"DEBUG: Output Dir: {dir(diarization_output)}")
-
-                        # Robust Unwrap
+                        # Run on file path
+                        diarization_output = pipeline("temp_audio.wav")
+                        
+                        # Handle Output Wrapper
                         if isinstance(diarization_output, tuple):
                             diarization = diarization_output[0]
                         else:
                             diarization = diarization_output
                             
-                        # Final Extraction Attempt
+                        # CRITICAL FIX: Extract annotation
                         if not hasattr(diarization, "itertracks"):
                              if hasattr(diarization_output, "annotation"):
                                  diarization = diarization_output.annotation
+                             elif hasattr(diarization_output, "get"):
+                                 diarization = diarization_output.get("annotation", diarization_output)
 
                     except Exception as e:
                         st.error(f"Diarization Error: {e}")
                         diarization = None
                     
                     # 2. Whisper Transcription
-                    st.write("📝 **Transcribing with Whisper (GPU Mode)...**")
+                    st.write("📝 **Transcribing with Whisper...**")
                     device = "cuda" if torch.cuda.is_available() else "cpu"
                     model = whisper.load_model("medium", device=device) 
                     result = model.transcribe("temp_audio.wav", word_timestamps=True)
@@ -209,7 +192,6 @@ if uploaded_file:
                     
                     if diarization:
                         try:
-                            # Iterate safely
                             iterator = None
                             if hasattr(diarization, 'itertracks'):
                                 iterator = diarization.itertracks(yield_label=True)
@@ -219,9 +201,9 @@ if uploaded_file:
                                     speaker_turns.append({"start": turn.start, "end": turn.end, "speaker": speaker_id})
                                 st.write(f"✅ Found {len(speaker_turns)} speaker turns.")
                             else:
-                                st.warning("⚠️ Pipeline ran but returned no tracks.")
+                                st.warning("⚠️ Pipeline ran but returned no iterable tracks.")
                         except Exception as e:
-                            st.error(f"Error iterating tracks: {e}")
+                            print(f"Error iterating tracks: {e}")
 
                     for segment in result['segments']:
                         mid_time = (segment['start'] + segment['end']) / 2
@@ -233,6 +215,7 @@ if uploaded_file:
                                     speaker = turn["speaker"]
                                     break
                             
+                            # Fallback distance matching
                             if speaker == "Unknown":
                                 best_dist = 1.0 
                                 for turn in speaker_turns: