feat: Enhance CUE parsing, editing, and metadata preservation

This commit introduces a comprehensive overhaul of the CUE sheet handling logic to significantly improve robustness, preserve all original metadata, and fix several critical bugs.

The primary architectural change is the move from a simple list of timestamps to a list of structured dictionaries (`track_data`). This allows each track to maintain its own metadata, such as its title. Furthermore, track selection for editing has been refactored to use stable numerical indices instead of fragile string matching, preventing data loss during operations.

app.py

@@ -2,6 +2,7 @@ import os
 import re
 import librosa
 import gradio as gr
+from copy import deepcopy
 
 # --- Helper Functions ---
 
@@ -23,34 +24,48 @@ def parse_cue_time_to_seconds(time_str):
         return m * 60 + s + f / 75.0
     return None
 
-def format_cue_text(times, audio_filename="CDImage.wav"):
-    """Generates the final CUE sheet string from a list of times."""
-    if not times:
+def format_cue_text(track_data, cue_globals):
+    """
+    Generates the final CUE sheet string from track data and global info.
+    MODIFIED: Now accepts track data with titles.
+    """
+    if not track_data:
         return ""
-    filename_no_ext = os.path.splitext(audio_filename)[0]
-    cue_text = f'PERFORMER "Unknown Artist"\n'
-    cue_text += f'TITLE "{filename_no_ext}"\n'
-    cue_text += f'FILE "{audio_filename}" WAVE\n'
-
-    # Always sort times before formatting to handle out-of-order additions from splitting
-    sorted_times = sorted(list(set(times)))
-    for idx, t in enumerate(sorted_times):
-        cue_time_str = seconds_to_cue_time(t)
+
+    # Sort tracks by time before formatting
+    sorted_tracks = sorted(track_data, key=lambda x: x['time'])
+    
+    cue_text = f'PERFORMER "{cue_globals.get("performer", "Unknown Artist")}"\n'
+    cue_text += f'TITLE "{cue_globals.get("title", os.path.splitext(cue_globals["filename"])[0])}"\n'
+    # Use parsed file type or default to WAVE
+    file_type = cue_globals.get("filetype", "WAVE")
+    cue_text += f'FILE "{cue_globals["filename"]}" {file_type}\n'
+
+    for idx, track in enumerate(sorted_tracks):
+        cue_time_str = seconds_to_cue_time(track['time'])
+        # ** FEATURE 1: Use existing title or create a default one **
+        title = track.get('title') or f"Track {idx+1:02d}"
+        
         cue_text += f'  TRACK {idx+1:02d} AUDIO\n'
-        cue_text += f'    TITLE "Track {idx+1:02d}"\n'
+        cue_text += f'    TITLE "{title}"\n'
         cue_text += f'    INDEX 01 {cue_time_str}\n'
     return cue_text
 
-def generate_track_labels(times, audio_duration):
-    """Creates descriptive labels for the checklist, including track length."""
-    if not times:
+def generate_track_choices(track_data, audio_duration):
+    """Creates choices for the CheckboxGroup as (label, index) tuples."""
+    if not track_data:
         return []
-    sorted_times = sorted(list(set(times)))
+    # Data is already sorted, but we re-sort just in case.
+    sorted_tracks = sorted(track_data, key=lambda x: x['time'])
     track_choices = []
-    for i, t in enumerate(sorted_times):
-        track_length = (sorted_times[i+1] - t) if i < len(sorted_times) - 1 else (audio_duration - t)
-        label = f"Track {i+1:02d} (Starts: {seconds_to_cue_time(t)}) [Length: {seconds_to_cue_time(track_length)}]"
-        track_choices.append(label)
+    for i, track in enumerate(sorted_tracks):
+        start_time = track['time']
+        end_time = sorted_tracks[i+1]['time'] if i < len(sorted_tracks) - 1 else audio_duration
+        track_length = end_time - start_time
+        title = track.get('title', f"Track {i+1:02d}")
+        
+        label = f'"{title}" (Starts: {seconds_to_cue_time(start_time)}) [Length: {seconds_to_cue_time(track_length)}]'
+        track_choices.append((label, i))
     return track_choices
 
 # --- Core Gradio Functions ---
