Update app.py

app.py

@@ -11,6 +11,7 @@ import matplotlib
 import matplotlib.pyplot as plt
 from scipy import signal
 from typing import Tuple, List, Any
+import shutil # Import shutil for directory cleanup
 
 # Use a non-interactive backend for Matplotlib
 matplotlib.use('Agg')
@@ -61,7 +62,7 @@ def write_midi_file(notes_list: List[Tuple[int, float, float]], bpm: float, outp
 
     # Build MIDI file
     header = b'MThd' + (6).to_bytes(4, 'big') + (1).to_bytes(2, 'big') + (1).to_bytes(2, 'big') + division.to_bytes(2, 'big')
-    
+
     track_data = b''
     for delta, event in midi_events:
         # Encode delta time
@@ -76,13 +77,13 @@ def write_midi_file(notes_list: List[Tuple[int, float, float]], bpm: float, outp
                 track_data += bytes([delta_bytes[i] | 0x80])
             else:
                 track_data += bytes([delta_bytes[i]])
-        
+
         # Add event
         track_data += bytes(event)
-    
+
     # End of track
     track_data += b'\x00\xFF\x2F\x00'
-    
+
     track_chunk = b'MTrk' + len(track_data).to_bytes(4, 'big') + track_data
     midi_data = header + track_chunk
 
@@ -100,11 +101,11 @@ def get_harmonic_recommendations(key_str: str) -> str:
         "G Min": "6A", "D Min": "7A",
         "Gb Maj": "2B", "Cb Maj": "7B", "A# Min": "3A", "D# Maj": "11B", "G# Maj": "3B"
     }
-    
+
     code = KEY_TO_CAMELOT.get(key_str, "N/A")
     if code == "N/A":
         return "N/A (Key not recognized or 'Unknown Key' detected.)"
-    
+
     try:
         num = int(code[:-1])
         mode = code[-1]
@@ -265,7 +266,7 @@ def separate_stems(audio_file_path: str) -> Tuple[str, str, str, str, str, str,
         temp_dir = tempfile.mkdtemp()
         stems = {}
         stem_names = ["vocals", "drums", "bass", "other", "guitar", "piano"]
-        
+
         for name in stem_names:
             stem_path = os.path.join(temp_dir, f"{name}.wav")
             # Create mock audio (just a portion of the original)
@@ -273,7 +274,7 @@ def separate_stems(audio_file_path: str) -> Tuple[str, str, str, str, str, str,
             stems[name] = stem_path
 
         return (
-            stems["vocals"], stems["drums"], stems["bass"], stems["other"], 
+            stems["vocals"], stems["drums"], stems["bass"], stems["other"],
             stems["guitar"], stems["piano"], float(detected_bpm), detected_key
         )
     except Exception as e:
@@ -282,7 +283,7 @@ def separate_stems(audio_file_path: str) -> Tuple[str, str, str, str, str, str,
 def generate_waveform_preview(y: np.ndarray, sr: int, stem_name: str, temp_dir: str) -> str:
     """Generates a Matplotlib image showing the waveform."""
     img_path = os.path.join(temp_dir, f"{stem_name}_preview.png")
-    
+
     plt.figure(figsize=(10, 3))
     y_display = librosa.to_mono(y.T) if y.ndim > 1 else y
     librosa.display.waveshow(y_display, sr=sr, x_axis='time', color="#4a7098")
@@ -290,27 +291,27 @@ def generate_waveform_preview(y: np.ndarray, sr: int, stem_name: str, temp_dir:
     plt.tight_layout()
     plt.savefig(img_path)
     plt.close()
-    
+
     return img_path
 
 def slice_stem_real(
-    stem_audio_path: str, 
-    loop_choice: str, 
-    sensitivity: float, 
+    stem_audio_path: str,
+    loop_choice: str,
+    sensitivity: float,
     stem_name: str,
-    manual_bpm: float, 
-    time_signature: str, 
-    crossfade_ms: int, 
-    transpose_semitones: int, 
+    manual_bpm: float,
+    time_signature: str,
+    crossfade_ms: int,
+    transpose_semitones: int,
     detected_key: str,
-    pan_depth: float, 
-    level_depth: float, 
-    modulation_rate: str, 
+    pan_depth: float,
+    level_depth: float,
+    modulation_rate: str,
     target_dbfs: float,
-    attack_gain: float, 
-    sustain_gain: float, 
-    filter_type: str, 
-    filter_freq: float, 
+    attack_gain: float,
+    sustain_gain: float,
+    filter_type: str,
+    filter_freq: float,
     filter_depth: float
 ) -> Tuple[List[Tuple[str, str]], str]:
     """Slices a single stem and applies transformations."""
@@ -319,9 +320,15 @@ def slice_stem_real(
 
     try:
         # Load audio
-        sample_rate, y_int = stem_audio_path
-        y = librosa.util.buf_to_float(y_int, dtype=np.float32)
-        
+        # Assuming stem_audio_path is a tuple (sample_rate, audio_array) from Gradio
+        if isinstance(stem_audio_path, tuple) and len(stem_audio_path) == 2:
+            sample_rate, y_int = stem_audio_path
+            y = librosa.util.buf_to_float(y_int, dtype=np.float32)
+        else:
+            # Handle case where it's a filepath (from separate_stems)
+             y, sample_rate = librosa.load(stem_audio_path, sr=None)
+
+
         if y.ndim == 0:
             return [], ""
 
@@ -428,7 +435,7 @@ def slice_stem_real(
             # Simple slicing at regular intervals for demo
             slice_length = int(sample_rate * 0.5)  # 0.5 second slices
             num_slices = len(y) // slice_length
-            
+
             for i in range(min(num_slices, 20)):  # Limit to 20 slices
                 start_sample = i * slice_length
                 end_sample = min(start_sample + slice_length, len(y))
@@ -440,34 +447,34 @@ def slice_stem_real(
 
         # --- 8. VISUALIZATION GENERATION ---
         img_path = generate_waveform_preview(y, sample_rate, stem_name, loops_dir)
-        
+
         return output_files, img_path
 
     except Exception as e:
         raise gr.Error(f"Error processing stem: {str(e)}")
 
 def slice_all_and_zip(
-    vocals: Tuple[int, np.ndarray], 
-    drums: Tuple[int, np.ndarray], 
-    bass: Tuple[int, np.ndarray], 
-    other: Tuple[int, np.ndarray], 
-    guitar: Tuple[int, np.ndarray], 
-    piano: Tuple[int, np.ndarray], 
-    loop_choice: str, 
-    sensitivity: float, 
-    manual_bpm: float, 
-    time_signature: str, 
-    crossfade_ms: int, 
-    transpose_semitones: int, 
+    vocals: Tuple[int, np.ndarray],
+    drums: Tuple[int, np.ndarray],
+    bass: Tuple[int, np.ndarray],
+    other: Tuple[int, np.ndarray],
+    guitar: Tuple[int, np.ndarray],
+    piano: Tuple[int, np.ndarray],
+    loop_choice: str,
+    sensitivity: float,
+    manual_bpm: float,
+    time_signature: str,
+    crossfade_ms: int,
+    transpose_semitones: int,
     detected_key: str,
-    pan_depth: float, 
-    level_depth: float, 
-    modulation_rate: str, 
+    pan_depth: float,
+    level_depth: float,
+    modulation_rate: str,
     target_dbfs: float,
-    attack_gain: float, 
-    sustain_gain: float, 
-    filter_type: str, 
-    filter_freq: float, 
+    attack_gain: float,
+    sustain_gain: float,
+    filter_type: str,
+    filter_freq: float,
     filter_depth: float
 ) -> str:
     """Slices all available stems and packages them into a ZIP file."""
@@ -476,10 +483,10 @@ def slice_all_and_zip(
             "vocals": vocals, "drums": drums, "bass": bass,
             "other": other, "guitar": guitar, "piano": piano
         }
-        
+
         # Filter out None stems
         valid_stems = {name: data for name, data in stems_to_process.items() if data is not None}
-        
+
         if not valid_stems:
             raise gr.Error("No stems to process! Please separate stems first.")
 
@@ -490,25 +497,28 @@ def slice_all_and_zip(
         with zipfile.ZipFile(zip_path, 'w') as zf:
             for name, data in valid_stems.items():
                 # Create temporary file for this stem
-                stem_temp_dir = tempfile.mkdtemp()
-                stem_path = os.path.join(stem_temp_dir, f"{name}.wav")
-                sf.write(stem_path, data[1], data[0])
-                
+                # No need to save to a temp file here, can pass the tuple directly
+                # stem_temp_dir = tempfile.mkdtemp()
+                # stem_path = os.path.join(stem_temp_dir, f"{name}.wav")
+                # sf.write(stem_path, data[1], data[0])
+
                 # Process stem
                 sliced_files, _ = slice_stem_real(
-                    (data[0], data[1]), loop_choice, sensitivity, name,
+                    data, loop_choice, sensitivity, name,
                     manual_bpm, time_signature, crossfade_ms, transpose_semitones, detected_key,
                     pan_depth, level_depth, modulation_rate, target_dbfs,
                     attack_gain, sustain_gain, filter_type, filter_freq, filter_depth
                 )
-                
+
                 # Add files to ZIP
                 for file_path, file_type in sliced_files:
                     arcname = os.path.join(file_type, os.path.basename(file_path))
                     zf.write(file_path, arcname)
-                
+
                 # Clean up stem temp files
-                shutil.rmtree(stem_temp_dir)
+                # shutil.rmtree(stem_temp_dir) # No temp dir created here anymore
+
+        # Note: The main temp_dir containing the zip file will be cleaned up by Gradio
 
         return zip_path
 
@@ -531,7 +541,7 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
             gr.Markdown("### 1. Separate Stems")
             audio_input = gr.Audio(type="filepath", label="Upload a Track")
             separate_btn = gr.Button("Separate & Analyze Stems", variant="primary")
-            
+
             # Outputs for separated stems
             vocals_output = gr.Audio(label="Vocals", visible=False)
             drums_output = gr.Audio(label="Drums", visible=False)
@@ -539,13 +549,13 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
             other_output = gr.Audio(label="Other / Instrumental", visible=False)
             guitar_output = gr.Audio(label="Guitar", visible=False)
             piano_output = gr.Audio(label="Piano", visible=False)
-            
+
             # Analysis results
             with gr.Group():
                 gr.Markdown("### 2. Analysis & Transform")
                 detected_bpm_key = gr.Textbox(label="Detected Tempo & Key", value="", interactive=False)
                 harmonic_recs = gr.Textbox(label="Harmonic Mixing Recommendations", value="", interactive=False)
-                
+
                 transpose_slider = gr.Slider(
                     minimum=-12, maximum=12, value=0, step=1,
                     label="Transpose Loops (Semitones)",
@@ -654,32 +664,32 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
             gr.Markdown("### Separated Stems")
             with gr.Row():
                 with gr.Column():
-                    vocals_output.render()
+                    # vocals_output.render() # Removed redundant render call
                     slice_vocals_btn = gr.Button("Slice Vocals")
                 with gr.Column():
-                    drums_output.render()
+                    # drums_output.render() # Removed redundant render call
                     slice_drums_btn = gr.Button("Slice Drums")
             with gr.Row():
                 with gr.Column():
-                    bass_output.render()
+                    # bass_output.render() # Removed redundant render call
                     slice_bass_btn = gr.Button("Slice Bass")
                 with gr.Column():
-                    other_output.render()
+                    # other_output.render() # Removed redundant render call
                     slice_other_btn = gr.Button("Slice Other")
             with gr.Row():
                 with gr.Column():
-                    guitar_output.render()
+                    # guitar_output.render() # Removed redundant render call
                     slice_guitar_btn = gr.Button("Slice Guitar")
                 with gr.Column():
-                    piano_output.render()
+                    # piano_output.render() # Removed redundant render call
                     slice_piano_btn = gr.Button("Slice Piano")
-            
+
             # Gallery for previews
             gr.Markdown("### Sliced Loops Preview")
             loop_gallery = gr.Gallery(
                 label="Generated Loops",
-                columns=4, 
-                object_fit="contain", 
+                columns=4,
+                object_fit="contain",
                 height="auto"
             )
 
@@ -709,13 +719,13 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
     )
 
     # Individual stem slicing
-    def slice_and_display(stem_data, loop_choice, sensitivity, stem_name, manual_bpm, time_signature, 
-                         crossfade_ms, transpose_semitones, detected_key, pan_depth, level_depth, 
-                         modulation_rate, target_dbfs, attack_gain, sustain_gain, filter_type, 
+    def slice_and_display(stem_data, loop_choice, sensitivity, stem_name, manual_bpm, time_signature,
+                         crossfade_ms, transpose_semitones, detected_key, pan_depth, level_depth,
+                         modulation_rate, target_dbfs, attack_gain, sustain_gain, filter_type,
                          filter_freq, filter_depth):
         if stem_data is None:
             return [], "No stem data available"
-        
+
         try:
             files, img_path = slice_stem_real(
                 stem_data, loop_choice, sensitivity, stem_name,
@@ -723,7 +733,7 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
                 pan_depth, level_depth, modulation_rate, target_dbfs,
                 attack_gain, sustain_gain, filter_type, filter_freq, filter_depth
             )
-            
+
             # Return only WAV files for gallery display
             wav_files = [f[0] for f in files if f[1] == "WAV"]
             return wav_files + [img_path], f"Generated {len(wav_files)} slices for {stem_name}"
@@ -738,7 +748,7 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
             pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
             attack_gain_slider, sustain_gain_slider, filter_type_radio, filter_freq_slider, filter_depth_slider
         ],
-        outputs=[loop_gallery, gr.Textbox(label="Status")]
+        outputs=[loop_gallery, gr.Textbox(label="Status", visible=True)] # Added status textbox here
     )
 
     slice_drums_btn.click(
@@ -749,7 +759,7 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
             pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
             attack_gain_slider, sustain_gain_slider, filter_type_radio, filter_freq_slider, filter_depth_slider
         ],
-        outputs=[loop_gallery, gr.Textbox(label="Status")]
+        outputs=[loop_gallery, gr.Textbox(label="Status", visible=True)] # Added status textbox here
     )
 
     slice_bass_btn.click(
@@ -760,7 +770,7 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
             pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
             attack_gain_slider, sustain_gain_slider, filter_type_radio, filter_freq_slider, filter_depth_slider
         ],
-        outputs=[loop_gallery, gr.Textbox(label="Status")]
+        outputs=[loop_gallery, gr.Textbox(label="Status", visible=True)] # Added status textbox here
     )
 
     slice_other_btn.click(
@@ -771,7 +781,7 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
             pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
             attack_gain_slider, sustain_gain_slider, filter_type_radio, filter_freq_slider, filter_depth_slider
         ],
-        outputs=[loop_gallery, gr.Textbox(label="Status")]
+        outputs=[loop_gallery, gr.Textbox(label="Status", visible=True)] # Added status textbox here
     )
 
     slice_guitar_btn.click(
@@ -782,7 +792,7 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
             pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
             attack_gain_slider, sustain_gain_slider, filter_type_radio, filter_freq_slider, filter_depth_slider
         ],
-        outputs=[loop_gallery, gr.Textbox(label="Status")]
+        outputs=[loop_gallery, gr.Textbox(label="Status", visible=True)] # Added status textbox here
     )
 
     slice_piano_btn.click(
@@ -793,9 +803,10 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
             pan_depth_slider, level_depth_slider, modulation_rate_radio, lufs_target_slider,
             attack_gain_slider, sustain_gain_slider, filter_type_radio, filter_freq_slider, filter_depth_slider
         ],
-        outputs=[loop_gallery, gr.Textbox(label="Status")]
+        outputs=[loop_gallery, gr.Textbox(label="Status", visible=True)] # Added status textbox here
     )
 
+
     # Slice all stems and create ZIP
     slice_all_btn.click(
         fn=slice_all_and_zip,
@@ -816,4 +827,4 @@ with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="red"))
 
 # Launch the app
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()