Update app.py

app.py

@@ -6,30 +6,74 @@ import librosa
 import numpy as np
 from pydub import AudioSegment
 from moviepy.editor import AudioFileClip, ImageClip, CompositeVideoClip
-# --- FIX: Import the video effects explicitly ---
+# Keep import available but unused (Full feature set available)
 from moviepy.video.fx.all import blackwhite, lum_contrast
 import subprocess
 from pathlib import Path
 import sys
+import yt_dlp
 
 # --- Configuration ---
 OUTPUT_DIR = Path("nightpulse_output")
 TEMP_DIR = Path("temp_processing")
 
+# --- Helper: Cloud Import (The Fix) ---
+def download_from_url(url):
+    """Downloads audio from YouTube/SC/Direct Link to bypass file picker crashes."""
+    if not url: return None
+    
+    print(f"Fetching URL: {url}")
+    # Configuration for high-quality audio extraction
+    ydl_opts = {
+        'format': 'bestaudio/best',
+        'outtmpl': str(TEMP_DIR / '%(title)s.%(ext)s'),
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'wav',
+            'preferredquality': '192',
+        }],
+        'quiet': True,
+        'no_warnings': True,
+    }
+    
+    # Clean temp before downloading
+    if TEMP_DIR.exists(): shutil.rmtree(TEMP_DIR)
+    TEMP_DIR.mkdir(parents=True, exist_ok=True)
+
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(url, download=True)
+        filename = ydl.prepare_filename(info)
+        # yt-dlp might change extension to .wav after conversion
+        final_path = Path(filename).with_suffix(".wav")
+        return str(final_path)
+
 # --- Core Logic Functions ---
 
-def analyze_and_separate(audio_file):
+def analyze_and_separate(file_input, url_input):
     """Phase 1: Separate 6 Stems (Drums, Bass, Guitar, Piano, Vocals, Other)"""
+    
+    # LOGIC: Check URL first (Safe Mode), then File (Desktop Mode)
+    audio_file = None
+    
+    if url_input and len(url_input) > 5:
+        print("Using Cloud Import...")
+        try:
+            audio_file = download_from_url(url_input)
+        except Exception as e:
+            raise gr.Error(f"Link Download Failed: {str(e)}")
+    elif file_input:
+        print("Using File Upload...")
+        audio_file = file_input
+    
+    if not audio_file:
+        raise gr.Error("No audio source found. Please paste a link or upload a file.")
+
     try:
-        if not audio_file:
-            raise ValueError("No audio file provided.")
-            
-        # Cleanup
+        # Cleanup Output
         if OUTPUT_DIR.exists(): shutil.rmtree(OUTPUT_DIR)
-        if TEMP_DIR.exists(): shutil.rmtree(TEMP_DIR)
         (OUTPUT_DIR / "Stems").mkdir(parents=True, exist_ok=True)
         (OUTPUT_DIR / "Loops").mkdir(parents=True, exist_ok=True)
-        TEMP_DIR.mkdir(parents=True, exist_ok=True)
+        if not TEMP_DIR.exists(): TEMP_DIR.mkdir(parents=True, exist_ok=True)
 
         filename = Path(audio_file).stem
         
@@ -45,7 +89,7 @@ def analyze_and_separate(audio_file):
         print(f"Detected BPM: {bpm}")
 
         # 2. Demucs Separation (Using 6-Stem Model)
-        print("Separating stems (6-Stem Model)...")
+        print("Separating stems...")
         subprocess.run([
             sys.executable, "-m", "demucs", "-n", "htdemucs_6s", "--out", str(TEMP_DIR), audio_file
         ], check=True, capture_output=True)
@@ -53,9 +97,9 @@ def analyze_and_separate(audio_file):
         # 3. Locate Stems
         demucs_out = TEMP_DIR / "htdemucs_6s" 
         track_folder = next(demucs_out.iterdir(), None)
-        if not track_folder: raise FileNotFoundError("Demucs failed to output files.")
+        if not track_folder: raise FileNotFoundError("Demucs separation failed.")
         
-        # Map all 6 stems
+        # Map stems
         drums = track_folder / "drums.wav"
         bass = track_folder / "bass.wav"
         guitar = track_folder / "guitar.wav"
@@ -63,17 +107,15 @@ def analyze_and_separate(audio_file):
         vocals = track_folder / "vocals.wav"
         other = track_folder / "other.wav"
         
-        # Return paths to the UI and the BPM
         return str(drums), str(bass), str(guitar), str(piano), str(other), str(vocals), bpm, str(track_folder)
 
     except Exception as e:
-        raise gr.Error(f"Separation Failed: {str(e)}")
+        raise gr.Error(f"Process Failed: {str(e)}")
 
 def package_and_export(track_folder_str, bpm, start_offset_sec, cover_art):
-    """Phase 2: Chop Loops, Generate Video, Zip"""
+    """Phase 2: Package & Export"""
     try:
         track_folder = Path(track_folder_str)
-        # Re-map paths
         stems = {
             "Drums": track_folder / "drums.wav",
             "Bass": track_folder / "bass.wav",
@@ -83,12 +125,12 @@ def package_and_export(track_folder_str, bpm, start_offset_sec, cover_art):
             "Vocals": track_folder / "vocals.wav"
         }
 