@@ -99,172 +114,216 @@ def analyze_audio_to_cue(audio_file, top_db, min_segment_len, merge_threshold, m
 
     # --- 4. Prepare Outputs for Gradio ---
     times = sorted(list(set(times)))
+    
+    # Convert times list to the new track_data structure
+    track_data = [{'time': t, 'title': None} for t in times]
+    
     audio_filename = os.path.basename(audio_file)
-    initial_cue_text = format_cue_text(times, audio_filename)
-    track_labels = generate_track_labels(times, audio_duration)
+    cue_globals = {"filename": audio_filename}
+    
+    initial_cue_text = format_cue_text(track_data, cue_globals)
+    track_choices = generate_track_choices(track_data, audio_duration)
     
     # This function now returns everything needed to update the entire UI in one step.
     return (
-        initial_cue_text, audio_filename, times, audio_duration,
-        gr.update(choices=track_labels, value=[]), gr.update(visible=True)
+        initial_cue_text, cue_globals, track_data, audio_duration,
+        gr.update(choices=track_choices, value=[]), gr.update(visible=True)
     )
 
 def parse_cue_and_update_ui(cue_text):
-    """Workflow 2: Parses pasted CUE text. NOW returns the text itself to populate the output box."""
+    """Workflow 2: Parses pasted CUE text, preserving titles."""
     if not cue_text or "INDEX 01" not in cue_text:
-        return cue_text, "CDImage.wav", None, 0, gr.update(choices=[], value=[]), gr.update(visible=False)
+        return cue_text, {}, [], 0, gr.update(choices=[], value=[]), gr.update(visible=False)
     
-    file_match = re.search(r'FILE\s+"([^"]+)"', cue_text, re.IGNORECASE)
-    audio_filename = file_match.group(1) if file_match else "CDImage.wav"
+    cue_globals = {}
+    track_data = []
+    current_track = None
     
-    index_matches = re.findall(r'INDEX\s+\d+\s+([\d:]{7,8})', cue_text)
-    times = [parse_cue_time_to_seconds(t) for t in index_matches if parse_cue_time_to_seconds(t) is not None]
+    lines = cue_text.split('\n')
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        if re.search(r'TRACK\s+\d+\s+AUDIO', line, re.IGNORECASE):
+            if current_track is not None:
+                track_data.append(current_track)
+            current_track = {}
+            continue
+        
+        if current_track is None:
+            # **OPTIMIZATION: Capture file type (WAVE, MP3, etc.)**
+            if match := re.search(r'FILE\s+"([^"]+)"\s+([A-Z0-9]+)', line, re.IGNORECASE):
+                cue_globals['filename'] = match.group(1)
+                cue_globals['filetype'] = match.group(2)
+            elif match := re.search(r'PERFORMER\s+"([^"]+)"', line, re.IGNORECASE):
+                cue_globals['performer'] = match.group(1)
+            elif match := re.search(r'^TITLE\s+"([^"]+)"', line, re.IGNORECASE):
+                cue_globals['title'] = match.group(1)
+        else:
+            if match := re.search(r'TITLE\s+"([^"]+)"', line, re.IGNORECASE):
+                current_track['title'] = match.group(1)
+            elif match := re.search(r'INDEX\s+\d+\s+([\d:]{7,8})', line, re.IGNORECASE):
+                # **BUG FIX: Check for None instead of truthiness to correctly handle 0.0**
+                time_sec = parse_cue_time_to_seconds(match.group(1))
+                if time_sec is not None:
+                    current_track['time'] = time_sec
+
+    if current_track:
+        track_data.append(current_track)
+
+    if not track_data or not cue_globals.get('filename'):
+        return cue_text, {}, [], 0, gr.update(choices=[], value=[]), gr.update(visible=False)
+        
+    #Filter incomplete tracks before sorting
+    track_data = sorted([t for t in track_data if 'time' in t], key=lambda x: x['time'])
     
-    if not times:
-        return cue_text, audio_filename, None, 0, gr.update(choices=[], value=[]), gr.update(visible=False)
+    if not track_data: # All tracks might have been invalid
+        return cue_text, {}, [], 0, gr.update(choices=[], value=[]), gr.update(visible=False)
         
-    times = sorted(list(set(times)))
-    # Estimate duration for UI labels. It's the last track's start time.
-    # This is a limitation of text-only mode, but makes the tool usable.
-    audio_duration = times[-1] if times else 0
-    track_labels = generate_track_labels(times, audio_duration)
+    audio_duration = track_data[-1]['time'] if track_data else 0
+    track_choices = generate_track_choices(track_data, audio_duration)
+    
+    # Re-generate the CUE text to ensure consistent formatting
+    formatted_text = format_cue_text(track_data, cue_globals)
     
-    return cue_text, audio_filename, times, audio_duration, gr.update(choices=track_labels, value=[]), gr.update(visible=True)
+    return formatted_text, cue_globals, track_data, audio_duration, gr.update(choices=track_choices, value=[]), gr.update(visible=True)
 
-def update_editing_tools(selected_tracks, current_times, audio_duration):
+def update_editing_tools(selected_indices, track_data, audio_duration):
     """Dynamically shows/hides editing tools based on selection count."""
-    num_selected = len(selected_tracks)
+    num_selected = len(selected_indices)
     
+    merge_update = gr.update(visible=False)
+    single_update = gr.update(visible=False)
+    slider_update = gr.update()
+    slider_label_update = gr.update()
+    edit_box_update = gr.update()
+
     if num_selected == 1:
-        # Configure and show Split UI
-        # --- 1. Get track boundaries ---
-        track_idx = int(selected_tracks[0].split(' ')[1]) - 1
-        start_time = current_times[track_idx]
-        end_time = audio_duration if (track_idx + 1) >= len(current_times) else current_times[track_idx + 1]
+        track_idx = selected_indices[0]
+        single_update['visible'] = True # Use dict update to avoid overwriting the object
+        
+        start_time = track_data[track_idx]['time']
+        end_time = audio_duration if (track_idx + 1) >= len(track_data) else track_data[track_idx + 1]['time']
 
-        # --- 2. [CORRECTION] Add padding to prevent splitting at the exact edges ---
+        # --- 2. Add padding to prevent splitting at the exact edges ---
         # A CUE sheet frame is 1/75s (~0.013s). We use a slightly larger padding.
         padding = 0.02
+        split_possible = (start_time + padding) < (end_time - padding)
         
-        new_min_time = start_time + padding
-        new_max_time = end_time
-
-        split_possible = new_min_time < new_max_time
-        # --- 4. Configure and show the Split UI with the corrected range ---
-        mid_point = start_time + (end_time - start_time) / 2
-        
-        current_start_time_str = seconds_to_cue_time(start_time)
-        
-        return (
-            gr.update(visible=False), # Hide Merge button
-            gr.update(visible=split_possible),  # Show/Hide Split Group
-            gr.update(visible=True), # Show Edit Time Group
-            gr.update(minimum=new_min_time, maximum=new_max_time, value=mid_point), # Configure Slider 
-            gr.update(value=f"Split at: {seconds_to_cue_time(mid_point)}"), # Update slider label
-            gr.update(value=current_start_time_str) # Set current start time in edit box
-        )
+        if split_possible:
+            mid_point = start_time + (end_time - start_time) / 2
+            slider_update = gr.update(minimum=start_time + padding, maximum=end_time - padding, value=mid_point)
+            slider_label_update = gr.update(value=f"Split at: {seconds_to_cue_time(mid_point)}")
+        else:
+            slider_label_update = gr.update(value="Track is too short to be split")
+
+        edit_box_update = gr.update(value=seconds_to_cue_time(start_time))
         
     elif num_selected > 1:
-        # Show Merge UI
-        return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), None, None, None
-    else:
-        # Hide everything
-        return gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), None, None, None
-
-def perform_manual_merge(selected_tracks, original_times, audio_duration, audio_filename):
-    """Merges selected tracks. The internal logic is robust and unchanged."""
+        merge_update['visible'] = True
 
