Update app.py

app.py

@@ -1,4 +1,5 @@
 # 1. Install all necessary libraries for the full application
+!pip install gradio "demucs>=4.0.0" librosa soundfile matplotlib
 
 # 2. Import libraries
 import gradio as gr
@@ -20,210 +21,144 @@ matplotlib.use('Agg') # Use a non-interactive backend for plotting
 
 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!")
-    progress(0, desc="Starting...")
+    progress(0, desc="Starting..."); await asyncio.sleep(0.1)
     try:
-        progress(0.05, desc="Preparing audio file...")
-        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"
+        progress(0.05, desc="Preparing audio file..."); 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}\""
-        progress(0.2, desc="Running Demucs (this may take a minute)...")
-        
-        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 to run. Error: {stderr.decode()[:500]}")
-
-        progress(0.8, desc="Locating separated stem files...")
-        stable_filename_base = os.path.basename(stable_input_path).rsplit('.', 1)[0]
-        model_folder_name = next(os.walk(output_dir))[1][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 finished, but the output directory was not found!")
-            
-        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
-        
+        progress(0.2, desc="Running Demucs..."); process = await asyncio.create_subprocess_shell(command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE); await process.communicate()
+        if process.returncode != 0: raise gr.Error(f"Demucs failed to run.")
+        progress(0.8, desc="Locating separated stem files..."); stable_filename_base = os.path.basename(stable_input_path).rsplit('.', 1)[0]; model_folder_name = next(os.walk(output_dir))[1][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 finished, but the output directory was not found!")
+        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)
         return vocals_path, drums_path, bass_path, other_path
     except Exception as e:
-        print(f"An error occurred: {e}")
-        raise gr.Error(str(e))
+        print(f"An error occurred: {e}"); raise gr.Error(str(e))
 
-def slice_stem_real(stem_audio_data, loop_choice, sensitivity, progress=gr.Progress(track_tqdm=True)):
+def visualize_slices(stem_audio_data, progress=gr.Progress(track_tqdm=True)):
     if stem_audio_data is None:
-        gr.Warning("This stem is empty. Cannot slice.")
-        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
-    
-    progress(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
-        gr.Warning("BPM detection failed, defaulting to 120 BPM.")
-    print(f"Detected BPM: {bpm_int}")
+        gr.Warning("This stem is empty. Cannot visualize."); return None, None, None
+    sample_rate, y_int = stem_audio_data; y = librosa.util.buf_to_float(y_int); 
+    progress(0.3, desc="Finding transients..."); onset_frames = librosa.onset.onset_detect(y=librosa.to_mono(y.T) if y.ndim > 1 else y, sr=sample_rate, wait=1, pre_avg=1, post_avg=1, post_max=1, delta=0.05)
+    onset_times = librosa.frames_to_time(onset_frames, sr=sample_rate)
+    progress(0.7, desc="Generating waveform plot...")
+    fig, ax = plt.subplots(figsize=(10, 3)); fig.patch.set_facecolor('#1f2937'); ax.set_facecolor('#111827')
+    librosa.display.waveshow(y, sr=sample_rate, ax=ax, color='#32f6ff', alpha=0.7)
+    for t in onset_times:
+        ax.axvline(x=t, color='#ff3b3b', linestyle='--', linewidth=1)
+    ax.tick_params(colors='gray'); ax.xaxis.label.set_color('gray'); ax.yaxis.label.set_color('gray'); ax.set_xlabel("Time (s)"); ax.set_ylabel("Amplitude"); ax.set_title("Detected Slices", color='white'); plt.tight_layout()
+    progress(1, desc="Done!")
+    return fig, onset_times, stem_audio_data
+
+def preview_slice(active_stem_audio, onset_times, evt: gr.SelectData):
+    if active_stem_audio is None or onset_times is None:
+        return None
+    sample_rate, y = active_stem_audio; clicked_time = evt.index[0]
+    start_time = 0; end_time = len(y) / sample_rate
+    for i, t in enumerate(onset_times):
+        if t > clicked_time:
+            end_time = t; break
+        start_time = t
+    start_sample = librosa.time_to_samples(start_time, sr=sample_rate); end_sample = librosa.time_to_samples(end_time, sr=sample_rate)
+    sliced_audio = y[start_sample:end_sample]
+    return (sample_rate, sliced_audio)
+
+# --- NEW FUNCTIONS FOR MANAGING THE PACK ---
+def add_slice_to_pack(current_preview, selection_list):
+    if current_preview is None:
+        gr.Warning("No slice is being previewed to add.")
+        return selection_list
+    selection_list.append(current_preview)
+    gr.Info(f"Slice added! You now have {len(selection_list)} slices in your pack.")
+    return selection_list
+
+def clear_selection():
+    gr.Info("Selection cleared.")
+    return []
+
+def create_final_pack(selection_list, progress=gr.Progress(track_tqdm=True)):
+    if not selection_list:
+        raise gr.Error("No slices have been selected to create a pack!")
     
-    output_files = []
-    loops_dir = tempfile.mkdtemp()
-
-    if "One-Shots" in loop_choice:
-        progress(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)
-        onset_samples = librosa.frames_to_samples(onset_frames)
-        
-        progress(0.5, desc="Slicing one-shots...")
-        if len(onset_samples) > 0:
-            for i, start_sample in enumerate(onset_samples):
-                end_sample = onset_samples[i+1] if i+1 < len(onset_samples) else len(y)
-                slice_data = y[start_sample:end_sample]
-                filename = os.path.join(loops_dir, f"one_shot_{i+1:03d}.wav")
-                sf.write(filename, slice_data, sample_rate, subtype='PCM_16')
-                output_files.append(filename)
-                if len(onset_samples) > 1:
-                    progress(0.5 + (i / (len(onset_samples) - 1) * 0.5), desc=f"Exporting slice {i+1}...")
-    else: # Handle bar loops
-        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)
-        
-        progress(0.4, desc=f"Slicing into {bars}-bar loops...")
-        num_loops = len(y) // loop_duration_samples
-        if num_loops == 0:
-            gr.Warning(f"Audio is too short to create a {bars}-bar loop 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
-            slice_data = y[start_sample:end_sample]
-            filename = os.path.join(loops_dir, f"{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 num_loops > 1:
-                progress(0.4 + (i / (num_loops - 1) * 0.6), desc=f"Exporting loop {i+1}...")
-
-    if not output_files:
-        gr.Warning("No loops or one-shots could be generated.")
-        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)):
-    progress(0, desc="Starting batch slice...")
-    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)
-    if num_stems == 0: raise gr.Error("No stems to process! Please separate stems first.")
+    progress(0, desc="Preparing final pack...")
+    zip_path = "Custom_Loop_Pack.zip"
+    temp_dir = tempfile.mkdtemp()
     
     with zipfile.ZipFile(zip_path, 'w') as zf:
