Upload 13 files

Dockerfile

@@ -1,7 +1,7 @@
 # TrendClip Video Composer Server
 # FastAPI server for scene selection and video composition
 
-FROM python:3.11-slim  
+FROM python:3.13-slim
 
 # Set working directory
 WORKDIR /app/composer

composer_v2.py

@@ -303,6 +303,42 @@ def get_font(size: int) -> ImageFont.FreeTypeFont:
 # TEXT DRAWING
 # ---------------------------------------------------------------------------
 
+def wrap_text(text: str, font, max_width: int = 900) -> str:
+    """
+    Wrap text to fit within max_width pixels.
+    Breaks long lines into multiple lines.
+    """
+    from PIL import ImageDraw
+    temp_draw = ImageDraw.Draw(Image.new("RGB", (1, 1)))
+    
+    lines = text.split("\n")
+    wrapped_lines = []
+    
+    for line in lines:
+        if not line.strip():
+            wrapped_lines.append("")
+            continue
+            
+        words = line.split()
+        current_line = ""
+        
+        for word in words:
+            test_line = current_line + (" " if current_line else "") + word
+            bbox = temp_draw.textbbox((0, 0), test_line, font=font)
+            width = bbox[2] - bbox[0]
+            
+            if width <= max_width:
+                current_line = test_line
+            else:
+                if current_line:
+                    wrapped_lines.append(current_line)
+                current_line = word
+        
+        if current_line:
+            wrapped_lines.append(current_line)
+    
+    return "\n".join(wrapped_lines)
+
 def draw_text_stroked(draw, text, pos, font, align="left", opacity=1.0):
     """White text with stroke, drop shadow, and opacity."""
     x, y = pos
@@ -363,6 +399,9 @@ def render_text_frame(cfg: dict, frame: int, total_frames: int) -> Image.Image:
     layer = Image.new("RGBA", (w, h), (0, 0, 0, 0))
     draw  = ImageDraw.Draw(layer)
     font  = get_font(tcfg["font_size"])
+    
+    # Wrap text to fit screen width
+    wrapped_label = wrap_text(label, font, max_width=900)
 
     if ttype == "quick_center_pop" or ttype == "center_stroke_pop":
         entry_f = tcfg["entry_frame"]
@@ -376,19 +415,19 @@ def render_text_frame(cfg: dict, frame: int, total_frames: int) -> Image.Image:
             opacity  = min(1.0, progress * 1.5)
             x = w // 2
             y = h // 2
-            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=opacity)
+            draw_text_stroked(draw, wrapped_label, (x, y), font, align="center", opacity=opacity)
         elif frame < fade_start:
             # Hold full opacity
             x = w // 2
             y = h // 2
-            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=1.0)
+            draw_text_stroked(draw, wrapped_label, (x, y), font, align="center", opacity=1.0)
         else:
             # Fade out quickly
             fade_progress = min(1.0, (frame - fade_start) / 4)
             opacity = 1.0 - fade_progress
             x = w // 2
             y = h // 2
-            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=opacity)
+            draw_text_stroked(draw, wrapped_label, (x, y), font, align="center", opacity=opacity)
 
     elif ttype == "center_pop" or ttype == "center_fade_pop":
         entry_f = tcfg["entry_frame"]
@@ -402,17 +441,17 @@ def render_text_frame(cfg: dict, frame: int, total_frames: int) -> Image.Image:
             opacity  = min(1.0, progress * 1.5)
             x = w // 2
             y = h // 2
-            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=opacity)
+            draw_text_stroked(draw, wrapped_label, (x, y), font, align="center", opacity=opacity)
         elif frame < fade_start:
             x = w // 2
             y = h // 2
-            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=1.0)
+            draw_text_stroked(draw, wrapped_label, (x, y), font, align="center", opacity=1.0)
         else:
             fade_progress = min(1.0, (frame - fade_start) / 4)
             opacity = 1.0 - fade_progress
             x = w // 2
             y = h // 2
-            draw_text_stroked(draw, label, (x, y), font, align="center", opacity=opacity)
+            draw_text_stroked(draw, wrapped_label, (x, y), font, align="center", opacity=opacity)
 
     return layer
 
@@ -459,12 +498,22 @@ def render():
     
     # Load SCENE_CONFIG from JSON if provided via environment variable
     config_path = os.environ.get("COMPOSER_MANIFEST_CONFIG")
-    if config_path and os.path.exists(config_path):
-        print(f"\n[INFO] Loading config from: {config_path}")
-        with open(config_path, "r") as f:
-            manifest_data = json.load(f)
-            SCENE_CONFIG = manifest_data.get("scenes", SCENE_CONFIG)
-        print(f"[INFO] Loaded {len(SCENE_CONFIG)} scenes from manifest")
+    if config_path:
+        # Try as absolute path first, then relative
+        if not os.path.isabs(config_path):
+            config_path = os.path.abspath(config_path)
+        
+        if os.path.exists(config_path):
+            print(f"[INFO] Loading config from: {config_path}")
+            try:
+                with open(config_path, "r") as f:
+                    manifest_data = json.load(f)
+                    SCENE_CONFIG = manifest_data.get("scenes", SCENE_CONFIG)
+                print(f"[INFO] Loaded {len(SCENE_CONFIG)} scenes from manifest")
+            except Exception as e:
+                print(f"[WARN] Failed to load config: {e}")
+        else:
+            print(f"[WARN] Config file not found: {config_path}")
     
     w, h = RESOLUTION
     Path(os.path.dirname(OUTPUT_PATH)).mkdir(parents=True, exist_ok=True)
@@ -478,7 +527,7 @@ def render():
     )
 
     print(f"\n{'='*55}")
-    print(f"  Sunset Reel (Fast-Paced)")
+    print(f"  Dynamic Video Composer")
     print(f"  {len(SCENE_CONFIG)} scenes | {FPS}fps | {w}x{h}")
     print(f"{'='*55}\n")
 
