Update app.py

app.py

@@ -21,6 +21,20 @@ OUTPUT_DIR = Path("nightpulse_output")
 TEMP_DIR = Path("temp_processing")
 
 
+# -----------------------------
+# Startup Checks
+# -----------------------------
+def check_ffmpeg():
+    """Ensure FFmpeg is installed and accessible."""
+    if shutil.which("ffmpeg") is None:
+        print("CRITICAL WARNING: FFmpeg not found in system PATH.")
+        print("Audio processing (pydub/demucs) will fail.")
+        return False
+    return True
+
+check_ffmpeg()
+
+
 # -----------------------------
 # Cloud Import
 # -----------------------------
@@ -30,6 +44,11 @@ def download_from_url(url):
         return None
 
     print(f"Fetching URL: {url}")
+    # Clean temp before new download to avoid collisions
+    if TEMP_DIR.exists():
+        shutil.rmtree(TEMP_DIR, ignore_errors=True)
+    TEMP_DIR.mkdir(parents=True, exist_ok=True)
+
     ydl_opts = {
         "format": "bestaudio/best",
         "outtmpl": str(TEMP_DIR / "%(title)s.%(ext)s"),
@@ -40,10 +59,6 @@ def download_from_url(url):
         "no_warnings": True,
     }
 
-    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)
@@ -51,13 +66,63 @@ def download_from_url(url):
         return str(final_path)
 
 
+# -----------------------------
+# File Handling (Safer)
+# -----------------------------
+def safe_copy_to_temp(audio_file: str) -> str:
+    """
+    Copy source file into TEMP_DIR with a safe filename (avoids path/space/unicode surprises).
+    """
+    src = Path(audio_file)
+    TEMP_DIR.mkdir(parents=True, exist_ok=True)
+    safe_stem = "".join(c if c.isalnum() or c in "._-" else "_" for c in src.stem)
+    dst = TEMP_DIR / f"{safe_stem}{src.suffix.lower()}"
+    try:
+        shutil.copy(src, dst)
+    except Exception:
+        return str(src)
+    return str(dst)
+
+
+def ensure_wav(input_path: str) -> str:
+    """
+    Convert input audio to WAV for Demucs reliability.
+    """
+    p = Path(input_path)
+    if p.suffix.lower() == ".wav":
+        return str(p)
+
+    TEMP_DIR.mkdir(parents=True, exist_ok=True)
+    out = TEMP_DIR / f"{p.stem}.wav"
+    audio = AudioSegment.from_file(str(p))
+    audio.export(str(out), format="wav")
+    return str(out)
+
+
+# -----------------------------
+# Demucs Runner
+# -----------------------------
+def run_demucs(cmd):
+    """
+    Run demucs and return stdout. If it fails, raise gr.Error with stdout/stderr tail.
+    """
+    p = subprocess.run(cmd, capture_output=True, text=True)
+    if p.returncode != 0:
+        raise gr.Error(
+            "Demucs failed.\n\n"
+            f"Command:\n{cmd}\n\n"
+            f"STDOUT (tail):\n{(p.stdout or '')[-4000:]}\n\n"
+            f"STDERR (tail):\n{(p.stderr or '')[-4000:]}"
+        )
+    return p.stdout or ""
+
+
 # -----------------------------
 # BPM + Grid
 # -----------------------------
 def detect_bpm_multiwindow(audio_path, windows=((0, 60), (60, 60), (120, 60))):
     """
     Multi-window BPM detection: sample multiple slices and take median.
-    windows = tuples of (offset_seconds, duration_seconds)
     """
     bpms = []
     for offset, dur in windows:
@@ -79,8 +144,7 @@ def detect_bpm_multiwindow(audio_path, windows=((0, 60), (60, 60), (120, 60))):
 
 def detect_bar_grid(audio_path, bpm, sr=22050, max_seconds=240):
     """
-    Returns bar start times in ms using beat tracking (every 4 beats = 1 bar in 4/4).
-    Fallback: synth grid from BPM if beat tracking is weak.
+    Returns bar start times in ms.
     """
     y, sr = librosa.load(audio_path, sr=sr, mono=True, duration=max_seconds)
 