-        processed_count = 0
-        for name, data in stems_to_process.items():
-            if data is not None:
-                def update_main_progress(p, desc=""):
-                    overall_progress = (processed_count + p) / num_stems
-                    progress(overall_progress, desc=f"Slicing {name}: {desc}")
-                
-                sliced_files, temp_dir = slice_stem_real((data[0], data[1]), loop_choice, sensitivity, progress=update_main_progress)
-                
-                if sliced_files:
-                    for loop_file in sliced_files:
-                        arcname = os.path.join(name, os.path.basename(loop_file))
-                        zf.write(loop_file, arcname)
-                
-                if temp_dir and os.path.exists(temp_dir):
-                    shutil.rmtree(temp_dir)
-                processed_count += 1
-
+        for i, audio_data in enumerate(selection_list):
+            progress(i / len(selection_list), desc=f"Adding slice {i+1} to pack...")
+            sample_rate, y = audio_data
+            filename = os.path.join(temp_dir, f"slice_{i+1:03d}.wav")
+            sf.write(filename, y, sample_rate, subtype='PCM_16')
+            zf.write(filename, os.path.basename(filename))
+            
+    shutil.rmtree(temp_dir)
     progress(1, desc="Pack Ready!")
     return zip_path, gr.update(visible=True)
 
-
 # --- Create the full Gradio Interface ---
 with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red")) as demo:
     gr.Markdown("# 🎵 Loop Architect")
+    
+    # State components
+    onset_times_state = gr.State(value=None)
+    active_stem_state = gr.State(value=None)
+    selected_slices_state = gr.State(value=[])
+    
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("### 1. Separate Stems")
-            audio_input = gr.Audio(type="filepath", label="Upload a Track")
+            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="Loop Length", value="One-Shots (All Transients)")
+                gr.Markdown("These options are for the final pack creation.")
+                loop_options_radio = gr.Radio(["One-Shots (All Transients)", "4 Bar Loops", "8 Bar Loops"], label="Loop Type (for 'Slice All')", 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")
-            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)
+            
         with gr.Column(scale=2):
             with gr.Accordion("Separated Stems", open=True):
