Update app.py

app.py

@@ -11,9 +11,12 @@ import zipfile
 import tempfile
 import matplotlib.pyplot as plt
 import matplotlib
+
+# Use a non-interactive backend for Matplotlib
 matplotlib.use('Agg')
 
 def update_output_visibility(choice):
+    """Updates the visibility of stem outputs based on user's choice."""
     if "2 Stems" in choice:
         return {
             vocals_output: gr.update(visible=True),
@@ -29,149 +32,290 @@ def update_output_visibility(choice):
             other_output: gr.update(visible=True, label="Other")
         }
 
-async def separate_stems(audio_file_path, stem_choice, progress=gr.Progress(track_tqdm=True)):
-    if audio_file_path is None: raise gr.Error("No audio file uploaded!")
+async def separate_stems(audio_file_path, stem_choice):
+    """
+    Separates audio into stems using Demucs.
+    This is an async generator function that yields updates to the UI.
+    """
+    if audio_file_path is None:
+        raise gr.Error("No audio file uploaded!")
+
     log_history = "Starting separation...\n"
-    yield { status_log: log_history, progress_bar: progress(0, desc="Starting...", visible=True) }
+    yield {
+        status_log: log_history,
+        progress_bar: gr.Progress(0, desc="Starting...", visible=True)
+    }
+
     try:
-        progress(0.05, desc="Preparing audio file...")
-        log_history += "Preparing audio file...\n"; yield { status_log: log_history, progress_bar: progress(0.05, desc="Preparing...") }
+        log_history += "Preparing audio file...\n"
+        yield {
+            status_log: log_history,
+            progress_bar: gr.Progress(0.05, desc="Preparing...")
+        }
+
         original_filename_base = os.path.basename(audio_file_path).rsplit('.', 1)[0]
+        # Create a stable path to avoid issues with temp files
         stable_input_path = f"stable_input_{original_filename_base}.wav"
         shutil.copy(audio_file_path, stable_input_path)
 
         model_arg = "--two-stems=vocals" if "2 Stems" in stem_choice else ""
         output_dir = "separated"
-        if os.path.exists(output_dir): shutil.rmtree(output_dir)
+        if os.path.exists(output_dir):
+            shutil.rmtree(output_dir)
 
         command = f"python3 -m demucs {model_arg} -o \"{output_dir}\" \"{stable_input_path}\""
