Update app.py

app.py

@@ -30,4 +30,163 @@ def format_timecode(seconds, fps=25):
     minutes = (total_seconds % 3600) // 60
     secs = total_seconds % 60
     frames = int((seconds - total_seconds) * fps)
-    return f"{hou
+    return f"{hours:02}:{minutes:02}:{secs:02}:{frames:02}"
+
+def generate_cmx_edl(edl_title, segments, source_name, fps=25):
+    """Constructs a CMX 3600 formatted EDL."""
+    edl_lines = [f"TITLE: {edl_title}", "FCM: NON-DROP FRAME\n"]
+    rec_start = 0.0
+    for i, seg in enumerate(segments, 1):
+        src_in = format_timecode(seg['src_start'], fps)
+        src_out = format_timecode(seg['src_end'], fps)
+        duration = seg['src_end'] - seg['src_start']
+        rec_in = format_timecode(rec_start, fps)
+        rec_out = format_timecode(rec_start + duration, fps)
+        
+        edl_lines.append(f"{i:03}  AX       V     C        {src_in} {src_out} {rec_in} {rec_out}")
+        edl_lines.append(f"* FROM CLIP NAME: {source_name}")
+        edl_lines.append(f"* {seg.get('note', 'Clip')}\n")
+        rec_start += duration
+    return "\n".join(edl_lines)
+
+def call_gemini_for_edl(transcript_data, story_prompt, api_key):
+    """Sends diarized, word-level transcript to Gemini Senior Editor."""
+    if not api_key:
+        st.error("Gemini API Key is missing. Set it in Space Secrets or app.py.")
+        return None
+        
+    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. "
+        "Output ONLY a valid JSON array of segments with 'src_start', 'src_end', and 'note'. "
+        "CRITICAL RULES:\n"
+        "1. IGNORE ALL INTERVIEWER COMMENTS: Do not include any speech or segments where the interviewer is speaking.\n"
+        "2. REMOVE FLUFF: Delete 'um', 'ah', repeats, and irrelevant filler.\n"
+        "3. NARRATIVE FLOW: Focus on the subject's high-energy responses and narrative hooks.\n"
+        "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"
+        }
+    }
+    
+    try:
+        res = requests.post(url, json=payload)
+        res.raise_for_status()
+        result_json = res.json()
+        return json.loads(result_json['candidates'][0]['content']['parts'][0]['text'])
+    except Exception as e:
+        st.error(f"Senior Editor AI Error: {e}")
+        return None
+
+# --- Streamlit UI ---
+st.set_page_config(page_title="DocAI Editor", layout="wide")
+st.title("Documentary AI: Pipeline")
+
+with st.sidebar:
+    st.header("Project Settings")
+    fps = st.number_input("Timeline FPS", value=25)
+    
+    st.divider()
+    st.info("API Keys and Tokens are managed via Environment Secrets for security.")
+    if not ACTIVE_GEMINI_KEY:
+        st.error("⚠️ Gemini API Key not found!")
+    if not ACTIVE_HF_TOKEN:
+        st.error("⚠️ HF Token not found!")
+
+uploaded_file = st.file_uploader("Upload Video/Audio Clip", type=["mp4", "m4a", "wav", "mp3", "mov"])
+
+if uploaded_file:
+    # --- Step 1: Technical Processing ---
+    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.")
+            else:
+                with st.spinner("Processing... Extracting audio, identifying speakers, and transcribing:"):
+                    # Save local temp file
+                    with open("temp_input", "wb") as f:
+                        f.write(uploaded_file.getbuffer())
+                    
+                    # Optimized Audio: m4a, 64kbps, 16kHz, mono
+                    subprocess.run([
+                        "ffmpeg", "-i", "temp_input", 
+                        "-vn", "-acodec", "aac", "-ab", "64k", "-ar", "16000", "-ac", "1", 
+                        "audio_optimized.m4a", "-y"
+                    ])
+                    
+                    # 1. Diarization
+                    try:
+                        pipeline = Pipeline.from_pretrained(
+                            "pyannote/speaker-diarization-3.1",
+                            use_auth_token=ACTIVE_HF_TOKEN
+                        )
+                        
+                        if torch.cuda.is_available():
+                            pipeline.to(torch.device("cuda"))
+                            
+                        diarization = pipeline("audio_optimized.m4a")
+                    except Exception as e:
+                        st.error(f"Diarization Error: {e}")
+                        st.stop()
+                    
+                    # 2. Whisper Transcription
+                    model = whisper.load_model("base")
+                    result = model.transcribe("audio_optimized.m4a", word_timestamps=True)
+                    
+                    # 3. Alignment
+                    final_segments = []
+                    for segment in result['segments']:
+                        mid_time = (segment['start'] + segment['end']) / 2
+                        speaker = "Unknown"
+                        for turn, _, speaker_id in diarization.itertracks(yield_label=True):
+                            if turn.start <= mid_time <= turn.end:
+                                speaker = speaker_id
+                                break
+                        
+                        final_segments.append({
+                            "speaker": speaker,
+                            "text": segment['text'],
+                            "start": segment['start'],
+                            "end": segment['end'],
+                            "words": segment.get('words', [])
+                        })
+                    
+                    st.session_state.transcript = final_segments
+                    st.success("Transcription and Diarization Complete.")
+
+    if "transcript" in st.session_state:
+        st.divider()
+        
+        # Diarization Preview to help the user identify roles
+        with st.expander("Transcript Preview (Diarized)"):
+            for seg in st.session_state.transcript[:20]: # Show first 20 segments
+                st.write(f"**{seg['speaker']}:** {seg['text']}")
+        
+        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:
+                st.error("Gemini API Key required. Please set it in Secrets or app.py.")
+            else:
+                with st.spinner("Analyzing..."):
+                    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)
+                        st.subheader("EDL Preview")
+                        st.code(final_edl, language="text")
+                        st.download_button("Download EDL", data=final_edl, file_name="edit.edl")