Update app.py

app.py

@@ -8,52 +8,37 @@ import subprocess
 import json
 import requests
 import gc
-import pandas as pd
+import math
 from datetime import timedelta
 
 # --- CRITICAL ENVIRONMENT FIXES ---
-# 1. Fix for Hugging Face millicore OMP_NUM_THREADS error
 if os.environ.get("OMP_NUM_THREADS", "").endswith("m"):
     os.environ["OMP_NUM_THREADS"] = "1"
 
-# 2. Force Torchaudio Backend
 try:
     if "ffmpeg" in torchaudio.list_audio_backends():
         torchaudio.set_audio_backend("ffmpeg")
 except Exception:
     pass
 
-# 3. GLOBAL PYTORCH SECURITY BYPASS (One-Time Patch)
 if not hasattr(torch.load, "_is_patched"):
     print("DEBUG: Applying Monkeypatch to torch.load")
     _original_torch_load = torch.load
 
     def patched_torch_load(*args, **kwargs):
-        # FORCE Disable security check
         kwargs['weights_only'] = False 
         return _original_torch_load(*args, **kwargs)
     
-    # Mark as patched to prevent recursion loop on Streamlit reruns
     patched_torch_load._is_patched = True
     torch.load = patched_torch_load
-else:
-    print("DEBUG: torch.load is already patched. Skipping.")
 
-# 4. EXPLICIT SAFE GLOBALS WHITELIST
 try:
-    safe_list = [
-        typing.Any,
-        torch.nn.modules.container.ModuleList,
-        np.dtype,
-    ]
-    
-    # NumPy internals
+    safe_list = [typing.Any, torch.nn.modules.container.ModuleList, np.dtype]
     if hasattr(np, '_core') and hasattr(np._core, 'multiarray'):
         safe_list.append(np._core.multiarray.scalar)
     elif hasattr(np, 'core') and hasattr(np.core, 'multiarray'):
         safe_list.append(np.core.multiarray.scalar)
-
-    # OmegaConf
+    
     try:
         from omegaconf.listconfig import ListConfig
         from omegaconf.dictconfig import DictConfig
@@ -62,7 +47,6 @@ try:
     except ImportError:
         pass
 
-    # Pyannote internals
     try:
         from pyannote.audio.core.task import Specifications, Problem, Resolution
         from pyannote.audio.core.model import Model
@@ -75,13 +59,12 @@ try:
 except Exception as e:
     print(f"Safe Globals Warning: {e}")
 
-# Fix NumPy 2.0+ attribute removal
 if not hasattr(np, 'NaN'):
     np.NaN = np.nan
 
 import whisperx
 
-# --- Configuration & Tokens ---
+# --- Configuration ---
 HARDCODED_HF_TOKEN = "PASTE_YOUR_HF_TOKEN_HERE" 
 HARDCODED_GEMINI_KEY = ""
 
@@ -91,8 +74,10 @@ ENV_GEMINI_KEY = os.environ.get("GEMINI_API_KEY", "")
 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
 
+# --- HELPER FUNCTIONS ---
+
 def format_timecode(seconds, fps=25):
-    """Converts seconds to HH:MM:SS:FF."""
+    """Converts seconds to HH:MM:SS:FF (for EDL)."""
     td = timedelta(seconds=seconds)
     total_seconds = int(td.total_seconds())
     hours = total_seconds // 3600
@@ -101,12 +86,14 @@ def format_timecode(seconds, fps=25):
     frames = int((seconds - total_seconds) * fps)
     return f"{hours:02}:{minutes:02}:{secs:02}:{frames:02}"
 
+def seconds_to_frames(seconds, fps):
+    """Converts seconds to integer frames (for XML)."""
+    return int(round(seconds * fps))
+
 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
-    
-    # Sanitize source name for the Reel ID column
     reel_id = source_name.replace(" ", "_")
     
     for i, seg in enumerate(segments, 1):
@@ -120,13 +107,88 @@ def generate_cmx_edl(edl_title, segments, source_name, fps=25):
         edl_lines.append(f"* FROM CLIP NAME: {source_name}")
         edl_lines.append(f"* {seg.get('note', 'Clip')}\n")
         
