first attempt here

.gitmodules

@@ -1,3 +1,3 @@
-[submodule "audiocraft"]
-	path = audiocraft
-	url = https://github.com/facebookresearch/audiocraft
+[submodule "stable-audio-tools"]
+	path = stable-audio-tools
+	url = https://github.com/Stability-AI/stable-audio-tools.git

app.py

@@ -1,344 +1,460 @@
 import gradio as gr
 import spaces
-from musiclang_predict import MusicLangPredictor
-import random
-import subprocess
-import os
-import torchaudio
 import torch
-import numpy as np
-from audiocraft.models import MusicGen
-from audiocraft.data.audio import audio_write
-from pydub import AudioSegment
-
-import tempfile
-from pydub import AudioSegment
+import torchaudio
 import io
+import base64
+import uuid
+import os
+import time
+import re
+import threading
+import gc
+import random
+import numpy as np
+from einops import rearrange
+from huggingface_hub import login
+from stable_audio_tools import get_pretrained_model
+from stable_audio_tools.inference.generation import generate_diffusion_cond
+from gradio_client import Client, handle_file
+from contextlib import contextmanager
+
+# Global model storage
+model_cache = {}
+model_lock = threading.Lock()
+
+@contextmanager
+def resource_cleanup():
+    """Context manager to ensure proper cleanup of GPU resources."""
+    try:
+        yield
+    finally:
+        if torch.cuda.is_available():
+            torch.cuda.synchronize()
+            torch.cuda.empty_cache()
+        gc.collect()
+
+def load_stable_audio_model():
+    """Load stable-audio-open-small model if not already loaded."""
+    with model_lock:
+        if 'stable_audio_model' not in model_cache:
+            print("🔄 Loading stable-audio-open-small model...")
+            
+            # Authenticate with HF
+            hf_token = os.getenv('HF_TOKEN')
+            if hf_token:
+                login(token=hf_token)
+                print(f"✅ HF authenticated")
+            
+            # Load model
+            model, config = get_pretrained_model("stabilityai/stable-audio-open-small")
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            model = model.to(device)
+            if device == "cuda":
+                model = model.half()
+            
+            model_cache['stable_audio_model'] = model
+            model_cache['stable_audio_config'] = config
+            model_cache['stable_audio_device'] = device
+            print(f"✅ Stable Audio model loaded on {device}")
+        
+        return (model_cache['stable_audio_model'], 
+                model_cache['stable_audio_config'], 
+                model_cache['stable_audio_device'])
 
-# Check if CUDA is available
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-# Utility Functions
-def peak_normalize(y, target_peak=0.97):
-    return target_peak * (y / np.max(np.abs(y)))
-
-def rms_normalize(y, target_rms=0.05):
-    return y * (target_rms / np.sqrt(np.mean(y**2)))
-
-def preprocess_audio(waveform):
-    waveform_np = waveform.cpu().squeeze().numpy()  # Move to CPU before converting to NumPy
-#   processed_waveform_np = rms_normalize(peak_normalize(waveform_np))
-    return torch.from_numpy(waveform_np).unsqueeze(0).to(device)
-
-def create_slices(song, sr, slice_duration, bpm, num_slices=5):
-    song_length = song.shape[-1] / sr
-    slices = []
-    
-    # Ensure the first slice is from the beginning of the song
-    first_slice_waveform = song[..., :int(slice_duration * sr)]
-    slices.append(first_slice_waveform)
-    
-    for i in range(1, num_slices):
-        possible_start_indices = list(range(int(slice_duration * sr), int(song_length * sr), int(4 * 60 / bpm * sr)))
-        if not possible_start_indices:
-            # If there are no valid start indices, duplicate the first slice
-            slices.append(first_slice_waveform)
-            continue
+@spaces.GPU
+def generate_stable_audio_loop(prompt, loop_type, bpm, bars, seed=-1):
+    """Generate a BPM-aware loop using stable-audio-open-small"""
+    try:
+        model, config, device = load_stable_audio_model()
         
-        random_start = random.choice(possible_start_indices)
-        slice_end = random_start + int(slice_duration * sr)
+        # Calculate loop duration based on BPM and bars
+        seconds_per_beat = 60.0 / bpm
+        seconds_per_bar = seconds_per_beat * 4  # 4/4 time
+        target_loop_duration = seconds_per_bar * bars
         
