Update app.py

app.py

@@ -21,7 +21,6 @@ matplotlib.use('Agg') # Use a non-interactive backend for plotting
 # --- Helper/Processing Functions ---
 
 def update_output_visibility(choice):
-    # This function remains the same
     if "2 Stems" in choice:
         return { 
             vocals_output: gr.update(visible=True), 
@@ -38,7 +37,6 @@ def update_output_visibility(choice):
         }
 
 async def separate_stems(audio_file_path, stem_choice, progress=gr.Progress(track_tqdm=True)):
-    # This function now returns to both the visible UI and the hidden state
     if audio_file_path is None: raise gr.Error("No audio file uploaded!")
     progress(0, desc="Starting...")
     try:
@@ -52,17 +50,25 @@ async def separate_stems(audio_file_path, stem_choice, progress=gr.Progress(trac
         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..."); 
-        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.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!")
+        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
@@ -71,65 +77,153 @@ async def separate_stems(audio_file_path, stem_choice, progress=gr.Progress(trac
         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 values for the visible UI and the hidden state variables
-        return vocals_path, drums_path, bass_path, other_path, vocals_path, drums_path, bass_path, other_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)):
+    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}")
+    
+    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.")
+    
+    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
+
+    progress(1, desc="Pack Ready!")
+    return zip_path, gr.update(visible=True)
 
-# --- NEW FUNCTION TO REPOPULATE UI ON PAGE LOAD ---
-def repopulate_ui_from_state(vocals_path, drums_path, bass_path, other_path):
-    # This function takes the saved paths from the state and updates the audio players
-    print("Page reloaded. Repopulating UI from session state.")
-    return vocals_path, drums_path, bass_path, other_path
 
 # --- Create the full Gradio Interface ---
 with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red")) as demo:
     gr.Markdown("# 🎵 Loop Architect")
-    
-    # --- NEW STATE COMPONENTS FOR PERSISTENCE ---
-    vocals_path_state = gr.State(None)
-    drums_path_state = gr.State(None)
-    bass_path_state = gr.State(None)
-    other_path_state = gr.State(None)
-    
     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="Loop Length", 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")
 
     # --- Define Event Listeners ---
-    
-    # The submit button now updates both the visible audio players AND the hidden state variables
-    submit_button.click(
-        fn=separate_stems, 
-        inputs=[audio_input, stem_options], 
-        outputs=[
-            vocals_output, drums_output, bass_output, other_output, 
-            vocals_path_state, drums_path_state, bass_path_state, other_path_state
-        ]
-    )
-    
-    stem_options.change(fn=update_output_visibility, inputs=stem_options, outputs=[vocals_output, drums_output, bass_output, other_output])
-
-    # --- NEW EVENT LISTENER FOR PAGE LOAD ---
-    demo.load(
-        fn=repopulate_ui_from_state,
-        inputs=[vocals_path_state, drums_path_state, bass_path_state, other_path_state],
-        outputs=[vocals_output, drums_output, bass_output, other_output]
-    )
-    
+    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])
+
 # --- Launch the UI ---
 demo.launch()