-    # --- 1. Identify which track start times to remove ---
-    indices_to_merge = {int(label.split(' ')[1]) - 1 for label in selected_tracks}
+    return merge_update, single_update, slider_update, slider_label_update, edit_box_update
 
-    # --- 2. Create the new list of times ---
+def perform_manual_merge(indices_to_merge, original_track_data, audio_duration, cue_globals):
+    """Merges selected tracks based on their indices."""
+    indices_set = set(indices_to_merge)
+    
+    # --- Create the new list of times ---
     # --- This logic correctly handles all merge cases. ---
-    new_times = []
-    # We iterate through the original times and decide which ones to KEEP.
-    for i, time in enumerate(original_times):
-        is_selected = i in indices_to_merge
-        
+    new_track_data = []
+    for i, track in enumerate(original_track_data):
         # Condition to KEEP a track's start time:
         # 1. It was NOT selected.
         # OR
         # 2. It WAS selected, BUT it's the start of a merge block.
         #    (This means it's the very first track, OR the track before it was NOT selected).
-        if not is_selected or (i == 0) or ((i - 1) not in indices_to_merge):
-            new_times.append(time)
+        if i not in indices_set or (i == 0) or ((i - 1) not in indices_set):
+            new_track_data.append(track)
     
-    # --- 3. Prepare all the outputs to update the UI ---
+    # --- Prepare all the outputs to update the UI ---
     # The new CUE text for the textbox