-        if slice_end > song_length * sr:
-            # Wrap around to the beginning of the song
-            remaining_samples = int(slice_end - song_length * sr)
-            slice_waveform = torch.cat([song[..., random_start:], song[..., :remaining_samples]], dim=-1)
-        else:
-            slice_waveform = song[..., random_start:slice_end]
+        # Enhance prompt based on loop type and BPM
+        if loop_type == "drums":
+            enhanced_prompt = f"{prompt} drum loop {bpm}bpm"
+            negative_prompt = "melody, harmony, pitched instruments, vocals, singing"
+        else:  # instruments
+            enhanced_prompt = f"{prompt} instrumental loop {bpm}bpm"
+            negative_prompt = "drums, percussion, kick, snare, hi-hat"
         
-        if len(slice_waveform.squeeze()) < int(slice_duration * sr):
-            additional_samples_needed = int(slice_duration * sr) - len(slice_waveform.squeeze())
-            slice_waveform = torch.cat([slice_waveform, song[..., :additional_samples_needed]], dim=-1)
+        # Set seed
+        if seed == -1:
+            seed = random.randint(0, 2**32 - 1)
         
-        slices.append(slice_waveform)
+        torch.manual_seed(seed)
+        if device == "cuda":
+            torch.cuda.manual_seed(seed)
         