-        # 1. Save Full Stems (Copy to Stems folder)
+        # 1. Save Full Stems
         for name, path in stems.items():
             if path.exists():
                 shutil.copy(path, OUTPUT_DIR / "Stems" / f"{bpm}BPM_Full_{name}.wav")
 
-        # 2. Create Loops (With User Offset)
+        # 2. Create Loops
         ms_per_beat = (60 / bpm) * 1000
         eight_bars_ms = ms_per_beat * 4 * 8
         start_ms = start_offset_sec * 1000
@@ -98,20 +140,17 @@ def package_and_export(track_folder_str, bpm, start_offset_sec, cover_art):
         def make_loop(src, name):
             if not src.exists(): return None
             audio = AudioSegment.from_wav(str(src))
-            
             end_ms = start_ms + eight_bars_ms
             if len(audio) < end_ms:
                 s = 0
                 e = min(len(audio), eight_bars_ms)
             else:
                 s, e = start_ms, end_ms
-                
             loop = audio[s:int(e)].fade_in(15).fade_out(15).normalize()
             out_path = OUTPUT_DIR / "Loops" / f"{bpm}BPM_{name}.wav"
             loop.export(out_path, format="wav")
             return out_path
 
-        # Generate loops for all 6 stems
         created_loops['melody'] = make_loop(stems['Synths'], "SynthLoop")
         make_loop(stems['Drums'], "DrumLoop")
         make_loop(stems['Bass'], "BassLoop")
@@ -122,22 +161,14 @@ def package_and_export(track_folder_str, bpm, start_offset_sec, cover_art):
         # 3. Generate Video
         video_path = None
         if cover_art and created_loops['melody']:
-            print("Rendering Dynamic Noir Video...")
+            print("Rendering Video...")
             vid_out = OUTPUT_DIR / "Promo_Video.mp4"
             audio_clip = AudioFileClip(str(created_loops['melody']))
             duration = audio_clip.duration
             
-            # Load and Resize Image
             img = ImageClip(cover_art).resize(width=1080)
             
-            # --- NIGHT PULSE AESTHETIC FILTER ---
-            # 1. Force Black & White
-            img = img.fx(blackwhite)
-            # 2. Boost Contrast (make the blacks deeper, whites brighter)
-            img = img.fx(lum_contrast, lum=0, contrast=1.3) 
-            # ------------------------------------
-            
-            # Simple Zoom Animation
+            # Zoom Animation (Full Color)
             img = img.resize(lambda t : 1 + 0.02*t) 
             img = img.set_position(('center', 'center'))
             img = img.set_duration(duration)
@@ -167,17 +198,24 @@ def package_and_export(track_folder_str, bpm, start_offset_sec, cover_art):
 
 
 # --- GUI (Blocks) ---
-with gr.Blocks(title="Night Pulse | Command Center (6-Stem)") as app:
-    gr.Markdown("# 🎛️ Night Pulse | 6-Stem Command Center")
-    gr.Markdown("Deconstruct audio into 6 stems: Drums, Bass, Guitar, Piano, Vocals, Synths.")
+with gr.Blocks(title="Night Pulse | Studio Pro") as app:
+    gr.Markdown("# 🎛️ Night Pulse | Studio Command Center")
+    gr.Markdown("Full 6-stem separation and video generation.")
     
-    # State storage
     stored_folder = gr.State()
     stored_bpm = gr.State()
     
     with gr.Row():
         with gr.Column(scale=1):
-            input_audio = gr.Audio(type="filepath", label="1. Upload Master Track")
+            gr.Markdown("### 1. Audio Source")
+            with gr.Tabs():
+                with gr.TabItem("☁️ Import Link (Mobile Safe)"):
+                    gr.Markdown("**Paste a link (YouTube/SoundCloud) to avoid browser reloads.**")
+                    input_url = gr.Textbox(label="Paste URL Here", placeholder="https://youtube.com/watch?v=...", show_label=False)
+                
+                with gr.TabItem("📂 Upload File (Desktop)"):
+                    input_file = gr.Audio(type="filepath", label="Upload Master Track")
+
             input_art = gr.Image(type="filepath", label="Cover Art (9:16)")
             btn_analyze = gr.Button("🔍 Phase 1: Separate (6 Stems)", variant="primary")
             
@@ -198,7 +236,7 @@ with gr.Blocks(title="Night Pulse | Command Center (6-Stem)") as app:
     with gr.Row():
         with gr.Column():
             gr.Markdown("### 3. Loop Logic")
-            slider_start = gr.Slider(minimum=0, maximum=120, value=15, label="Loop Start Time (Seconds)", info="Select the start point for the 8-bar loop cut.")
+            slider_start = gr.Slider(minimum=0, maximum=120, value=15, label="Loop Start Time (Seconds)")
             btn_package = gr.Button("📦 Phase 2: Package & Export", variant="primary")
         
         with gr.Column():
@@ -209,7 +247,7 @@ with gr.Blocks(title="Night Pulse | Command Center (6-Stem)") as app:
     # Events
     btn_analyze.click(
         fn=analyze_and_separate,
-        inputs=[input_audio],
+        inputs=[input_file, input_url],
         outputs=[p_drums, p_bass, p_guitar, p_piano, p_other, p_vocals, stored_bpm, stored_folder]
     )