@@ -101,22 +165,15 @@ def detect_bar_grid(audio_path, bpm, sr=22050, max_seconds=240):
 
 
 # -----------------------------
-# Loudness + Click/Loop Handling
+# Loudness + Processing
 # -----------------------------
 def rms_dbfs(seg: AudioSegment) -> float:
-    """Approximate RMS loudness in dBFS for ranking."""
     if seg.rms <= 0:
         return -120.0
     return 20.0 * float(np.log10(seg.rms / 32768.0))
 
 
 def apply_loudness(seg: AudioSegment, mode: str, target_dbfs: float = -14.0) -> AudioSegment:
-    """
-    mode:
-      - "none": no change
-      - "peak": peak normalize (pydub normalize)
-      - "rms": adjust RMS-ish toward target_dbfs (clamped)
-    """
     mode = (mode or "none").lower().strip()
     if mode == "none":
         return seg
@@ -131,7 +188,7 @@ def apply_loudness(seg: AudioSegment, mode: str, target_dbfs: float = -14.0) ->
 
 
 def trim_tiny(seg: AudioSegment, window_ms: int = 8) -> AudioSegment:
-    """Shave a few ms off both ends to reduce clicks, then rely on fades/seam."""
+    """Shave window_ms off BOTH ends."""
     if len(seg) <= window_ms * 2:
         return seg
     return seg[window_ms:-window_ms]
@@ -139,7 +196,8 @@ def trim_tiny(seg: AudioSegment, window_ms: int = 8) -> AudioSegment:
 
 def loop_seam_crossfade(seg: AudioSegment, seam_ms=20) -> AudioSegment:
     """
-    Loop-safe seam: blend the end into the start so repeats are cleaner than fade-out/fade-in.
+    Takes the tail (seam_ms) and crossfades it into the head.
+    This reduces total length by seam_ms.
     """
     seam_ms = int(seam_ms)
     if seam_ms <= 0 or len(seg) <= seam_ms * 2:
@@ -147,18 +205,18 @@ def loop_seam_crossfade(seg: AudioSegment, seam_ms=20) -> AudioSegment:
     head = seg[:seam_ms]
     tail = seg[-seam_ms:]
     body = seg[seam_ms:-seam_ms]
+    
+    # Append head to tail (blending)
     blended = tail.append(head, crossfade=seam_ms)
+    
+    # Reattach to body
     return body.append(blended, crossfade=seam_ms)
 
 
 # -----------------------------
-# De-dup for Variety
+# De-dup
 # -----------------------------
 def dedupe_by_bar_spacing(candidates, bar_starts_ms, min_bar_gap=4):
-    """
-    candidates: list[(score, start_ms, bar_len)]
-    Keep only candidates whose bar start is at least min_bar_gap away from previously selected.
-    """
     if not bar_starts_ms:
         return candidates
 
@@ -176,7 +234,7 @@ def dedupe_by_bar_spacing(candidates, bar_starts_ms, min_bar_gap=4):
 
 
 # -----------------------------
