Update server.py

server.py

@@ -12,7 +12,6 @@ from typing import List, Dict, Optional, Tuple
 
 from fastapi import FastAPI, HTTPException
 from fastapi.responses import JSONResponse
-from contextlib import asynccontextmanager
 import uvicorn
 
 try:
@@ -33,15 +32,7 @@ if not HF_TOKEN:
     print("Error: Missing HF_TOKEN in .env")
     exit(1)
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Load Whisper in background, then kick off video processing."""
-    loop = asyncio.get_event_loop()
-    await loop.run_in_executor(None, _load_whisper_model)
-    asyncio.create_task(scan_and_process_videos())
-    yield
-
-app = FastAPI(title="Video Processing Service", lifespan=lifespan)
+app = FastAPI(title="Video Processing Service")
 
 # Global state
 processing_state = {
@@ -244,7 +235,6 @@ def process_video_segment(
     4. Mux processed video with original audio
     """
     ffmpeg_video_proc = None
-    cap = None  # Declared here so finally block can always release it
     temp_wav = output_path.replace(".mp4", "_audio.wav")
     temp_video_path = output_path.replace(".mp4", "_noaudio.mp4")
 
@@ -334,7 +324,7 @@ def process_video_segment(
             frame = cv2.resize(frame, (target_width, target_height), interpolation=cv2.INTER_LANCZOS4)
             frame = apply_color_grading_wedding_retro(frame)
 
-            # Set caption for this frame (empty if none)
+            # Set caption for this frame (empty if none).
             current_caption = frame_caption_map.get(processed_frames, "")
 
             if current_caption:
@@ -347,9 +337,9 @@ def process_video_segment(
                 progress = (processed_frames / target_frames) * 100
                 print(f"Progress: {progress:.1f}%")
 
-        # Close stdin and wait for FFmpeg to finish encoding
         ffmpeg_video_proc.stdin.close()
         ffmpeg_video_proc.wait()
+        cap.release()
 
         if ffmpeg_video_proc.returncode != 0:
             print(f"✗ FFmpeg video encoding failed (code {ffmpeg_video_proc.returncode})")
@@ -398,10 +388,6 @@ def process_video_segment(
         return False
 
     finally:
-        # Always release VideoCapture regardless of success or failure
-        if cap is not None:
-            cap.release()
-        # Always clean up temp files
         for tmp in [temp_video_path, temp_wav]:
             if tmp and os.path.exists(tmp):
                 try:
@@ -453,12 +439,11 @@ async def process_movie_segments(movie_name: str) -> bool:
             print(f"No segment JSON files found for {movie_name}")
             return False
 
-        print(f"Found {len(segment_files)} segments: {segment_files}")
+        print(f"Found {len(segment_files)} segments")
         temp_dir = tempfile.mkdtemp()
 
         try:
             for segment_file in segment_files:
-                print(f"\n── Processing file: {segment_file}")
                 try:
                     segment_path = hf_hub_download(
                         repo_id=HF_DATASET_REPO,
@@ -475,7 +460,7 @@ async def process_movie_segments(movie_name: str) -> bool:
                     start_time = segment_data.get("start_time", "00:00:00")
                     end_time = segment_data.get("end_time", "00:10:00")
 
-                    print(f"Processing segment {segment_number}: {start_time} to {end_time}")
+                    print(f"\nProcessing segment {segment_number}: {start_time} to {end_time}")
 
                     output_filename = f"segment-{segment_number:02d}.mp4"
                     output_path = os.path.join(temp_dir, output_filename)
@@ -488,8 +473,7 @@ async def process_movie_segments(movie_name: str) -> bool:
                     )
 
                     if not success:
-                        print(f"✗ Failed to process segment {segment_number}, continuing to next...")
-                        processing_state["error_count"] += 1
+                        print(f"Failed to process segment {segment_number}")
                         continue
 
                     upload_path = f"{READY_VIDEOS_FOLDER}/{movie_name}/{output_filename}"
@@ -505,15 +489,8 @@ async def process_movie_segments(movie_name: str) -> bool:
                     )
                     print(f"✓ Segment {segment_number} uploaded successfully")
 
-                    # Clean up the output file after successful upload
-                    if os.path.exists(output_path):
-                        try:
-                            os.remove(output_path)
-                        except Exception:
-                            pass
-
                 except Exception as e:
-                    print(f"✗ Error processing segment file {segment_file}: {e}")
+                    print(f"✗ Error processing segment: {e}")
                     processing_state["error_count"] += 1
                     continue
 
@@ -529,7 +506,7 @@ async def process_movie_segments(movie_name: str) -> bool:
     except Exception as e:
         processing_state["error_count"] += 1
         processing_state["last_error"] = str(e)
-        print(f"✗ Error in process_movie_segments: {e}")
+        print(f"✗ Error: {e}")
         return False
 
 
@@ -539,7 +516,8 @@ async def scan_and_process_videos():
         print("Video processing already running, skipping...")
         return
 
-    startup_delay = int(os.getenv("STARTUP_DELAY", 5))
+    # Wait for Space to fully initialize (reduced for testing)
+    startup_delay = int(os.getenv("STARTUP_DELAY", 5))  # Default 5 seconds for testing
     print(f"Waiting {startup_delay} seconds before starting video processing...")
     await asyncio.sleep(startup_delay)
 
@@ -562,7 +540,7 @@ async def scan_and_process_videos():
                 if len(parts) >= 2:
                     movie_folders.add(parts[1])
 
-        print(f"Found {len(movie_folders)} movies to process: {sorted(movie_folders)}")
+        print(f"Found {len(movie_folders)} movies to process")
 
         for movie_name in sorted(movie_folders):
             await process_movie_segments(movie_name)
@@ -575,13 +553,21 @@ async def scan_and_process_videos():
         print("="*80 + "\n")
 
     except Exception as e:
-        print(f"Critical error in scan_and_process_videos: {e}")
+        print(f"Critical error: {e}")
         processing_state["last_error"] = str(e)
     finally:
         processing_state["is_running"] = False
-        processing_state["current_file"] = None
 
 
+@app.on_event("startup")
+async def startup_event():
+    """Load Whisper in background, then kick off video processing after 3 min."""
+    loop = asyncio.get_event_loop()
+    # Load Whisper model in thread so it doesn't block the event loop / health check
+    await loop.run_in_executor(None, _load_whisper_model)
+    # Kick off processing task (has its own 3-min delay inside)
+    asyncio.create_task(scan_and_process_videos())
+
 
 @app.get("/")
 async def health():
@@ -632,5 +618,5 @@ async def trigger_processing():
 
 if __name__ == "__main__":
     print("Starting Video Processing Service on port 7860...")
-    print("Whisper will load at startup, processing begins after startup delay")
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    print("Whisper will load at startup, processing begins 3 minutes after")
+    uvicorn.run(app, host="0.0.0.0", port=7860)