-    final_cue_text = format_cue_text(new_times, audio_filename)
-    new_track_labels = generate_track_labels(new_times, audio_duration)
+    final_cue_text = format_cue_text(new_track_data, cue_globals)
+    new_track_choices = generate_track_choices(new_track_data, audio_duration)
     
     # Return a tuple that will update the textbox, the state, and the checklist
-    return final_cue_text, new_times, gr.update(choices=new_track_labels, value=[])
-
+    return final_cue_text, new_track_data, gr.update(choices=new_track_choices, value=[])
 
-def perform_manual_split(split_time_sec, original_times, audio_duration, audio_filename):
+def perform_manual_split(split_time_sec, original_track_data, audio_duration, cue_globals):
     """Splits a track at the time specified by the slider."""
-    if split_time_sec in original_times:
+    if any(abs(t['time'] - split_time_sec) < 1e-3 for t in original_track_data):
         raise gr.Error("This exact timestamp already exists.")
     
-    new_times = sorted(original_times + [split_time_sec])
-    final_cue_text = format_cue_text(new_times, audio_filename)
-    new_track_labels = generate_track_labels(new_times, audio_duration)
-    return final_cue_text, new_times, gr.update(choices=new_track_labels, value=[])
+    new_track = {'time': split_time_sec, 'title': None}
+    new_track_data = sorted(original_track_data + [new_track], key=lambda x: x['time'])
+
+    final_cue_text = format_cue_text(new_track_data, cue_globals)
+    new_track_choices = generate_track_choices(new_track_data, audio_duration)
+    return final_cue_text, new_track_data, gr.update(choices=new_track_choices, value=[])
 
 # --- Timeline Shift ---
-def shift_timeline(shift_amount_sec, original_times, audio_duration, audio_filename):
+def shift_timeline(shift_amount_sec, original_track_data, audio_duration, cue_globals):
     """Shifts all track start times by a specified amount."""
-    if not original_times:
+    if not original_track_data:
         raise gr.Error("No track times to shift.")
     
-    # Apply the shift, ensuring no time is negative or exceeds audio duration
-    new_times = [min(max(0, t + shift_amount_sec), audio_duration) for t in original_times]
-    
-    # Clean up by sorting and removing duplicates (e.g., if multiple tracks are clamped to 0)
-    new_times = sorted(list(set(new_times)))
+    # Use deepcopy to avoid modifying the original state directly
+    new_track_data = deepcopy(original_track_data)
     