-    return slices
-
-def calculate_duration(bpm, min_duration=29, max_duration=30):
-    single_bar_duration = 4 * 60 / bpm
-    bars = max(min_duration // single_bar_duration, 1)
-    
-    while single_bar_duration * bars < min_duration:
-        bars += 1
-    
-    duration = single_bar_duration * bars
-    
-    while duration > max_duration and bars > 1:
-        bars -= 1
-        duration = single_bar_duration * bars
+        print(f"🎵 Generating {loop_type} loop:")
+        print(f"   Enhanced prompt: {enhanced_prompt}")
+        print(f"   Target duration: {target_loop_duration:.2f}s ({bars} bars at {bpm}bpm)")
+        print(f"   Seed: {seed}")
+        
+        # Prepare conditioning
+        conditioning = [{
+            "prompt": enhanced_prompt,
+            "seconds_total": 12  # Model generates 12s max
+        }]
+        
+        negative_conditioning = [{
+            "prompt": negative_prompt,
+            "seconds_total": 12
+        }]
+        
+        start_time = time.time()
+        
+        with resource_cleanup():
+            if device == "cuda":
+                torch.cuda.empty_cache()
+            
+            with torch.cuda.amp.autocast(enabled=(device == "cuda")):
+                output = generate_diffusion_cond(
+                    model,
+                    steps=8,  # Fast generation
+                    cfg_scale=1.0,  # Good balance for loops
+                    conditioning=conditioning,
+                    negative_conditioning=negative_conditioning,
+                    sample_size=config["sample_size"],
+                    sampler_type="pingpong",
+                    device=device,
+                    seed=seed
+                )
+            
+            generation_time = time.time() - start_time
+            
+            # Post-process audio
+            output = rearrange(output, "b d n -> d (b n)")  # (2, N) stereo
+            output = output.to(torch.float32).div(torch.max(torch.abs(output))).clamp(-1, 1)
+            
+            # Extract the loop portion
+            sample_rate = config["sample_rate"]
+            loop_samples = int(target_loop_duration * sample_rate)
+            available_samples = output.shape[1]
+            
+            if loop_samples > available_samples:
+                loop_samples = available_samples
+                actual_duration = available_samples / sample_rate
+                print(f"⚠️ Requested {target_loop_duration:.2f}s, got {actual_duration:.2f}s")
+            
+            # Extract loop from beginning (cleanest beat alignment)
+            loop_output = output[:, :loop_samples]
+            loop_output_int16 = loop_output.mul(32767).to(torch.int16).cpu()
+            
+            # Save to temporary file
+            loop_filename = f"loop_{loop_type}_{bpm}bpm_{bars}bars_{seed}.wav"
+            torchaudio.save(loop_filename, loop_output_int16, sample_rate)
+            
+            actual_duration = loop_samples / sample_rate
+            print(f"✅ {loop_type.title()} loop generated: {actual_duration:.2f}s in {generation_time:.2f}s")
+            
+            return loop_filename, f"Generated {actual_duration:.2f}s {loop_type} loop at {bpm}bpm ({bars} bars)"
     
-    return duration
-
-@spaces.GPU(duration=60)
-def generate_midi(seed, use_chords, chord_progression, bpm):
-    if seed == "":
-        seed = random.randint(1, 10000)
-
-    ml = MusicLangPredictor('musiclang/musiclang-v2')
+    except Exception as e:
+        print(f"❌ Generation error: {str(e)}")
+        return None, f"Error: {str(e)}"
 
+def combine_loops(drums_audio, instruments_audio, bpm, bars, num_repeats):
+    """Combine drum and instrument loops with specified repetitions"""
     try:
-        seed = int(seed)
-    except ValueError:
-        seed = random.randint(1, 10000)
-
-    nb_tokens = 1024
-    temperature = 0.9
-    top_p = 1.0
-
-    if use_chords and chord_progression.strip():
-        score = ml.predict_chords(
-            chord_progression,
-            time_signature=(4, 4),
-            temperature=temperature,
-            topp=top_p,
-            rng_seed=seed
-        )
-    else:
-        score = ml.predict(
-            nb_tokens=nb_tokens,
-            temperature=temperature,
-            topp=top_p,
-            rng_seed=seed
-        )
-
-    midi_filename = f"output_{seed}.mid"
-    wav_filename = midi_filename.replace(".mid", ".wav")
-
-    score.to_midi(midi_filename, tempo=bpm, time_signature=(4, 4))
-
-    subprocess.run(["fluidsynth", "-ni", "font.sf2", midi_filename, "-F", wav_filename, "-r", "44100"])
-
-    # Clean up temporary MIDI file
-    os.remove(midi_filename)
-
-    sample_rate = 44100  # Assuming fixed sample rate from fluidsynth command
-    return wav_filename
-
-@spaces.GPU(duration=120)
-def generate_music(wav_filename, prompt_duration, musicgen_model, num_iterations, bpm):
-    # Load the audio from the passed file path
-    song, sr = torchaudio.load(wav_filename)
-    song = song.to(device)
-    # Use the user-provided BPM value for duration calculation
-    duration = calculate_duration(bpm)
-
-    # Create slices from the song using the user-provided BPM value
-    slices = create_slices(song, sr, 35, bpm, num_slices=5)
-
-    # Load the model
-    model_name = musicgen_model.split(" ")[0]
-    model_continue = MusicGen.get_pretrained(model_name)
-
-    # Setting generation parameters
-    model_continue.set_generation_params(
-        use_sampling=True,
-        top_k=250,
-        top_p=0.0,
-        temperature=1.0,
-        duration=duration,
-        cfg_coef=3
-    )
-
-    all_audio_files = []
-
-    for i in range(num_iterations):
-        slice_idx = i % len(slices)
+        if not drums_audio and not instruments_audio:
+            return None, "No audio files to combine"
         
-        print(f"Running iteration {i + 1} using slice {slice_idx}...")
+        # Calculate timing
+        seconds_per_beat = 60.0 / bpm
+        seconds_per_bar = seconds_per_beat * 4
+        loop_duration = seconds_per_bar * bars
+        total_duration = loop_duration * num_repeats
         
-        prompt_waveform = slices[slice_idx][..., :int(prompt_duration * sr)]
-        prompt_waveform = preprocess_audio(prompt_waveform)
+        print(f"🎛️ Combining loops:")
+        print(f"   Loop duration: {loop_duration:.2f}s ({bars} bars)")
+        print(f"   Repeats: {num_repeats}")
+        print(f"   Total duration: {total_duration:.2f}s")
         
-        output = model_continue.generate_continuation(prompt_waveform, prompt_sample_rate=sr, progress=True)
-        output = output.cpu()  # Move the output tensor back to CPU
+        combined_audio = None
+        sample_rate = None
         
-        # Make sure the output tensor has at most 2 dimensions
-        if len(output.size()) > 2:
-            output = output.squeeze()
+        # Process each audio file
+        for audio_path, audio_type in [(drums_audio, "drums"), (instruments_audio, "instruments")]:
+            if audio_path:
+                # Load audio
+                waveform, sr = torchaudio.load(audio_path)
+                if sample_rate is None:
+                    sample_rate = sr
+                
+                # Ensure we have the exact loop duration
+                target_samples = int(loop_duration * sr)
+                if waveform.shape[1] > target_samples:
+                    waveform = waveform[:, :target_samples]
+                elif waveform.shape[1] < target_samples:
+                    # Pad if necessary
+                    padding = target_samples - waveform.shape[1]
+                    waveform = torch.cat([waveform, torch.zeros(waveform.shape[0], padding)], dim=1)
+                
+                # Repeat the loop
+                repeated_waveform = waveform.repeat(1, num_repeats)
+                
+                print(f"   {audio_type}: {waveform.shape[1]/sr:.2f}s repeated {num_repeats}x = {repeated_waveform.shape[1]/sr:.2f}s")
+                
+                # Add to combined audio
+                if combined_audio is None:
+                    combined_audio = repeated_waveform
+                else:
+                    combined_audio = combined_audio + repeated_waveform
         
-        filename_without_extension = f'continue_{i}'
-        filename_with_extension = f'{filename_without_extension}.wav'
+        if combined_audio is None:
+            return None, "No valid audio to combine"
         
-        audio_write(filename_with_extension, output, model_continue.sample_rate, strategy="loudness", loudness_compressor=True)
-        all_audio_files.append(f'{filename_without_extension}.wav.wav')  # Assuming the library appends an extra .wav
-
-    # Combine all audio files
-    combined_audio = AudioSegment.empty()
-    for filename in all_audio_files:
-        combined_audio += AudioSegment.from_wav(filename)
-
-    combined_audio_filename = f"combined_audio_{random.randint(1, 10000)}.mp3"
-    combined_audio.export(combined_audio_filename, format="mp3")
-
-    # Clean up temporary files
-    for filename in all_audio_files:
-        os.remove(filename)
-
-    return combined_audio_filename
-
-@spaces.GPU(duration=120)
-def continue_music(input_audio_path, prompt_duration, musicgen_model, num_iterations, bpm):
-    # Load the audio from the given file path
-    song, sr = torchaudio.load(input_audio_path)
-    song = song.to(device)
-
-    # Load the model and set generation parameters
-    model_continue = MusicGen.get_pretrained(musicgen_model.split(" ")[0])
-    model_continue.set_generation_params(
-        use_sampling=True,
-        top_k=250,
-        top_p=0.0,
-        temperature=1.0,
-        duration=calculate_duration(bpm),
-        cfg_coef=3
-    )
-
-    original_audio = AudioSegment.from_mp3(input_audio_path)
-    current_audio = original_audio
-
-    file_paths_for_cleanup = []  # List to track generated file paths for cleanup
-
-    for i in range(num_iterations):
-        # Calculate the slice from the end of the current audio based on prompt_duration
-        num_samples = int(prompt_duration * sr)
-        if current_audio.duration_seconds * 1000 < prompt_duration * 1000:
-            raise ValueError("The prompt_duration is longer than the current audio length.")
-
-        start_time = current_audio.duration_seconds * 1000 - prompt_duration * 1000
-        prompt_audio = current_audio[start_time:]
-
-        # Convert the prompt audio to a PyTorch tensor
-        prompt_bytes = prompt_audio.export(format="wav").read()
-        prompt_waveform, _ = torchaudio.load(io.BytesIO(prompt_bytes))
-        prompt_waveform = prompt_waveform.to(device)
-
-        # Prepare the audio slice for generation
-        prompt_waveform = preprocess_audio(prompt_waveform)
-
-        output = model_continue.generate_continuation(prompt_waveform, prompt_sample_rate=sr, progress=True)
-        output = output.cpu()  # Move the output tensor back to CPU
-
-        if len(output.size()) > 2:
-            output = output.squeeze()
-
-        filename_without_extension = f'continue_{i}'
-        filename_with_extension = f'{filename_without_extension}.wav'
-        correct_filename_extension = f'{filename_without_extension}.wav.wav'  # Apply the workaround for audio_write
-
-        audio_write(filename_with_extension, output, model_continue.sample_rate, strategy="loudness", loudness_compressor=True)
-        generated_audio_segment = AudioSegment.from_wav(correct_filename_extension)
-
-        # Replace the prompt portion with the generated audio
-        current_audio = current_audio[:start_time] + generated_audio_segment
-
-        file_paths_for_cleanup.append(correct_filename_extension)  # Add to cleanup list
-
-    combined_audio_filename = f"combined_audio_{random.randint(1, 10000)}.mp3"
-    current_audio.export(combined_audio_filename, format="mp3")
-
-    # Clean up temporary files using the list of file paths
-    for file_path in file_paths_for_cleanup:
-        os.remove(file_path)
-
-    return combined_audio_filename
-
-
-
-# Define the expandable sections
-musiclang_blurb = """
-## musiclang
-musiclang is a controllable ai midi model. it can generate midi sequences based on user-provided parameters, or unconditionally.
-[<img src="https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png" alt="GitHub" width="20" style="vertical-align:middle"> musiclang github](https://github.com/MusicLang/musiclang_predict)
-[<img src="https://huggingface.co/front/assets/huggingface_logo-noborder.svg" alt="Hugging Face" width="20" style="vertical-align:middle"> musiclang huggingface space](https://huggingface.co/spaces/musiclang/musiclang-predict)
-"""
-
-musicgen_blurb = """
-## musicgen
-musicgen is a transformer-based music model that generates audio. It can also do something called a continuation, which was initially meant to extend musicgen outputs beyond 30 seconds. it can be used with any input audio to produce surprising results.
-[<img src="https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png" alt="GitHub" width="20" style="vertical-align:middle"> audiocraft github](https://github.com/facebookresearch/audiocraft)
-visit https://thecollabagepatch.com/infinitepolo.mp3 or https://thecollabagepatch.com/audiocraft.mp3 to hear continuations in action.
-see also https://youtube.com/@thecollabagepatch 
-"""
-
-finetunes_blurb = """
-## fine-tuned models
-the fine-tunes hosted on the huggingface hub are provided collectively by the musicgen discord community. thanks to vanya, mj, hoenn, septicDNB and of course, lyra.
-[<img src="https://cdn.iconscout.com/icon/free/png-256/discord-3691244-3073764.png" alt="Discord" width="20" style="vertical-align:middle"> musicgen discord](https://discord.gg/93kX8rGZ)
-[<img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab" style="vertical-align:middle"> fine-tuning colab notebook by lyra](https://colab.research.google.com/drive/13tbcC3A42KlaUZ21qvUXd25SFLu8WIvb)
-"""
-
-# Define the fine-tunes blurb for each model
-fine_tunes_info = """
-## thepatch/vanya_ai_dnb_0.1
-thepatch/vanya_ai_dnb_0.1 was trained by vanya. [vanya's Twitter](https://twitter.com/@veryVANYA) 🔗 - it treats almost all input audio as the beginning of a buildup to a dnb drop (can do downtempo well)
-
-## thepatch/bleeps-medium
-thepatch/bleeps-medium was trained by kevin and lyra [lyra's Twitter](https://twitter.com/@_lyraaaa_) 🔗 - it is a medium model. it's more melodic and ambient sometimes than vanya's, but there's a 50/50 chance it gets real heavy with the edm vibes. It can be amazing at turning your chords into pads, and is a good percussionist.
-
-## thepatch/budots_remix
-thepatch/budots_remix was trained by MJ BERSABEph. budots is a dope niche genre from the philippines apparently. this one will often do fascinating, demonic, kinds of vocal chopping. warning: it tends to speed up and slow down tempo, which makes it hard to use in a daw.
-
-## thepatch/hoenn_lofi
-thepatch/hoenn_lofi is a large fine-tune by hoenn. [hoenn's Twitter](https://twitter.com/@eschatolocation) 🔗 - this model is a large boi, and it shows. even tho it is trained to do lo-fi, its ability to run with your melodies and not ruin them is unparalleled among the fine-tunes so far.
-
-## thepatch/PhonkV2
-thepatch/PhonkV2 was trained by MJ BERSABEph. there are multiple versions in the discord.
-
-## foureyednymph/musicgen-sza-sos-small
-foureyednymph/musicgen-sza-sos-small was just trained by foureyednymph. We're all about to find out if it does continuations well.
-"""
-
-# Create the Gradio interface
-with gr.Blocks() as iface:
-    gr.Markdown("# the-slot-machine")
-    gr.Markdown("two ai's jamming. warning: outputs will be very strange, likely stupid, and possibly rad.")
-    gr.Markdown("this is a musical slot machine. using musiclang, we get a midi output. then, we let a musicgen model. trim it so that you like the beginning of the output, and choose the prompt duration. Then we give it to musicgen to continue for 30 seconds. We can then choose a new model and prompt duration, trim it, and give it to musicgen to continue from the end of the output. Re-upload, trim again and repeat with a new musicgen model and different prompt duration if you want. ")
-
-    with gr.Accordion("more info", open=False):
-        gr.Markdown(musiclang_blurb)
-        gr.Markdown(musicgen_blurb)
-        gr.Markdown(finetunes_blurb)
+        # Normalize to prevent clipping
+        combined_audio = combined_audio / torch.max(torch.abs(combined_audio))
+        combined_audio = combined_audio.clamp(-1, 1)
+        
+        # Convert to int16 and save
+        combined_audio_int16 = combined_audio.mul(32767).to(torch.int16)
+        combined_filename = f"combined_{bpm}bpm_{bars}bars_{num_repeats}loops_{random.randint(1000, 9999)}.wav"
+        torchaudio.save(combined_filename, combined_audio_int16, sample_rate)
+        
+        actual_duration = combined_audio.shape[1] / sample_rate
+        status = f"Combined into {actual_duration:.2f}s audio ({num_repeats} × {bars} bars at {bpm}bpm)"
+        
+        print(f"✅ {status}")
+        return combined_filename, status
+    
+    except Exception as e:
+        print(f"❌ Combine error: {str(e)}")
+        return None, f"Combine error: {str(e)}"
+
+def transform_with_melodyflow_api(audio_path, prompt, solver="euler", flowstep=0.12):
+    """Transform audio using Facebook/MelodyFlow space API"""
+    if audio_path is None:
+        return None, "❌ No audio file provided"
+    
+    try:
+        # Initialize client for Facebook MelodyFlow space
+        client = Client("facebook/MelodyFlow")
+        
+        # Set steps based on solver
+        if solver == "midpoint":
+            base_steps = 128
+            effective_steps = base_steps // 2  # 64 effective steps
+        else:  # euler
+            base_steps = 125  
+            effective_steps = base_steps // 5  # 25 effective steps
+        
+        print(f"🎛️ MelodyFlow transformation:")
+        print(f"   Prompt: {prompt}")
+        print(f"   Solver: {solver} ({effective_steps} effective steps)")
+        print(f"   Flowstep: {flowstep}")
+        
+        # Call the MelodyFlow API
+        result = client.predict(
+            model="facebook/melodyflow-t24-30secs",
+            text=prompt,
+            solver=solver,
+            steps=base_steps,
+            target_flowstep=flowstep,
+            regularize=solver == "euler",
+            regularization_strength=0.2,
+            duration=30,
+            melody=handle_file(audio_path),
+            api_name="/predict"
+        )
+        
+        if result and len(result) > 0 and result[0]:
+            # Save the result locally
+            output_filename = f"melodyflow_transformed_{random.randint(1000, 9999)}.wav"
+            import shutil
+            shutil.copy2(result[0], output_filename)
+            
+            status_msg = f"✅ Transformed with prompt: '{prompt}' (flowstep: {flowstep}, {effective_steps} steps)"
+            return output_filename, status_msg
+        else:
+            return None, "❌ MelodyFlow API returned no results"
+            
+    except Exception as e:
+        return None, f"❌ MelodyFlow API error: {str(e)}"
+
+def calculate_optimal_bars(bpm):
+    """Calculate optimal bar count for given BPM to fit in ~10s"""
+    seconds_per_beat = 60.0 / bpm
+    seconds_per_bar = seconds_per_beat * 4
+    max_duration = 10.0
+    
+    for bars in [8, 4, 2, 1]:
+        if seconds_per_bar * bars <= max_duration:
+            return bars
+    return 1
 
-    with gr.Accordion("fine-tunes info", open=False):
-        gr.Markdown(fine_tunes_info)
+# ========== GRADIO INTERFACE ==========
 
+with gr.Blocks(title="🎵 Stable Audio Loop Generator") as iface:
+    gr.Markdown("# 🎵 Stable Audio Loop Generator")
+    gr.Markdown("**Generate synchronized drum and instrument loops with stable-audio-open-small, then transform with MelodyFlow!**")
+    
+    with gr.Accordion("How This Works", open=False):
+        gr.Markdown("""
+        **Workflow:**
+        1. **Set global BPM and bars** - affects both drum and instrument generation
+        2. **Generate drum loop** - creates BPM-aware percussion
+        3. **Generate instrument loop** - creates melodic/harmonic content  
+        4. **Combine loops** - layer them together with repetitions (up to 30s)
+        5. **Transform** - use MelodyFlow to stylistically transform the combined result
+        
+        **Features:**
+        - BPM-aware generation ensures perfect sync between loops
+        - Negative prompting separates drums from instruments cleanly
+        - Smart bar calculation optimizes loop length for the BPM
+        - MelodyFlow integration for advanced style transfer
+        """)
+    
+    # ========== GLOBAL CONTROLS ==========
+    gr.Markdown("## 🎛️ Global Settings")
+    
+    with gr.Row():
+        global_bpm = gr.Dropdown(
+            label="Global BPM",
+            choices=[90, 100, 110, 120, 130, 140, 150],
+            value=120,
+            info="BPM applied to both drum and instrument generation"
+        )
+        
+        global_bars = gr.Dropdown(
+            label="Loop Length (Bars)",
+            choices=[1, 2, 4, 8],
+            value=4,
+            info="Number of bars for each loop"
+        )
+        
+        base_prompt = gr.Textbox(
+            label="Base Prompt",
+            value="techno",
+            placeholder="e.g., 'techno', 'jazz', 'ambient', 'hip-hop'",
+            info="Style applied to both loops"
+        )
+    
+    # Auto-suggest optimal bars based on BPM
+    def update_suggested_bars(bpm):
+        optimal = calculate_optimal_bars(bpm)
+        return gr.update(info=f"Suggested: {optimal} bars for {bpm}bpm (≤10s)")
+    
+    global_bpm.change(update_suggested_bars, inputs=[global_bpm], outputs=[global_bars])
+    
+    # ========== LOOP GENERATION ==========
+    gr.Markdown("## 🥁 Step 1: Generate Individual Loops")
+    
     with gr.Row():
         with gr.Column():
-            seed = gr.Textbox(label="Seed (leave blank for random)", value="")
-            use_chords = gr.Checkbox(label="Control Chord Progression", value=False)
-            chord_progression = gr.Textbox(label="Chord Progression (e.g., Am CM Dm E7 Am)", visible=True)
-            bpm = gr.Slider(label="BPM", minimum=60, maximum=200, step=1, value=120)
-            generate_midi_button = gr.Button("Generate MIDI")
-            midi_audio = gr.Audio(label="Generated MIDI Audio", type="filepath")  # Ensure this is set to handle file paths
-
+            gr.Markdown("### 🥁 Drum Loop")
+            generate_drums_btn = gr.Button("Generate Drums", variant="primary", size="lg")
+            drums_audio = gr.Audio(label="Drum Loop", type="filepath")
+            drums_status = gr.Textbox(label="Drums Status", value="Ready to generate")
+            
         with gr.Column():
-            prompt_duration = gr.Dropdown(label="Prompt Duration (seconds)", choices=list(range(1, 11)), value=5)
-            musicgen_model = gr.Dropdown(label="MusicGen Model", choices=[
-                "thepatch/vanya_ai_dnb_0.1 (small)",
-                "thepatch/budots_remix (small)",
-                "thepatch/PhonkV2 (small)",
-                "thepatch/bleeps-medium (medium)",
-                "thepatch/hoenn_lofi (large)",
-                "foureyednymph/musicgen-sza-sos-small (small)"
-            ], value="thepatch/vanya_ai_dnb_0.1 (small)")
-            num_iterations = gr.Slider(label="this does nothing rn", minimum=1, maximum=1, step=1, value=1)
-            generate_music_button = gr.Button("Generate Music")
-            output_audio = gr.Audio(label="Generated Music", type="filepath")
-            continue_button = gr.Button("Continue Generating Music")
-            continue_output_audio = gr.Audio(label="Continued Music Output", type="filepath")
-
-    # Connecting the components
-    generate_midi_button.click(generate_midi, inputs=[seed, use_chords, chord_progression, bpm], outputs=[midi_audio])
-    generate_music_button.click(generate_music, inputs=[midi_audio, prompt_duration, musicgen_model, num_iterations, bpm], outputs=[output_audio])
-    continue_button.click(continue_music, inputs=[output_audio, prompt_duration, musicgen_model, num_iterations, bpm], outputs=continue_output_audio)
+            gr.Markdown("### 🎹 Instrument Loop")
+            generate_instruments_btn = gr.Button("Generate Instruments", variant="secondary", size="lg")
+            instruments_audio = gr.Audio(label="Instrument Loop", type="filepath")
+            instruments_status = gr.Textbox(label="Instruments Status", value="Ready to generate")
+    
+    # Seed controls
+    with gr.Row():
+        drums_seed = gr.Number(label="Drums Seed", value=-1, info="-1 for random")
+        instruments_seed = gr.Number(label="Instruments Seed", value=-1, info="-1 for random")
+    
+    # ========== COMBINATION ==========
+    gr.Markdown("## 🎛️ Step 2: Combine Loops")
+    
+    with gr.Row():
+        num_repeats = gr.Slider(
+            label="Number of Repetitions",
+            minimum=1,
+            maximum=5,
+            step=1,
+            value=2,
+            info="How many times to repeat each loop (creates longer audio)"
+        )
+        combine_btn = gr.Button("🎛️ Combine Loops", variant="primary", size="lg")
+    
+    combined_audio = gr.Audio(label="Combined Loops", type="filepath")
+    combine_status = gr.Textbox(label="Combine Status", value="Generate loops first")
+    
+    # ========== MELODYFLOW TRANSFORMATION ==========
+    gr.Markdown("## 🎨 Step 3: Transform with MelodyFlow")
+    
+    with gr.Row():
+        with gr.Column():
+            transform_prompt = gr.Textbox(
+                label="Transformation Prompt",
+                value="aggressive industrial techno with distorted sounds",
+                placeholder="Describe the style transformation",
+                lines=2
+            )
+            
+        with gr.Column():
+            transform_solver = gr.Dropdown(
+                label="Solver",
+                choices=["euler", "midpoint"],
+                value="euler",
+                info="EULER: faster (25 steps), MIDPOINT: slower (64 steps)"
+            )
+            transform_flowstep = gr.Slider(
+                label="Transform Intensity",
+                minimum=0.0,
+                maximum=0.15,
+                step=0.01,
+                value=0.12,
+                info="Lower = more dramatic transformation"
+            )
+    
+    transform_btn = gr.Button("🎨 Transform Audio", variant="secondary", size="lg")
+    transformed_audio = gr.Audio(label="Transformed Audio", type="filepath")
+    transform_status = gr.Textbox(label="Transform Status", value="Combine audio first")
+    
+    # ========== EVENT HANDLERS ==========
+    
+    # Generate drums
+    generate_drums_btn.click(
+        generate_stable_audio_loop,
+        inputs=[base_prompt, gr.State("drums"), global_bpm, global_bars, drums_seed],
+        outputs=[drums_audio, drums_status]
+    )
+    
+    # Generate instruments  
+    generate_instruments_btn.click(
+        generate_stable_audio_loop,
+        inputs=[base_prompt, gr.State("instruments"), global_bpm, global_bars, instruments_seed],
+        outputs=[instruments_audio, instruments_status]
+    )
+    
+    # Combine loops
+    combine_btn.click(
+        combine_loops,
+        inputs=[drums_audio, instruments_audio, global_bpm, global_bars, num_repeats],
+        outputs=[combined_audio, combine_status]
+    )
+    
+    # Transform with MelodyFlow
+    transform_btn.click(
+        transform_with_melodyflow_api,
+        inputs=[combined_audio, transform_prompt, transform_solver, transform_flowstep],
+        outputs=[transformed_audio, transform_status]
+    )
+    
+    # ========== EXAMPLES ==========
+    gr.Markdown("## 🎯 Example Workflows")
+    
+    examples = gr.Examples(
+        examples=[
+            ["techno", 128, 4, "aggressive industrial techno"],
+            ["jazz", 110, 2, "smooth lo-fi jazz with vinyl crackle"],
+            ["ambient", 90, 8, "ethereal ambient soundscape"],
+            ["hip-hop", 100, 4, "classic boom bap hip-hop"],
+            ["drum and bass", 140, 4, "liquid drum and bass"],
+        ],
+        inputs=[base_prompt, global_bpm, global_bars, transform_prompt],
+    )
 
-iface.launch()
+if __name__ == "__main__":
+    iface.launch()

requirements.txt

@@ -1,7 +1,22 @@
-torch==2.1.0
-torchaudio
-audiocraft
-musiclang_predict
-pyFluidSynth 
-midi2audio
-spaces
+# Core ML dependencies  
+torch>=2.5.0
+torchaudio>=2.5.0
+einops
+transformers
+accelerate
+diffusers
+scipy
+librosa
+soundfile
+huggingface-hub
+
+# Gradio and HF Spaces
+gradio
+gradio-client
+spaces
+
+# Additional utilities
+numpy
+
+# Install stable-audio-tools from local submodule
+-e ./stable-audio-tools

stable-audio-tools

@@ -0,0 +1 @@
+Subproject commit 9e5954dd60718373c90445ede390b02aa7119665