Update app.py

app.py

@@ -113,285 +113,9 @@ def generate_cmx_edl(edl_title, segments, source_name, fps=25):
     return "\n".join(edl_lines)
 
 def generate_xml(sequence_name, segments, source_name, fps=25):
-    """Constructs a Final Cut Pro 7 XML (compatible with DaVinci Resolve)."""
+    """Constructs a Final Cut Pro 7 XML with Video AND Audio Track 1."""
     
-    # XML Header
     xml_output = [
         '<?xml version="1.0" encoding="UTF-8"?>',
         '<!DOCTYPE xmeml>',
-        '<xmeml version="4">',
-        '<sequence>',
-        f'\t<name>{sequence_name}</name>',
-        '\t<rate>',
-        f'\t\t<timebase>{fps}</timebase>',
-        '\t</rate>',
-        '\t<media>',
-        '\t\t<video>',
-        '\t\t\t<format>',
-        '\t\t\t\t<samplecharacteristics>',
-        f'\t\t\t\t\t<rate><timebase>{fps}</timebase></rate>',
-        '\t\t\t\t\t<width>1920</width>',
-        '\t\t\t\t\t<height>1080</height>',
-        '\t\t\t\t\t<pixelaspectratio>square</pixelaspectratio>',
-        '\t\t\t\t</samplecharacteristics>',
-        '\t\t\t</format>',
-        '\t\t\t<track>'
-    ]
-
-    # Timeline Tracker
-    timeline_head_frames = 0
-    
-    for i, seg in enumerate(segments, 1):
-        # Calculate Frame Data
-        src_in_frames = seconds_to_frames(seg['src_start'], fps)
-        src_out_frames = seconds_to_frames(seg['src_end'], fps)
-        duration_frames = src_out_frames - src_in_frames
-        
-        # Timeline positions
-        tl_start = timeline_head_frames
-        tl_end = tl_start + duration_frames
-        
-        clip_note = seg.get('note', 'Junior Editor Selection')
-
-        # XML Clip Item
-        xml_output.append(f'\t\t\t\t<clipitem id="clipitem-{i}">')
-        xml_output.append(f'\t\t\t\t\t<name>{clip_note}</name>')
-        xml_output.append(f'\t\t\t\t\t<duration>{duration_frames}</duration>')
-        xml_output.append(f'\t\t\t\t\t<rate><timebase>{fps}</timebase></rate>')
-        xml_output.append(f'\t\t\t\t\t<start>{tl_start}</start>')
-        xml_output.append(f'\t\t\t\t\t<end>{tl_end}</end>')
-        xml_output.append(f'\t\t\t\t\t<in>{src_in_frames}</in>')
-        xml_output.append(f'\t\t\t\t\t<out>{src_out_frames}</out>')
-        
-        # File Reference (The Multicam Link)
-        xml_output.append(f'\t\t\t\t\t<file id="multicam_file">')
-        xml_output.append(f'\t\t\t\t\t\t<name>{source_name}</name>')
-        xml_output.append(f'\t\t\t\t\t\t<pathurl>file://localhost/placeholder/{source_name}</pathurl>')
-        xml_output.append(f'\t\t\t\t\t\t<rate><timebase>{fps}</timebase></rate>')
-        xml_output.append(f'\t\t\t\t\t\t<timecode><string>00:00:00:00</string></timecode>')
-        xml_output.append(f'\t\t\t\t\t</file>')
-        
-        xml_output.append(f'\t\t\t\t</clipitem>')
-        
-        # Handle Gaps
-        gap_seconds = seg.get('gap', 0.0)
-        gap_frames = seconds_to_frames(gap_seconds, fps)
-        timeline_head_frames = tl_end + gap_frames
-
-    # XML Footer
-    xml_output.extend([
-        '\t\t\t</track>',
-        '\t\t</video>',
-        '\t</media>',
-        '</sequence>',
-        '</xmeml>'
-    ])
-    
-    return "\n".join(xml_output)
-
-def call_gemini_for_edl(transcript_data, story_prompt, api_key):
-    if not api_key:
-        st.error("Gemini API Key is missing.")
-        return None
-        
-    url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-09-2025:generateContent?key={api_key}"
-    
-    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', 'note', and optionally 'gap'. "
-        "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.\n"
-        "5. PACING: Group related clips together. Between distinct ideas, add a 'gap': 1.0 (float seconds) "
-        "to the segment preceding the break."
-    )
-    
-    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="Junior Editor", layout="wide")
-st.title("Junior Editor")
-
-st.markdown("""
-**Instructions**
-* **For Multicam Workflows:** Use the **XML** option in the sidebar and enter the **exact name** of your Multicam Sequence.
-* Upload your file here (video or audio).
-* Set your timeline FPS and transcription quality.
-* Junior Editor will transcribe and separate speakers. You can then instruct it to find engaging bits or construct a narrative.
-* It will create an EDL or XML to import back into your editing software (Resolve, Premiere).
-""")
-
-st.divider()
-
-with st.sidebar:
-    st.header("Project Settings")
-    fps = st.number_input("Timeline FPS", value=25)
-    
-    st.header("Export Settings")
-    export_format = st.radio("Output Format", ["EDL", "XML (Multicam)"], index=0)
-    
-    input_label = "EDL Reel Name"
-    input_help = "Leave empty to use the uploaded file name."
-    
-    if export_format == "XML (Multicam)":
-        input_label = "Multicam Sequence Name"
-        input_help = "EXACT name of your Multicam Clip in Resolve."
-    
-    st.info("💡 **Conform Helper**")
-    custom_reel_name = st.text_input(
-        input_label, 
-        placeholder="e.g. Interview_Day1_Multi", 
-        help=input_help
-    )
-
-    st.header("Model Settings")
-    model_size = st.selectbox("Whisper Model", ["large-v2", "medium", "base"], index=0)
-    
-    language_map = {
-        "Auto-Detect": None,
-        "English": "en",
-        "Spanish": "es",
-        "French": "fr",
-        "German": "de",
-        "Italian": "it",
-        "Portuguese": "pt"
-    }
-    selected_lang_label = st.selectbox("Audio Language", list(language_map.keys()), index=1)
-    target_language = language_map[selected_lang_label]
-    
-    num_speakers = st.number_input("Speakers (0=Auto)", min_value=0, value=0)
-    
-    st.divider()
-    if ACTIVE_HF_TOKEN == "PASTE_YOUR_HF_TOKEN_HERE":
-        st.warning("⚠️ HF_TOKEN not set in Secrets!")
-    else:
-        st.success("✅ HF_TOKEN Loaded")
-
-uploaded_file = st.file_uploader("Upload Video/Audio Clip", type=["mp4", "m4a", "wav", "mp3", "mov"])
-
-if uploaded_file:
-    # --- Auto-Reset Logic ---
-    if "last_processed_file" not in st.session_state or st.session_state.last_processed_file != uploaded_file.name:
-        if "transcript" in st.session_state:
-            del st.session_state.transcript
-        st.session_state.last_processed_file = uploaded_file.name
-
-    # --- Auto-Process Logic ---
-    if "transcript" not in st.session_state:
-        if not ACTIVE_HF_TOKEN or "PASTE_YOUR_HF_TOKEN" in ACTIVE_HF_TOKEN:
-            st.error("Please provide a valid Hugging Face Token in the Sidebar/Secrets.")
-        else:
-            progress_container = st.container()
-            with progress_container:
-                st.info("🤖 **Junior Editor is processing your file...**")
-                status_text = st.empty()
-                progress_bar = st.progress(0)
-                
-                try:
-                    # Phase 1
-                    status_text.markdown("**Phase 1/4: Extracting Audio...**")
-                    with open("temp_input", "wb") as f:
-                        f.write(uploaded_file.getbuffer())
-                    
-                    subprocess.run(["ffmpeg", "-i", "temp_input", "-vn", "-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", "temp_audio.wav", "-y"])
-                    progress_bar.progress(25)
-                    
-                    device = "cuda" if torch.cuda.is_available() else "cpu"
-                    if device == "cpu": st.warning("⚠️ No GPU detected.")
-                    
-                    # Phase 2
-                    status_text.markdown(f"**Phase 2/4: Transcribing (Whisper {model_size})... This is the longest step.**")
-                    compute_type = "float16" if device == "cuda" else "int8"
-                    model = whisperx.load_model(model_size, device, compute_type=compute_type)
-                    audio = whisperx.load_audio("temp_audio.wav")
-                    result = model.transcribe(audio, batch_size=16, language=target_language)
-                    del model
-                    gc.collect()
-                    torch.cuda.empty_cache()
-                    progress_bar.progress(50)
-                    
-                    # Phase 3
-                    status_text.markdown("**Phase 3/4: Aligning Text...**")
-                    model_a, metadata = whisperx.load_align_model(language_code=result["language"], device=device)
-                    result = whisperx.align(result["segments"], model_a, metadata, audio, device, return_char_alignments=False)
-                    del model_a
-                    gc.collect()
-                    torch.cuda.empty_cache()
-                    progress_bar.progress(75)
-                    
-                    # Phase 4
-                    status_text.markdown("**Phase 4/4: Identifying Speakers...**")
-                    diarize_model = whisperx.DiarizationPipeline(use_auth_token=ACTIVE_HF_TOKEN, device=device)
-                    diarize_kwargs = {"min_speakers": num_speakers, "max_speakers": num_speakers} if num_speakers > 0 else {}
-                    diarize_segments = diarize_model(audio, **diarize_kwargs)
-                    
-                    # Final Merge
-                    status_text.markdown("**Finalizing...**")
-                    final_result = whisperx.assign_word_speakers(diarize_segments, result)
-                    
-                    processed_segments = []
-                    for segment in final_result["segments"]:
-                        processed_segments.append({
-                            "speaker": segment.get("speaker", "Unknown"),
-                            "text": segment["text"].strip(),
-                            "start": segment["start"],
-                            "end": segment["end"]
-                        })
-                    
-                    st.session_state.transcript = processed_segments
-                    if os.path.exists("temp_input"): os.remove("temp_input")
-                    if os.path.exists("temp_audio.wav"): os.remove("temp_audio.wav")
-                    progress_bar.progress(100)
-                    status_text.success(f"Done! Processed {len(processed_segments)} segments.")
-
-                except Exception as e:
-                    status_text.error(f"Error: {e}")
-                    if os.path.exists("temp_input"): os.remove("temp_input")
-                    st.stop()
-
-    if "transcript" in st.session_state:
-        st.divider()
-        with st.expander("Transcript Preview", expanded=True):
-            for seg in st.session_state.transcript: 
-                st.markdown(f"**{seg['speaker']}:** {seg['text']}")
-        
-        st.subheader("Your Instruction")
-        brief = st.text_area("What should the Junior Editor do?", placeholder="e.g. Find the most engaging bits and put them together from Speaker 1.")
-        
-        if st.button("Generate Edit"):
-            if not ACTIVE_GEMINI_KEY:
-                st.error("Gemini API Key required.")
-            else:
-                with st.spinner("Junior Editor is thinking..."):
-                    final_source_name = custom_reel_name.strip() if custom_reel_name.strip() else uploaded_file.name
-                    
-                    edl_segments = call_gemini_for_edl(st.session_state.transcript, brief, ACTIVE_GEMINI_KEY)
-                    if edl_segments:
-                        if export_format == "EDL":
-                            final_output = generate_cmx_edl("Junior_Editor_Cut", edl_segments, final_source_name, fps)
-                            ext = "edl"
-                        else:
-                            final_output = generate_xml("Junior_Editor_Cut", edl_segments, final_source_name, fps)
-                            ext = "xml"
-                            
-                        st.subheader("Ready for Import")
-                        st.code(final_output, language="xml" if ext == "xml" else "text")
-                        st.download_button(f"Download .{ext.upper()}", data=final_output, file_name=f"junior_editor_cut.{ext}")
+        '<x