Update app.py

app.py

@@ -15,69 +15,68 @@ matplotlib.use('Agg')
 
 def update_output_visibility(choice):
     if "2 Stems" in choice:
-        return { 
-            vocals_output: gr.update(visible=True), 
-            drums_output: gr.update(visible=False), 
-            bass_output: gr.update(visible=False), 
-            other_output: gr.update(visible=True, label="Instrumental (No Vocals)") 
+        return {
+            vocals_output: gr.update(visible=True),
+            drums_output: gr.update(visible=False),
+            bass_output: gr.update(visible=False),
+            other_output: gr.update(visible=True, label="Instrumental (No Vocals)")
         }
     elif "4 Stems" in choice:
-        return { 
-            vocals_output: gr.update(visible=True), 
-            drums_output: gr.update(visible=True), 
-            bass_output: gr.update(visible=True), 
-            other_output: gr.update(visible=True, label="Other") 
+        return {
+            vocals_output: gr.update(visible=True),
+            drums_output: gr.update(visible=True),
+            bass_output: gr.update(visible=True),
+            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!")
     log_history = "Starting separation...\n"
-    # Make progress bar visible at the start
-    yield { status_log: log_history, progress_bar: progress(0, desc="Starting...", visible=True) } 
+    yield { status_log: log_history, progress_bar: 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...") }
         original_filename_base = os.path.basename(audio_file_path).rsplit('.', 1)[0]
         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)
-        
+
         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"; 
+        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...") }
 
         process = await asyncio.create_subprocess_shell(
             command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
         stdout, stderr = await process.communicate()
 
-        if process.returncode != 0: 
+        if process.returncode != 0:
             raise gr.Error(f"Demucs failed. 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]
-        
+
         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!")
-        model_folder_name = subfolders[0] 
+        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): 
+
+        if not os.path.exists(stems_path):
             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
-        
+
         os.remove(stable_input_path)
-        
-        log_history += "✅ Stem separation complete!\n"; 
-        yield { 
-            status_log: log_history, 
+
+        log_history += "✅ Stem separation complete!\n";
+        yield {
+            status_log: log_history,
             progress_bar: 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),
@@ -89,7 +88,6 @@ async def separate_stems(audio_file_path, stem_choice, progress=gr.Progress(trac
         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):
-    # This function remains the same internally
     if stem_audio_data is None: return None, None
     sample_rate, y_int = stem_audio_data; y = librosa.util.buf_to_float(y_int)
     y_mono = librosa.to_mono(y.T) if y.ndim > 1 else y
@@ -133,9 +131,8 @@ def slice_stem_real(stem_audio_data, loop_choice, sensitivity, stem_name, progre
 
 async def slice_all_and_zip_real(vocals, drums, bass, other, loop_choice, sensitivity, progress=gr.Progress(track_tqdm=True)):
     log_history = "Starting batch slice...\n"
-    # Make progress bar visible at the start
-    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: progress(0, desc="Starting...", visible=True) }
+    await asyncio.sleep(0.1)
     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)
@@ -147,38 +144,34 @@ async def slice_all_and_zip_real(vocals, drums, bass, other, loop_choice, sensit
             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 }
-                    
                     def update_main_progress(p, desc=""):
                         overall_progress = (processed_count + p) / num_stems
-                        # Ensure progress updates visibility
-                        progress(overall_progress, desc=f"Slicing {name}: {desc}", visible=True) 
-                    
+                        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)
-                    
+
                     if sliced_files:
                         log_history += f"Generated {len(sliced_files)} slices for {name}.\n"; yield { status_log: log_history }
-                        all_temp_dirs.append(temp_dir) 
+                        all_temp_dirs.append(temp_dir)
                         for loop_file in sliced_files:
-                            arcname = os.path.join(name, os.path.basename(loop_file)) 
+                            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 }
 
                     processed_count += 1
-                    # Yield intermediate progress after each stem is fully processed
                     yield { status_log: log_history, progress_bar: progress(processed_count / num_stems, desc=f"Finished {name}", visible=True) }
 
-        log_history += "Packaging complete!\n"; 
-        yield { 
-            status_log: log_history + "✅ Pack ready for download!", 
-            progress_bar: progress(1, desc="Pack Ready!", visible=False), # Hide when done
-            download_zip_file: gr.update(value=zip_path, visible=True) 
+        log_history += "Packaging complete!\n";
+        yield {
+            status_log: log_history + "✅ Pack ready for download!",
+            progress_bar: 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) } # Hide on error
+         yield { status_log: log_history + f"❌ ERROR: {e}", progress_bar: gr.update(visible=False) }
     finally:
-        # Ensure cleanup happens even if there's an error during zipping
         for d in all_temp_dirs:
             if d and os.path.exists(d):
                 shutil.rmtree(d)
@@ -192,32 +185,32 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
             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")
-            
+
             gr.Markdown("### 3. Create Pack")
             slice_all_button = gr.Button("Slice All Stems & Create Pack", variant="primary")
             download_zip_file = gr.File(label="Download Your Loop Pack", visible=False)
 
             gr.Markdown("### Status")
-            # --- THIS IS THE FIX --- Initialize without arguments
-            progress_bar = gr.Progress(visible=False) 
+            # --- THIS IS THE FIX --- 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.Row(): 
+                with gr.Row():
                     vocals_output = gr.Audio(label="Vocals", scale=4)
                     slice_vocals_btn = gr.Button("Slice Vocals", scale=1)
-                with gr.Row(): 
+                with gr.Row():
                     drums_output = gr.Audio(label="Drums", scale=4)
                     slice_drums_btn = gr.Button("Slice Drums", scale=1)
-                with gr.Row(): 
+                with gr.Row():
                     bass_output = gr.Audio(label="Bass", scale=4)
                     slice_bass_btn = gr.Button("Slice Bass", scale=1)
-                with gr.Row(): 
+                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)")
@@ -227,44 +220,44 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
     def slice_and_display(stem_data, loop_choice, sensitivity, stem_name):
         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}...") } 
-        
+        yield {
+            status_log: log_history,
+            progress_bar: gr.update(value=0, visible=True, label=f"Slicing {stem_name}...")
+        }
+
         # Define how slice_stem_real updates the progress bar using gr.Progress directly
         def update_single_progress(p, desc=""):
-            gr.Progress(track_tqdm=True)(p, desc=desc) # Directly update the bar
+             gr.Progress(track_tqdm=True)(p, desc=desc) # Pass progress updates
 
         files, temp_dir = slice_stem_real(stem_data, loop_choice, sensitivity, stem_name, progress_fn=update_single_progress)
-        
+
         if temp_dir and os.path.exists(temp_dir):
-             shutil.rmtree(temp_dir) 
-        
-        yield { 
-            loop_gallery: gr.update(value=files), 
+             shutil.rmtree(temp_dir)
+
+        yield {
+            loop_gallery: gr.update(value=files),
             status_log: log_history + f"✅ Sliced {stem_name} into {len(files) if files else 0} pieces.",
             progress_bar: gr.update(visible=False) # Hide progress bar when done
         }
 
     submit_event = submit_button.click(
-        fn=separate_stems, 
-        inputs=[audio_input, stem_options], 
-        # Corrected: progress_bar is not an output here
-        outputs=[vocals_output, drums_output, bass_output, other_output, status_log] 
+        fn=separate_stems,
+        inputs=[audio_input, stem_options],
+        outputs=[vocals_output, drums_output, bass_output, other_output, status_log]
     )
 
     stem_options.change(fn=update_output_visibility, inputs=stem_options, outputs=[vocals_output, drums_output, bass_output, other_output])
-    
-    # Use the wrapper function for individual slice buttons
+
     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])
-    
+
     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], 
-        # Corrected: progress_bar is not an output here
-        outputs=[download_zip_file, download_zip_file, status_log] 
+        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]
     )
 
 # --- Launch the UI ---
-demo.launch()
+demo.launch()