Update app.py

app.py

@@ -1,8 +1,6 @@
 """
 ⚡ TimeLapseForge — JSON to Timelapse Video in One Click
 Main Gradio Application for Hugging Face Spaces.
-
-Paste your GPT JSON → Generate consistent panels → Smooth video output
 """
 
 import os
@@ -15,19 +13,11 @@ from typing import List, Optional
 
 # Import our modules
 from prompt_parser import PromptParser, QuickGenerator
-from image_generator import ImageGenerator
 from frame_interpolator import FrameInterpolator
 from video_assembler import VideoAssembler
 
-# Try importing spaces for ZeroGPU support
-try:
-    import spaces
-    ZERO_GPU = True
-except ImportError:
-    ZERO_GPU = False
-
 # ─── Initialize Modules ─────────────────────────────────────
-parser = PromptParser()
+prompt_parser = PromptParser()
 quick_gen = QuickGenerator()
 interpolator = FrameInterpolator()
 assembler = VideoAssembler()
@@ -39,17 +29,26 @@ MODELS = {
     "SD 1.5 (Lightweight, 512px)": "runwayml/stable-diffusion-v1-5",
 }
 
+# ─── Lazy import image generator (heavy deps) ───────────────
+_image_gen_class = None
+
+def get_image_generator_class():
+    global _image_gen_class
+    if _image_gen_class is None:
+        from image_generator import ImageGenerator
+        _image_gen_class = ImageGenerator
+    return _image_gen_class
+
 # ─── Core Functions ──────────────────────────────────────────
 
-def parse_input(json_text: str, quick_text: str, num_panels: int, mode: str):
+def parse_input(json_text, quick_text, num_panels, mode):
     """Parse JSON input or generate from quick text."""
     if json_text and json_text.strip():
-        result = parser.parse(json_text)
+        result = prompt_parser.parse(json_text)
         if result["success"]:
             data = result["data"]
-            prompts = parser.extract_prompts(data)
-            summary = parser.get_summary(data)
-            # Create preview table
+            prompts = prompt_parser.extract_prompts(data)
+            summary = prompt_parser.get_summary(data)
             table_data = [
                 [p["panel_id"], p["phase"], p["panel_title"], p["main_prompt"][:100] + "..."]
                 for p in prompts
@@ -62,53 +61,53 @@ def parse_input(json_text: str, quick_text: str, num_panels: int, mode: str):
             )
         else:
             return (
-                f"❌ JSON Parse Error: {result['error']}\n\nPlease check your JSON format.",
+                f"❌ JSON Parse Error: {result['error']}\n\nCheck your JSON format.",
                 [],
                 "",
                 gr.update(visible=False),
             )
     elif quick_text and quick_text.strip():
-        data = quick_gen.generate(quick_text, num_panels=num_panels, mode=mode)
-        prompts = parser.extract_prompts(data)
-        summary = parser.get_summary(data)
+        data = quick_gen.generate(quick_text, num_panels=int(num_panels), mode=mode)
+        prompts = prompt_parser.extract_prompts(data)
+        summary = prompt_parser.get_summary(data)
         table_data = [
             [p["panel_id"], p["phase"], p["panel_title"], p["main_prompt"][:100] + "..."]
             for p in prompts
         ]
         return (
-            summary + "\n\n⚠️ *Generated from quick text. For better results, use the GPT to generate detailed JSON.*",
+            summary + "\n\n⚠️ *Generated from quick text. Use GPT JSON for better results.*",
             table_data,
             json.dumps(data, indent=2),
             gr.update(visible=True),
         )
     else:
-        return "⚠️ Please paste JSON or enter a quick text description.", [], "", gr.update(visible=False)
+        return (
+            "⚠️ Please paste JSON or enter a quick text description.",
+            [],
+            "",
+            gr.update(visible=False),
+        )
 
 
 def generate_panels(
-    parsed_json: str,
-    model_name: str,
-    strength: float,
-    base_seed: int,
-    steps: int,
-    guidance: float,
-    ref_image: Optional[Image.Image],
-    progress=gr.Progress(),
+    parsed_json, model_name, strength, base_seed,
+    steps, guidance, ref_image, progress=gr.Progress(),
 ):
