Update app.py

app.py

@@ -7,11 +7,12 @@ 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 hf_hub_download
+from huggingface_hub import login, hf_hub_download
 
-# --- Safe Globals for PyTorch 2.6+ ---
+# --- Safe Globals ---
 try:
     from pyannote.audio.core.task import Specifications, Problem, Resolution
     from pyannote.audio.core.model import Model
@@ -42,7 +43,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
@@ -76,7 +77,6 @@ def call_gemini_for_edl(transcript_data, story_prompt, api_key):
         
     url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-09-2025:generateContent?key={api_key}"
     
-    # Updated system prompt to explicitly ignore interviewer comments
     system_prompt = (
         "You are an expert Documentary Senior Editor. Use the provided transcript JSON "
         "(which includes Speaker IDs and word-level timestamps) to create a condensed story. "
@@ -88,19 +88,12 @@ def call_gemini_for_edl(transcript_data, story_prompt, api_key):
         "4. TIMESTAMP INTEGRITY: Use only the exact word-level start and end times from the data."
     )
     
-    # Cleaned up payload to prevent SyntaxErrors with f-strings
     prompt_text = f"Creative Brief: {story_prompt}\n\nTranscript Data:\n{json.dumps(transcript_data)}"
     
     payload = {
-        "contents": [{
-            "parts": [{"text": prompt_text}]
-        }],
-        "systemInstruction": {
-            "parts": [{"text": system_prompt}]
-        },
-        "generationConfig": {
-            "responseMimeType": "application/json"
-        }
+        "contents": [{"parts": [{"text": prompt_text}]}],
+        "systemInstruction": {"parts": [{"text": system_prompt}]},
+        "generationConfig": {"responseMimeType": "application/json"}
     }
     
     try:
@@ -121,7 +114,7 @@ with st.sidebar:
     fps = st.number_input("Timeline FPS", value=25)
     
     st.divider()
-    st.info("API Keys and Tokens are managed via Environment Secrets for security.")
+    st.info("API Keys are managed via Environment Secrets.")
     if not ACTIVE_GEMINI_KEY:
         st.error("⚠️ Gemini API Key not found!")
     if not ACTIVE_HF_TOKEN:
@@ -134,18 +127,16 @@ if uploaded_file:
     if "transcript" not in st.session_state:
         if st.button("Step 1: Transcribe & Diarize"):
             if not ACTIVE_HF_TOKEN or "PASTE_YOUR_HF_TOKEN" in ACTIVE_HF_TOKEN:
-                st.error("Please provide a valid Hugging Face Token in Space Secrets or app.py.")
+                st.error("Please provide a valid Hugging Face Token.")
             else:
-                status_container = st.empty()
-                with status_container.container():
-                    st.write("🔄 **Processing Started...**")
+                with st.spinner("Processing... This may take a moment."):
+                    # Authenticate Globally
+                    login(token=ACTIVE_HF_TOKEN)
                     
-                    # Save local temp file
                     with open("temp_input", "wb") as f:
                         f.write(uploaded_file.getbuffer())
                     
-                    st.write("🎵 **Extracting Audio (WAV)...**")
-                    # Force strict PCM 16kHz Mono for Pyannote compatibility
+                    # Convert to strict WAV using FFmpeg
                     subprocess.run([
                         "ffmpeg", "-i", "temp_input", 
                         "-vn", "-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", 
@@ -153,63 +144,53 @@ if uploaded_file:
                     ])
                     
                     # 1. Diarization
-                    st.write("🗣️ **Running Speaker Diarization...**")
                     diarization = None
                     try:
-                        # Download config manually
+                        # 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 manually into tensor for robust processing
+                        # Load Audio into Memory (Fix for file read issues)
                         waveform, sample_rate = torchaudio.load("temp_audio.wav")
                         
-                        # Ensure we are on GPU
+                        # Move to GPU if available
                         if torch.cuda.is_available():
-                            st.write("🚀 Using GPU for Diarization")
                             pipeline.to(torch.device("cuda"))
                             waveform = waveform.to(torch.device("cuda"))
-                        
-                        # Run pipeline by passing the tensor dictionary
-                        # This is the most reliable way to avoid file I/O issues in Docker
+                            
+                        # Run Pipeline on Tensor
                         diarization_output = pipeline({"waveform": waveform, "sample_rate": sample_rate})
                         
-                        # Handle Wrapper
+                        # Unwrap result
                         if isinstance(diarization_output, tuple):
                             diarization = diarization_output[0]
                         else:
                             diarization = diarization_output
                             
-                        # CRITICAL FIX: Extract annotation from wrapper
+                        # Extract Annotation object
                         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...**")
-                    device = "cuda" if torch.cuda.is_available() else "cpu"
-                    model = whisper.load_model("medium", device=device) 
+                    model = whisper.load_model("medium", device="cuda" if torch.cuda.is_available() else "cpu")
                     result = model.transcribe("temp_audio.wav", word_timestamps=True)
                     
                     # 3. Alignment
-                    st.write("🔗 **Aligning Speakers...**")
                     final_segments = []
-                    
-                    # Pre-calculate turns
                     speaker_turns = []
+                    
                     if diarization:
                         try:
-                            # Robust iteration check
+                            # Iterate safely
                             iterator = None
                             if hasattr(diarization, 'itertracks'):
                                 iterator = diarization.itertracks(yield_label=True)
@@ -217,25 +198,21 @@ if uploaded_file:
                             if iterator:
                                 for turn, _, speaker_id in iterator:
                                     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.")
                         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
                         speaker = "Unknown"
                         
-                        # Matching logic
                         if speaker_turns:
-                            # 1. Strict
+                            # Match speaker
                             for turn in speaker_turns:
                                 if turn["start"] <= mid_time <= turn["end"]:
                                     speaker = turn["speaker"]
                                     break
                             
-                            # 2. Relaxed Fallback
+                            # Fallback distance matching
                             if speaker == "Unknown":
                                 best_dist = 1.0 
                                 for turn in speaker_turns:
@@ -257,20 +234,17 @@ if uploaded_file:
 
     if "transcript" in st.session_state:
         st.divider()
-        
-        # Diarization Preview
         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, remove the interviewer.")
+        brief = st.text_area("Creative Brief", placeholder="e.g. Focus on the yeast story.")
         
         if st.button("Step 2: Create EDL"):
             if not ACTIVE_GEMINI_KEY:
-                st.error("Gemini API Key required. Please set it in Secrets or app.py.")
+                st.error("Gemini API Key required.")
             else:
                 with st.spinner("Analyzing..."):
-                    # Fixed missing parenthesis here
                     edl_segments = call_gemini_for_edl(st.session_state.transcript, brief, ACTIVE_GEMINI_KEY)
                     if edl_segments:
                         final_edl = generate_cmx_edl("AI_Senior_Editor_Cut", edl_segments, uploaded_file.name, fps)