initial add app.py

.gitignore

@@ -0,0 +1,12 @@
+.vs
+.vscode
+# Byte-compiled / optimized / DLL files
+__pycache__/
+
+venv/
+tmp/
+sf2/
+models/
+output/
+rendered_midi/
+transcribed_/

README.md

@@ -1,6 +1,6 @@
 ---
 title: Audio To CUE Generator
-emoji: 👁
+emoji: 📝
 colorFrom: green
 colorTo: blue
 sdk: gradio

app.py

@@ -0,0 +1,305 @@
+import os
+import re
+import librosa
+import gradio as gr
+
+# --- Helper Functions ---
+
+def seconds_to_cue_time(t):
+    """Converts a time in seconds to the CUE sheet format (MM:SS:FF)."""
+    t = max(0, t)
+    minutes = int(t // 60)
+    seconds = int(t % 60)
+    frames = int((t - minutes * 60 - seconds) * 75)
+    return f'{minutes:02d}:{seconds:02d}:{frames:02d}'
+
+def parse_cue_time_to_seconds(time_str):
+    """Parses MM:SS:FF into seconds. Returns None on failure."""
+    if not time_str:
+        return None
+    match = re.match(r'(\d+):(\d{1,2}):(\d{1,2})', time_str)
+    if match:
+        m, s, f = map(int, match.groups())
+        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:
+        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)
+        cue_text += f'  TRACK {idx+1:02d} AUDIO\n'
+        cue_text += f'    TITLE "Track {idx+1:02d}"\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:
+        return []
+    sorted_times = sorted(list(set(times)))
+    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)
+    return track_choices
+
+# --- Core Gradio Functions ---
+def analyze_audio_to_cue(audio_file, top_db, min_segment_len, merge_threshold, merge_protection_len):
+    """Workflow 1: Analyzes an uploaded audio file to generate the initial CUE text."""
+    if not audio_file:
+        raise gr.Error("Please upload an audio file first.")
+    
+    # --- 1. Load Audio File ---
+    try:
+        y, sr = librosa.load(audio_file, sr=None)
+        audio_duration = librosa.get_duration(y=y, sr=sr)
+    except Exception as e:
+        raise gr.Error(f"Could not load audio file: {e}")
+    
+    # --- 2. Detect Segments using Silence Detection ---
+    intervals = librosa.effects.split(y, top_db=top_db)
+
+    # Corrected way to check if NumPy array is empty
+    times = [iv[0] / sr for iv in intervals if (iv[1] - iv[0]) / sr >= min_segment_len] if intervals.size > 0 else []
+
+    # --- 3. Post-process Tracks (Add Start, Auto-Merge) ---
+    if not times or times[0] > 0.5:
+        times.insert(0, 0.0)
+        
+    # Auto-merging logic
+    if len(times) > 1:
+        final_times = [times[0]]
+        i = 0
+        while i < len(times) - 1:
+            track_length = times[i+1] - times[i]
+            
+            # Merge if track is shorter than threshold AND not longer than protection length
+            if (track_length < merge_threshold) and (track_length <= merge_protection_len):
+                # Condition to MERGE is met. Skip adding the next timestamp.
+                pass
+            else:
+                # Condition to KEEP is met.
+                final_times.append(times[i+1])
+            
+            i += 1
+
+        if len(final_times) > 1 and (audio_duration - final_times[-1]) < merge_threshold:
+            final_times.pop()
+        times = final_times
+
+    # --- 4. Prepare Outputs for Gradio ---
+    times = sorted(list(set(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)
+    
+    # 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)
+    )
+
+def parse_cue_and_update_ui(cue_text):
+    """Workflow 2: Parses pasted CUE text. NOW returns the text itself to populate the output box."""
+    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)
+    
+    file_match = re.search(r'FILE\s+"([^"]+)"', cue_text, re.IGNORECASE)
+    audio_filename = file_match.group(1) if file_match else "CDImage.wav"
+    
+    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]
+    
+    if not times:
+        return cue_text, audio_filename, None, 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)
+    
+    return cue_text, audio_filename, times, audio_duration, gr.update(choices=track_labels, value=[]), gr.update(visible=True)
+
+def update_editing_tools(selected_tracks, current_times, audio_duration):
+    """Dynamically shows/hides Merge or Split tools based on selection count."""
+    num_selected = len(selected_tracks)
+    
+    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]
+
+        # --- 2. [CORRECTION] 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
+        
+        new_min_time = start_time + padding
+        new_max_time = end_time
+
+        # --- 3. [CORRECTION] Check if the track is too short to be split ---
+        if new_min_time >= new_max_time:
+            # If the track is too short, splitting is not possible. Hide the tools.
+            return (
+                gr.update(visible=False), # Hide Merge button
+                gr.update(visible=False), # Hide Split Group
+                None,
+                None
+            )
+
+        # --- 4. Configure and show the Split UI with the corrected range ---
+        mid_point = start_time + (end_time - start_time) / 2
+        
+        return (
+            gr.update(visible=False), # Hide Merge button
+            gr.update(visible=True),  # Show Split Group
+            # Use the new padded min/max values for the slider
+            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
+        )
+        
+    elif num_selected > 1:
+        # Show Merge UI
+        return gr.update(visible=True), gr.update(visible=False), None, None
+    else:
+        # Hide everything
+        return gr.update(visible=False), gr.update(visible=False), None, None
+
+def perform_manual_merge(selected_tracks, original_times, audio_duration, audio_filename):
+    """Merges selected tracks. The internal logic is robust and unchanged."""
+
+    # --- 1. Identify which track start times to remove ---
+    indices_to_merge = {int(label.split(' ')[1]) - 1 for label in selected_tracks}
+
+    # --- 2. 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
+        
+        # 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)
+    
+    # --- 3. 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)
+    
+    # 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=[])
+
+
+def perform_manual_split(split_time_sec, original_times, audio_duration, audio_filename):
+    """Splits a track at the time specified by the slider."""
+    if split_time_sec in original_times:
+        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=[])
+
+
+# --- 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([])
+    audio_duration_state = gr.State(0)
+    audio_filename_state = gr.State("CDImage.wav")
+
+    with gr.Tabs():
+        with gr.TabItem("Start with Audio File"):
+            gr.Markdown("Upload an audio file to automatically detect track points.")
+            audio_input = gr.Audio(type="filepath", label="Upload Audio File")
+            with gr.Accordion("Analysis Parameters", open=False):
+                threshold_slider = gr.Slider(10, 80, 40, step=1, label="Silence Threshold (dB)")
+                min_length_slider = gr.Slider(0.5, 30, 2, step=0.1, label="Min. Segment Length (s)")
+                merge_length_slider = gr.Slider(1, 60, 15, step=1, label="Auto-Merge Threshold (s)")
+                min_silence_length_slider = gr.Slider(0.5, 60, 5, step=0.1, label="Merge Protection Length (s)")
+            generate_button = gr.Button("Analyze Audio", variant="primary")
+        
+        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)
+
+    # 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)
+
+    with gr.Group(visible=False) as manual_editing_group:
+        gr.Markdown("### Manual Editing Tools")
+        track_checkboxes = gr.CheckboxGroup(label="Select Tracks to Edit")
+
+        with gr.Row(visible=False) as merge_tools:
+            merge_button = gr.Button("Merge Selected Tracks", variant="secondary", size="lg")
+
+        with gr.Group(visible=False) as split_tools:
+            split_slider_label = gr.Textbox(label="Current Split Time", interactive=False)
+            split_slider = gr.Slider(label="Drag to select split point")
+            split_button = gr.Button("Split Track at Selected Time", variant="secondary")
+
+    # --- Event Wiring ---
+    
+    # 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, manual_editing_group]
+    )
+    
+    # Workflow 2: Pasting text in the dedicated input box populates the main output and enables tools.
+    # The `.change` event now updates all necessary outputs in a single, direct step.
+    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, manual_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, split_tools, split_slider, split_slider_label]
+    )
+
+    # 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]
+    )
+
+    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]
+    )
+
+if __name__ == "__main__":
+    demo.launch(inbrowser=True)