-    """Generate all panel images using the selected model."""
+    """Generate all panel images."""
     if not parsed_json:
-        return [], [], "❌ No parsed JSON found. Please parse input first."
+        return [], [], "❌ No parsed JSON found. Parse input first."
 
     try:
         data = json.loads(parsed_json)
     except json.JSONDecodeError:
         return [], [], "❌ Invalid parsed JSON."
 
-    prompts = parser.extract_prompts(data)
+    prompts = prompt_parser.extract_prompts(data)
     if not prompts:
         return [], [], "❌ No panels found in JSON."
 
     model_id = MODELS.get(model_name, "stabilityai/sdxl-turbo")
+    ImageGenerator = get_image_generator_class()
     gen = ImageGenerator(model_id)
 
     progress(0, desc="Loading model...")
@@ -116,21 +115,19 @@ def generate_panels(
     def progress_cb(current, total):
         progress(current / total, desc=f"Generating panel {current}/{total}")
 
-    # Handle steps and guidance for SDXL Turbo
-    gen_steps = steps if steps > 0 else None
-    gen_guidance = guidance if guidance >= 0 else None
+    gen_steps = int(steps) if steps and int(steps) > 0 else None
+    gen_guidance = float(guidance) if guidance is not None and float(guidance) >= 0 else None
 
     images = gen.generate_all_panels(
         prompts=prompts,
-        strength=strength,
-        base_seed=base_seed,
+        strength=float(strength),
+        base_seed=int(base_seed),
         steps=gen_steps,
         guidance=gen_guidance,
         reference_image=ref_image,
         progress_callback=progress_cb,
     )
 
-    # Create gallery data with labels
     gallery_items = []
     for i, img in enumerate(images):
         label = prompts[i]["panel_title"] if i < len(prompts) else f"Panel {i+1}"
@@ -141,24 +138,16 @@ def generate_panels(
 
 
 def interpolate_and_assemble(
-    images_state: List[Image.Image],
-    parsed_json: str,
-    interp_multiplier: int,
-    interp_method: str,
-    fps: int,
-    hold_seconds: float,
-    add_labels: bool,
-    add_progress_bar: bool,
-    add_bookend: bool,
-    music_file: Optional[str],
-    export_gif: bool,
-    progress=gr.Progress(),
+    images_state, parsed_json, interp_multiplier, interp_method,
+    fps, hold_seconds, add_labels, add_progress_bar, add_bookend,
+    music_file, export_gif, progress=gr.Progress(),
 ):
-    """Interpolate frames and assemble the final video."""
+    """Interpolate frames and assemble video."""
     if not images_state:
-        return None, None, None, "❌ No images to assemble. Generate panels first."
+        return None, None, None, "❌ No images. Generate panels first."
 
     images = images_state
+    interp_multiplier = int(interp_multiplier)
 
     # Step 1: Interpolate
     progress(0.1, desc="Interpolating frames...")
@@ -168,23 +157,25 @@ def interpolate_and_assemble(
             progress(p, desc=f"Interpolating {current}/{total} pairs")
 
         smooth_frames = interpolator.interpolate_sequence(
-            images, multiplier=interp_multiplier, method=interp_method, progress_callback=interp_cb
+            images,
+            multiplier=interp_multiplier,
+            method=interp_method,
+            progress_callback=interp_cb,
         )
     else:
-        smooth_frames = images
+        smooth_frames = list(images)
 
-    # Step 2: Extract labels from JSON
+    # Step 2: Extract labels
     labels = None
     if add_labels and parsed_json:
         try:
             data = json.loads(parsed_json)
-            prompts = parser.extract_prompts(data)
-            # Map labels to interpolated frames
+            prompts = prompt_parser.extract_prompts(data)
             if interp_multiplier > 1:
                 labels = []
                 for i, p in enumerate(prompts):
                     labels.append(p.get("timestamp_label", ""))
-                    labels.extend([""] * interp_multiplier)  # No labels for interpolated frames
+                    labels.extend([""] * interp_multiplier)
                 labels = labels[:len(smooth_frames)]
             else:
                 labels = [p.get("timestamp_label", "") for p in prompts]
@@ -193,11 +184,13 @@ def interpolate_and_assemble(
 
     # Step 3: Assemble video
     progress(0.5, desc="Assembling video...")
-    adj_hold = hold_seconds / max(interp_multiplier, 1) if interp_multiplier > 1 else hold_seconds
+    adj_hold = float(hold_seconds)
+    if interp_multiplier > 1:
+        adj_hold = adj_hold / max(interp_multiplier, 1)
 
     video_path = assembler.create_video(
         images=smooth_frames,
-        fps=fps,
+        fps=int(fps),
         hold_seconds=adj_hold,
         add_labels=add_labels,
         labels=labels,
@@ -205,33 +198,28 @@ def interpolate_and_assemble(
         add_bookend_labels=add_bookend,
     )
 
-    # Step 4: Add audio if provided
+    # Step 4: Add audio
     if music_file:
         progress(0.8, desc="Adding audio...")
         video_path = assembler.add_audio_to_video(video_path, music_file)
 
-    # Step 5: Create comparison image
+    # Step 5: Comparison image
     progress(0.9, desc="Creating comparison...")
     comparison = assembler.create_comparison_image(images[0], images[-1])
 
-    # Step 6: Create GIF (optional)
+    # Step 6: GIF
     gif_path = None
     if export_gif:
         progress(0.95, desc="Creating GIF...")
         gif_path = assembler.create_gif(images, duration_per_frame=400)
 
     progress(1.0, desc="Done!")
-    status = f"✅ Video created! {len(smooth_frames)} frames at {fps}fps"
+    status = f"✅ Video created! {len(smooth_frames)} frames at {int(fps)}fps"
     return video_path, comparison, gif_path, status
 
 
 def regenerate_single(
-    panel_num: int,
-    parsed_json: str,
-    images_state: List[Image.Image],
-    model_name: str,
-    strength: float,
-    base_seed: int,
+    panel_num, parsed_json, images_state, model_name, strength, base_seed,
 ):
     """Regenerate a single panel."""
     if not images_state or not parsed_json:
@@ -239,7 +227,7 @@ def regenerate_single(
 
     try:
         data = json.loads(parsed_json)
-        prompts = parser.extract_prompts(data)
+        prompts = prompt_parser.extract_prompts(data)
     except Exception:
         return images_state, [], "❌ Invalid JSON."
 
@@ -248,9 +236,12 @@ def regenerate_single(
         return images_state, [], f"❌ Invalid panel number. Must be 1-{len(images_state)}."
 
     model_id = MODELS.get(model_name, "stabilityai/sdxl-turbo")
+    ImageGenerator = get_image_generator_class()
     gen = ImageGenerator(model_id)
 
-    _, updated = gen.regenerate_single_panel(idx, prompts, images_state, strength, base_seed)
+    _, updated = gen.regenerate_single_panel(
+        idx, prompts, images_state, float(strength), int(base_seed)
+    )
 
     gallery_items = [(img, f"Panel {i+1}") for i, img in enumerate(updated)]
     return updated, gallery_items, f"✅ Panel {int(panel_num)} regenerated!"
@@ -263,54 +254,49 @@ HEADER_MD = """
 ### JSON to Timelapse Video — One Click Pipeline
 
 **Workflow:** Paste GPT JSON → Generate Consistent Panels → Smooth Interpolation → Export Video
-
-Built for use with **Timelapse Vision Master GPT** — or use Quick Text for simple projects.
 """
 
 with gr.Blocks(
     title="⚡ TimeLapseForge",
     theme=gr.themes.Soft(primary_hue="emerald", secondary_hue="blue"),
-    css="""
-    .panel-gallery { min-height: 300px; }
-    .status-box { padding: 10px; border-radius: 8px; }
-    """
 ) as app:
 
-    # ── Shared State ──
+    # Shared State
     images_state = gr.State(value=[])
     parsed_json_state = gr.State(value="")
 
     gr.Markdown(HEADER_MD)
 
     with gr.Tabs():
-        # ════════════════════════════════════════
-        # TAB 1: INPUT
-        # ════════════════════════════════════════
-        with gr.Tab("📥 Input & Parse", id="input"):
+
+        # ── TAB 1: INPUT ──
+        with gr.Tab("📥 Input & Parse"):
             with gr.Row():
                 with gr.Column(scale=2):
                     json_input = gr.Textbox(
                         label="📋 Paste GPT JSON Output",
-                        placeholder='Paste the complete JSON from your Timelapse GPT here...\n\n{\n  "project_metadata": { ... },\n  "panels": [ ... ]\n}',
+                        placeholder='Paste the complete JSON here...\n{\n  "project_metadata": {...},\n  "panels": [...]\n}',
                         lines=15,
-                        max_lines=30,
                     )
                 with gr.Column(scale=1):
-                    gr.Markdown("**— OR —**\n\nUse Quick Text for simple projects:")
+                    gr.Markdown("**— OR — Quick Text:**")
                     quick_text = gr.Textbox(
                         label="⚡ Quick Text Command",
-                        placeholder="e.g., Restore a rusty 1969 Camaro SS in a workshop",
+                        placeholder="e.g., Restore a rusty 1969 Camaro SS",
                         lines=3,
                     )
                     with gr.Row():
-                        quick_panels = gr.Slider(8, 40, value=20, step=1, label="Panels")
+                        quick_panels = gr.Slider(
+                            8, 40, value=20, step=1, label="Panels"
+                        )
                         quick_mode = gr.Dropdown(
-                            ["restoration", "creation"], value="restoration", label="Mode"
+                            ["restoration", "creation"],
+                            value="restoration",
+                            label="Mode",
                         )
 
             parse_btn = gr.Button("🔍 Parse & Preview", variant="primary", size="lg")
-
-            parse_status = gr.Markdown("", elem_classes=["status-box"])
+            parse_status = gr.Markdown("")
             prompt_table = gr.Dataframe(
                 headers=["#", "Phase", "Title", "Prompt Preview"],
                 label="📊 Extracted Panels",
@@ -318,10 +304,8 @@ with gr.Blocks(
                 wrap=True,
             )
 
-        # ════════════════════════════════════════
-        # TAB 2: GENERATE
-        # ════════════════════════════════════════
-        with gr.Tab("🎨 Generate Panels", id="generate"):
+        # ── TAB 2: GENERATE ──
+        with gr.Tab("🎨 Generate Panels"):
             with gr.Row():
                 with gr.Column(scale=1):
                     model_choice = gr.Dropdown(
@@ -331,21 +315,20 @@ with gr.Blocks(
                     )
                     strength = gr.Slider(
                         0.15, 0.70, value=0.38, step=0.01,
-                        label="🔄 Change Strength (lower = more consistent)",
-                        info="0.25=barely changes, 0.38=natural, 0.55=significant change",
+                        label="🔄 Change Strength",
+                        info="Lower = more consistent between panels",
                     )
                     base_seed = gr.Number(value=42, label="🌱 Base Seed", precision=0)
                     steps = gr.Slider(
                         0, 50, value=0, step=1,
-                        label="🔢 Steps (0 = auto for model)",
+                        label="🔢 Steps (0=auto)",
                     )
                     guidance = gr.Slider(
                         -1, 15, value=-1, step=0.5,
-                        label="🎯 Guidance Scale (-1 = auto for model)",
+                        label="🎯 Guidance (-1=auto)",
                     )
                     ref_image = gr.Image(
-                        label="🖼️ Reference Image (optional)",
-                        type="pil",
+                        label="🖼️ Reference Image (optional)", type="pil",
                     )
 
                 with gr.Column(scale=3):
@@ -359,62 +342,63 @@ with gr.Blocks(
                         rows=3,
                         height=450,
                         object_fit="contain",
-                        elem_classes=["panel-gallery"],
                     )
 
             with gr.Accordion("🔄 Regenerate Single Panel", open=False):
                 with gr.Row():
-                    regen_panel_num = gr.Number(value=1, label="Panel Number", precision=0)
-                    regen_btn = gr.Button("🔄 Regenerate This Panel", variant="secondary")
+                    regen_panel_num = gr.Number(
+                        value=1, label="Panel Number", precision=0
+                    )
+                    regen_btn = gr.Button("🔄 Regenerate", variant="secondary")
                 regen_status = gr.Markdown("")
 
-        # ════════════════════════════════════════
-        # TAB 3: VIDEO
-        # ════════════════════════════════════════
-        with gr.Tab("🎬 Create Video", id="video"):
+        # ── TAB 3: VIDEO ──
+        with gr.Tab("🎬 Create Video"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("### 🎞️ Interpolation Settings")
+                    gr.Markdown("### 🎞️ Interpolation")
                     interp_mult = gr.Slider(
                         1, 8, value=3, step=1,
                         label="Frame Multiplier",
-                        info="1=no interpolation, 3=smooth, 6=ultra smooth",
+                        info="1=none, 3=smooth, 6=ultra",
                     )
                     interp_method = gr.Dropdown(
                         ["blend", "flow"], value="blend",
-                        label="Interpolation Method",
-                        info="blend=fast & reliable, flow=better quality but slower",
+                        label="Method",
                     )
 
-                    gr.Markdown("### 🎬 Video Settings")
+                    gr.Markdown("### 🎬 Video")
                     vid_fps = gr.Slider(12, 60, value=24, step=1, label="FPS")
                     frame_hold = gr.Slider(
-                        0.3, 5.0, value=1.5, step=0.1, label="Seconds per Panel"
+                        0.3, 5.0, value=1.5, step=0.1,
+                        label="Seconds per Panel",
                     )
 
                     gr.Markdown("### 🏷️ Overlays")
-                    add_labels = gr.Checkbox(value=True, label="Add timestamp labels")
-                    add_progress_bar = gr.Checkbox(value=True, label="Add progress bar")
-                    add_bookend = gr.Checkbox(value=True, label="Add BEFORE / AFTER labels")
+                    add_labels = gr.Checkbox(value=True, label="Timestamp labels")
+                    add_progress_bar = gr.Checkbox(value=True, label="Progress bar")
+                    add_bookend = gr.Checkbox(value=True, label="BEFORE / AFTER")
 
                     gr.Markdown("### 🎵 Audio")
-                    music_file = gr.Audio(label="Upload Background Music", type="filepath")
+                    music_file = gr.Audio(
+                        label="Background Music", type="filepath"
+                    )
 
                     gr.Markdown("### 📦 Export")
-                    export_gif = gr.Checkbox(value=False, label="Also export as GIF")
+                    export_gif = gr.Checkbox(value=False, label="Also export GIF")
 
                 with gr.Column(scale=2):
                     assemble_btn = gr.Button(
-                        "🎬 Interpolate & Create Video", variant="primary", size="lg"
+                        "🎬 Interpolate & Create Video",
+                        variant="primary",
+                        size="lg",
                     )
                     vid_status = gr.Markdown("")
-
-                    video_output = gr.Video(label="🎥 Your Timelapse Video")
-                    comparison_output = gr.Image(label="📊 Before / After Comparison")
+                    video_output = gr.Video(label="🎥 Timelapse Video")
+                    comparison_output = gr.Image(label="📊 Before / After")
                     gif_output = gr.File(label="📦 GIF Download")
 
     # ── Event Handlers ──
-
     parse_btn.click(
         fn=parse_input,
         inputs=[json_input, quick_text, quick_panels, quick_mode],