Update app.py

app.py

@@ -11,26 +11,20 @@ from pathlib import Path
 import sys
 
 # --- Configuration ---
-# We use Path objects for robust cross-platform compatibility
 OUTPUT_DIR = Path("nightpulse_output")
 TEMP_DIR = Path("temp_processing")
 
 def process_track(audio_file, cover_art_image):
-    """
-    Main pipeline function.
-    Returns: (zip_path, video_path)
-    """
-    # Initialize return variables to None to prevent 'UnboundLocalError'
+    # Initialize return variables
     zip_path = None
     video_path = None
 
     try:
-        # --- 0. Input Validation (Robustness Check) ---
+        # --- 0. Input Validation ---
         if not audio_file:
-            raise ValueError("No audio file provided. Please upload a track.")
+            raise ValueError("No audio file provided.")
             
         # --- 1. Setup Directories ---
-        # Clean previous runs to prevent file mixing
         if OUTPUT_DIR.exists():
             shutil.rmtree(OUTPUT_DIR)
         if TEMP_DIR.exists():
@@ -43,25 +37,24 @@ def process_track(audio_file, cover_art_image):
         # --- 2. Analyze BPM & Key (Librosa) ---
         print(f"Analyzing {filename}...")
         try:
-            # Load 60s for better context, mono=True for BPM analysis
+            # Mono load for robust BPM detection
             y, sr = librosa.load(audio_file, duration=60, mono=True)
             tempo, _ = librosa.beat.beat_track(y=y, sr=sr)
             
-            # Robustness: Handle different librosa versions returning array vs float
+            # Handle different librosa return types (float vs array)
             if np.ndim(tempo) > 0:
                 detected_bpm = int(round(tempo[0]))
             else:
                 detected_bpm = int(round(tempo))
-                
             print(f"Detected BPM: {detected_bpm}")
         except Exception as e:
-            print(f"BPM Detection Warning: {e}")
+            print(f"BPM Warning: {e}")
             detected_bpm = 120 # Safe Fallback
         
         # --- 3. AI Stem Separation (Demucs) ---
-        print("Separating stems with Demucs...")
+        print("Separating stems...")
         try:
-            # We call demucs as a module using sys.executable to ensure we use the correct python environment
+            # Call Demucs via subprocess to ensure clean execution
             subprocess.run([
                 sys.executable, "-m", "demucs", 
                 "-n", "htdemucs", 
@@ -69,111 +62,89 @@ def process_track(audio_file, cover_art_image):
                 audio_file
             ], check=True, capture_output=True)
         except subprocess.CalledProcessError as e:
-            # Capture the specific error from the subprocess
-            raise RuntimeError(f"Demucs processing failed. Error: {e.stderr.decode()}")
+            raise RuntimeError(f"Demucs failed: {e.stderr.decode()}")
         
-        # Locate separated stems (Robust Path Finding)
+        # Locate Stems (Robust Search)
         demucs_out = TEMP_DIR / "htdemucs"
-        # Demucs might normalize filenames (spaces -> underscores), so we just find the first folder
         track_folder = next(demucs_out.iterdir(), None)
         
         if not track_folder:
-             raise FileNotFoundError("Demucs output folder could not be found.")
+             raise FileNotFoundError("Demucs output folder missing.")
 
         drums_path = track_folder / "drums.wav"
         melody_path = track_folder / "other.wav"
         bass_path = track_folder / "bass.wav"
-        
-        if not drums_path.exists():
-            raise FileNotFoundError(f"Stems were not generated in {track_folder}")
 
-        # --- 4. Loop Logic (Pydub) ---
-        # Calculate duration of 8 bars in milliseconds
+        # --- 4. Loop Logic ---
         if detected_bpm <= 0: detected_bpm = 120
         ms_per_beat = (60 / detected_bpm) * 1000
         eight_bars_ms = ms_per_beat * 4 * 8
         
         def create_loop(source_path, output_name):
-            if not source_path.exists():
-                return None, None
-                
-            audio = AudioSegment.from_wav(str(source_path))
+            if not source_path.exists(): return None, None
             
-            # Smart Chop: Grab the "middle" 8 bars to avoid intro/outro silence
-            start_time = len(audio) // 3 
-            end_time = start_time + eight_bars_ms
+            audio = AudioSegment.from_wav(str(source_path))
+            # Grab middle 8 bars
+            start = len(audio) // 3
+            end = start + eight_bars_ms
             
-            # Safety check if audio is shorter than 8 bars
-            if len(audio) < end_time:
-                start_time = 0
-                end_time = min(len(audio), eight_bars_ms)
+            if len(audio) < end:
+                start = 0
+                end = min(len(audio), eight_bars_ms)
                 