requirements.txt

@@ -0,0 +1,3 @@
+gradio
+librosa
+soundfile

webui.bat

@@ -0,0 +1,162 @@
+@echo off
+
+:: The original source of the webui.bat file is stable-diffusion-webui
+:: Modified and enhanced by Gemini with features for venv management and requirements handling.
+
+:: --------- Configuration ---------
+set COMMANDLINE_ARGS=
+:: Define the name of the Launch application
+set APPLICATION_NAME=app.py
+:: Define the name of the virtual environment directory
+set VENV_NAME=venv
+:: Set to 1 to always attempt to update packages from requirements.txt on every launch
+set ALWAYS_UPDATE_REQS=0
+:: ---------------------------------
+
+
+:: Set PYTHON executable if not already defined
+if not defined PYTHON (set PYTHON=python)
+:: Set VENV_DIR using VENV_NAME if not already defined
+if not defined VENV_DIR (set "VENV_DIR=%~dp0%VENV_NAME%")
+
+mkdir tmp 2>NUL
+
+:: Check if Python is callable
+%PYTHON% -c "" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :check_pip
+echo Couldn't launch python
+goto :show_stdout_stderr
+
+:check_pip
+:: Check if pip is available
+%PYTHON% -mpip --help >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :start_venv
+:: If pip is not available and PIP_INSTALLER_LOCATION is set, try to install pip
+if "%PIP_INSTALLER_LOCATION%" == "" goto :show_stdout_stderr
+%PYTHON% "%PIP_INSTALLER_LOCATION%" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :start_venv
+echo Couldn't install pip
+goto :show_stdout_stderr
+
+:start_venv
+:: Skip venv creation/activation if VENV_DIR is explicitly set to "-"
+if ["%VENV_DIR%"] == ["-"] goto :skip_venv_entirely
+:: Skip venv creation/activation if SKIP_VENV is set to "1"
+if ["%SKIP_VENV%"] == ["1"] goto :skip_venv_entirely
+
+:: Check if the venv already exists by looking for Python.exe in its Scripts directory
+dir "%VENV_DIR%\Scripts\Python.exe" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% == 0 goto :activate_venv_and_maybe_update
+
+:: Venv does not exist, create it
+echo Virtual environment not found in "%VENV_DIR%". Creating a new one.
+for /f "delims=" %%i in ('CALL %PYTHON% -c "import sys; print(sys.executable)"') do set PYTHON_FULLNAME="%%i"
+echo Creating venv in directory %VENV_DIR% using python %PYTHON_FULLNAME%
+%PYTHON_FULLNAME% -m venv "%VENV_DIR%" >tmp/stdout.txt 2>tmp/stderr.txt
+if %ERRORLEVEL% NEQ 0 (
+    echo Unable to create venv in directory "%VENV_DIR%"
+    goto :show_stdout_stderr
+)
+echo Venv created.
+
+:: Install requirements for the first time if venv was just created
+:: This section handles the initial installation of packages from requirements.txt
+:: immediately after a new virtual environment is created.
+echo Checking for requirements.txt for initial setup in %~dp0
+if exist "%~dp0requirements.txt" (
+    echo Found requirements.txt, attempting to install for initial setup...
+    call "%VENV_DIR%\Scripts\activate.bat"
+    echo Installing packages from requirements.txt ^(initial setup^)...
+    "%VENV_DIR%\Scripts\python.exe" -m pip install -r "%~dp0requirements.txt"
+    if %ERRORLEVEL% NEQ 0 (
+        echo Failed to install requirements during initial setup. Please check the output above.
+        pause
+        goto :show_stdout_stderr_custom_pip_initial 
+    )
+    echo Initial requirements installed successfully.
+    call "%VENV_DIR%\Scripts\deactivate.bat"
+) else (
+    echo No requirements.txt found for initial setup, skipping package installation.
+)
+goto :activate_venv_and_maybe_update
+
+
+:activate_venv_and_maybe_update
+:: This label is reached if the venv exists or was just created.
+:: Set PYTHON to point to the venv's Python interpreter.
+set PYTHON="%VENV_DIR%\Scripts\Python.exe"
+echo Activating venv: %PYTHON%
+
+:: Always update requirements if ALWAYS_UPDATE_REQS is 1
+:: This section allows for updating packages from requirements.txt on every launch
+:: if the ALWAYS_UPDATE_REQS variable is set to 1.
+if defined ALWAYS_UPDATE_REQS (
+    if "%ALWAYS_UPDATE_REQS%"=="1" (
+        echo ALWAYS_UPDATE_REQS is enabled.
+        if exist "%~dp0requirements.txt" (
+            echo Attempting to update packages from requirements.txt...
+            REM No need to call activate.bat here again, PYTHON is already set to the venv's python
+            %PYTHON% -m pip install -r "%~dp0requirements.txt"
+            if %ERRORLEVEL% NEQ 0 (
+                echo Failed to update requirements. Please check the output above.
+                pause
+                goto :endofscript 
+            )
+            echo Requirements updated successfully.
+        ) else (
+            echo ALWAYS_UPDATE_REQS is enabled, but no requirements.txt found. Skipping update.
+        )
+    ) else (
+        echo ALWAYS_UPDATE_REQS is not enabled or not set to 1. Skipping routine update.
+    )
+)
+
+goto :launch
+
+:skip_venv_entirely
+:: This label is reached if venv usage is explicitly skipped.
+echo Skipping venv.
+goto :launch
+
+:launch
+:: Launch the main application
+echo Launching Web UI with arguments: %COMMANDLINE_ARGS% %*
+%PYTHON% %APPLICATION_NAME% %COMMANDLINE_ARGS% %*
+echo Launch finished.
+pause
+exit /b
+
+:show_stdout_stderr_custom_pip_initial
+:: Custom error handler for failures during the initial pip install process.
+echo.
+echo exit code ^(pip initial install^): %errorlevel%
+echo Errors during initial pip install. See output above.
+echo.
+echo Launch unsuccessful. Exiting.
+pause
+exit /b
+
+
+:show_stdout_stderr
+:: General error handler: displays stdout and stderr from the tmp directory.
+echo.
+echo exit code: %errorlevel%
+
+for /f %%i in ("tmp\stdout.txt") do set size=%%~zi
+if %size% equ 0 goto :show_stderr
+echo.
+echo stdout:
+type tmp\stdout.txt
+
+:show_stderr
+for /f %%i in ("tmp\stderr.txt") do set size=%%~zi
+if %size% equ 0 goto :endofscript
+echo.
+echo stderr:
+type tmp\stderr.txt
+
+:endofscript
+echo.
+echo Launch unsuccessful. Exiting.
+pause
+exit /b