-    final_cue_text = format_cue_text(new_times, audio_filename)
-    new_track_labels = generate_track_labels(new_times, audio_duration)
-    return final_cue_text, new_times, gr.update(choices=new_track_labels, value=[])
+    # ** FEATURE 2: Apply shift without an upper bound, allowing the last track to move forward **
+    for track in new_track_data:
+        track['time'] = max(0, track['time'] + shift_amount_sec)
+
+    # Remove duplicates that might be created if multiple tracks are clamped to 0
+    unique_tracks = []
+    seen_times = set()
+    for track in sorted(new_track_data, key=lambda x: x['time']):
+        if track['time'] not in seen_times:
+            unique_tracks.append(track)
+            seen_times.add(track['time'])
+            
+    final_cue_text = format_cue_text(unique_tracks, cue_globals)
+    new_track_choices = generate_track_choices(unique_tracks, audio_duration)
+    return final_cue_text, unique_tracks, gr.update(choices=new_track_choices, value=[])
 
 
 # --- Edit Track Start Time ---
-def edit_track_start_time(selected_track, new_time_str, original_times, audio_duration, audio_filename):
-    """Edits the start time of a single selected track."""
-    if not selected_track:
+def edit_track_start_time(selected_indices, new_time_str, original_track_data, audio_duration, cue_globals):
+    """Edits the start time of a single selected track using its index."""
+    if not selected_indices:
         raise gr.Error("No track selected for editing.")
-        
+    
     new_time_sec = parse_cue_time_to_seconds(new_time_str)
     if new_time_sec is None:
         raise gr.Error("Invalid time format. Please use MM:SS:FF.")
 
-    track_idx = int(selected_track[0].split(' ')[1]) - 1
-
+    track_idx = selected_indices[0]
+    
     # Boundary checks
-    prev_track_time = original_times[track_idx - 1] if track_idx > 0 else -1
-    next_track_time = original_times[track_idx + 1] if track_idx < len(original_times) - 1 else audio_duration + 1
+    prev_time = original_track_data[track_idx - 1]['time'] if track_idx > 0 else -1
+    next_time = original_track_data[track_idx + 1]['time'] if track_idx < len(original_track_data) - 1 else float('inf')
 
-    if new_time_sec <= prev_track_time:
-        raise gr.Error(f"New time cannot be earlier than the previous track's start time ({seconds_to_cue_time(prev_track_time)}).")
-    if new_time_sec >= next_track_time:
-        raise gr.Error(f"New time cannot be later than the next track's start time ({seconds_to_cue_time(next_track_time)}).")
+    if new_time_sec <= prev_time:
+        raise gr.Error(f"New time cannot be earlier than the previous track's start time.")
+    if new_time_sec >= next_time:
+        raise gr.Error(f"New time cannot be later than or equal to the next track's start time.")
 
-    new_times = original_times[:]
-    new_times[track_idx] = new_time_sec
+    new_track_data = deepcopy(original_track_data)
+    new_track_data[track_idx]['time'] = new_time_sec
     
-    final_cue_text = format_cue_text(new_times, audio_filename)
-    new_track_labels = generate_track_labels(new_times, audio_duration)
-    return final_cue_text, new_times, gr.update(choices=new_track_labels, value=[])
-
+    final_cue_text = format_cue_text(new_track_data, cue_globals)
+    new_track_choices = generate_track_choices(new_track_data, audio_duration)
+    return final_cue_text, new_track_data, gr.update(choices=new_track_choices, value=[])
 
 # --- Gradio User Interface Definition ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 🎵 Advanced CUE Sheet Generator")
     
     # --- Hidden State Variables ---
-    track_times_state = gr.State([])
+    cue_globals_state = gr.State({})
+    track_data_state = gr.State([])
     audio_duration_state = gr.State(0)
-    audio_filename_state = gr.State("CDImage.wav")
 
     with gr.Tabs():
         with gr.TabItem("Start with Audio File"):
@@ -279,7 +338,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         
         with gr.TabItem("Start with CUE Text"):
             gr.Markdown("Or paste CUE text below and click outside the box. The editing tools will appear automatically.")
-            cue_text_input_for_paste = gr.Textbox(label="Paste CUE Text Here", lines=8)
+            cue_text_input_for_paste = gr.Textbox(label="Paste CUE Text Here", lines=8, placeholder="Paste your CUE sheet content here and click outside the box. The editing tools will appear automatically.")
 
     # The main output textbox is now outside the tabs, serving as a central display.
     output_text = gr.Textbox(label="CUE Sheet Output", lines=15, show_copy_button=True, interactive=True)