@@ -486,9 +535,12 @@ def render():
     print("[1/3] Loading + grading images...")
     base_images = []
     for cfg in SCENE_CONFIG:
+        print(f"  Loading scene {cfg['idx']}...", end=" ", flush=True)
         raw  = load_scene_image(cfg["idx"])
+        print(f"grading...", end=" ", flush=True)
         graded = grade_image(raw, cfg["grade"])
         base_images.append(graded)
+        print(f"ok", flush=True)
     print("    [OK] Done\n")
 
     # Render scenes

example_manifest.json

@@ -0,0 +1,56 @@
+{
+  "scenes": [
+    {
+      "label": "which type of anger do you have?",
+      "score": 0.95,
+      "duration_s": 4.7
+    },
+    {
+      "label": "shouting",
+      "score": 0.92,
+      "duration_s": 2.3
+    },
+    {
+      "label": "revenge",
+      "score": 0.88,
+      "duration_s": 2.3
+    },
+    {
+      "label": "ignoring",
+      "score": 0.85,
+      "duration_s": 2.3
+    },
+    {
+      "label": "slamming",
+      "score": 0.90,
+      "duration_s": 2.3
+    },
+    {
+      "label": "cursing",
+      "score": 0.87,
+      "duration_s": 2.3
+    },
+    {
+      "label": "walking away",
+      "score": 0.89,
+      "duration_s": 2.3
+    },
+    {
+      "label": "fighting",
+      "score": 0.84,
+      "duration_s": 2.3
+    },
+    {
+      "label": "crying",
+      "score": 0.91,
+      "duration_s": 2.3
+    }
+  ],
+  "metadata": {
+    "topic": "anger psychology",
+    "version": "1.0",
+    "created_at": "2026-05-31",
+    "content_type": "educational"
+  },
+  "candidates_path": "workspace/renders/candidates"
+}

full_pipeline.py