-            loop = audio[start_time:end_time]
-            # 15ms fade to prevent clicks
-            loop = loop.fade_in(15).fade_out(15).normalize() 
-            
-            out_filename = f"{detected_bpm}BPM_{output_name}.wav"
-            out_file = OUTPUT_DIR / out_filename
-            loop.export(out_file, format="wav")
-            return out_file, loop
+            loop = audio[start:int(end)].fade_in(15).fade_out(15).normalize()
+            out_name = OUTPUT_DIR / f"{detected_bpm}BPM_{output_name}.wav"
+            loop.export(out_name, format="wav")
+            return out_name, loop
 
-        # Generate Loops
-        loop_drums_path, _ = create_loop(drums_path, "DrumLoop")
-        loop_melody_path, melody_audio = create_loop(melody_path, "MelodyLoop")
+        loop_drums, _ = create_loop(drums_path, "DrumLoop")
+        loop_melody, _ = create_loop(melody_path, "MelodyLoop")
         create_loop(bass_path, "BassLoop")
         
-        # --- 5. Video Generation (MoviePy) ---
-        # Logic: Only generate video if User uploaded Art AND we successfully made a melody loop
-        if cover_art_image is not None and loop_melody_path is not None:
-            print("Rendering Promo Video...")
+        # --- 5. Video Generation ---
+        if cover_art_image and loop_melody:
+            print("Rendering Video...")
             try:
-                video_out_path = OUTPUT_DIR / "Promo_Video_Reel.mp4"
-                
-                audio_clip = AudioFileClip(str(loop_melody_path))
-                image_clip = ImageClip(cover_art_image)
-                
-                # Resize logic: Fit to width 1080 (standard), maintain aspect ratio
-                image_clip = image_clip.resize(width=1080)
+                vid_out = OUTPUT_DIR / "Promo_Video.mp4"
+                audio_clip = AudioFileClip(str(loop_melody))
+                img_clip = ImageClip(cover_art_image)
                 
-                # Set duration to match audio loop
-                image_clip = image_clip.set_duration(audio_clip.duration)
-                image_clip = image_clip.set_audio(audio_clip)
-                image_clip.fps = 24
+                # Resize to 1080w (maintain aspect ratio)
+                img_clip = img_clip.resize(width=1080)
+                img_clip = img_clip.set_duration(audio_clip.duration)
+                img_clip = img_clip.set_audio(audio_clip)
+                img_clip.fps = 24
                 
-                image_clip.write_videofile(str(video_out_path), codec="libx264", audio_codec="aac", logger=None)
-                video_path = str(video_out_path)
+                img_clip.write_videofile(str(vid_out), codec="libx264", audio_codec="aac", logger=None)
+                video_path = str(vid_out)
             except Exception as e:
-                print(f"Video generation skipped due to error: {e}")
-                # We don't fail the whole pipeline here, we just skip the video part
-                video_path = None
-        
-        # --- 6. Zip It Up ---
-        zip_file_path = "NightPulse_Pack.zip"
-        with zipfile.ZipFile(zip_file_path, 'w') as zipf:
-            for file in OUTPUT_DIR.iterdir():
-                zipf.write(file, file.name)
-        zip_path = zip_file_path
+                print(f"Video skipped: {e}")
+
+        # --- 6. Zip Export ---
+        zip_file = "NightPulse_Pack.zip"
+        with zipfile.ZipFile(zip_file, 'w') as zf:
+            for f in OUTPUT_DIR.iterdir():
+                zf.write(f, f.name)
+        zip_path = zip_file
         
         return zip_path, video_path
 
     except Exception as e:
-        # This catches ANY crash and shows it in the UI as a red Error box
         raise gr.Error(f"System Error: {str(e)}")
 
-# --- UI Definition ---
+# --- UI Definition (Corrected) ---
 iface = gr.Interface(
     fn=process_track,
     inputs=[
-        gr.Audio(type="filepath", label="Upload Suno Track (MP3/WAV)"),
-        gr.Image(type="filepath", label="Upload Cover Art (Optional)")
+        gr.Audio(type="filepath", label="Upload Suno Track"),
+        gr.Image(type="filepath", label="Upload Cover Art")
     ],
     outputs=[
-        gr.File(label="Download Completed Pack (ZIP)"),
-        gr.Video(label="Preview Promo Video")
+        gr.File(label="Download ZIP"),
+        gr.Video(label="Preview Video")
     ],
     title="Night Pulse Audio | Automator",
-    description="<b>Night Pulse Pipeline v1.0</b><br>Upload a Suno track to automatically separate stems, normalize, chop loops, and generate a promo video.",
-    theme="default"
+    description="Night Pulse Pipeline v1.1 (Stable)"
 )
 
 if __name__ == "__main__":