-# Loop Engine
+# Loop Engine (FIXED DRIFT)
 # -----------------------------
 def make_quantized_loops(
     stem_path: Path,
@@ -195,7 +253,6 @@ def make_quantized_loops(
     target_dbfs: float,
     out_dir: Path
 ):
-    """Generate multiple loops per stem, quantized to bar grid, ranked by RMS, de-duped by spacing."""
     if not stem_path.exists():
         return []
 
@@ -208,42 +265,65 @@ def make_quantized_loops(
     fade_ms = int(fade_ms)
     seam_ms = int(seam_ms)
     min_bar_gap = int(min_bar_gap)
+    
+    # Calculate extra audio needed to compensate for trim and seam
+    # trim_tiny removes 2x window (8ms start, 8ms end)
+    trim_window = 8 
+    needed_extra = 0
+    if loop_seam:
+        needed_extra += seam_ms
+    needed_extra += (trim_window * 2)
 
     grid = bar_starts_ms[::hop_bars] if bar_starts_ms else []
     candidates = []
 
     for bar_len in bar_lengths:
-        dur_ms = ms_per_bar * int(bar_len)
+        target_dur_ms = ms_per_bar * int(bar_len)
+        extract_dur_ms = target_dur_ms + needed_extra
+        
         for start_ms in grid:
-            if start_ms + dur_ms > len(audio):
+            if start_ms + extract_dur_ms > len(audio):
                 continue
-            seg = audio[start_ms:start_ms + dur_ms]
-            if len(seg) < dur_ms:
+            
+            # Extract WITH the buffer
+            seg = audio[start_ms : start_ms + extract_dur_ms]
+            
+            if len(seg) < extract_dur_ms:
                 continue
+                
+            # Score based on RMS
             candidates.append((rms_dbfs(seg), int(start_ms), int(bar_len)))
 
     candidates.sort(key=lambda x: x[0], reverse=True)
 
-    # limit candidates before dedupe
     if int(top_k) > 0:
         candidates = candidates[:int(top_k)]
 
-    # variety dedupe
     candidates = dedupe_by_bar_spacing(candidates, bar_starts_ms, min_bar_gap=min_bar_gap)
 
     exported = []
     for rank, (score, start_ms, bar_len) in enumerate(candidates[:loops_per_stem], start=1):
-        dur_ms = ms_per_bar * int(bar_len)
-        loop = audio[start_ms:start_ms + dur_ms]
+        target_dur_ms = ms_per_bar * int(bar_len)
+        extract_dur_ms = target_dur_ms + needed_extra
+        
+        loop = audio[start_ms : start_ms + extract_dur_ms]
 
-        loop = trim_tiny(loop, window_ms=8)
+        # 1. Trim Tiny (removes trim_window from start and end)
+        loop = trim_tiny(loop, window_ms=trim_window)
 
+        # 2. Seam or Fade
         if loop_seam:
             loop = loop_seam_crossfade(loop, seam_ms=seam_ms)
         else:
+            # If no seam, we just have extra audio hanging off the end. Trim it.
+            loop = loop[:target_dur_ms]
             if fade_ms > 0:
                 loop = loop.fade_in(fade_ms).fade_out(fade_ms)
 
+        # 3. Final Hard Quantize (Critical for DAW sync)
+        # Force length to be exactly the grid length
+        loop = loop[:target_dur_ms]
+
         loop = apply_loudness(loop, mode=loudness_mode, target_dbfs=float(target_dbfs))
 
         if bar_starts_ms:
@@ -298,6 +378,7 @@ def vocal_chops_silence(
     scored = [(rms_dbfs(c), c) for c in kept]
     scored.sort(key=lambda x: x[0], reverse=True)
 
+    out_dir.mkdir(parents=True, exist_ok=True)
     exported = []
     for i, (score, c) in enumerate(scored[:int(max_chops)], start=1):
         c = trim_tiny(c, window_ms=8)
@@ -371,6 +452,7 @@ def vocal_chops_onset(
     scored = [(rms_dbfs(s), s) for s in segments]
     scored.sort(key=lambda x: x[0], reverse=True)
 
+    out_dir.mkdir(parents=True, exist_ok=True)
     exported = []
     for i, (score, seg) in enumerate(scored[:int(max_chops)], start=1):
         seg = trim_tiny(seg, window_ms=8)
@@ -397,10 +479,6 @@ def vocal_chops_grid(
     target_dbfs: float = -14.0,
     rms_gate: int = 200
 ):
-    """
-    Grid chops snapped to BPM. Great for producer packs.
-    grid_size: half | 1beat | 2beat | 1bar
-    """
     if not vocals_path.exists():
         return []
 
@@ -424,6 +502,7 @@ def vocal_chops_grid(
 
     chops.sort(key=lambda x: x[0], reverse=True)
 
+    out_dir.mkdir(parents=True, exist_ok=True)
     exported = []
     for i, (score, seg) in enumerate(chops[:int(max_chops)], start=1):
         seg = trim_tiny(seg, 6)
@@ -443,12 +522,6 @@ def vocal_chops_grid(
 # Demucs Modes + Stem Mapping
 # -----------------------------
 def demucs_command(model_mode: str, audio_file: str):
-    """
-    Supported modes:
-      - "2stem": vocals + instrumental (no_vocals)
-      - "4stem": drums/bass/other/vocals
-      - "6stem": drums/bass/guitar/piano/other/vocals
-    """
     model_mode = (model_mode or "6stem").lower().strip()
 
     if model_mode == "2stem":
@@ -488,8 +561,16 @@ def map_stems(track_folder: Path, mode: str):
 # Phase 1: Analyze + Separate
 # -----------------------------
 def analyze_and_separate(file_input, url_input, stem_mode, manual_bpm):
-    audio_file = None
+    # --- CRITICAL FIX: CLEAN UP OLD RUNS TO PREVENT GHOST STEMS ---
+    if TEMP_DIR.exists():
+        try:
+            shutil.rmtree(TEMP_DIR, ignore_errors=True)
+        except Exception:
+            pass
+    TEMP_DIR.mkdir(parents=True, exist_ok=True)
+    # -------------------------------------------------------------
 
+    audio_file = None
     if url_input and len(url_input) > 5:
         print("Using Cloud Import...")
         try:
@@ -504,13 +585,15 @@ def analyze_and_separate(file_input, url_input, stem_mode, manual_bpm):
         raise gr.Error("No audio source found. Paste a link or upload a file.")
 
     try:
-        # cleanup output dirs
         if OUTPUT_DIR.exists():
-            shutil.rmtree(OUTPUT_DIR)
+            shutil.rmtree(OUTPUT_DIR, ignore_errors=True)
         (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)
 
+        audio_file = safe_copy_to_temp(audio_file)
+        audio_file = ensure_wav(audio_file)
+
         # BPM
         if manual_bpm and int(manual_bpm) > 0:
             bpm = int(manual_bpm)
@@ -522,12 +605,19 @@ def analyze_and_separate(file_input, url_input, stem_mode, manual_bpm):
         bpm = max(40, min(220, int(bpm)))
         print(f"Using BPM: {bpm}")
 
-        # Demucs separation
         cmd, demucs_model_folder = demucs_command(stem_mode, audio_file)
         print(f"Separating stems (mode={stem_mode})...")
-        subprocess.run(cmd, check=True, capture_output=True)
+        try:
+            run_demucs(cmd)
+        except gr.Error as e:
+            if (stem_mode or "").lower().strip() == "6stem":
+                print("6-stem failed; falling back to 4-stem htdemucs...")
+                stem_mode = "4stem"
+                cmd, demucs_model_folder = demucs_command(stem_mode, audio_file)
+                run_demucs(cmd)
+            else:
+                raise
 
-        # locate track folder
         demucs_out = TEMP_DIR / demucs_model_folder
         track_folder = next(demucs_out.iterdir(), None)
         if not track_folder:
@@ -535,7 +625,6 @@ def analyze_and_separate(file_input, url_input, stem_mode, manual_bpm):
 
         stems = map_stems(track_folder, stem_mode)
 
-        # preview outputs (6 slots)
         p_drums = str(stems["Drums"]) if "Drums" in stems and stems["Drums"].exists() else None
         p_bass = str(stems["Bass"]) if "Bass" in stems and stems["Bass"].exists() else None
         p_guitar = str(stems["Guitar"]) if "Guitar" in stems and stems["Guitar"].exists() else None
@@ -552,9 +641,6 @@ def analyze_and_separate(file_input, url_input, stem_mode, manual_bpm):
 
         return p_drums, p_bass, p_guitar, p_piano, p_other, p_vocals, bpm, str(track_folder), stem_mode
 
-    except subprocess.CalledProcessError as e:
-        err = e.stderr.decode("utf-8", errors="ignore") if e.stderr else str(e)
-        raise gr.Error(f"Demucs Failed: {err}")
     except Exception as e:
         raise gr.Error(f"Process Failed: {str(e)}")
 
@@ -593,9 +679,8 @@ def package_and_export(
         bpm = int(bpm)
         stems = map_stems(track_folder, stem_mode)
 
-        # cleanup output dirs
         if OUTPUT_DIR.exists():
-            shutil.rmtree(OUTPUT_DIR)
+            shutil.rmtree(OUTPUT_DIR, ignore_errors=True)
         (OUTPUT_DIR / "Stems").mkdir(parents=True, exist_ok=True)
         (OUTPUT_DIR / "Loops").mkdir(parents=True, exist_ok=True)
         (OUTPUT_DIR / "Vocal_Chops").mkdir(parents=True, exist_ok=True)
@@ -603,12 +688,10 @@ def package_and_export(
         export_stems = set(export_stems or [])
         loop_stems = set(loop_stems or [])
 
-        # export full stems (selected only)
         for name, path in stems.items():
             if name in export_stems and path.exists():
                 shutil.copy(path, OUTPUT_DIR / "Stems" / f"{bpm}BPM_Full_{name}.wav")
 
-        # build bar grid source preference
         grid_source = None
         for k in ("Drums", "Synths", "Instrumental", "Vocals", "Bass"):
             if k in stems and stems[k].exists():
@@ -619,7 +702,6 @@ def package_and_export(
 
         bar_starts_ms = detect_bar_grid(str(grid_source), bpm=bpm, max_seconds=240)
 
-        # parse bar lengths
         if not bar_lengths:
             bar_lengths = ["4", "8"]
         bar_lengths_int = sorted(list({int(x) for x in bar_lengths if str(x).strip().isdigit()}))
@@ -629,7 +711,6 @@ def package_and_export(
         loops_dir = OUTPUT_DIR / "Loops"
         all_loops = {}
 
-        # generate loops only for selected stems (excluding vocals)
         for stem_name, stem_path in stems.items():
             if stem_name == "Vocals":
                 continue
@@ -657,7 +738,6 @@ def package_and_export(
             )
             all_loops[stem_name] = exported
 
-        # vocals: chops (if enabled) else (optional) treat as loops if user included Vocals in loop list
         vocal_exports = []
         if "Vocals" in stems and stems["Vocals"].exists():
             if enable_vocal_chops:
@@ -702,7 +782,6 @@ def package_and_export(
                 else:
                     vocal_exports = []
             else:
-                # if chops disabled, user may still want vocal loops (treat vocals like a loop stem only if selected)
                 if "Vocals" in loop_stems:
                     vocal_exports = make_quantized_loops(
                         stem_path=stems["Vocals"],
@@ -724,7 +803,6 @@ def package_and_export(
 
         all_loops["Vocals"] = vocal_exports
 
-        # Promo video chooses first melodic-ish loop
         video_loop = None
         for key in ("Synths", "Piano", "Guitar", "Instrumental"):
             if all_loops.get(key):
@@ -752,7 +830,6 @@ def package_and_export(
             final_clip.write_videofile(str(vid_out), codec="libx264", audio_codec="aac", logger=None)
             video_path = str(vid_out)
 
-        # Manifest (so you can reproduce packs later)
         manifest = {
             "created_at": datetime.utcnow().isoformat() + "Z",
             "bpm": bpm,
@@ -780,7 +857,6 @@ def package_and_export(
         }
         (OUTPUT_DIR / "manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
 
-        # Zip pack
         zip_file = "NightPulse_Pack.zip"
         with zipfile.ZipFile(zip_file, "w") as zf:
             for root, dirs, files in os.walk(OUTPUT_DIR):
@@ -958,4 +1034,4 @@ with gr.Blocks(title="Night Pulse | Studio Pro") as app:
     )
 
 if __name__ == "__main__":
-    app.launch()
+    app.launch()