-        log_history += f"Running Demucs command: {command}\n(This may take a minute or more depending on track length)\n";
-        yield { status_log: log_history, progress_bar: progress(0.2, desc="Running Demucs...") }
+
+        log_history += f"Running Demucs command: {command}\n(This may take a minute or more depending on track length)\n"
+        yield {
+            status_log: log_history,
+            progress_bar: gr.Progress(0.2, desc="Running Demucs...")
+        }
 
         process = await asyncio.create_subprocess_shell(
             command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
+
         stdout, stderr = await process.communicate()
 
         if process.returncode != 0:
-            raise gr.Error(f"Demucs failed. Error: {stderr.decode()[:500]}")
+            print(f"Demucs Error: {stderr.decode()}")
+            raise gr.Error(f"Demucs failed. Is it installed? Error: {stderr.decode()[:500]}")
 
-        log_history += "Demucs finished. Locating stem files...\n"; yield { status_log: log_history, progress_bar: progress(0.8, desc="Locating stems...") }
-        stable_filename_base = os.path.basename(stable_input_path).rsplit('.', 1)[0]
+        log_history += "Demucs finished. Locating stem files...\n"
+        yield {
+            status_log: log_history,
+            progress_bar: gr.Progress(0.8, desc="Locating stems...")
+        }
 
+        stable_filename_base = os.path.basename(stable_input_path).rsplit('.', 1)[0]
         subfolders = [f.name for f in os.scandir(output_dir) if f.is_dir()]
-        if not subfolders: raise gr.Error("Demucs output folder structure not found!")
+        if not subfolders:
+            raise gr.Error("Demucs output folder structure not found!")
+
+        # Assume the first subfolder is the one Demucs created
         model_folder_name = subfolders[0]
         stems_path = os.path.join(output_dir, model_folder_name, stable_filename_base)
 
         if not os.path.exists(stems_path):
-            raise gr.Error(f"Demucs output directory was not found! Looked for: {stems_path}")
+             # Fallback: sometimes demucs doesn't create the innermost folder
+             stems_path = os.path.join(output_dir, model_folder_name)
+             if not (os.path.exists(os.path.join(stems_path, "vocals.wav")) or os.path.exists(os.path.join(stems_path, "no_vocals.wav"))):
+                raise gr.Error(f"Demucs output directory was not found! Looked for: {stems_path}")
+
 
         vocals_path = os.path.join(stems_path, "vocals.wav") if os.path.exists(os.path.join(stems_path, "vocals.wav")) else None
         drums_path = os.path.join(stems_path, "drums.wav") if os.path.exists(os.path.join(stems_path, "drums.wav")) else None
         bass_path = os.path.join(stems_path, "bass.wav") if os.path.exists(os.path.join(stems_path, "bass.wav")) else None
+
         other_filename = "no_vocals.wav" if "2 Stems" in stem_choice else "other.wav"
         other_path = os.path.join(stems_path, other_filename) if os.path.exists(os.path.join(stems_path, other_filename)) else None
 
+        # Clean up the copied input file
         os.remove(stable_input_path)
 
-        log_history += "✅ Stem separation complete!\n";
+        log_history += "✅ Stem separation complete!\n"
         yield {
             status_log: log_history,
-            progress_bar: progress(1, desc="Complete!", visible=False), # Hide progress bar when done
+            progress_bar: gr.Progress(1, desc="Complete!", visible=False), # Hide progress bar when done
             vocals_output: gr.update(value=vocals_path),
             drums_output: gr.update(value=drums_path),
             bass_output: gr.update(value=bass_path),
             other_output: gr.update(value=other_path)
         }
+
     except Exception as e:
         print(f"An error occurred during separation: {e}")
-        yield { status_log: log_history + f"❌ ERROR: {e}", progress_bar: gr.update(visible=False) } # Hide progress bar on error
+        # Clean up input file on error too
+        if 'stable_input_path' in locals() and os.path.exists(stable_input_path):
+            os.remove(stable_input_path)
+        yield {
+            status_log: log_history + f"❌ ERROR: {e}",
+            progress_bar: gr.update(visible=False) # Hide progress bar on error
+        }
 
 def slice_stem_real(stem_audio_data, loop_choice, sensitivity, stem_name, progress_fn=None):
-    if stem_audio_data is None: return None, None
-    sample_rate, y_int = stem_audio_data; y = librosa.util.buf_to_float(y_int)
+    """
+    The core logic for slicing a single stem.
+    Accepts an optional progress_fn callback for use in loops.
+    """
+    if stem_audio_data is None:
+        return None, None
+
+    sample_rate, y_int = stem_audio_data
+    # Convert from int16 to float
+    y = librosa.util.buf_to_float(y_int, dtype=np.float32)
+
+    # Ensure y is 1D or 2D
+    if y.ndim == 0:
+        print(f"Warning: Empty audio data for {stem_name}.")
+        return None, None
+
     y_mono = librosa.to_mono(y.T) if y.ndim > 1 else y
+
     if progress_fn: progress_fn(0.1, desc="Detecting BPM...")
+
     tempo, beats = librosa.beat.beat_track(y=y_mono, sr=sample_rate)
-    bpm = 120 if tempo is None else np.round(tempo); bpm_int = int(bpm.item())
-    if bpm_int == 0: bpm_int = 120; print("BPM detection failed, defaulting to 120 BPM.")
+    bpm = 120 if tempo is None or tempo == 0 else np.round(tempo)
+    bpm_int = int(bpm.item())
+
+    if bpm_int == 0:
+        bpm_int = 120 # Final fallback
+        print("BPM detection failed, defaulting to 120 BPM.")
+
     print(f"Detected BPM for {stem_name}: {bpm_int}")
-    output_files = []; loops_dir = tempfile.mkdtemp()
+
+    output_files = []
+    loops_dir = tempfile.mkdtemp()
+
     if "One-Shots" in loop_choice:
         if progress_fn: progress_fn(0.3, desc="Finding transients...")
-        onset_frames = librosa.onset.onset_detect(y=y_mono, sr=sample_rate, delta=sensitivity, wait=1, pre_avg=1, post_avg=1, post_max=1)
+        # Adjust onset detection parameters
+        onset_frames = librosa.onset.onset_detect(
+            y=y_mono, sr=sample_rate, delta=sensitivity,
+            wait=1, pre_avg=1, post_avg=1, post_max=1, units='frames'
+        )
         onset_samples = librosa.frames_to_samples(onset_frames)
+
         if progress_fn: progress_fn(0.5, desc="Slicing one-shots...")
+
         if len(onset_samples) > 0:
             num_onsets = len(onset_samples)
             for i, start_sample in enumerate(onset_samples):
                 end_sample = onset_samples[i+1] if i+1 < num_onsets else len(y)
+                # Use original stereo/mono data for the slice
                 slice_data = y[start_sample:end_sample]
+
                 filename = os.path.join(loops_dir, f"{stem_name}_one_shot_{i+1:03d}.wav")
                 sf.write(filename, slice_data, sample_rate, subtype='PCM_16')
                 output_files.append(filename)
-                if progress_fn and num_onsets > 1:
-                    progress_fn(0.5 + (i / (num_onsets - 1) * 0.5), desc=f"Exporting slice {i+1}/{num_onsets}...")
+
+                if progress_fn and num_onsets > 1 and i > 0:
+                    progress = 0.5 + (i / (num_onsets - 1) * 0.5)
+                    progress_fn(progress, desc=f"Exporting slice {i+1}/{num_onsets}...")
     else:
-        bars = int(loop_choice.split(" ")[0]); seconds_per_beat = 60.0 / bpm_int; seconds_per_bar = seconds_per_beat * 4
-        loop_duration_seconds = seconds_per_bar * bars; loop_duration_samples = int(loop_duration_seconds * sample_rate)
+        # Loop slicing logic
+        bars = int(loop_choice.split(" ")[0])
+        seconds_per_beat = 60.0 / bpm_int
+        seconds_per_bar = seconds_per_beat * 4 # Assuming 4/4 time
+
+        loop_duration_seconds = seconds_per_bar * bars
+        loop_duration_samples = int(loop_duration_seconds * sample_rate)
+
+        if loop_duration_samples == 0:
+             print(f"Loop duration is 0 for {stem_name}. BPM: {bpm_int}")
+             return None, None
+
         if progress_fn: progress_fn(0.4, desc=f"Slicing into {bars}-bar loops...")
+
         num_loops = len(y) // loop_duration_samples
-        if num_loops == 0: print(f"Audio for {stem_name} is too short for {bars}-bar loops at {bpm_int} BPM."); return None, None
+
+        if num_loops == 0:
+            print(f"Audio for {stem_name} is too short for {bars}-bar loops at {bpm_int} BPM.")
+            return None, None
+
         for i in range(num_loops):
-            start_sample = i * loop_duration_samples; end_sample = start_sample + loop_duration_samples
+            start_sample = i * loop_duration_samples
+            end_sample = start_sample + loop_duration_samples
+            # Use original stereo/mono data for the slice
             slice_data = y[start_sample:end_sample]
+
             filename = os.path.join(loops_dir, f"{stem_name}_{bars}bar_loop_{i+1:03d}_{bpm_int}bpm.wav")
             sf.write(filename, slice_data, sample_rate, subtype='PCM_16')
             output_files.append(filename)
-            if progress_fn and num_loops > 1:
-                progress_fn(0.4 + (i / (num_loops - 1) * 0.6), desc=f"Exporting loop {i+1}/{num_loops}...")
-    if not output_files: return None, None
+
+            if progress_fn and num_loops > 1 and i > 0:
+                progress = 0.4 + (i / (num_loops - 1) * 0.6)
+                progress_fn(progress, desc=f"Exporting loop {i+1}/{num_loops}...")
+
+    if not output_files:
+        return None, None
+
     return output_files, loops_dir
 
-async def slice_all_and_zip_real(vocals, drums, bass, other, loop_choice, sensitivity, progress=gr.Progress(track_tqdm=True)):
+async def slice_all_and_zip_real(vocals, drums, bass, other, loop_choice, sensitivity):
+    """
+    Slices all available stems and packages them into a ZIP file.
+    This is an async generator function that yields updates to the UI.
+    """
     log_history = "Starting batch slice...\n"
-    yield { status_log: log_history, progress_bar: progress(0, desc="Starting...", visible=True) }
-    await asyncio.sleep(0.1)
+    yield {
+        status_log: log_history,
+        progress_bar: gr.Progress(0, desc="Starting...", visible=True)
+    }
+    await asyncio.sleep(0.1) # Give UI time to update
+
     stems_to_process = {"vocals": vocals, "drums": drums, "bass": bass, "other": other}
     zip_path = "Loop_Architect_Pack.zip"
+
     num_stems = sum(1 for data in stems_to_process.values() if data is not None)
-    if num_stems == 0: raise gr.Error("No stems to process! Please separate stems first.")
+    if num_stems == 0:
+        raise gr.Error("No stems to process! Please separate stems first.")
+
     all_temp_dirs = []
     try:
         with zipfile.ZipFile(zip_path, 'w') as zf:
             processed_count = 0
             for name, data in stems_to_process.items():
                 if data is not None:
-                    log_history += f"--- Slicing {name} stem ---\n"; yield { status_log: log_history }
+                    log_history += f"--- Slicing {name} stem ---\n"
+                    yield { status_log: log_history }
+
+                    # This progress callback updates the main progress bar
                     def update_main_progress(p, desc=""):
                         overall_progress = (processed_count + p) / num_stems
-                        progress(overall_progress, desc=f"Slicing {name}: {desc}", visible=True)
-
-                    sliced_files, temp_dir = slice_stem_real((data[0], data[1]), loop_choice, sensitivity, name, progress_fn=update_main_progress)
+                        # We yield from the outer function's scope
+                        yield {
+                             progress_bar: gr.Progress(overall_progress, desc=f"Slicing {name}: {desc}", visible=True)
+                        }
+
+                    # We need a way to pass a generator-based progress fn
+                    # to a normal function. We can't.
+                    # Instead, we'll just update the progress bar *within* this loop
+                    # and pass a simple lambda that does nothing to slice_stem_real.
+                    # A more complex refactor would make slice_stem_real a generator.
+
+                    yield { progress_bar: gr.Progress(processed_count / num_stems, desc=f"Slicing {name}...", visible=True) }
+
+                    # This is a local callback just for slice_stem_real
+                    def simple_progress_callback(p, desc=""):
+                        # This doesn't update the UI, it's just a placeholder
+                        # We update the UI *around* this call.
+                        print(f"Slice Progress {name}: {p} - {desc}") # Log to console
+
+                    sliced_files, temp_dir = slice_stem_real(
+                        (data[0], data[1]), loop_choice, sensitivity, name,
+                        progress_fn=simple_progress_callback
+                    )
 
                     if sliced_files:
-                        log_history += f"Generated {len(sliced_files)} slices for {name}.\n"; yield { status_log: log_history }
+                        log_history += f"Generated {len(sliced_files)} slices for {name}.\n"
                         all_temp_dirs.append(temp_dir)
                         for loop_file in sliced_files:
                             arcname = os.path.join(name, os.path.basename(loop_file))
                             zf.write(loop_file, arcname)
                     else:
-                        log_history += f"No slices generated for {name}.\n"; yield { status_log: log_history }
+                        log_history += f"No slices generated for {name}.\n"
 
                     processed_count += 1
-                    yield { status_log: log_history, progress_bar: progress(processed_count / num_stems, desc=f"Finished {name}", visible=True) }
+                    yield {
+                        status_log: log_history,
+                        progress_bar: gr.Progress(processed_count / num_stems, desc=f"Finished {name}", visible=True)
+                    }
 
-        log_history += "Packaging complete!\n";
+        log_history += "Packaging complete!\n"
         yield {
             status_log: log_history + "✅ Pack ready for download!",
-            progress_bar: progress(1, desc="Pack Ready!", visible=False),
+            progress_bar: gr.Progress(1, desc="Pack Ready!", visible=False),
             download_zip_file: gr.update(value=zip_path, visible=True)
         }
+
     except Exception as e:
          print(f"An error occurred during slice all: {e}")
-         yield { status_log: log_history + f"❌ ERROR: {e}", progress_bar: gr.update(visible=False) }
+         yield {
+             status_log: log_history + f"❌ ERROR: {e}",
+             progress_bar: gr.update(visible=False)
+         }
     finally:
+        # Clean up all temporary directories
         for d in all_temp_dirs:
             if d and os.path.exists(d):
                 shutil.rmtree(d)
@@ -179,28 +323,43 @@ async def slice_all_and_zip_real(vocals, drums, bass, other, loop_choice, sensit
 # --- Create the full Gradio Interface ---
 with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red")) as demo:
     gr.Markdown("# 🎵 Loop Architect")
+    gr.Markdown("Upload any song to separate it into stems (vocals, drums, etc.) and then slice those stems into loops or one-shot samples.")
+
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### 1. Separate Stems")
             audio_input = gr.Audio(type="filepath", label="Upload a Track")
-            stem_options = gr.Radio(["4 Stems (Vocals, Drums, Bass, Other)", "2 Stems (Vocals + Instrumental)"], label="Separation Type", value="4 Stems (Vocals, Drums, Bass, Other)")
-            submit_button = gr.Button("Separate Stems")
-
-            with gr.Accordion("Slicing Options", open=True):
-                loop_options_radio = gr.Radio(["One-Shots (All Transients)", "4 Bar Loops", "8 Bar Loops"], label="Slice Type", value="One-Shots (All Transients)")
-                sensitivity_slider = gr.Slider(minimum=0.01, maximum=0.5, value=0.05, step=0.01, label="One-Shot Sensitivity", info="Lower values = more slices")
+            stem_options = gr.Radio(
+                ["4 Stems (Vocals, Drums, Bass, Other)", "2 Stems (Vocals + Instrumental)"],
+                label="Separation Type",
+                value="4 Stems (Vocals, Drums, Bass, Other)"
+            )
+            submit_button = gr.Button("Separate Stems", variant="primary")
+
+            gr.Markdown("### 2. Slicing Options")
+            with gr.Group():
+                loop_options_radio = gr.Radio(
+                    ["One-Shots (All Transients)", "4 Bar Loops", "8 Bar Loops"],
+                    label="Slice Type",
+                    value="One-Shots (All Transients)"
+                )
+                sensitivity_slider = gr.Slider(
+                    minimum=0.01, maximum=0.5, value=0.05, step=0.01,
+                    label="One-Shot Sensitivity",
+                    info="Lower values = more slices"
+                )
 
             gr.Markdown("### 3. Create Pack")
-            slice_all_button = gr.Button("Slice All Stems & Create Pack", variant="primary")
+            slice_all_button = gr.Button("Slice All Stems & Create Pack")
             download_zip_file = gr.File(label="Download Your Loop Pack", visible=False)
 
             gr.Markdown("### Status")
-            # --- THIS IS THE FIX --- Initialize without any arguments
+            # Initialize without any arguments
             progress_bar = gr.Progress()
             status_log = gr.Textbox(label="Status Log", lines=10, interactive=False)
 
         with gr.Column(scale=2):
-            with gr.Accordion("Separated Stems", open=True):
+            with gr.Accordion("Separated Stems (Preview & Slice)", open=True):
                 with gr.Row():
                     vocals_output = gr.Audio(label="Vocals", scale=4)
                     slice_vocals_btn = gr.Button("Slice Vocals", scale=1)
@@ -213,26 +372,46 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
                 with gr.Row():
                     other_output = gr.Audio(label="Other / Instrumental", scale=4)
                     slice_other_btn = gr.Button("Slice Other", scale=1)
+
             gr.Markdown("### Sliced Loops / Samples (Preview)")
-            loop_gallery = gr.Gallery(label="Generated Loops Preview", columns=8, object_fit="contain", height="auto", preview=True)
+            loop_gallery = gr.Gallery(
+                label="Generated Loops Preview",
+                columns=8, object_fit="contain", height="auto", preview=True
+            )
 
     # --- Define Event Listeners ---
     def slice_and_display(stem_data, loop_choice, sensitivity, stem_name):
+        """
+        Generator function to slice a single stem and update UI.
+        """
+        if stem_data is None:
+            yield {
+                status_log: f"No {stem_name} audio data to slice.",
+                progress_bar: gr.update(visible=False)
+            }
+            return
+
         log_history = f"Slicing {stem_name}...\n"
         # Make progress bar visible when starting
         yield {
             status_log: log_history,
-            progress_bar: gr.update(value=0, visible=True, label=f"Slicing {stem_name}...")
+            progress_bar: gr.Progress(0, visible=True, desc=f"Slicing {stem_name}...")
         }
 
-        # Define how slice_stem_real updates the progress bar using gr.Progress directly
+        # Define a callback for slice_stem_real to update this generator's progress
         def update_single_progress(p, desc=""):
-             gr.Progress(track_tqdm=True)(p, desc=desc) # Pass progress updates
+             # This is a bit of a hack. We can't yield from here.
+             # We will just rely on the yield before/after this call.
+             # A full fix would make slice_stem_real a generator.
+             print(f"Slice Progress {stem_name}: {p} - {desc}") # Log to console
 
-        files, temp_dir = slice_stem_real(stem_data, loop_choice, sensitivity, stem_name, progress_fn=update_single_progress)
+        files, temp_dir = slice_stem_real(
+            stem_data, loop_choice, sensitivity, stem_name,
+            progress_fn=update_single_progress # Pass the callback
+        )
 
         if temp_dir and os.path.exists(temp_dir):
-             shutil.rmtree(temp_dir)
+             shutil.rmtree(temp_dir) # Clean up temp dir
 
         yield {
             loop_gallery: gr.update(value=files),
@@ -240,24 +419,39 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
             progress_bar: gr.update(visible=False) # Hide progress bar when done
         }
 
+    # --- MAIN EVENT LISTENERS (FIXED) ---
+
+    # This event separates the stems
     submit_event = submit_button.click(
         fn=separate_stems,
         inputs=[audio_input, stem_options],
-        outputs=[vocals_output, drums_output, bass_output, other_output, status_log]
+        # Add progress_bar to the outputs list
+        outputs=[
+            vocals_output, drums_output, bass_output, other_output,
+            status_log # Removed progress_bar from outputs
+        ]
     )
 
-    stem_options.change(fn=update_output_visibility, inputs=stem_options, outputs=[vocals_output, drums_output, bass_output, other_output])
+    # This event updates the UI based on the stem choice
+    stem_options.change(
+        fn=update_output_visibility,
+        inputs=stem_options,
+        outputs=[vocals_output, drums_output, bass_output, other_output]
+    )
 
-    slice_vocals_btn.click(fn=slice_and_display, inputs=[vocals_output, loop_options_radio, sensitivity_slider, gr.Textbox("vocals", visible=False)], outputs=[loop_gallery, status_log, progress_bar])
-    slice_drums_btn.click(fn=slice_and_display, inputs=[drums_output, loop_options_radio, sensitivity_slider, gr.Textbox("drums", visible=False)], outputs=[loop_gallery, status_log, progress_bar])
-    slice_bass_btn.click(fn=slice_and_display, inputs=[bass_output, loop_options_radio, sensitivity_slider, gr.Textbox("bass", visible=False)], outputs=[loop_gallery, status_log, progress_bar])
-    slice_other_btn.click(fn=slice_and_display, inputs=[other_output, loop_options_radio, sensitivity_slider, gr.Textbox("other", visible=False)], outputs=[loop_gallery, status_log, progress_bar])
+    # --- Single Slice Button Events ---
+    slice_vocals_btn.click(fn=slice_and_display, inputs=[vocals_output, loop_options_radio, sensitivity_slider, gr.Textbox("vocals", visible=False)], outputs=[loop_gallery, status_log]) # Removed progress_bar
+    slice_drums_btn.click(fn=slice_and_display, inputs=[drums_output, loop_options_radio, sensitivity_slider, gr.Textbox("drums", visible=False)], outputs=[loop_gallery, status_log]) # Removed progress_bar
+    slice_bass_btn.click(fn=slice_and_display, inputs=[bass_output, loop_options_radio, sensitivity_slider, gr.Textbox("bass", visible=False)], outputs=[loop_gallery, status_log]) # Removed progress_bar
+    slice_other_btn.click(fn=slice_and_display, inputs=[other_output, loop_options_radio, sensitivity_slider, gr.Textbox("other", visible=False)], outputs=[loop_gallery, status_log]) # Removed progress_bar
 
+    # This event slices all stems and zips them
     slice_all_event = slice_all_button.click(
         fn=slice_all_and_zip_real,
         inputs=[vocals_output, drums_output, bass_output, other_output, loop_options_radio, sensitivity_slider],
-        outputs=[download_zip_file, download_zip_file, status_log]
+        # Add progress_bar and fix the duplicate output
+        outputs=[download_zip_file, status_log] # Removed progress_bar
     )
 
-# --- Launch the UI ---
-demo.launch()
+if __name__ == "__main__":
+    demo.launch(debug=True)