-        # --- NEW LOGIC: Support Gaps ---
-        # Add the duration of this clip AND any requested gap to the record timeline
         gap = seg.get('gap', 0.0)
         rec_start += duration + gap
         
     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)."""
+    
+    # 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.")
@@ -134,7 +196,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 ---
     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. "
@@ -144,9 +205,8 @@ def call_gemini_for_edl(transcript_data, story_prompt, api_key):
         "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 so they flow seamlessly. HOWEVER, between distinct ideas or sections, "
-        "add a 'gap': 1.0 property (float, in seconds) to the segment preceding the break. "
-        "This will leave blank space on the timeline to signal a topic change."
+        "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)}"
@@ -172,10 +232,11 @@ st.title("Junior Editor")
 
 st.markdown("""
 **Instructions**
-* Upload your file here, either an video file or audio. 
-* Set your timeline FPS, choose the quality of your transcription and ,if you know the language, set this to speed up the transcription phase. 
-* Junior Editor will transcribe it and separate by speakers and then await your instruction. You can ask it to find the most engaging bits and put them together from “Speaker 1”, remove all of Speaker 2, or construct a narrative around whatever idea you choose. 
-* It will create an EDL to import back into your editing software. If you want it to reference a Master Clip rather than the proxy, type this in the side bar at the start. 
+* **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()
@@ -184,11 +245,21 @@ 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(
-        "EDL Reel Name", 
-        placeholder="Paste Raw File Name Here...", 
-        help="Leave empty to use the uploaded file name. Use this to link proxies to original camera files."
+        input_label, 
+        placeholder="e.g. Interview_Day1_Multi", 
+        help=input_help
     )
 
     st.header("Model Settings")
@@ -217,7 +288,7 @@ with st.sidebar:
 uploaded_file = st.file_uploader("Upload Video/Audio Clip", type=["mp4", "m4a", "wav", "mp3", "mov"])
 
 if uploaded_file:
-    # --- Auto-Reset Logic for New Files ---
+    # --- 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
@@ -235,54 +306,41 @@ if uploaded_file:
                 progress_bar = st.progress(0)
                 
                 try:
-                    # Phase 1: Save File
+                    # 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"
-                    ])
+                    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. This will be slow.")
+                    if device == "cpu": st.warning("⚠️ No GPU detected.")
                     
-                    # Phase 2: Transcribe
+                    # 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: Align
+                    # 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: Diarize
+                    # Phase 4
                     status_text.markdown("**Phase 4/4: Identifying Speakers...**")
                     diarize_model = whisperx.DiarizationPipeline(use_auth_token=ACTIVE_HF_TOKEN, device=device)
-                    
-                    diarize_kwargs = {}
-                    if num_speakers > 0:
-                        diarize_kwargs = {"min_speakers": num_speakers, "max_speakers": num_speakers}
-                    
+                    diarize_kwargs = {"min_speakers": num_speakers, "max_speakers": num_speakers} if num_speakers > 0 else {}
                     diarize_segments = diarize_model(audio, **diarize_kwargs)
                     
                     # Final Merge
@@ -299,18 +357,14 @@ if uploaded_file:
                         })
                     
                     st.session_state.transcript = processed_segments
-                    
-                    # --- CLEANUP ON SUCCESS ---
                     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 during processing: {e}")
+                    status_text.error(f"Error: {e}")
                     if os.path.exists("temp_input"): os.remove("temp_input")
-                    if os.path.exists("temp_audio.wav"): os.remove("temp_audio.wav")
                     st.stop()
 
     if "transcript" in st.session_state:
@@ -320,18 +374,24 @@ if uploaded_file:
                 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, or remove all of Speaker 2.")
+        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 in Secrets.")
+                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:
-                        final_edl = generate_cmx_edl("Junior_Editor_Cut", edl_segments, final_source_name, fps)
+                        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_edl, language="text")
-                        st.download_button("Download .EDL", data=final_edl, file_name="junior_editor_cut.edl")
+                        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}")