Update app.py

app.py

@@ -6,28 +6,21 @@ 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
+from huggingface_hub import hf_hub_download
 
 # --- Safe Globals ---
 try:
     from pyannote.audio.core.task import Specifications, Problem, Resolution
-    from pyannote.audio.core.model import Model
-    from pyannote.audio.pipelines.speaker_diarization import SpeakerDiarization
     
     torch.serialization.add_safe_globals([
         torch.torch_version.TorchVersion,
         Specifications,
         Problem,
         Resolution,
-        Model,
-        SpeakerDiarization,
         numpy.dtype,
         torch.nn.modules.container.ModuleList,
-        numpy.core.multiarray.scalar
     ])
 except Exception as e:
     print(f"Safe Globals Warning: {e}")
@@ -129,94 +122,79 @@ 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)
-                    
+                with st.spinner("Processing... This may take a few minutes."):
                     with open("temp_input", "wb") as f:
                         f.write(uploaded_file.getbuffer())
                     
-                    # Convert to strict WAV using FFmpeg
+                    # Convert to WAV
                     subprocess.run([
                         "ffmpeg", "-i", "temp_input", 
                         "-vn", "-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", 
                         "temp_audio.wav", "-y"
-                    ])
+                    ], capture_output=True)
                     
-                    # 1. Diarization
+                    # 1. Diarization - FIXED VERSION
                     diarization = None
+                    speaker_turns = []
+                    
                     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)
+                        st.write("Loading diarization pipeline...")
                         
-                        # Load Audio into Memory (Fix for file read issues)
-                        waveform, sample_rate = torchaudio.load("temp_audio.wav")
+                        # THE KEY FIX: Use direct from_pretrained with token
+                        pipeline = Pipeline.from_pretrained(
+                            "pyannote/speaker-diarization-3.1",
+                            use_auth_token=ACTIVE_HF_TOKEN
+                        )
                         
-                        # Move to GPU if available
                         if torch.cuda.is_available():
                             pipeline.to(torch.device("cuda"))
-                            waveform = waveform.to(torch.device("cuda"))
-                            
-                        # Run Pipeline on Tensor
-                        diarization_output = pipeline({"waveform": waveform, "sample_rate": sample_rate})
                         
-                        # Unwrap result
-                        if isinstance(diarization_output, tuple):
-                            diarization = diarization_output[0]
+                        st.write("Running speaker diarization...")
+                        diarization = pipeline("temp_audio.wav")
+                        
+                        # Extract speaker turns
+                        if diarization and hasattr(diarization, 'itertracks'):
+                            for turn, _, speaker_id in diarization.itertracks(yield_label=True):
+                                speaker_turns.append({
+                                    "start": turn.start, 
+                                    "end": turn.end, 
+                                    "speaker": speaker_id
+                                })
+                            st.write(f"✓ Found {len(speaker_turns)} speaker segments")
                         else:
-                            diarization = diarization_output
+                            st.warning("Diarization completed but no speaker turns detected")
                             
-                        # Extract Annotation object
-                        if not hasattr(diarization, "itertracks"):
-                             if hasattr(diarization_output, "annotation"):
-                                 diarization = diarization_output.annotation
-
                     except Exception as e:
                         st.error(f"Diarization Error: {e}")
-                        diarization = None
+                        st.write("Continuing without speaker identification...")
                     
                     # 2. Whisper Transcription
-                    model = whisper.load_model("medium", device="cuda" if torch.cuda.is_available() else "cpu")
+                    st.write("Transcribing audio...")
+                    model = whisper.load_model("base")
                     result = model.transcribe("temp_audio.wav", word_timestamps=True)
                     
                     # 3. Alignment
                     final_segments = []
-                    speaker_turns = []
                     
-                    if diarization:
-                        try:
-                            # Iterate safely
-                            iterator = None
-                            if hasattr(diarization, 'itertracks'):
-                                iterator = diarization.itertracks(yield_label=True)
-                            
-                            if iterator:
-                                for turn, _, speaker_id in iterator:
-                                    speaker_turns.append({"start": turn.start, "end": turn.end, "speaker": speaker_id})
-                        except Exception as e:
-                            print(f"Error iterating tracks: {e}")
-
                     for segment in result['segments']:
                         mid_time = (segment['start'] + segment['end']) / 2
                         speaker = "Unknown"
                         
                         if speaker_turns:
-                            # Match speaker
+                            # Match speaker by midpoint
                             for turn in speaker_turns:
                                 if turn["start"] <= mid_time <= turn["end"]:
                                     speaker = turn["speaker"]
                                     break
                             
-                            # Fallback distance matching
+                            # Fallback: find closest speaker within 1 second
                             if speaker == "Unknown":
-                                best_dist = 1.0 
+                                best_dist = 1.0
                                 for turn in speaker_turns:
-                                    dist = min(abs(turn["start"] - mid_time), abs(turn["end"] - mid_time))
+                                    dist = min(
+                                        abs(turn["start"] - mid_time), 
+                                        abs(turn["end"] - mid_time)
+                                    )
                                     if dist < best_dist:
                                         best_dist = dist
                                         speaker = turn["speaker"]
@@ -230,15 +208,16 @@ if uploaded_file:
                         })
                     
                     st.session_state.transcript = final_segments
-                    st.success("Complete!")
+                    st.success(f"✓ Processing complete! Transcribed {len(final_segments)} segments")
 
     if "transcript" in st.session_state:
         st.divider()
+        
         with st.expander("Transcript Preview (Diarized)"):
             for seg in st.session_state.transcript[:20]: 
                 st.markdown(f"**{seg['speaker']}:** {seg['text']}")
         
-        brief = st.text_area("Creative Brief", placeholder="e.g. Focus on the yeast story.")
+        brief = st.text_area("Creative Brief", placeholder="e.g. Focus on the yeast story, remove the interviewer.")
         
         if st.button("Step 2: Create EDL"):
             if not ACTIVE_GEMINI_KEY: