Update app.py

app.py

@@ -1,16 +1,556 @@
+import gradio as gr
+from pydub import AudioSegment
+import numpy as np
+import tempfile
+import os
+import noisereduce as nr
+import torch
+from demucs import pretrained
+from demucs.apply import apply_model
+import torchaudio
+from pathlib import Path
+import matplotlib.pyplot as plt
+from io import BytesIO
+from PIL import Image
+import zipfile
+import datetime
+import librosa
+import warnings
+from TTS.api import TTS
+import base64
+import pickle
+import json
+import soundfile as sf
+
+warnings.filterwarnings("ignore")
+
+# ==============================
+# Helper Functions
+# ==============================
+
+def audiosegment_to_array(audio):
+    return np.array(audio.get_array_of_samples()), audio.frame_rate
+
+def array_to_audiosegment(samples, frame_rate, channels=1):
+    return AudioSegment(
+        samples.tobytes(),
+        frame_rate=int(frame_rate),
+        sample_width=samples.dtype.itemsize,
+        channels=channels
+    )
+
+def save_audiosegment_to_temp(audio: AudioSegment, suffix=".wav"):
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as f:
+        audio.export(f.name, format=suffix.lstrip('.'))
+        return f.name
+
+def load_audiofile_to_numpy(path):
+    samples, sr = sf.read(path, dtype="int16")
+    if samples.ndim > 1 and samples.shape[1] > 2:
+        samples = samples[:, :2]
+    return samples, sr
+
+def show_waveform(audio_file):
+    try:
+        audio = AudioSegment.from_file(audio_file)
+        samples = np.array(audio.get_array_of_samples())
+        plt.figure(figsize=(10, 2))
+        plt.plot(samples[:10000], color="skyblue")
+        plt.axis('off')
+        buf = BytesIO()
+        plt.savefig(buf, format="png", bbox_inches="tight", dpi=100)
+        plt.close()
+        buf.seek(0)
+        return Image.open(buf)
+    except Exception:
+        return None
+
+# ==============================
+# Effect Functions (as per original)
+# ==============================
+
+def apply_normalize(audio):
+    return audio.normalize()
+
+def apply_noise_reduction(audio):
+    samples, sr = audiosegment_to_array(audio)
+    reduced = nr.reduce_noise(y=samples, sr=sr)
+    return array_to_audiosegment(reduced, sr, channels=audio.channels)
+
+def apply_compression(audio):
+    return audio.compress_dynamic_range()
+
+def apply_reverb(audio):
+    reverb = audio - 10
+    return audio.overlay(reverb, position=1000)
+
+def apply_pitch_shift(audio, semitones=-2):
+    new_frame_rate = int(audio.frame_rate * (2 ** (semitones / 12)))
+    shifted = audio._spawn(audio.raw_data, overrides={"frame_rate": new_frame_rate}).set_frame_rate(audio.frame_rate)
+    return shifted
+
+def apply_echo(audio, delay_ms=500, decay=0.5):
+    echo = audio - 10
+    return audio.overlay(echo, position=delay_ms)
+
+def apply_stereo_widen(audio, pan_amount=0.3):
+    left = audio.pan(-pan_amount)
+    right = audio.pan(pan_amount)
+    return AudioSegment.from_mono_audiosegments(left, right)
+
+def apply_bass_boost(audio, gain=10):
+    return audio.low_pass_filter(100).apply_gain(gain)
+
+def apply_treble_boost(audio, gain=10):
+    return audio.high_pass_filter(4000).apply_gain(gain)
+
+def apply_limiter(audio, limit_dB=-1):
+    limiter = audio._spawn(audio.raw_data, overrides={"frame_rate": audio.frame_rate})
+    return limiter.apply_gain(limit_dB)
+
+def apply_auto_gain(audio, target_dB=-20):
+    change = target_dB - audio.dBFS
+    return audio.apply_gain(change)
+
+def apply_vocal_distortion(audio, intensity=0.3):
+    samples = np.array(audio.get_array_of_samples()).astype(np.float32)
+    distorted = samples + intensity * np.sin(samples * 2 * np.pi / 32768)
+    return array_to_audiosegment(distorted.astype(np.int16), audio.frame_rate, channels=audio.channels)
+
+def apply_harmony(audio, shift_semitones=4):
+    shifted_up = apply_pitch_shift(audio, shift_semitones)
+    shifted_down = apply_pitch_shift(audio, -shift_semitones)
+    return audio.overlay(shifted_up).overlay(shifted_down)
+
+def apply_stage_mode(audio):
+    processed = apply_reverb(audio)
+    processed = apply_bass_boost(processed, gain=6)
+    return apply_limiter(processed, limit_dB=-2)
+
+def apply_bitcrush(audio, bit_depth=8):
+    samples = np.array(audio.get_array_of_samples())
+    max_val = 2 ** bit_depth - 1
+    downsampled = np.round(samples / (32768 / max_val)).astype(np.int16)
+    return array_to_audiosegment(downsampled, audio.frame_rate // 2, channels=audio.channels)
+
+# ==============================
+# Loudness Matching (EBU R128)
+# ==============================
+
+try:
+    import pyloudnorm as pyln
+except ImportError:
+    import subprocess
+    subprocess.run(["pip", "install", "pyloudnorm"])
+    import pyloudnorm as pyln
+
+def match_loudness(audio_path, target_lufs=-14.0):
+    meter = pyln.Meter(44100)
+    wav = AudioSegment.from_file(audio_path).set_frame_rate(44100)
+    samples = np.array(wav.get_array_of_samples()).astype(np.float64) / 32768.0
+    loudness = meter.integrated_loudness(samples)
+    gain_db = target_lufs - loudness
+    adjusted = wav + gain_db
+    out_path = save_audiosegment_to_temp(adjusted, ".wav")
+    return out_path
+
+# ==============================
+# EQ Map and Function
+# ==============================
+
+eq_map = {
+    "Pop": [(200, 500, -3), (2000, 4000, +4)],
+    # (Add other genres as needed)
+}
+
+def auto_eq(audio, genre="Pop"):
+    from scipy.signal import butter, sosfilt
+    samples, sr = audiosegment_to_array(audio)
+    samples = samples.astype(np.float64)
+
+    def band_eq(samples, sr, lowcut, highcut, gain):
+        sos = butter(10, [lowcut, highcut], btype='band', output='sos', fs=sr)
+        filtered = sosfilt(sos, samples)
+        return samples + gain * filtered
+
+    for low, high, gain in eq_map.get(genre, []):
+        samples = band_eq(samples, sr, low, high, gain)
+    return array_to_audiosegment(samples.astype(np.int16), sr, channels=audio.channels)
+
+# ==============================
+# Load & Save Track for Models
+# ==============================
+
+def load_track_local(path, sample_rate, channels=2):
+    sig, rate = torchaudio.load(path)
+    if rate != sample_rate:
+        sig = torchaudio.functional.resample(sig, rate, sample_rate)
+    if channels == 1:
+        sig = sig.mean(0)
+    return sig
+
+def save_track(path, wav, sample_rate):
+    Path(path).parent.mkdir(parents=True, exist_ok=True)
+    torchaudio.save(str(path), wav, sample_rate)
+
+# ==============================
+# Vocal isolation and stem splitting
+# ==============================
+
+def apply_vocal_isolation(audio_path):
+    model = pretrained.get_model(name='htdemucs')
+    wav = load_track_local(audio_path, model.samplerate, channels=2)
+    ref = wav.mean(0)
+    wav -= ref[:, None]
+    sources = apply_model(model, wav[None])[0]
+    wav += ref[:, None]
+    vocal_track = sources[3].cpu()
+    out_path = os.path.join(tempfile.gettempdir(), "vocals.wav")
+    save_track(out_path, vocal_track, model.samplerate)
+    return out_path
+
+def stem_split(audio_path):
+    model = pretrained.get_model(name='htdemucs')
+    wav = load_track_local(audio_path, model.samplerate, channels=2)
+    sources = apply_model(model, wav[None])[0]
+    output_dir = tempfile.mkdtemp()
+    file_paths = []
+    for i, name in enumerate(['drums', 'bass', 'other', 'vocals']):
+        path = os.path.join(output_dir, f"{name}.wav")
+        save_track(path, sources[i].cpu(), model.samplerate)
+        file_paths.append(path)
+    # Return in order vocals, drums, bass, other per your UI
+    return file_paths[3], file_paths[0], file_paths[1], file_paths[2]
+
+# ==============================
+# Full Audio Processor with Effects Map
+# ==============================
+
+def process_audio(audio_file, selected_effects, isolate_vocals, preset_name, export_format):
+    try:
+        audio = AudioSegment.from_file(audio_file)
+        effect_map = {
+            "Noise Reduction": apply_noise_reduction,
+            "Compress Dynamic Range": apply_compression,
+            "Add Reverb": apply_reverb,
+            "Pitch Shift": apply_pitch_shift,
+            "Echo": apply_echo,
+            "Stereo Widening": apply_stereo_widen,
+            "Bass Boost": apply_bass_boost,
+            "Treble Boost": apply_treble_boost,
+            "Normalize": apply_normalize,
+            "Limiter": lambda a: apply_limiter(a, limit_dB=-1),
+            "Auto Gain": lambda a: apply_auto_gain(a, target_dB=-20),
+            "Vocal Distortion": apply_vocal_distortion,
+            "Stage Mode": apply_stage_mode,
+            "Harmony": apply_harmony,
+            "Bitcrusher": apply_bitcrush,
+        }
+        for eff in selected_effects:
+            if eff in effect_map:
+                audio = effect_map[eff](audio)
+        if isolate_vocals:
+            temp_path = save_audiosegment_to_temp(audio, suffix=".wav")
+            vocal_path = apply_vocal_isolation(temp_path)
+            audio = AudioSegment.from_file(vocal_path)
+        output_path = save_audiosegment_to_temp(audio, suffix=f".{export_format.lower()}")
+        samples, sr = load_audiofile_to_numpy(output_path)
+        waveform = show_waveform(output_path)
+        session_log = json.dumps({
+            "timestamp": str(datetime.datetime.now()),
+            "filename": os.path.basename(audio_file),
+            "effects_applied": selected_effects,
+            "isolate_vocals": isolate_vocals,
+            "export_format": export_format,
+            "detected_genre": "Unknown"
+        }, indent=2)
+        return (samples, sr), waveform, session_log, "Unknown", "🎉 Done!"
+    except Exception as e:
+        return None, None, f"❌ Error: {e}", "", f"❌ Error: {e}"
+
+# ==============================
+# Batch Processing
+# ==============================
+
+def batch_process_audio(files, selected_effects, isolate_vocals, preset_name, export_format):
+    try:
+        output_dir = tempfile.mkdtemp()
+        paths = []
+        logs = []
+        for i, file in enumerate(files):
+            result, _, log, _, _ = process_audio(file.name, selected_effects, isolate_vocals, preset_name, export_format)
+            if result is None:
+                continue
+            samples, sr = result
+            filepath = os.path.join(output_dir, f"processed_{i}.{export_format.lower()}")
+            sf.write(filepath, samples, sr)
+            paths.append(filepath)
+            logs.append(log)
+        zip_path = os.path.join(tempfile.gettempdir(), "batch_output.zip")
+        with zipfile.ZipFile(zip_path, 'w') as zf:
+            for i, p in enumerate(paths):
+                zf.write(p, os.path.basename(p))
+                zf.writestr(f"session_log_{i}.json", logs[i])
+        return zip_path, "📦 Batch processing complete!"
+    except Exception as e:
+        return None, f"❌ Batch processing failed: {e}"
+
+# ==============================
+# AI Remastering
+# ==============================
+
+def ai_remaster(audio_path):
+    try:
+        audio = AudioSegment.from_file(audio_path)
+        samples, sr = audiosegment_to_array(audio)
+        reduced = nr.reduce_noise(y=samples, sr=sr)
+        cleaned = array_to_audiosegment(reduced, sr, channels=audio.channels)
+        cleaned_path = save_audiosegment_to_temp(cleaned, ".wav")
+        isolated_path = apply_vocal_isolation(cleaned_path)
+        final_path = ai_mastering_chain(isolated_path, genre="Pop", target_lufs=-14.0)
+        samples, sr = load_audiofile_to_numpy(final_path)
+        return (samples, sr)
+    except Exception as e:
+        print(f"Remastering error: {e}")
+        return None
+
+def ai_mastering_chain(audio_path, genre="Pop", target_lufs=-14.0):
+    audio = AudioSegment.from_file(audio_path)
+    audio = auto_eq(audio, genre=genre)
+    loud_adj_path = match_loudness(audio_path, target_lufs)
+    audio = AudioSegment.from_file(loud_adj_path)
+    audio = apply_stereo_widen(audio, pan_amount=0.3)
+    out_path = save_audiosegment_to_temp(audio, ".wav")
+    return out_path
+
+def apply_stereo_widen(audio, pan_amount=0.3):
+    left = audio.pan(-pan_amount)
+    right = audio.pan(pan_amount)
+    return AudioSegment.from_mono_audiosegments(left, right)
+
+# ==============================
+# Harmonic Saturation
+# ==============================
+
+def harmonic_saturation(audio_path, saturation_type="Tube", intensity=0.2):
+    audio = AudioSegment.from_file(audio_path)
+    samples = np.array(audio.get_array_of_samples()).astype(np.float32)
+    if saturation_type == "Tube":
+        saturated = np.tanh(intensity * samples)
+    elif saturation_type == "Tape":
+        saturated = np.where(samples > 0, 1 - np.exp(-intensity * samples), -1 + np.exp(intensity * samples))
+    elif saturation_type == "Console":
+        saturated = np.clip(samples, -32768, 32768) * intensity
+    elif saturation_type == "Mix Bus":
+        saturated = np.log1p(np.abs(samples)) * np.sign(samples) * intensity
+    else:
+        saturated = samples
+    saturated_audio = array_to_audiosegment(saturated.astype(np.int16), audio.frame_rate, audio.channels)
+    out_path = save_audiosegment_to_temp(saturated_audio, ".wav")
+    samples, sr = load_audiofile_to_numpy(out_path)
+    return (samples, sr)
+
+# ==============================
+# Vocal Doubler Harmony
+# ==============================
+
+def run_harmony(audio_file):
+    if not audio_file:
+        return None, "❌ Upload a vocal clip first."
+    try:
+        audio = AudioSegment.from_file(audio_file)
+        out_audio = apply_harmony(audio)
+        tmp_path = save_audiosegment_to_temp(out_audio, ".wav")
+        samples, sr = load_audiofile_to_numpy(tmp_path)
+        return (samples, sr), "✅ Success"
+    except Exception as e:
+        return None, f"❌ Error: {e}"
+
+# ==============================
+# Auto-Tune helper
+# ==============================
+
+def key_to_semitone(key="C"):
+    mapping = {"C": 0, "C#": 1, "D": 2, "D#": 3, "E": 4, "F": 5,
+               "F#": 6, "G": 7, "G#": 8, "A": 9, "A#": 10, "B": 11}
+    return mapping.get(key, 0)
+
+def auto_tune_vocal(audio_file, target_key="C"):
+    try:
+        audio = AudioSegment.from_file(audio_file.name)
+        semitones = key_to_semitone(target_key)
+        tuned_audio = apply_pitch_shift(audio, semitones)
+        tmp_path = save_audiosegment_to_temp(tuned_audio, ".wav")
+        samples, sr = load_audiofile_to_numpy(tmp_path)
+        return (samples, sr)
+    except Exception as e:
+        print(f"Auto-Tune Error: {e}")
+        return None
+
+# ==============================
+# Loop Section Utility
+# ==============================
+
+def loop_section(audio_file, start_ms, end_ms, loops=2):
+    audio = AudioSegment.from_file(audio_file)
+    section = audio[start_ms:end_ms]
+    looped = section * loops
+    tmp_path = save_audiosegment_to_temp(looped, ".wav")
+    samples, sr = load_audiofile_to_numpy(tmp_path)
+    return (samples, sr)
+
+# ==============================
+# Frequency Spectrum Visualization
+# ==============================
+
+def visualize_spectrum(audio_file):
+    y, sr = torchaudio.load(audio_file)
+    import librosa.display
+    y_np = y.numpy().flatten()
+    stft = librosa.stft(y_np)
+    db = librosa.amplitude_to_db(abs(stft))
+    plt.figure(figsize=(10, 4))
+    img = librosa.display.specshow(db, sr=sr, x_axis="time", y_axis="hz", cmap="magma")
+    plt.colorbar(img, format="%+2.0f dB")
+    plt.title("Frequency Spectrum")
+    plt.tight_layout()
+    buf = BytesIO()
+    plt.savefig(buf, format="png")
+    plt.close()
+    buf.seek(0)
+    return Image.open(buf)
+
+# ==============================
+# A/B Compare Function
+# ==============================
+
+def compare_ab(track1_path, track2_path):
+    return track1_path, track2_path
+
+# ==============================
+# DAW Template Generation
+# ==============================
+
+def generate_ableton_template(stem_files):
+    template = {
+        "format": "Ableton Live",
+        "stems": [os.path.basename(s.name) for s in stem_files],
+        "effects": ["Reverb", "EQ", "Compression"],
+        "tempo": 128,
+        "title": "Studio Pulse Project"
+    }
+    out_path = os.path.join(tempfile.gettempdir(), "ableton_template.json")
+    with open(out_path, "w") as f:
+        json.dump(template, f, indent=2)
+    return out_path
+
+# ==============================
+# Export Full Mix as ZIP
+# ==============================
+
+def export_full_mix(stem_files, final_mix_file):
+    zip_path = os.path.join(tempfile.gettempdir(), "full_export.zip")
+    with zipfile.ZipFile(zip_path, "w") as zipf:
+        for i, stem in enumerate(stem_files):
+            zipf.write(stem.name, f"stem_{i}.wav")
+        zipf.write(final_mix_file.name, "final_mix.wav")
+    return zip_path
+
+# ==============================
+# Save/Load Project Functions
+# ==============================
+
+def save_project(audio_file, preset, effects):
+    audio = AudioSegment.from_file(audio_file.name)
+    project_data = {
+        "audio": audio.raw_data,
+        "preset": preset,
+        "effects": effects
+    }
+    out_path = os.path.join(tempfile.gettempdir(), "project.aiproj")
+    with open(out_path, "wb") as f:
+        pickle.dump(project_data, f)
+    return out_path
+
+def load_project(project_file):
+    with open(project_file.name, "rb") as f:
+        data = pickle.load(f)
+    return data.get("preset", ""), data.get("effects", [])
+
+# ==============================
+# Prompt-based editing
+# ==============================
+
+def process_prompt(audio_file, prompt):
+    audio = AudioSegment.from_file(audio_file)
+    processed_audio = apply_noise_reduction(audio)  # Example; real model integration can be added here
+    tmp_path = save_audiosegment_to_temp(processed_audio, ".wav")
+    samples, sr = load_audiofile_to_numpy(tmp_path)
+    return (samples, sr)
+
+# ==============================
+# Voice Swap
+# ==============================
+
+def clone_voice(source_audio_file, reference_audio_file):
+    source = AudioSegment.from_file(source_audio_file.name)
+    ref = AudioSegment.from_file(reference_audio_file.name)
+    mixed = source.overlay(ref - 10)
+    tmp_path = save_audiosegment_to_temp(mixed, ".wav")
+    return tmp_path
+
+# ==============================
+# Presets dictionary (use your full original content)
+# ==============================
+
+preset_choices = {
+    "Default": [],
+    "Clean Podcast": ["Noise Reduction", "Normalize"],
+    "Podcast Mastered": ["Noise Reduction", "Normalize", "Compress Dynamic Range"],
+    "Radio Ready": ["Bass Boost", "Treble Boost", "Limiter"],
+    "Music Production": ["Reverb", "Stereo Widening", "Pitch Shift"],
+    "ASMR Creator": ["Noise Gate", "Auto Gain", "Low-Pass Filter"],
+    "Voiceover Pro": ["Vocal Isolation", "TTS", "EQ Match"],
+    "8-bit Retro": ["Bitcrusher", "Echo", "Mono Downmix"],
+    "🎙 Clean Vocal": ["Noise Reduction", "Normalize", "High Pass Filter (80Hz)"],
+    "🧪 Vocal Distortion": ["Vocal Distortion", "Reverb", "Compress Dynamic Range"],
+    "🎶 Singer's Harmony": ["Harmony", "Stereo Widening", "Pitch Shift"],
+    "🌫 ASMR Vocal": ["Auto Gain", "Low-Pass Filter (3000Hz)", "Noise Gate"],
+    "🎼 Stage Mode": ["Reverb", "Bass Boost", "Limiter"],
+    "🎵 Auto-Tune Style": ["Pitch Shift (+1 semitone)", "Normalize", "Treble Boost"],
+    "🎤 R&B Vocal": ["Noise Reduction", "Bass Boost (100-300Hz)", "Treble Boost (2000-4000Hz)"],
+    "💃 Soul Vocal": ["Noise Reduction", "Bass Boost (80-200Hz)", "Treble Boost (1500-3500Hz)"],
+    "🕺 Funk Groove": ["Bass Boost (80-200Hz)", "Treble Boost (1000-3000Hz)"],
+    "Studio Master": ["Noise Reduction", "Normalize", "Bass Boost", "Treble Boost", "Limiter"],
+    "Podcast Voice": ["Noise Reduction", "Auto Gain", "High Pass Filter (85Hz)"],
+    "Lo-Fi Chill": ["Noise Gate", "Low-Pass Filter (3000Hz)", "Mono Downmix", "Bitcrusher"],
+    # Add other presets from your original exactly
+}
+
+preset_names = list(preset_choices.keys())
+
+# ==============================
+# Gradio UI Construction with Explicit Components + Clicks
+# ==============================
+
 with gr.Blocks() as demo:
     gr.HTML('<h3 style="text-align:center;">Where Your Audio Meets Intelligence</h3>')
     gr.Markdown('### Upload, edit, export — powered by AI!')
 
+    # === Single File Studio Tab ===
+    with gr.Blocks() as demo:
+    gr.HTML('<h3 style="text-align:center;">Where Your Audio Meets Intelligence</h3>')
+    gr.Markdown('### Upload, edit, export — powered by AI!')
+
     # --- Single File Studio Tab ---
     with gr.Tab("🎵 Single File Studio"):
         with gr.Row():
             with gr.Column():
                 input_audio = gr.Audio(label="Upload Audio", type="filepath")
-                effect_checkbox = gr.CheckboxGroup(
-                    choices=list({e for effects in preset_choices.values() for e in effects}),
-                    label="Apply Effects in Order"
-                )
+
+                effect_choices = list({eff for effects in preset_choices.values() for eff in effects})
+                effect_checkbox = gr.CheckboxGroup(choices=effect_choices, label="Apply Effects in Order")
+
                 preset_dropdown = gr.Dropdown(choices=preset_names, label="Select Preset", value=preset_names[0])
                 export_format = gr.Dropdown(choices=["WAV", "MP3"], label="Export Format", value="WAV")
                 isolate_vocals = gr.Checkbox(label="Isolate Vocals After Effects")
@@ -23,17 +563,18 @@ with gr.Blocks() as demo:
                 genre_out = gr.Textbox(label="Detected Genre")
                 status_box = gr.Textbox(label="Status", lines=1, value="Ready")
 
-        def update_effects_for_preset(preset_name):
-            return preset_choices.get(preset_name, [])
-
-        preset_dropdown.change(update_effects_for_preset, inputs=preset_dropdown, outputs=effect_checkbox)
+        preset_dropdown.change(
+            lambda x: preset_choices.get(x, []),
+            inputs=preset_dropdown,
+            outputs=effect_checkbox
+        )
 
-        def execute_processing(audio_path, effects, isolate, preset, fmt):
+        def process_wrapper(audio_file, effects, isolate, preset, fmt):
             effs = preset_choices.get(preset, []) if preset in preset_choices else effects
-            return process_audio(audio_path, effs, isolate, preset, fmt)
+            return process_audio(audio_file, effs, isolate, preset, fmt)
 
         process_btn.click(
-            fn=execute_processing,
+            process_wrapper,
             inputs=[input_audio, effect_checkbox, isolate_vocals, preset_dropdown, export_format],
             outputs=[output_audio, waveform_img, session_log_out, genre_out, status_box]
         )
@@ -51,7 +592,7 @@ with gr.Blocks() as demo:
                 other_file = gr.File(label="Other")
 
         split_button.click(
-            fn=stem_split,
+            stem_split,
             inputs=remix_input,
             outputs=[vocals_file, drums_file, bass_file, other_file]
         )
@@ -63,8 +604,10 @@ with gr.Blocks() as demo:
         remaster_status = gr.Textbox(label="Status", value="Ready", interactive=False)
         remaster_btn = gr.Button("Remaster")
 
-        remaster_btn.click(fn=ai_remaster, inputs=remaster_input, outputs=remaster_output)
-        remaster_btn.click(lambda _: "Done!", remaster_btn, remaster_status)
+        remaster_btn.click(remaster_audio := ai_remaster,
+                           inputs=remaster_input,
+                           outputs=remaster_output)
+        remaster_btn.click(lambda _: "✅ Done!", remaster_btn, remaster_status)
 
     # --- Harmonic Saturation Tab ---
     with gr.Tab("🧬 Harmonic Saturation"):
@@ -74,7 +617,11 @@ with gr.Blocks() as demo:
         saturation_out = gr.Audio(label="Warm Output", type="numpy")
         saturation_btn = gr.Button("Apply Saturation")
 
-        saturation_btn.click(fn=harmonic_saturation, inputs=[saturation_in, saturation_type, saturation_intensity], outputs=saturation_out)
+        saturation_btn.click(
+            harmonic_saturation,
+            inputs=[saturation_in, saturation_type, saturation_intensity],
+            outputs=saturation_out
+        )
 
     # --- Vocal Doubler / Harmonizer Tab ---
     with gr.Tab("🎧 Vocal Doubler / Harmonizer"):
@@ -83,12 +630,16 @@ with gr.Blocks() as demo:
         vocal_status = gr.Textbox(label="Status", interactive=False)
         vocal_btn = gr.Button("Add Vocal Doubling / Harmony")
 
-        vocal_btn.click(fn=run_harmony, inputs=vocal_in, outputs=[vocal_out, vocal_status])
+        vocal_btn.click(
+            run_harmony,
+            inputs=vocal_in,
+            outputs=[vocal_out, vocal_status]
+        )
 
     # --- Batch Processing Tab ---
     with gr.Tab("🔊 Batch Processing"):
         batch_files = gr.File(label="Upload Multiple Files", file_count="multiple")
-        batch_effects = gr.CheckboxGroup(choices=list({e for effects in preset_choices.values() for e in effects}), label="Apply Effects in Order")
+        batch_effects = gr.CheckboxGroup(choices=effect_choices, label="Apply Effects in Order")
         batch_isolate = gr.Checkbox(label="Isolate Vocals After Effects")
         batch_preset = gr.Dropdown(choices=preset_names, label="Select Preset", value=preset_names[0])
         batch_export_format = gr.Dropdown(choices=["MP3", "WAV"], label="Export Format", value="MP3")
@@ -97,7 +648,7 @@ with gr.Blocks() as demo:
         batch_status = gr.Textbox(label="Status", interactive=False)
 
         batch_process_btn.click(
-            fn=batch_process_audio,
+            batch_process_audio,
             inputs=[batch_files, batch_effects, batch_isolate, batch_preset, batch_export_format],
             outputs=[batch_download, batch_status]
         )