@@ -0,0 +1,545 @@
+"""
+Full Pipeline: Prompt → Manifest → Images → Selection → Composition
+Orchestrates the complete workflow from user prompt to final MP4 video
+"""
+
+import requests
+import json
+import os
+from pathlib import Path
+from PIL import Image
+from io import BytesIO
+import asyncio
+import subprocess
+import sys
+from datetime import datetime
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Configuration
+# ─────────────────────────────────────────────────────────────────────────
+
+MANIFEST_SERVER = "https://factorstudios-content-gen.hf.space"
+IMAGE_SERVER = "https://factorstudios-pinteresting.hf.space"
+PIPELINE_DIR = Path(__file__).parent
+CANDIDATES_DIR = PIPELINE_DIR / "candidates"
+SELECTED_DIR = PIPELINE_DIR / "selected"
+RENDERS_DIR = PIPELINE_DIR / "renders"
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Step 1: Generate Manifest from Prompt
+# ─────────────────────────────────────────────────────────────────────────
+
+async def step_generate_manifest(prompt: str, output_dir: Path = PIPELINE_DIR) -> dict:
+    """
+    Call content-gen server to generate manifest from prompt.
+    Saves manifest to manifest_response.json
+    
+    Args:
+        prompt (str): User prompt describing video content
+        output_dir (Path): Directory to save manifest
+        
+    Returns:
+        dict: Manifest with title and scenes
+    """
+    print("\n" + "="*70)
+    print(f"[STEP 1] Generating Manifest from Prompt")
+    print("="*70)
+    print(f"Prompt: {prompt[:80]}...")
+    
+    try:
+        # Call manifest generation server
+        payload = {"prompt": prompt}
+        print(f"Calling {MANIFEST_SERVER}/generate...")
+        
+        response = requests.post(
+            f"{MANIFEST_SERVER}/generate",
+            json=payload,
+            timeout=60
+        )
+        response.raise_for_status()
+        manifest = response.json()
+        
+        # Save manifest to file
+        manifest_path = output_dir / "manifest_response.json"
+        with open(manifest_path, "w") as f:
+            json.dump(manifest, f, indent=2)
+        
+        scenes = manifest.get("scenes", [])
+        print(f"✓ Generated manifest with {len(scenes)} scenes")
+        print(f"✓ Saved to {manifest_path.name}")
+        
+        # Print scene details
+        for idx, scene in enumerate(scenes):
+            label = scene.get("label", f"Scene {idx}")
+            query = scene.get("image_query", "")
+            print(f"  Scene {idx}: {label} (query: '{query[:30]}...')")
+        
+        return manifest
+        
+    except Exception as e:
+        print(f"✗ Failed to generate manifest: {e}")
+        raise
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Step 2: Download Images for Each Scene
+# ─────────────────────────────────────────────────────────────────────────
+
+async def step_download_images(
+    manifest: dict,
+    output_dir: Path = CANDIDATES_DIR,
+    images_per_scene: int = 5
+) -> int:
+    """
+    Download images from pinteresting server for each scene in manifest.
+    IMPORTANT: Downloads image for TITLE (scene 0) + all scenes in manifest.scenes
+    Follows the pattern from test_api.py
+    
+    Args:
+        manifest (dict): Manifest with title and scenes
+        output_dir (Path): Base directory to organize images
+        images_per_scene (int): Number of images per scene
+        
+    Returns:
+        int: Total number of images downloaded
+    """
+    print("\n" + "="*70)
+    print(f"[STEP 2] Downloading Images (Title + Scenes)")
+    print("="*70)
+    
+    # Clear and recreate candidates directory
+    if output_dir.exists():
+        import shutil
+        shutil.rmtree(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    total_downloaded = 0
+    
+    # STEP 2.0: Download image for TITLE (becomes scene_0)
+    title = manifest.get("title", "")
+    if title:
+        scene_dir = output_dir / "scene_0"
+        scene_dir.mkdir(parents=True, exist_ok=True)
+        
+        print(f"\n[Scene 0] {title} (TITLE/INTRO)")
+        print(f"  Query: {title}")
+        
+        try:
+            payload = {
+                "keyword": title,
+                "count": images_per_scene
+            }
+            
+            print(f"  Calling {IMAGE_SERVER}/scrape...")
+            response = requests.post(
+                f"{IMAGE_SERVER}/scrape",
+                json=payload,
+                timeout=60
+            )
+            response.raise_for_status()
+            data = response.json()
+            images = data.get("images", [])
+            
+            print(f"  Downloaded {len(images)} images")
+            
+            for img_idx, img_url in enumerate(images):
+                try:
+                    img_response = requests.get(img_url, timeout=30)
+                    if img_response.status_code == 200:
+                        img_path = scene_dir / f"candidate_{img_idx:02d}.jpg"
+                        with open(img_path, "wb") as f:
+                            f.write(img_response.content)
+                        total_downloaded += 1
+                except Exception as e:
+                    print(f"    ⚠  Failed to save image {img_idx}: {e}")
+                    
+        except Exception as e:
+            print(f"  ⚠  Error downloading images for title: {e}")
+    
+    # STEP 2.1: Download images for each content scene (becomes scene_1, scene_2, etc)
+    scenes = manifest.get("scenes", [])
+    
+    for scene_idx, scene in enumerate(scenes):
+        actual_idx = scene_idx + 1  # scene_1, scene_2, etc (title is scene_0)
+        scene_label = scene.get("label", f"Scene {actual_idx}")
+        image_query = scene.get("image_query", "")
+        
+        if not image_query:
+            print(f"\n[Scene {actual_idx}] ⚠  No image query found, skipping...")
+            continue
+        
+        # Create scene-specific folder
+        scene_dir = output_dir / f"scene_{actual_idx}"
+        scene_dir.mkdir(parents=True, exist_ok=True)
+        
+        print(f"\n[Scene {actual_idx}] {scene_label}")
+        print(f"  Query: {image_query}")
+        
+        # Fetch images from pinteresting API
+        try:
+            payload = {
+                "keyword": image_query,
+                "count": images_per_scene
+            }
+            
+            print(f"  Calling {IMAGE_SERVER}/scrape...")
+            response = requests.post(
+                f"{IMAGE_SERVER}/scrape",
+                json=payload,
+                timeout=60
+            )
+            response.raise_for_status()
+            data = response.json()
+            
+            if data.get("success"):
+                images = data.get("images", [])
+                print(f"  ✓ Found {len(images)} images")
+                
+                # Download each image
+                for img_idx, img_data in enumerate(images):
+                    img_url = img_data.get("url")
+                    if not img_url:
+                        continue
+                    
+                    try:
+                        # Download image
+                        img_response = requests.get(img_url, timeout=15)
+                        img_response.raise_for_status()
+                        
+                        # Verify it's a valid image
+                        img = Image.open(BytesIO(img_response.content))
+                        
+                        # Save image
+                        file_name = f"candidate_{img_idx:02d}.jpg"
+                        file_path = scene_dir / file_name
+                        
+                        with open(file_path, "wb") as f:
+                            f.write(img_response.content)
+                        
+                        size_kb = len(img_response.content) / 1024
+                        dims = f"{img_data.get('width', '?')}x{img_data.get('height', '?')}"
+                        print(f"    ✓ {file_name} ({dims}, {size_kb:.0f}KB)")
+                        total_downloaded += 1
+                        
+                    except Exception as e:
+                        print(f"    ✗ Image {img_idx} failed: {e}")
+            else:
+                print(f"  ✗ API Error: {data.get('message')}")
+                
+        except Exception as e:
+            print(f"  ✗ Request failed: {e}")
+    
+    print(f"\n✓ Downloaded {total_downloaded} images total")
+    return total_downloaded
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Step 3: Select Best Image from Each Scene's Candidates
+# ─────────────────────────────────────────────────────────────────��───────
+
+async def step_select_scenes(manifest: dict, candidates_dir: Path = CANDIDATES_DIR) -> dict:
+    """
+    Select best image from each scene's candidate folder.
+    IMPORTANT: Selects from TITLE (scene_0) + all scenes in manifest.scenes
+    Evaluates by file size (largest = best quality).
+    
+    Args:
+        manifest (dict): Manifest with scene count
+        candidates_dir (Path): Directory with candidate images
+        
+    Returns:
+        dict: Selection results
+    """
+    print("\n" + "="*70)
+    print(f"[STEP 3] Selecting Best Images from Candidates")
+    print("="*70)
+    
+    # Ensure selected directory exists
+    SELECTED_DIR.mkdir(parents=True, exist_ok=True)
+    
+    scenes = manifest.get("scenes", [])
+    selected_count = 0
+    
+    # Select from scene_0 (title) through scene_N (content scenes)
+    # Total scenes = len(scenes) + 1 (for title as scene_0)
+    total_scene_count = len(scenes) + 1
+    
+    for scene_idx in range(total_scene_count):
+        scene_folder = candidates_dir / f"scene_{scene_idx}"
+        
+        if not scene_folder.exists():
+            if scene_idx == 0:
+                print(f"[Scene {scene_idx}] ✗ No candidates found (TITLE)")
+            else:
+                print(f"[Scene {scene_idx}] ✗ No candidates found")
+            continue
+        
+        # Find largest image (best quality)
+        images = list(scene_folder.glob("*.jpg"))
+        if not images:
+            if scene_idx == 0:
+                print(f"[Scene {scene_idx}] ✗ No JPEG images found (TITLE)")
+            else:
+                print(f"[Scene {scene_idx}] ✗ No JPEG images found")
+            continue
+        
+        best_img = max(images, key=lambda p: p.stat().st_size)
+        size_kb = best_img.stat().st_size / 1024
+        
+        # Copy to selected folder
+        selected_path = SELECTED_DIR / f"scene_{scene_idx:02d}.jpg"
+        import shutil
+        shutil.copy2(best_img, selected_path)
+        
+        if scene_idx == 0:
+            print(f"[Scene {scene_idx}] ✓ Selected {best_img.name} ({size_kb:.0f}KB) [TITLE]")
+        else:
+            print(f"[Scene {scene_idx}] ✓ Selected {best_img.name} ({size_kb:.0f}KB)")
+        selected_count += 1
+    
+    print(f"\n✓ Selected {selected_count} images ({total_scene_count} total: title + {len(scenes)} scenes)")
+    
+    return {
+        "status": "success",
+        "selected": selected_count,
+        "total": total_scene_count
+    }
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Step 4: Compose Video with Selected Images and Manifest
+# ─────────────────────────────────────────────────────────────────────────
+
+async def step_compose_video(manifest: dict) -> dict:
+    """
+    Compose final video using selected images and manifest labels.
+    Calls the FastAPI /compose endpoint which handles scene config generation.
+    
+    Args:
+        manifest (dict): Manifest with title and scenes
+        
+    Returns:
+        dict: Composition results with video path and metadata
+    """
+    print("\n" + "="*70)
+    print(f"[STEP 4] Composing Video from Selected Images")
+    print("="*70)
+    
+    scenes = manifest.get("scenes", [])
+    selected_images = sorted(SELECTED_DIR.glob("scene_*.jpg"))
+    
+    print(f"Manifest title: {manifest.get('title', 'Untitled')}")
+    print(f"Selected images: {len(selected_images)}")
+    print(f"Required images: {len(scenes) + 1} (title + {len(scenes)} scenes)")
+    
+    # Expected: title + all scenes
+    expected_images = len(scenes) + 1
+    if len(selected_images) != expected_images:
+        raise Exception(
+            f"Image count mismatch: expected {expected_images}, "
+            f"found {len(selected_images)}"
+        )
+    
+    # Call the FastAPI /compose endpoint
+    print(f"\nCalling /compose endpoint...")
+    
+    try:
+        payload = {
+            "title": manifest.get("title", "Untitled"),
+            "scenes": [
+                {
+                    "label": s.get("label", f"Scene {idx}"),
+                    "image_query": s.get("image_query", "")
+                }
+                for idx, s in enumerate(scenes)
+            ]
+        }
+        
+        response = requests.post(
+            f"http://localhost:7860/compose",
+            json=payload,
+            timeout=300
+        )
+        
+        if response.status_code != 200:
+            error_data = response.json() if response.headers.get("content-type") == "application/json" else response.text
+            print(f"✗ Server returned {response.status_code}: {error_data}")
+            raise Exception(f"Compose endpoint failed: {error_data}")
+        
+        # Check if response is binary (video file) or JSON
+        if response.headers.get("content-type", "").startswith("video"):
+            # Save video file
+            output_path = PIPELINE_DIR / "output_video.mp4"
+            with open(output_path, "wb") as f:
+                f.write(response.content)
+            
+            size_mb = output_path.stat().st_size / (1024 * 1024)
+            print(f"✓ Video saved: {output_path.name} ({size_mb:.2f}MB)")
+            
+            return {
+                "status": "success",
+                "video_path": str(output_path),
+                "size_mb": size_mb,
+                "scenes": len(scenes) + 1
+            }
+        else:
+            # Response is JSON (might be error or status)
+            data = response.json()
+            if data.get("status") == "success":
+                print(f"✓ Compose completed successfully")
+                return data
+            else:
+                raise Exception(f"Compose failed: {data.get('message', 'Unknown error')}")
+    
+    except Exception as e:
+        print(f"✗ Composition failed: {e}")
+        raise
+    
+    # Generate dynamic SCENE_CONFIG from manifest
+    print(f"\nGenerating scene configuration...")
+    
+    try:
+        payload = {
+            "title": manifest.get("title", "Untitled"),
+            "scenes": [
+                {
+                    "label": s.get("label", f"Scene {idx}"),
+                    "image_query": s.get("image_query", "")
+                }
+                for idx, s in enumerate(scenes)
+            ]
+        }
+        
+        response = requests.post(
+            f"http://localhost:7860/compose",
+            json=payload,
+            timeout=300
+        )
+        
+        if response.status_code != 200:
+            error_data = response.json() if response.headers.get("content-type") == "application/json" else response.text
+            print(f"✗ Server returned {response.status_code}: {error_data}")
+            raise Exception(f"Compose endpoint failed: {error_data}")
+        
+        # Check if response is binary (video file) or JSON
+        if response.headers.get("content-type", "").startswith("video"):
+            # Save video file
+            output_path = PIPELINE_DIR / "output_video.mp4"
+            with open(output_path, "wb") as f:
+                f.write(response.content)
+            
+            size_mb = output_path.stat().st_size / (1024 * 1024)
+            print(f"✓ Video saved: {output_path.name} ({size_mb:.2f}MB)")
+            
+            return {
+                "status": "success",
+                "video_path": str(output_path),
+                "size_mb": size_mb,
+                "scenes": len(scenes) + 1
+            }
+        else:
+            # Response is JSON (might be error or status)
+            data = response.json()
+            if data.get("status") == "success":
+                print(f"✓ Compose completed successfully")
+                return data
+            else:
+                raise Exception(f"Compose failed: {data.get('message', 'Unknown error')}")
+    
+    except Exception as e:
+        print(f"✗ Composition failed: {e}")
+        raise
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Main Pipeline Orchestrator
+# ─────────────────────────────────────────────────────────────────────────
+
+async def generate_video_from_prompt(prompt: str) -> dict:
+    """
+    Complete pipeline: Prompt → Manifest → Images → Selection → Video
+    
+    Args:
+        prompt (str): User prompt describing video content
+        
+    Returns:
+        dict: Final result with video path or error
+    """
+    try:
+        # Step 1: Generate manifest from prompt
+        manifest = await step_generate_manifest(prompt)
+        
+        # Step 2: Download images for each scene
+        downloaded = await step_download_images(manifest)
+        if downloaded == 0:
+            raise Exception("No images were downloaded")
+        
+        # Step 3: Select best images from candidates
+        selection = await step_select_scenes(manifest)
+        if selection["selected"] != selection["total"]:
+            raise Exception(
+                f"Selection incomplete: {selection['selected']}/{selection['total']}"
+            )
+        
+        # Step 4: Compose final video
+        composition = await step_compose_video(manifest)
+        
+        # Success!
+        print("\n" + "="*70)
+        print("[SUCCESS] Pipeline Complete!")
+        print("="*70)
+        print(f"Title: {manifest.get('title', 'Untitled')}")
+        print(f"Scenes: {len(manifest.get('scenes', []))}")
+        print(f"Video: {composition['output_path']}")
+        print(f"Size: {composition['size_mb']:.1f}MB")
+        print("="*70)
+        
+        return {
+            "status": "success",
+            "message": "Video generated successfully",
+            "title": manifest.get("title"),
+            "scenes": len(manifest.get("scenes", [])),
+            "output_path": composition["output_path"],
+            "size_mb": composition["size_mb"],
+        }
+        
+    except Exception as e:
+        print("\n" + "="*70)
+        print(f"[ERROR] Pipeline Failed: {e}")
+        print("="*70)
+        
+        return {
+            "status": "error",
+            "message": str(e),
+            "output_path": None,
+        }
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# Local Testing
+# ─────────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1:
+        prompt = " ".join(sys.argv[1:])
+    else:
+        prompt = "A motivational video about personal growth and success"
+    
+    # Ensure directories exist
+    PIPELINE_DIR.mkdir(exist_ok=True)
+    RENDERS_DIR.mkdir(exist_ok=True)
+    
+    # Run pipeline
+    result = asyncio.run(generate_video_from_prompt(prompt))
+    
+    # Print final status
+    if result["status"] == "success":
+        print(f"\n✓ Video saved to: {result['output_path']}")
+        sys.exit(0)
+    else:
+        print(f"\n✗ Error: {result['message']}")
+        sys.exit(1)

manifest_config.json

@@ -0,0 +1,194 @@
+{
+  "title": "The 6AM Glow Up",
+  "scenes": [
+    {
+      "idx": 0,
+      "label": "THE 6AM GLOW UP",
+      "duration_s": 4.7,
+      "motion": {
+        "type": "slow_push_in",
+        "scale_start": 1.0,
+        "scale_end": 1.08
+      },
+      "text": {
+        "type": "center_stroke_pop",
+        "entry_frame": 2,
+        "hold_frames": 125,
+        "font_size": 95,
+        "align": "center"
+      },
+      "grade": {
+        "crush_blacks": 15,
+        "contrast": 1.15
+      },
+      "transition": {
+        "type": "hard_cut",
+        "frames": 1
+      }
+    },
+    {
+      "idx": 1,
+      "label": "~SILENT WAKE CALL",
+      "duration_s": 2.3,
+      "motion": {
+        "type": "snap_zoom",
+        "scale_start": 1.0,
+        "scale_end": 1.12
+      },
+      "text": {
+        "type": "center_pop",
+        "entry_frame": 0,
+        "hold_frames": 69,
+        "font_size": 110,
+        "align": "center"
+      },
+      "grade": {
+        "warm_tint": true,
+        "lift_mids": 10
+      },
+      "transition": {
+        "type": "whip_pan_right",
+        "frames": 4
+      }
+    },
+    {
+      "idx": 2,
+      "label": "~FIRST SIP CLARITY",
+      "duration_s": 2.3,
+      "motion": {
+        "type": "static"
+      },
+      "text": {
+        "type": "center_fade_pop",
+        "entry_frame": 2,
+        "hold_frames": 66,
+        "font_size": 110,
+        "align": "center"
+      },
+      "grade": {
+        "desaturate": true,
+        "lift_blacks": 5
+      },
+      "transition": {
+        "type": "whip_pan_right",
+        "frames": 4
+      }
+    },
+    {
+      "idx": 3,
+      "label": "~GENTLE BODY FLOW",
+      "duration_s": 2.3,
+      "motion": {
+        "type": "static"
+      },
+      "text": {
+        "type": "center_fade_pop",
+        "entry_frame": 2,
+        "hold_frames": 66,
+        "font_size": 110,
+        "align": "center"
+      },
+      "grade": {
+        "cool_tint": true,
+        "highlights": -15
+      },
+      "transition": {
+        "type": "whip_pan_right",
+        "frames": 4
+      }
+    },
+    {
+      "idx": 4,
+      "label": "~PAGES OF PURPOSE",
+      "duration_s": 2.3,
+      "motion": {
+        "type": "static"
+      },
+      "text": {
+        "type": "center_fade_pop",
+        "entry_frame": 2,
+        "hold_frames": 66,
+        "font_size": 110,
+        "align": "center"
+      },
+      "grade": {
+        "soft_pink": true,
+        "lift_mids": 15
+      },
+      "transition": {
+        "type": "whip_pan_right",
+        "frames": 4
+      }
+    },
+    {
+      "idx": 5,
+      "label": "~SKIN DEEP RITUAL",
+      "duration_s": 2.3,
+      "motion": {
+        "type": "static"
+      },
+      "text": {
+        "type": "center_fade_pop",
+        "entry_frame": 2,
+        "hold_frames": 66,
+        "font_size": 110,
+        "align": "center"
+      },
+      "grade": {
+        "indoor_warm": true,
+        "lift_shadows": 8
+      },
+      "transition": {
+        "type": "whip_pan_right",
+        "frames": 4
+      }
+    },
+    {
+      "idx": 6,
+      "label": "~INTENTIONAL DAY BLUEPRINT",
+      "duration_s": 2.3,
+      "motion": {
+        "type": "static"
+      },
+      "text": {
+        "type": "center_fade_pop",
+        "entry_frame": 2,
+        "hold_frames": 66,
+        "font_size": 110,
+        "align": "center"
+      },
+      "grade": {
+        "teal_orange": true,
+        "crush_blacks": 10
+      },
+      "transition": {
+        "type": "whip_pan_right",
+        "frames": 4
+      }
+    },
+    {
+      "idx": 7,
+      "label": "~READY TO CONQUER",
+      "duration_s": 2.3,
+      "motion": {
+        "type": "static"
+      },
+      "text": {
+        "type": "center_fade_pop",
+        "entry_frame": 2,
+        "hold_frames": 66,
+        "font_size": 110,
+        "align": "center"
+      },
+      "grade": {
+        "dark_moody": true,
+        "crush_blacks": 20,
+        "desaturate": 15
+      },
+      "transition": {
+        "type": "whip_pan_right",
+        "frames": 4
+      }
+    }
+  ]
+}

requirements_server.txt

@@ -1,8 +1,8 @@
 fastapi==0.104.1
 uvicorn==0.24.0
-pydantic==2.10.6
+pydantic==2.6.3
 requests==2.31.0
 python-multipart==0.0.6
 pillow==11.0.0
 opencv-python==4.8.1.78
-numpy==1.26.4
+numpy>=2.0.0

server.py

@@ -13,6 +13,9 @@ import shutil
 from pathlib import Path
 import subprocess
 import sys
+import requests
+from PIL import Image
+from io import BytesIO
 
 # ─────────────────────────────────────────────────────────────────────────
 # Pydantic Models
@@ -39,6 +42,12 @@ class VideoResponse(BaseModel):
     duration_s: Optional[float] = None
 
 
+class PromptRequest(BaseModel):
+    """Request with user prompt to generate video from scratch"""
+    prompt: str
+    title: Optional[str] = None
+
+
 # ─────────────────────────────────────────────────────────────────────────
 # FastAPI App
 # ─────────────────────────────────────────────────────────────────────────
@@ -135,10 +144,19 @@ SCENES_TEMPLATES = [
 
 
 def generate_scene_config(manifest: ManifestRequest) -> list:
-    """Generate SCENE_CONFIG from manifest, extracting and uppercasing labels."""
+    """Generate SCENE_CONFIG from manifest with title as intro slide."""
     config = []
     
-    for idx, scene in enumerate(manifest.scenes):
+    # Scene 0: Title as intro (4.7s, 95pt)
+    title_cfg = {
+        "idx": 0,
+        "label": manifest.title.upper(),
+    }
+    title_cfg.update(INTRO_CONFIG)
+    config.append(title_cfg)
+    
+    # Scenes 1+: Manifest scenes with templates
+    for idx, scene in enumerate(manifest.scenes, start=1):
         # Extract label and convert to UPPERCASE for captions
         label = scene.label.upper()
         
@@ -147,13 +165,9 @@ def generate_scene_config(manifest: ManifestRequest) -> list:
             "label": label,
         }
         
-        if idx == 0:
-            # First scene is intro
-            scene_cfg.update(INTRO_CONFIG)
-        else:
-            # Use templated config for subsequent scenes
-            template_idx = min(idx - 1, len(SCENES_TEMPLATES) - 1)
-            scene_cfg.update(SCENES_TEMPLATES[template_idx])
+        # Use templated config for subsequent scenes (cycle through templates)
+        template_idx = min(idx - 1, len(SCENES_TEMPLATES) - 1)
+        scene_cfg.update(SCENES_TEMPLATES[template_idx])
         
         config.append(scene_cfg)
     
@@ -287,6 +301,7 @@ async def _select_scenes(manifest: ManifestRequest, source_dir: Path):
     """
     Internal: Select scenes from source directory.
     Copies best image from each scene folder to selected/ folder.
+    Includes title image from scene_0 + content scenes from scene_1, scene_2, etc.
     """
     try:
         # Clean and recreate selected directory
@@ -296,11 +311,37 @@ async def _select_scenes(manifest: ManifestRequest, source_dir: Path):
         
         selected_count = 0
         
+        print(f"  [DEBUG] SELECTED_DIR = {SELECTED_DIR}")
+        print(f"  [DEBUG] source_dir = {source_dir}")
+        
+        # ─────────────────────────────────────────────────────────────────
+        # SELECT FROM TITLE (scene_0)
+        # ─────────────────────────────────────────────────────────────────
+        title_folder = source_dir / "scene_0"
+        if title_folder.exists() and title_folder.is_dir():
+            images = sorted(
+                list(title_folder.glob("*.jpg")) + list(title_folder.glob("*.png")),
+                key=lambda p: p.stat().st_size,
+                reverse=True
+            )
+            if images:
+                dest = SELECTED_DIR / "scene_00.jpg"  # Use 00 for scene_0
+                shutil.copy2(images[0], dest)
+                selected_count += 1
+                print(f"  [TITLE] Selected: {images[0].name} → {dest}")
+                if not dest.exists():
+                    print(f"  [ERROR] File was not saved! {dest}")
+        
+        # ─────────────────────────────────────────────────────────────────
+        # SELECT FROM CONTENT SCENES (scene_1, scene_2, etc)
+        # ─────────────────────────────────────────────────────────────────
         # For each scene, find and copy its image
         for i, scene in enumerate(manifest.scenes):
+            actual_i = i + 1  # scene_1, scene_2, etc
+            
             # Try multiple naming conventions
             scene_folder = None
-            for pattern in [f"scene_{i}", f"scene_{i:02d}", f"{i}", f"scene{i}"]:
+            for pattern in [f"scene_{actual_i}", f"scene_{actual_i:02d}", f"{actual_i}", f"scene{actual_i}"]:
                 potential = source_dir / pattern
                 if potential.exists():
                     scene_folder = potential
@@ -308,13 +349,14 @@ async def _select_scenes(manifest: ManifestRequest, source_dir: Path):
             
             # If no folder, look for files named with scene index
             if scene_folder is None:
-                images = list(source_dir.glob(f"*scene*{i}*")) + list(
-                    source_dir.glob(f"{i:02d}*")
+                images = list(source_dir.glob(f"*scene*{actual_i}*")) + list(
+                    source_dir.glob(f"{actual_i:02d}*")
                 )
                 if images:
-                    dest = SELECTED_DIR / f"scene_{i:02d}.jpg"
+                    dest = SELECTED_DIR / f"scene_{actual_i:02d}.jpg"
                     shutil.copy2(images[0], dest)
                     selected_count += 1
+                    print(f"  [Scene {actual_i}] Selected: {images[0].name} → {dest}")
                     continue
             
             # If folder found, get best image
@@ -325,9 +367,12 @@ async def _select_scenes(manifest: ManifestRequest, source_dir: Path):
                     reverse=True
                 )
                 if images:
-                    dest = SELECTED_DIR / f"scene_{i:02d}.jpg"
+                    dest = SELECTED_DIR / f"scene_{actual_i:02d}.jpg"
                     shutil.copy2(images[0], dest)
                     selected_count += 1
+                    print(f"  [Scene {actual_i}] Selected: {images[0].name} → {dest}")
+        
+        total_expected = len(manifest.scenes) + 1  # title + content scenes
         
         if selected_count == 0:
             raise Exception(
@@ -335,9 +380,14 @@ async def _select_scenes(manifest: ManifestRequest, source_dir: Path):
                 "Expected scene_0/, scene_1/, etc. folders or numbered files."
             )
         
+        if selected_count != total_expected:
+            raise Exception(
+                f"Expected {total_expected} selected images (title + {len(manifest.scenes)} scenes), found {selected_count}"
+            )
+        
         return {
             "status": "success",
-            "message": f"Selected {selected_count}/{len(manifest.scenes)} scenes",
+            "message": f"Selected {selected_count}/{total_expected} scenes",
             "selected_count": selected_count,
             "selected_dir": str(SELECTED_DIR),
         }
@@ -351,17 +401,22 @@ async def _select_scenes(manifest: ManifestRequest, source_dir: Path):
 async def _compose(manifest: ManifestRequest):
     """
     Internal: Compose video from manifest and selected images.
+    Note: generate_scene_config adds title as scene 0, so we expect:
+    selected_images_count = manifest_scenes + 1
     """
     try:
         # Verify selected directory has images
         selected_images = sorted(SELECTED_DIR.glob("scene_*.jpg"))
-        if len(selected_images) != len(manifest.scenes):
-            raise Exception(
-                f"Expected {len(manifest.scenes)} selected images, found {len(selected_images)}"
-            )
         
-        # Generate dynamic SCENE_CONFIG from manifest
+        # Generate dynamic SCENE_CONFIG from manifest (adds title as scene 0)
         scene_config = generate_scene_config(manifest)
+        expected_images = len(scene_config)  # includes title as scene 0
+        
+        if len(selected_images) != expected_images:
+            raise Exception(
+                f"Expected {expected_images} selected images (title + {len(manifest.scenes)} scenes), "
+                f"found {len(selected_images)}"
+            )
         
         # Save config as JSON for composer to use
         config_json = {
@@ -417,6 +472,227 @@ async def _compose(manifest: ManifestRequest):
         }
 
 
+@app.post("/generate-from-prompt")
+async def generate_from_prompt(request: PromptRequest):
+    """
+    Full End-to-End Pipeline: Prompt → Manifest → Images → Selection → Video
+    
+    Workflow:
+    1. Call content-gen server to generate manifest from prompt
+    2. Call pinteresting server to download images for each scene
+    3. Select best images from candidates
+    4. Compose video with manifest labels
+    5. Return MP4 file
+    
+    Args:
+        request.prompt: User description (e.g., "A motivational video about success")
+        request.title: Optional override for video title
+        
+    Returns: MP4 video file (video/mp4)
+    """
+    try:
+        print(f"\n[PROMPT] {request.prompt[:80]}...")
+        
+        # ─────────────────────────────────────────────────────────────────
+        # Step 1: Generate Manifest from Prompt
+        # ─────────────────────────────────────────────────────────────────
+        print("[STEP 1] Generating manifest from prompt...")
+        
+        manifest_server = "https://factorstudios-content-gen.hf.space"
+        manifest_payload = {"topic": request.prompt}
+        
+        manifest_response = requests.post(
+            f"{manifest_server}/generate",
+            json=manifest_payload,
+            timeout=120
+        )
+        manifest_response.raise_for_status()
+        manifest_data = manifest_response.json()
+        
+        # Override title if provided
+        if request.title:
+            manifest_data["title"] = request.title
+        
+        # Save manifest
+        manifest_path = BASE_DIR / "manifest_from_prompt.json"
+        with open(manifest_path, "w") as f:
+            json.dump(manifest_data, f, indent=2)
+        
+        scenes = manifest_data.get("scenes", [])
+        print(f"[OK] Generated manifest with {len(scenes)} scenes")
+        
+        # ─────────────────────────────────────────────────────────────────
+        # Step 2: Download Images from Pinteresting Server
+        # ─────────────────────────────────────────────────────────────────
+        print("[STEP 2] Downloading images for each scene...")
+        
+        # Clear candidates directory
+        if CANDIDATES_DIR.exists():
+            shutil.rmtree(CANDIDATES_DIR)
+        CANDIDATES_DIR.mkdir(parents=True, exist_ok=True)
+        
+        image_server = "https://factorstudios-pinteresting.hf.space"
+        total_downloaded = 0
+        images_per_scene = 5
+        
+        # ─────────────────────────────────────────────────────────────────
+        # STEP 2.0: Download images for TITLE (as scene_0)
+        # ─────────────────────────────────────────────────────────────────
+        title = manifest_data.get("title", "")
+        if title:
+            scene_dir = CANDIDATES_DIR / "scene_0"
+            scene_dir.mkdir(parents=True, exist_ok=True)
+            
+            try:
+                payload = {"keyword": title, "count": images_per_scene}
+                
+                img_response = requests.post(
+                    f"{image_server}/scrape",
+                    json=payload,
+                    timeout=120
+                )
+                img_response.raise_for_status()
+                img_data = img_response.json()
+                
+                if img_data.get("success"):
+                    images = img_data.get("images", [])
+                    
+                    for img_idx, img_info in enumerate(images):
+                        img_url = img_info.get("url")
+                        if not img_url:
+                            continue
+                        
+                        try:
+                            dl_response = requests.get(img_url, timeout=15)
+                            dl_response.raise_for_status()
+                            Image.open(BytesIO(dl_response.content))
+                            
+                            file_path = scene_dir / f"candidate_{img_idx:02d}.jpg"
+                            with open(file_path, "wb") as f:
+                                f.write(dl_response.content)
+                            
+                            total_downloaded += 1
+                        except Exception as e:
+                            print(f"  [TITLE] Image {img_idx} failed: {e}")
+                    
+                    print(f"  [TITLE] Downloaded {len(images)} images")
+                else:
+                    print(f"  [TITLE] API error: {img_data.get('message')}")
+            except Exception as e:
+                print(f"  [TITLE] Request failed: {e}")
+        
+        # ─────────────────────────────────────────────────────────────────
+        # STEP 2.1: Download images for each CONTENT SCENE (as scene_1+)
+        # ─────────────────────────────────────────────────────────────────
+        for scene_idx, scene in enumerate(scenes):
+            actual_scene_idx = scene_idx + 1  # scene_1, scene_2, etc
+            scene_label = scene.get("label", f"Scene {actual_scene_idx}")
+            image_query = scene.get("image_query", "")
+            
+            if not image_query:
+                print(f"  [Scene {actual_scene_idx}] No query found")
+                continue
+            
+            # Create scene folder
+            scene_dir = CANDIDATES_DIR / f"scene_{actual_scene_idx}"
+            scene_dir.mkdir(parents=True, exist_ok=True)
+            
+            try:
+                # Fetch from pinteresting
+                payload = {"keyword": image_query, "count": images_per_scene}
+                
+                img_response = requests.post(
+                    f"{image_server}/scrape",
+                    json=payload,
+                    timeout=120
+                )
+                img_response.raise_for_status()
+                img_data = img_response.json()
+                
+                if img_data.get("success"):
+                    images = img_data.get("images", [])
+                    
+                    # Download each image
+                    for img_idx, img_info in enumerate(images):
+                        img_url = img_info.get("url")
+                        if not img_url:
+                            continue
+                        
+                        try:
+                            # Download and verify
+                            dl_response = requests.get(img_url, timeout=15)
+                            dl_response.raise_for_status()
+                            
+                            # Verify it's valid image
+                            Image.open(BytesIO(dl_response.content))
+                            
+                            # Save
+                            file_path = scene_dir / f"candidate_{img_idx:02d}.jpg"
+                            with open(file_path, "wb") as f:
+                                f.write(dl_response.content)
+                            
+                            total_downloaded += 1
+                            
+                        except Exception as e:
+                            print(f"  [Scene {actual_scene_idx}] Image {img_idx} failed: {e}")
+                    
+                    print(f"  [Scene {actual_scene_idx}] Downloaded {len(images)} images")
+                else:
+                    print(f"  [Scene {actual_scene_idx}] API error: {img_data.get('message')}")
+                    
+            except Exception as e:
+                print(f"  [Scene {actual_scene_idx}] Request failed: {e}")
+        
+        if total_downloaded == 0:
+            raise Exception(f"No images were downloaded from {image_server}")
+        
+        print(f"[OK] Downloaded {total_downloaded} images total")
+        
+        # ─────────────────────────────────────────────────────────────────
+        # Step 3: Select Best Images from Candidates
+        # ─────────────────────────────────────────────────────────────────
+        print("[STEP 3] Selecting best images from candidates...")
+        
+        manifest_req = ManifestRequest(**manifest_data)
+        select_result = await _select_scenes(manifest_req, CANDIDATES_DIR)
+        
+        if select_result["status"] != "success":
+            raise Exception(select_result.get("message", "Scene selection failed"))
+        
+        print(f"[OK] Selected {select_result['selected_count']} images")
+        
+        # ─────────────────────────────────────────────────────────────────
+        # Step 4: Compose Video
+        # ─────────────────────────────────────────────────────────────────
+        print("[STEP 4] Composing video...")
+        
+        compose_result = await _compose(manifest_req)
+        
+        if compose_result["status"] != "success":
+            raise Exception(compose_result.get("message", "Composition failed"))
+        
+        print(f"[OK] Video composed ({compose_result['size_mb']:.1f}MB)")
+        
+        # ─────────────────────────────────────────────────────────────────
+        # Step 5: Return Video File
+        # ─────────────────────────────────────────────────────────────────
+        output_file = Path(compose_result["output_path"])
+        if not output_file.exists():
+            raise Exception("Output video file not found")
+        
+        print(f"[SUCCESS] Video ready: {output_file.name}")
+        
+        return FileResponse(
+            path=output_file,
+            media_type="video/mp4",
+            filename="video.mp4"
+        )
+    
+    except Exception as e:
+        print(f"[ERROR] {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @app.get("/health")
 async def health_check():
     """Health check endpoint"""