@@ -312,18 +371,18 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     # --- Event Wiring ---
     
     # Combined update for enabling editing groups
-    def show_editing_groups(times):
-        is_visible = bool(times)
+    def show_editing_groups(track_data):
+        is_visible = bool(track_data)
         return gr.update(visible=is_visible), gr.update(visible=is_visible)
 
     # Workflow 1: Audio analysis button now updates everything, including the editing tools.
     generate_button.click(
         fn=analyze_audio_to_cue,
         inputs=[audio_input, threshold_slider, min_length_slider, merge_length_slider, min_silence_length_slider],
-        outputs=[output_text, audio_filename_state, track_times_state, audio_duration_state, track_checkboxes]
+        outputs=[output_text, cue_globals_state, track_data_state, audio_duration_state, track_checkboxes]
     ).then(
         fn=show_editing_groups,
-        inputs=[track_times_state],
+        inputs=[track_data_state],
         outputs=[manual_editing_group, global_editing_group]
     )
     
@@ -332,51 +391,51 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     cue_text_input_for_paste.change(
         fn=parse_cue_and_update_ui,
         inputs=[cue_text_input_for_paste],
-        outputs=[output_text, audio_filename_state, track_times_state, audio_duration_state, track_checkboxes]
+        outputs=[output_text, cue_globals_state, track_data_state, audio_duration_state, track_checkboxes]
     ).then(
         fn=show_editing_groups,
-        inputs=[track_times_state],
+        inputs=[track_data_state],
         outputs=[manual_editing_group, global_editing_group]
     )
 
     # Dynamic UI controller for showing/hiding Merge/Split tools
     track_checkboxes.change(
         fn=update_editing_tools,
-        inputs=[track_checkboxes, track_times_state, audio_duration_state],
-        outputs=[merge_tools, single_track_tools, edit_time_input, split_slider, split_slider_label, edit_time_input]
+        inputs=[track_checkboxes, track_data_state, audio_duration_state],
+        outputs=[merge_tools, single_track_tools, split_slider, split_slider_label, edit_time_input]
     )
-
+    
     # Live update for the split slider's time display
     split_slider.input(
         fn=lambda t: f"Split at: {seconds_to_cue_time(t)}",
         inputs=[split_slider],
         outputs=[split_slider_label]
     )
-
+    
     # Action buttons
     merge_button.click(
         fn=perform_manual_merge,
-        inputs=[track_checkboxes, track_times_state, audio_duration_state, audio_filename_state],
-        outputs=[output_text, track_times_state, track_checkboxes]
+        inputs=[track_checkboxes, track_data_state, audio_duration_state, cue_globals_state],
+        outputs=[output_text, track_data_state, track_checkboxes]
     )
-
+    
     split_button.click(
         fn=perform_manual_split,
-        inputs=[split_slider, track_times_state, audio_duration_state, audio_filename_state],
-        outputs=[output_text, track_times_state, track_checkboxes]
+        inputs=[split_slider, track_data_state, audio_duration_state, cue_globals_state],
+        outputs=[output_text, track_data_state, track_checkboxes]
     )
     
     # --- Action Buttons for New Features ---
     shift_button.click(
         fn=shift_timeline,
-        inputs=[shift_amount_input, track_times_state, audio_duration_state, audio_filename_state],
-        outputs=[output_text, track_times_state, track_checkboxes]
+        inputs=[shift_amount_input, track_data_state, audio_duration_state, cue_globals_state],
+        outputs=[output_text, track_data_state, track_checkboxes]
     )
     
     edit_time_button.click(
         fn=edit_track_start_time,
-        inputs=[track_checkboxes, edit_time_input, track_times_state, audio_duration_state, audio_filename_state],
-        outputs=[output_text, track_times_state, track_checkboxes]
+        inputs=[track_checkboxes, edit_time_input, track_data_state, audio_duration_state, cue_globals_state],
+        outputs=[output_text, track_data_state, track_checkboxes]
     )
 
 if __name__ == "__main__":