-                with gr.Row(): 
-                    vocals_output = gr.Audio(label="Vocals", scale=4)
-                    slice_vocals_btn = gr.Button("Slice", scale=1)
-                with gr.Row(): 
-                    drums_output = gr.Audio(label="Drums", scale=4)
-                    slice_drums_btn = gr.Button("Slice", scale=1)
-                with gr.Row(): 
-                    bass_output = gr.Audio(label="Bass", scale=4)
-                    slice_bass_btn = gr.Button("Slice", scale=1)
-                with gr.Row(): 
-                    other_output = gr.Audio(label="Other / Instrumental", scale=4)
-                    slice_other_btn = gr.Button("Slice", scale=1)
-            gr.Markdown("### Sliced Loops / Samples")
-            loop_gallery = gr.Gallery(label="Generated Loops", columns=8, object_fit="contain", height="auto")
+                with gr.Row(): vocals_output = gr.Audio(label="Vocals", scale=4); slice_vocals_btn = gr.Button("Visualize Slices", scale=1)
+                with gr.Row(): drums_output = gr.Audio(label="Drums", scale=4); slice_drums_btn = gr.Button("Visualize Slices", scale=1)
+                with gr.Row(): bass_output = gr.Audio(label="Bass", scale=4); slice_bass_btn = gr.Button("Visualize Slices", scale=1)
+                with gr.Row(): other_output = gr.Audio(label="Other / Instrumental", scale=4); slice_other_btn = gr.Button("Visualize Slices", scale=1)
+            
+            gr.Markdown("### Slice Editor")
+            slice_plot = gr.Plot(label="Click a region on the waveform to preview a slice")
+            with gr.Row():
+                preview_player = gr.Audio(label="Slice Preview", scale=3)
+                add_to_pack_btn = gr.Button("Add to Pack", variant="primary", scale=1)
+            
+            gr.Markdown("### Your Custom Pack")
+            with gr.Row():
+                create_pack_btn = gr.Button("Create Pack from Selection", variant="primary")
+                clear_selection_btn = gr.Button("Clear Selection")
+            selected_gallery = gr.Gallery(label="Selected Slices", columns=8, object_fit="contain", height="auto")
+            download_zip_file = gr.File(label="Download Your Custom Pack", visible=False)
 
     # --- Define Event Listeners ---
-    def slice_and_display(stem_data, loop_choice, sensitivity):
-        files, _ = slice_stem_real(stem_data, loop_choice, sensitivity)
-        return files
-
     submit_button.click(fn=separate_stems, inputs=[audio_input, stem_options], outputs=[vocals_output, drums_output, bass_output, other_output])
-    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], outputs=loop_gallery)
-    slice_drums_btn.click(fn=slice_and_display, inputs=[drums_output, loop_options_radio, sensitivity_slider], outputs=loop_gallery)
-    slice_bass_btn.click(fn=slice_and_display, inputs=[bass_output, loop_options_radio, sensitivity_slider], outputs=loop_gallery)
-    slice_other_btn.click(fn=slice_and_display, inputs=[other_output, loop_options_radio, sensitivity_slider], outputs=loop_gallery)
-    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])
+    stem_options.change(fn=update_output_visibility, inputs=stem_options, outputs=[vocals_output, drums_output, bass_output, other_output])
+    
+    slice_vocals_btn.click(fn=visualize_slices, inputs=vocals_output, outputs=[slice_plot, onset_times_state, active_stem_state])
+    slice_drums_btn.click(fn=visualize_slices, inputs=drums_output, outputs=[slice_plot, onset_times_state, active_stem_state])
+    slice_bass_btn.click(fn=visualize_slices, inputs=bass_output, outputs=[slice_plot, onset_times_state, active_stem_state])
+    slice_other_btn.click(fn=visualize_slices, inputs=other_output, outputs=[slice_plot, onset_times_state, active_stem_state])
+    
+    slice_plot.select(fn=preview_slice, inputs=[active_stem_state, onset_times_state], outputs=preview_player)
+    
+    add_to_pack_btn.click(fn=add_slice_to_pack, inputs=[preview_player, selected_slices_state], outputs=selected_slices_state)
+    selected_slices_state.change(fn=lambda x: x, inputs=selected_slices_state, outputs=selected_gallery) # Update gallery when state changes
+    clear_selection_btn.click(fn=clear_selection, outputs=selected_slices_state)
+    create_pack_btn.click(fn=create_final_pack, inputs=selected_slices_state, outputs=[download_zip_file, download_zip_file])
 
 # --- Launch the UI ---
-# Use demo.launch() for Hugging Face Spaces
-# Use demo.launch(debug=True) for local testing
-demo.launch()
+demo.launch(debug=True)