Update app.py

app.py

@@ -1,6 +1,5 @@
-# 1. Install all necessary libraries for the full application
-# This line is for Colab. On Hugging Face, these should be in your requirements.txt
-# !pip install gradio "demucs>=4.0.0" librosa soundfile matplotlib
+# 1. Install necessary libraries
+!pip install gradio "demucs>=4.0.0" librosa soundfile matplotlib
 
 # 2. Import libraries
 import gradio as gr
@@ -16,25 +15,24 @@ import zipfile
 import tempfile
 import matplotlib.pyplot as plt
 import matplotlib
-matplotlib.use('Agg') # Use a non-interactive backend for plotting
+matplotlib.use('Agg')
 
 # --- Helper/Processing Functions ---
 
 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)") 
-        }
-    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") 
-        }
+    # Now handles 2, 4, and 6 stem visibility
+    is_6_stem = "6 Stems" in choice
+    is_4_stem = "4 Stems" in choice
+    is_2_stem = "2 Stems" in choice
+    
+    return { 
+        vocals_output: gr.update(visible=True), 
+        drums_output: gr.update(visible=is_4_stem or is_6_stem), 
+        bass_output: gr.update(visible=is_4_stem or is_6_stem), 
+        guitar_output: gr.update(visible=is_6_stem), # Guitar visible only for 6 stems
+        piano_output: gr.update(visible=is_6_stem),  # Piano visible only for 6 stems
+        other_output: gr.update(visible=True, label="Instrumental (No Vocals)" if is_2_stem else "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!")
@@ -45,185 +43,99 @@ async def separate_stems(audio_file_path, stem_choice, progress=gr.Progress(trac
         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 ""
+        # Determine Demucs model based on choice
+        model_name = "htdemucs" # Default to 4-stem model
+        model_arg = ""
+        if "2 Stems" in stem_choice:
+            model_arg = "--two-stems=vocals"
+        elif "6 Stems" in stem_choice:
+            model_name = "htdemucs_6s" # Use the 6-stem model
+
         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)
+        # Use -n flag to specify the model name
+        command = f"python3 -m demucs -n {model_name} {model_arg} -o \"{output_dir}\" \"{stable_input_path}\""
+        progress(0.2, desc=f"Running Demucs ({model_name})...")
         
+        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]}")
+            raise gr.Error(f"Demucs failed. 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)
+        # Demucs output folder now matches the model name
+        stems_path = os.path.join(output_dir, model_name, stable_filename_base)
         
         if not os.path.exists(stems_path): 
-            raise gr.Error(f"Demucs finished, but the output directory was not found!")
+            raise gr.Error(f"Demucs finished, but output directory '{stems_path}' not found!")
             
+        # Check for all possible stem files
         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
+        guitar_path = os.path.join(stems_path, "guitar.wav") if os.path.exists(os.path.join(stems_path, "guitar.wav")) else None
+        piano_path = os.path.join(stems_path, "piano.wav") if os.path.exists(os.path.join(stems_path, "piano.wav")) else None
+        
+        # Handle 'other' vs 'no_vocals' based on model
         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
+        return vocals_path, drums_path, bass_path, guitar_path, piano_path, other_path
     except Exception as 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)
-
-
 # --- Create the full Gradio Interface ---
 with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red")) as demo:
     gr.Markdown("# 🎵 Loop Architect")
+    
     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)")
+            # Added 6-stem option
+            stem_options = gr.Radio(
+                ["6 Stems (Vocals, Drums, Bass, Guitar, Piano, Other)", 
+                 "4 Stems (Vocals, Drums, Bass, Other)", 
+                 "2 Stems (Vocals + Instrumental)"], 
+                label="Separation Type", 
+                value="4 Stems (Vocals, Drums, Bass, Other)" # Default still 4 stems
+            )
             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):
+                # Added players for guitar and piano, initially hidden
                 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)
+                    drums_output = gr.Audio(label="Drums", scale=4, visible=True)
+                with gr.Row(): 
+                    bass_output = gr.Audio(label="Bass", scale=4, visible=True)
+                with gr.Row(): 
+                    guitar_output = gr.Audio(label="Guitar", scale=4, visible=False)
                 with gr.Row(): 
-                    bass_output = gr.Audio(label="Bass", scale=4)
-                    slice_bass_btn = gr.Button("Slice", scale=1)
+                    piano_output = gr.Audio(label="Piano", scale=4, visible=False)
                 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")
+                    other_output = gr.Audio(label="Other / Instrumental", scale=4, visible=True)
 
     # --- 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])
-
+    submit_button.click(
+        fn=separate_stems, 
+        inputs=[audio_input, stem_options], 
+        # Update outputs to include new players
+        outputs=[vocals_output, drums_output, bass_output, guitar_output, piano_output, other_output]
+    )
+    stem_options.change(
+        fn=update_output_visibility, 
+        inputs=stem_options, 
+        # Update outputs to include new players
+        outputs=[vocals_output, drums_output, bass_output, guitar_output, piano_output, other_output]
+    )
+    
 # --- Launch the UI ---
-demo.launch()
+demo.launch()