Update app.py

app.py

@@ -90,32 +90,32 @@ def clean_json_response(text):
     except Exception:
         return text
 
-def timecode_to_seconds(tc, fps=25):
-    """Converts HH:MM:SS:FF or HH:MM:SS.SS to total seconds."""
+def timecode_to_frames(tc, fps):
+    """Converts HH:MM:SS:FF to absolute integer frames based on timebase."""
     if not tc or not re.match(r"\d{2}:\d{2}:\d{2}[:\.]\d{2}", tc):
-        return 0.0
-    
+        return 0
     parts = re.split(r'[:\.]', tc)
     h, m, s, f = map(int, parts)
-    return h * 3600 + m * 60 + s + (f / fps)
+    timebase = int(round(fps)) # 29.97 becomes 30, 23.98 becomes 24
+    return (h * 3600 * timebase) + (m * 60 * timebase) + (s * timebase) + f
 
-def format_timecode(seconds, fps=25):
-    """Converts seconds to HH:MM:SS:FF (for EDL)."""
-    total_frames = int(round(seconds * fps))
-    hours = total_frames // (3600 * int(fps))
-    minutes = (total_frames // (60 * int(fps))) % 60
-    secs = (total_frames // int(fps)) % 60
-    frames = total_frames % int(fps)
-    return f"{hours:02}:{minutes:02}:{secs:02}:{frames:02}"
+def frames_to_timecode(frames, fps):
+    """Converts absolute integer frames back to HH:MM:SS:FF (NDF)."""
+    timebase = int(round(fps))
+    hours = frames // (3600 * timebase)
+    minutes = (frames // (60 * timebase)) % 60
+    secs = (frames // timebase) % 60
+    f = frames % timebase
+    return f"{hours:02}:{minutes:02}:{secs:02}:{f:02}"
 
 def seconds_to_frames(seconds, fps):
-    """Converts seconds to integer frames (for XML)."""
+    """Converts real seconds to integer frames."""
     return int(round(seconds * fps))
 
-def generate_cmx_edl(edl_title, segments, source_name, fps=25, start_offset=0.0):
+def generate_cmx_edl(edl_title, segments, source_name, fps=25, start_offset_frames=0):
     """Constructs a CMX 3600 formatted EDL with source offset."""
     edl_lines = [f"TITLE: {edl_title}", "FCM: NON-DROP FRAME\n"]
-    rec_start = 0.0
+    rec_start_frames = 0
     reel_id = source_name.replace(" ", "_")[:8] # EDL reel IDs are traditionally short max 8 chars
     
     for i, seg in enumerate(segments, 1):
@@ -123,41 +123,44 @@ def generate_cmx_edl(edl_title, segments, source_name, fps=25, start_offset=0.0)
         
         if is_vo:
             vo_text = seg.get('text', 'VO')
-            duration = float(seg.get('duration', max(1.0, len(vo_text.split()) / 2.5)))
-            src_in = format_timecode(0, fps)
-            src_out = format_timecode(duration, fps)
+            duration_sec = float(seg.get('duration', max(1.0, len(vo_text.split()) / 2.5)))
+            duration_frames = seconds_to_frames(duration_sec, fps)
+            src_in_frames = 0
+            src_out_frames = duration_frames
             current_source = "GEN_VO"
             note_text = f"VO SCRIPT: {vo_text}"
         else:
             src_start_val = float(seg.get('src_start', seg.get('start', 0.0)))
             src_end_val = float(seg.get('src_end', seg.get('end', 0.0)))
-            src_in = format_timecode(src_start_val + start_offset, fps)
-            src_out = format_timecode(src_end_val + start_offset, fps)
-            duration = src_end_val - src_start_val
+            src_in_frames = seconds_to_frames(src_start_val, fps) + start_offset_frames
+            src_out_frames = seconds_to_frames(src_end_val, fps) + start_offset_frames
+            duration_frames = src_out_frames - src_in_frames
             current_source = reel_id
             note_text = seg.get('note', 'Clip')
+            
+        src_in = frames_to_timecode(src_in_frames, fps)
+        src_out = frames_to_timecode(src_out_frames, fps)
         
-        rec_in = format_timecode(rec_start, fps)
-        rec_out = format_timecode(rec_start + duration, fps)
+        rec_in = frames_to_timecode(rec_start_frames, fps)
+        rec_out = frames_to_timecode(rec_start_frames + duration_frames, fps)
         
         edl_lines.append(f"{i:03}  {current_source:8} V     C        {src_in} {src_out} {rec_in} {rec_out}")
         if not is_vo:
             edl_lines.append(f"* FROM CLIP NAME: {source_name}")
         edl_lines.append(f"* {note_text}\n")
         
-        gap = float(seg.get('gap', 0.0))
-        rec_start += duration + gap
+        gap_frames = seconds_to_frames(float(seg.get('gap', 0.0)), fps)
+        rec_start_frames += duration_frames + gap_frames
         
     return "\n".join(edl_lines)
 
-def generate_xml(sequence_name, segments, source_name, fps=25, start_offset=0.0):
+def generate_xml(sequence_name, segments, source_name, fps=25, start_offset_frames=0):
     """Constructs a Robust XML with source timecode offset for Premiere AND Resolve."""
     master_id = "masterfile-1"
     timebase = int(round(fps))
     is_ntsc = "TRUE" if fps % 1 != 0 else "FALSE"
     
-    start_offset_frames = seconds_to_frames(start_offset, fps)
-    start_tc_string = format_timecode(start_offset, fps)
+    start_tc_string = frames_to_timecode(start_offset_frames, fps)
 
     encoded_name = quote(source_name)
     path_url = f"file://localhost/{encoded_name}" 
@@ -337,7 +340,7 @@ def generate_xml(sequence_name, segments, source_name, fps=25, start_offset=0.0)
     
     return "\n".join(lines)
 
-def generate_transcript_txt(sequence_name, segments, fps=25, start_offset=0.0, transcript_data=None):
+def generate_transcript_txt(sequence_name, segments, fps=25, start_offset_frames=0, transcript_data=None):
     """Generates a human-readable text document of the edit decisions and exact transcription."""
     lines = [f"Sequence Transcript: {sequence_name}", "=" * 50, ""]
     
@@ -352,16 +355,17 @@ def generate_transcript_txt(sequence_name, segments, fps=25, start_offset=0.0, t
         else:
             src_start_val = float(seg.get('src_start', seg.get('start', 0.0)))
             src_end_val = float(seg.get('src_end', seg.get('end', 0.0)))
-            src_in = format_timecode(src_start_val + start_offset, fps)
-            src_out = format_timecode(src_end_val + start_offset, fps)
+            src_in_frames = seconds_to_frames(src_start_val, fps) + start_offset_frames
+            src_out_frames = seconds_to_frames(src_end_val, fps) + start_offset_frames
+            
+            src_in = frames_to_timecode(src_in_frames, fps)
+            src_out = frames_to_timecode(src_out_frames, fps)
             note = seg.get('note', 'No note provided.')
             
-            # Cross-reference the exact times with the original Whisper transcript to get the exact words
             actual_text = ""
             if transcript_data:
                 clip_words = []
                 for t_seg in transcript_data:
-                    # Check if the transcript segment overlaps with our clip's time window
                     if max(src_start_val, t_seg['start']) < min(src_end_val, t_seg['end']):
                         clip_words.append(t_seg['text'])
                 actual_text = " ".join(clip_words).strip()
@@ -371,12 +375,12 @@ def generate_transcript_txt(sequence_name, segments, fps=25, start_offset=0.0, t
             if actual_text:
                 lines.append(f"Exact Audio Text: \"{actual_text}\"")
             
-        lines.append("") # Blank line to separate clips visually
+        lines.append("") 
         
     return "\n".join(lines)
 
 
-def call_gemini_for_edl(transcript_data, story_prompt, api_key):
+def call_gemini_for_edl(transcript_data, story_prompt, api_key, previous_edit=None):
     if not api_key:
         st.error("Gemini API Key is missing.")
         return None
@@ -399,7 +403,15 @@ def call_gemini_for_edl(transcript_data, story_prompt, api_key):
         "PACING: Group related clips. Add a 'gap' (in seconds) between distinct ideas."
     )
     
-    prompt_text = f"Creative Brief: {story_prompt}\n\nTranscript Data:\n{json.dumps(transcript_data)}"
+    if previous_edit:
+        prompt_text = (
+            f"Transcript Data:\n{json.dumps(transcript_data)}\n\n"
+            f"Previous Edit You Generated:\n{json.dumps(previous_edit)}\n\n"
+            f"Director's Note for Revision: {story_prompt}\n\n"
+            "Please output a NEW JSON array of segments applying these requested changes to the previous edit."
+        )
+    else:
+        prompt_text = f"Creative Brief: {story_prompt}\n\nTranscript Data:\n{json.dumps(transcript_data)}"
     
     payload = {
         "contents": [
@@ -637,7 +649,7 @@ if uploaded_file:
             else:
                 with st.spinner("Junior Editor is thinking..."):
                     final_source_name = custom_reel_name.strip() if custom_reel_name.strip() else uploaded_file.name
-                    offset_sec = timecode_to_seconds(source_start_tc, fps)
+                    offset_frames = timecode_to_frames(source_start_tc, fps)
                     
                     edl_segments, used_model, used_endpoint = call_gemini_for_edl(st.session_state.transcript, brief, ACTIVE_GEMINI_KEY)
                     
@@ -649,14 +661,14 @@ if uploaded_file:
                             
                         # Generate the selected edit format (EDL/XML)
                         if export_format == "EDL":
-                            final_output = generate_cmx_edl(final_source_name, edl_segments, final_source_name, fps, offset_sec)
+                            final_output = generate_cmx_edl(final_source_name, edl_segments, final_source_name, fps, offset_frames)
                             ext = "edl"
                         else:
-                            final_output = generate_xml(final_source_name, edl_segments, final_source_name, fps, offset_sec)
+                            final_output = generate_xml(final_source_name, edl_segments, final_source_name, fps, offset_frames)
                             ext = "xml"
                             
-                        # Generate the companion human-readable transcript, passing the raw transcript data for exact word matching
-                        transcript_txt = generate_transcript_txt(final_source_name, edl_segments, fps, offset_sec, st.session_state.transcript)
+                        # Generate the companion human-readable transcript
+                        transcript_txt = generate_transcript_txt(final_source_name, edl_segments, fps, offset_frames, st.session_state.transcript)
                         
                         # Save to session state so buttons don't disappear on click
                         st.session_state.edit_generated = True
@@ -666,6 +678,7 @@ if uploaded_file:
                         st.session_state.safe_filename = safe_filename
                         st.session_state.used_model = used_model
                         st.session_state.used_endpoint = used_endpoint
+                        st.session_state.edl_segments = edl_segments
                         
         # Render the download buttons outside the Generate block using session state
         if st.session_state.get("edit_generated"):
@@ -679,9 +692,38 @@ if uploaded_file:
             with col2:
                 st.download_button(f"Download Reference Transcript (.TXT)", data=st.session_state.transcript_txt, file_name=f"{st.session_state.safe_filename}-Transcript.txt")
             
-            with st.expander(f"Show {st.session_state.ext.upper()} Code", expanded=False):
-                st.code(st.session_state.final_output, language="xml" if st.session_state.ext == "xml" else "text")
+            st.divider()
+            st.subheader("Revise Edit")
+            revision_brief = st.text_area("Want changes? Tell Junior Editor:", placeholder="e.g. Make it twice as long, add more details about X, or write a VO intro.")
             
-            with st.expander("Show Transcript Reference", expanded=False):
-                st.text(st.session_state.transcript_txt)
+            if st.button("Apply Revisions"):
+                with st.spinner("Junior Editor is revising the edit..."):
+                    final_source_name = custom_reel_name.strip() if custom_reel_name.strip() else uploaded_file.name
+                    offset_frames = timecode_to_frames(source_start_tc, fps)
+                    
+                    new_edl_segments, used_model, used_endpoint = call_gemini_for_edl(
+                        st.session_state.transcript, 
+                        revision_brief, 
+                        ACTIVE_GEMINI_KEY, 
+                        previous_edit=st.session_state.edl_segments
+                    )
+                    
+                    if new_edl_segments:
+                        if export_format == "EDL":
+                            final_output = generate_cmx_edl(final_source_name, new_edl_segments, final_source_name, fps, offset_frames)
+                            ext = "edl"
+                        else:
+                            final_output = generate_xml(final_source_name, new_edl_segments, final_source_name, fps, offset_frames)
+                            ext = "xml"
+                            
+                        transcript_txt = generate_transcript_txt(final_source_name, new_edl_segments, fps, offset_frames, st.session_state.transcript)
+                        
+                        st.session_state.final_output = final_output
+                        st.session_state.ext = ext
+                        st.session_state.transcript_txt = transcript_txt
+                        st.session_state.used_model = used_model
+                        st.session_state.used_endpoint = used_endpoint
+                        st.session_state.edl_segments = new_edl_segments
+                        st.rerun()
+