Update app.py

app.py

@@ -7,17 +7,22 @@ Features:
 - Domain-optimized presets
 - Person-specific filtering (optional)
 - Scene-aware clip cutting
+- Batch testing with parameter variations
 """
 
 import os
 import sys
 import tempfile
 import shutil
+import json
+import zipfile
 from pathlib import Path
 import time
 import traceback
+from typing import List, Dict, Any, Optional
 
 import gradio as gr
+import pandas as pd
 
 # Add project root to path
 sys.path.insert(0, str(Path(__file__).parent))
@@ -33,13 +38,18 @@ except Exception:
     logger = logging.getLogger("app")
 
 
-def build_metrics_output(result, domain: str) -> str:
+# =============================================================================
+# Shared Utilities
+# =============================================================================
+
+def build_metrics_output(result, domain: str, custom_prompt: Optional[str] = None) -> str:
     """
     Build formatted metrics output for testing and evaluation.
 
     Args:
         result: PipelineResult object
         domain: Content domain used for processing
+        custom_prompt: Custom prompt used (if any)
 
     Returns:
         Formatted string with all metrics
@@ -58,6 +68,7 @@ def build_metrics_output(result, domain: str) -> str:
     lines.append(f"scenes_detected: {len(result.scenes)}")
     lines.append(f"audio_segments_analyzed: {len(result.audio_features)}")
     lines.append(f"domain: {domain}")
+    lines.append(f"custom_prompt: {custom_prompt if custom_prompt else 'none'}")
 
     # Count hooks from scores (estimate based on high-scoring segments)
     hooks_detected = sum(1 for s in result.scores if s.combined_score > 0.7) if result.scores else 0
@@ -119,6 +130,10 @@ def build_metrics_output(result, domain: str) -> str:
     return "\n".join(lines)
 
 
+# =============================================================================
+# Single Video Processing
+# =============================================================================
+
 def process_video(
     video_file,
     domain,
@@ -129,7 +144,7 @@ def process_video(
     progress=gr.Progress()
 ):
     """
-    Main video processing function.
+    Main video processing function for single video mode.
 
     Args:
         video_file: Uploaded video file path
@@ -239,7 +254,7 @@ def process_video(
             status = f"Successfully extracted {len(clip_paths)} highlight clips!\nProcessing time: {result.processing_time:.1f}s"
 
             # Build metrics output
-            metrics_output = build_metrics_output(result, domain_value)
+            metrics_output = build_metrics_output(result, domain_value, custom_prompt.strip() if custom_prompt else None)
 
             pipeline.cleanup()
             progress(1.0, desc="Done!")
@@ -263,7 +278,417 @@ def process_video(
         return error_msg, None, None, None, "\n".join(log_messages), ""
 
 
-# Build Gradio interface
+# =============================================================================
+# Batch Testing Functions
+# =============================================================================
+
+def generate_test_queue(
+    videos: List[str],
+    domains: List[str],
+    durations: List[int],
+    num_clips: int,
+    ref_image: Optional[str],
+    prompts: List[str],
+    include_no_prompt: bool
+) -> List[Dict[str, Any]]:
+    """Generate all parameter combinations to test (cartesian product)."""
+    # Build prompt list
+    prompt_list = []
+    if include_no_prompt:
+        prompt_list.append(None)  # No prompt baseline
+    prompt_list.extend([p.strip() for p in prompts if p and p.strip()])
+
+    # If no prompts at all, use just None
+    if not prompt_list:
+        prompt_list = [None]
+
+    # Map domain display names to internal values
+    domain_map = {
+        "Sports": "sports",
+        "Vlogs": "vlogs",
+        "Music Videos": "music",
+        "Podcasts": "podcasts",
+        "Gaming": "gaming",
+        "General": "general",
+    }
+
+    queue = []
+    test_id = 1
+    for video in videos:
+        video_name = Path(video).name if video else "unknown"
+        for domain in domains:
+            domain_value = domain_map.get(domain, "general")
+            for duration in durations:
+                for prompt in prompt_list:
+                    queue.append({
+                        "test_id": test_id,
+                        "video_path": video,
+                        "video_name": video_name,
+                        "domain": domain,
+                        "domain_value": domain_value,
+                        "clip_duration": duration,
+                        "num_clips": num_clips,
+                        "reference_image": ref_image,
+                        "custom_prompt": prompt,
+                    })
+                    test_id += 1
+    return queue
+
+
+def run_single_batch_test(config: Dict[str, Any], output_base_dir: Path) -> Dict[str, Any]:
+    """Run a single test from the batch queue."""
+    from utils.helpers import validate_video_file
+    from pipeline.orchestrator import PipelineOrchestrator
+
+    test_id = config["test_id"]
+    video_path = config["video_path"]
+    video_name = config["video_name"]
+    domain_value = config["domain_value"]
+    duration = config["clip_duration"]
+    num_clips = config["num_clips"]
+    ref_image = config["reference_image"]
+    custom_prompt = config["custom_prompt"]
+
+    # Create unique output folder for this test
+    prompt_suffix = "no_prompt" if not custom_prompt else f"prompt_{hash(custom_prompt) % 1000}"
+    test_folder = f"{Path(video_name).stem}_{domain_value}_{duration}s_{prompt_suffix}"
+    output_dir = output_base_dir / test_folder
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    result_data = {
+        "test_id": test_id,
+        "video_name": video_name,
+        "domain": domain_value,
+        "clip_duration": duration,
+        "custom_prompt": custom_prompt if custom_prompt else "none",
+        "num_clips": num_clips,
+        "status": "failed",
+        "error": None,
+        "processing_time": 0,
+        "frames_analyzed": 0,
+        "scenes_detected": 0,
+        "hooks_detected": 0,
+        "clips": [],
+        "clip_paths": [],
+    }
+
+    try:
+        # Validate video
+        validation = validate_video_file(video_path)
+        if not validation.is_valid:
+            result_data["error"] = validation.error_message
+            return result_data
+
+        # Initialize and run pipeline
+        pipeline = PipelineOrchestrator()
+        result = pipeline.process(
+            video_path=video_path,
+            num_clips=num_clips,
+            clip_duration=float(duration),
+            domain=domain_value,
+            reference_image=ref_image,
+            custom_prompt=custom_prompt,
+        )
+
+        if result.success:
+            result_data["status"] = "success"
+            result_data["processing_time"] = round(result.processing_time, 2)
+            result_data["frames_analyzed"] = len(result.visual_features)
+            result_data["scenes_detected"] = len(result.scenes)
+            result_data["hooks_detected"] = sum(1 for s in result.scores if s.combined_score > 0.7) if result.scores else 0
+
+            # Copy clips and collect data
+            for i, clip in enumerate(result.clips):
+                if clip.clip_path.exists():
+                    clip_output = output_dir / f"clip_{i+1}.mp4"
+                    shutil.copy2(clip.clip_path, clip_output)
+                    result_data["clip_paths"].append(str(clip_output))
+
+                    # Find hook type for this clip
+                    hook_type = "none"
+                    hook_confidence = 0.0
+                    for score in result.scores:
+                        if abs(score.start_time - clip.start_time) < 1.0:
+                            if score.combined_score > 0.7:
+                                hook_confidence = score.combined_score
+                                if score.audio_score > score.visual_score and score.audio_score > score.motion_score:
+                                    hook_type = "audio_peak"
+                                elif score.motion_score > score.visual_score:
+                                    hook_type = "motion_spike"
+                                else:
+                                    hook_type = "visual_highlight"
+                            break
+
+                    result_data["clips"].append({
+                        "clip_id": i + 1,
+                        "start_time": round(clip.start_time, 2),
+                        "end_time": round(clip.end_time, 2),
+                        "duration": round(clip.duration, 2),
+                        "hype_score": round(clip.hype_score, 4),
+                        "visual_score": round(clip.visual_score, 4),
+                        "audio_score": round(clip.audio_score, 4),
+                        "motion_score": round(clip.motion_score, 4),
+                        "hook_type": hook_type,
+                        "hook_confidence": round(hook_confidence, 4),
+                    })
+        else:
+            result_data["error"] = result.error_message
+
+        pipeline.cleanup()
+
+    except Exception as e:
+        result_data["error"] = str(e)
+        logger.exception(f"Batch test {test_id} failed")
+
+    return result_data
+
+
+def results_to_dataframe(results: List[Dict[str, Any]]) -> pd.DataFrame:
+    """Convert batch results to a pandas DataFrame for display."""
+    rows = []
+    for r in results:
+        row = {
+            "Test ID": r["test_id"],
+            "Video": r["video_name"],
+            "Domain": r["domain"],
+            "Duration": f"{r['clip_duration']}s",
+            "Prompt": r["custom_prompt"][:20] + "..." if len(r["custom_prompt"]) > 20 else r["custom_prompt"],
+            "Status": r["status"],
+            "Time (s)": r["processing_time"],
+            "Frames": r["frames_analyzed"],
+            "Hooks": r["hooks_detected"],
+        }
+        # Add clip scores
+        for i, clip in enumerate(r.get("clips", [])[:3]):
+            row[f"Clip {i+1} Hype"] = clip.get("hype_score", 0)
+        rows.append(row)
+    return pd.DataFrame(rows)
+
+
+def results_to_csv(results: List[Dict[str, Any]]) -> str:
+    """Convert results to CSV format."""
+    rows = []
+    for r in results:
+        row = {
+            "test_id": r["test_id"],
+            "video_name": r["video_name"],
+            "domain": r["domain"],
+            "clip_duration": r["clip_duration"],
+            "custom_prompt": r["custom_prompt"],
+            "num_clips": r["num_clips"],
+            "status": r["status"],
+            "error": r.get("error", ""),
+            "processing_time": r["processing_time"],
+            "frames_analyzed": r["frames_analyzed"],
+            "scenes_detected": r["scenes_detected"],
+            "hooks_detected": r["hooks_detected"],
+        }
+        # Add per-clip data
+        for i in range(3):
+            if i < len(r.get("clips", [])):
+                clip = r["clips"][i]
+                row[f"clip_{i+1}_start"] = clip["start_time"]
+                row[f"clip_{i+1}_end"] = clip["end_time"]
+                row[f"clip_{i+1}_hype"] = clip["hype_score"]
+                row[f"clip_{i+1}_visual"] = clip["visual_score"]
+                row[f"clip_{i+1}_audio"] = clip["audio_score"]
+                row[f"clip_{i+1}_motion"] = clip["motion_score"]
+                row[f"clip_{i+1}_hook_type"] = clip["hook_type"]
+            else:
+                row[f"clip_{i+1}_start"] = ""
+                row[f"clip_{i+1}_end"] = ""
+                row[f"clip_{i+1}_hype"] = ""
+                row[f"clip_{i+1}_visual"] = ""
+                row[f"clip_{i+1}_audio"] = ""
+                row[f"clip_{i+1}_motion"] = ""
+                row[f"clip_{i+1}_hook_type"] = ""
+        rows.append(row)
+
+    df = pd.DataFrame(rows)
+    return df.to_csv(index=False)
+
+
+def results_to_json(results: List[Dict[str, Any]]) -> str:
+    """Convert results to JSON format."""
+    # Remove clip_paths from export (they're temp files)
+    export_results = []
+    for r in results:
+        r_copy = r.copy()
+        r_copy.pop("clip_paths", None)
+        export_results.append(r_copy)
+    return json.dumps(export_results, indent=2)
+
+
+def create_clips_zip(results: List[Dict[str, Any]]) -> Optional[str]:
+    """Create a ZIP file of all extracted clips."""
+    zip_path = Path(tempfile.mkdtemp()) / "batch_clips.zip"
+
+    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+        for r in results:
+            if r["status"] == "success":
+                folder_name = f"{Path(r['video_name']).stem}_{r['domain']}_{r['clip_duration']}s"
+                if r["custom_prompt"] != "none":
+                    folder_name += f"_prompt"
+                for clip_path in r.get("clip_paths", []):
+                    if Path(clip_path).exists():
+                        arcname = f"{folder_name}/{Path(clip_path).name}"
+                        zf.write(clip_path, arcname)
+
+    return str(zip_path) if zip_path.exists() else None
+
+
+# Batch state (module level for simplicity)
+batch_state = {
+    "is_running": False,
+    "should_cancel": False,
+    "results": [],
+    "output_dir": None,
+}
+
+
+def run_batch_tests(
+    videos,
+    domains,
+    durations,
+    num_clips,
+    reference_image,
+    include_no_prompt,
+    prompt1,
+    prompt2,
+    prompt3,
+    progress=gr.Progress()
+):
+    """Main batch testing function."""
+    global batch_state
+
+    # Validate inputs
+    if not videos:
+        return "Please upload at least one video.", None, "", "", None, None, None
+
+    if not domains:
+        return "Please select at least one domain.", None, "", "", None, None, None
+
+    if not durations:
+        return "Please select at least one duration.", None, "", "", None, None, None
+
+    # Collect prompts
+    prompts = [p for p in [prompt1, prompt2, prompt3] if p and p.strip()]
+
+    # Generate test queue
+    queue = generate_test_queue(
+        videos=videos,
+        domains=domains,
+        durations=durations,
+        num_clips=int(num_clips),
+        ref_image=reference_image,
+        prompts=prompts,
+        include_no_prompt=include_no_prompt,
+    )
+
+    if not queue:
+        return "No tests to run. Please check your configuration.", None, "", "", None, None, None
+
+    # Initialize batch state
+    batch_state["is_running"] = True
+    batch_state["should_cancel"] = False
+    batch_state["results"] = []
+    batch_state["output_dir"] = Path(tempfile.mkdtemp(prefix="shortsmith_batch_"))
+
+    total_tests = len(queue)
+    log_messages = []
+
+    def log(msg):
+        log_messages.append(f"[{time.strftime('%H:%M:%S')}] {msg}")
+        logger.info(msg)
+
+    log(f"Starting batch testing: {total_tests} tests")
+    log(f"Videos: {len(videos)}, Domains: {len(domains)}, Durations: {len(durations)}, Prompts: {len(prompts) + (1 if include_no_prompt else 0)}")
+
+    # Run tests sequentially
+    for i, test_config in enumerate(queue):
+        if batch_state["should_cancel"]:
+            log("Batch cancelled by user")
+            break
+
+        test_id = test_config["test_id"]
+        video_name = test_config["video_name"]
+        domain = test_config["domain_value"]
+        duration = test_config["clip_duration"]
+        prompt = test_config["custom_prompt"] or "no-prompt"
+
+        log(f"[{i+1}/{total_tests}] Testing: {video_name} | {domain} | {duration}s | {prompt[:30]}...")
+        progress((i + 1) / total_tests, desc=f"Test {i+1}/{total_tests}: {video_name}")
+
+        # Run the test
+        result = run_single_batch_test(test_config, batch_state["output_dir"])
+        batch_state["results"].append(result)
+
+        if result["status"] == "success":
+            log(f"  ✓ Completed in {result['processing_time']}s")
+        else:
+            log(f"  ✗ Failed: {result.get('error', 'Unknown error')}")
+
+    # Finalize
+    batch_state["is_running"] = False
+    completed = len([r for r in batch_state["results"] if r["status"] == "success"])
+    failed = len([r for r in batch_state["results"] if r["status"] == "failed"])
+
+    log(f"Batch complete: {completed} succeeded, {failed} failed")
+
+    # Generate outputs
+    results_df = results_to_dataframe(batch_state["results"])
+    csv_content = results_to_csv(batch_state["results"])
+    json_content = results_to_json(batch_state["results"])
+
+    # Save CSV and JSON to files for download
+    csv_path = batch_state["output_dir"] / "results.csv"
+    json_path = batch_state["output_dir"] / "results.json"
+    csv_path.write_text(csv_content)
+    json_path.write_text(json_content)
+
+    # Create ZIP of clips
+    zip_path = create_clips_zip(batch_state["results"])
+
+    status = f"Batch complete: {completed}/{total_tests} tests succeeded"
+
+    return (
+        status,
+        results_df,
+        "\n".join(log_messages),
+        json_content,
+        str(csv_path),
+        str(json_path),
+        zip_path,
+    )
+
+
+def cancel_batch():
+    """Cancel the running batch."""
+    global batch_state
+    batch_state["should_cancel"] = True
+    return "Cancelling batch... (will stop after current test completes)"
+
+
+def calculate_queue_size(videos, domains, durations, include_no_prompt, prompt1, prompt2, prompt3):
+    """Calculate and display the queue size."""
+    num_videos = len(videos) if videos else 0
+    num_domains = len(domains) if domains else 0
+    num_durations = len(durations) if durations else 0
+
+    prompts = [p for p in [prompt1, prompt2, prompt3] if p and p.strip()]
+    num_prompts = len(prompts) + (1 if include_no_prompt else 0)
+    if num_prompts == 0:
+        num_prompts = 1  # Default to no-prompt if nothing selected
+
+    total = num_videos * num_domains * num_durations * num_prompts
+
+    return f"Queue: {num_videos} video(s) × {num_domains} domain(s) × {num_durations} duration(s) × {num_prompts} prompt(s) = **{total} tests**"
+
+
+# =============================================================================
+# Build Gradio Interface
+# =============================================================================
+
 with gr.Blocks(
     title="ShortSmith v2",
     theme=gr.themes.Soft(),
@@ -274,129 +699,294 @@ with gr.Blocks(
 ) as demo:
 
     gr.Markdown("""
-    # 🎬 ShortSmith v2
+    # ShortSmith v2
     ### AI-Powered Video Highlight Extractor
 
     Upload a video and automatically extract the most engaging highlight clips using AI analysis.
     """)
 
-    with gr.Row():
-        # Left column - Inputs
-        with gr.Column(scale=1):
-            gr.Markdown("### 📤 Input")
+    with gr.Tabs():
+        # =================================================================
+        # Tab 1: Single Video
+        # =================================================================
+        with gr.TabItem("Single Video"):
+            with gr.Row():
+                # Left column - Inputs
+                with gr.Column(scale=1):
+                    gr.Markdown("### Input")
+
+                    video_input = gr.Video(
+                        label="Upload Video",
+                        sources=["upload"],
+                    )
+
+                    with gr.Accordion("Settings", open=True):
+                        domain_dropdown = gr.Dropdown(
+                            choices=["Sports", "Vlogs", "Music Videos", "Podcasts", "Gaming", "General"],
+                            value="General",
+                            label="Content Domain",
+                            info="Select the type of content for optimized scoring"
+                        )
+
+                        with gr.Row():
+                            num_clips_slider = gr.Slider(
+                                minimum=1,
+                                maximum=3,
+                                value=3,
+                                step=1,
+                                label="Number of Clips",
+                                info="How many highlight clips to extract"
+                            )
+                            duration_slider = gr.Slider(
+                                minimum=5,
+                                maximum=30,
+                                value=15,
+                                step=1,
+                                label="Clip Duration (seconds)",
+                                info="Target duration for each clip"
+                            )
+
+                    with gr.Accordion("Person Filtering (Optional)", open=False):
+                        reference_image = gr.Image(
+                            label="Reference Image",
+                            type="filepath",
+                            sources=["upload"],
+                        )
+                        gr.Markdown("*Upload a photo of a person to prioritize clips featuring them.*")
+
+                    with gr.Accordion("Custom Instructions (Optional)", open=False):
+                        custom_prompt = gr.Textbox(
+                            label="Additional Instructions",
+                            placeholder="E.g., 'Focus on crowd reactions' or 'Prioritize action scenes'",
+                            lines=2,
+                        )
+
+                    process_btn = gr.Button(
+                        "Extract Highlights",
+                        variant="primary",
+                        size="lg"
+                    )
+
+                # Right column - Outputs
+                with gr.Column(scale=1):
+                    gr.Markdown("### Output")
 
-            video_input = gr.Video(
-                label="Upload Video",
-                sources=["upload"],
+                    status_output = gr.Textbox(
+                        label="Status",
+                        lines=2,
+                        interactive=False
+                    )
+
+                    gr.Markdown("#### Extracted Clips")
+                    clip1_output = gr.Video(label="Clip 1", elem_classes=["output-video"])
+                    clip2_output = gr.Video(label="Clip 2", elem_classes=["output-video"])
+                    clip3_output = gr.Video(label="Clip 3", elem_classes=["output-video"])
+
+                    with gr.Accordion("Processing Log", open=True):
+                        log_output = gr.Textbox(
+                            label="Log",
+                            lines=10,
+                            interactive=False,
+                            show_copy_button=True
+                        )
+
+                    with gr.Accordion("Automated Metrics (System-Generated)", open=True):
+                        metrics_output = gr.Textbox(
+                            label="Metrics for Testing",
+                            lines=20,
+                            interactive=False,
+                            show_copy_button=True,
+                            info="Copy these metrics for evaluation spreadsheets"
+                        )
+
+            # Connect single video processing
+            process_btn.click(
+                fn=process_video,
+                inputs=[
+                    video_input,
+                    domain_dropdown,
+                    num_clips_slider,
+                    duration_slider,
+                    reference_image,
+                    custom_prompt
+                ],
+                outputs=[
+                    status_output,
+                    clip1_output,
+                    clip2_output,
+                    clip3_output,
+                    log_output,
+                    metrics_output
+                ],
+                show_progress="full"
             )
 
-            with gr.Accordion("⚙️ Settings", open=True):
-                domain_dropdown = gr.Dropdown(
-                    choices=["Sports", "Vlogs", "Music Videos", "Podcasts", "Gaming", "General"],
-                    value="General",
-                    label="Content Domain",
-                    info="Select the type of content for optimized scoring"
-                )
+        # =================================================================
+        # Tab 2: Batch Testing
+        # =================================================================
+        with gr.TabItem("Batch Testing"):
+            with gr.Row():
+                # Left column - Configuration
+                with gr.Column(scale=1):
+                    gr.Markdown("### Batch Configuration")
+
+                    batch_videos = gr.File(
+                        label="Upload Video(s)",
+                        file_count="multiple",
+                        file_types=["video"],
+                    )
+
+                    gr.Markdown("#### Domains to Test")
+                    batch_domains = gr.CheckboxGroup(
+                        choices=["Sports", "Vlogs", "Music Videos", "Podcasts", "Gaming", "General"],
+                        value=["General"],
+                        label="Select domains",
+                    )
+
+                    gr.Markdown("#### Clip Durations to Test")
+                    batch_durations = gr.CheckboxGroup(
+                        choices=[10, 15, 20, 30],
+                        value=[15],
+                        label="Select durations (seconds)",
+                    )
 
-                with gr.Row():
-                    num_clips_slider = gr.Slider(
+                    batch_num_clips = gr.Slider(
                         minimum=1,
                         maximum=3,
                         value=3,
                         step=1,
-                        label="Number of Clips",
-                        info="How many highlight clips to extract"
+                        label="Number of Clips per Test",
                     )
-                    duration_slider = gr.Slider(
-                        minimum=5,
-                        maximum=30,
-                        value=15,
-                        step=1,
-                        label="Clip Duration (seconds)",
-                        info="Target duration for each clip"
+
+                    with gr.Accordion("Custom Prompts", open=True):
+                        batch_no_prompt = gr.Checkbox(
+                            label="Include no-prompt baseline",
+                            value=True,
+                            info="Test without any custom prompt for comparison"
+                        )
+                        batch_prompt1 = gr.Textbox(
+                            label="Prompt 1",
+                            placeholder="E.g., 'Focus on action moments'",
+                            lines=1,
+                        )
+                        batch_prompt2 = gr.Textbox(
+                            label="Prompt 2",
+                            placeholder="E.g., 'Find crowd reactions'",
+                            lines=1,
+                        )
+                        batch_prompt3 = gr.Textbox(
+                            label="Prompt 3",
+                            placeholder="E.g., 'Prioritize emotional moments'",
+                            lines=1,
+                        )
+
+                    with gr.Accordion("Reference Image (Optional)", open=False):
+                        batch_ref_image = gr.Image(
+                            label="Reference Image (applies to all tests)",
+                            type="filepath",
+                            sources=["upload"],
+                        )
+
+                    # Queue size indicator
+                    queue_info = gr.Markdown("Queue: 0 tests")
+
+                    with gr.Row():
+                        batch_start_btn = gr.Button(
+                            "Start Batch",
+                            variant="primary",
+                            size="lg"
+                        )
+                        batch_cancel_btn = gr.Button(
+                            "Cancel",
+                            variant="secondary",
+                            size="lg"
+                        )
+
+                # Right column - Results
+                with gr.Column(scale=1):
+                    gr.Markdown("### Results")
+
+                    batch_status = gr.Textbox(
+                        label="Status",
+                        lines=2,
+                        interactive=False
                     )
 
-            with gr.Accordion("👤 Person Filtering (Optional)", open=False):
-                reference_image = gr.Image(
-                    label="Reference Image",
-                    type="filepath",
-                    sources=["upload"],
-                )
-                gr.Markdown("*Upload a photo of a person to prioritize clips featuring them.*")
+                    batch_results_table = gr.Dataframe(
+                        label="Test Results",
+                        headers=["Test ID", "Video", "Domain", "Duration", "Prompt", "Status", "Time (s)", "Frames", "Hooks"],
+                        interactive=False,
+                    )
 
-            with gr.Accordion("📝 Custom Instructions (Optional)", open=False):
-                custom_prompt = gr.Textbox(
-                    label="Additional Instructions",
-                    placeholder="E.g., 'Focus on crowd reactions' or 'Prioritize action scenes'",
-                    lines=2,
+                    with gr.Accordion("Processing Log", open=True):
+                        batch_log = gr.Textbox(
+                            label="Log",
+                            lines=15,
+                            interactive=False,
+                            show_copy_button=True
+                        )
+
+                    with gr.Accordion("Full Results (JSON)", open=False):
+                        batch_json = gr.Textbox(
+                            label="JSON Output",
+                            lines=10,
+                            interactive=False,
+                            show_copy_button=True
+                        )
+
+                    gr.Markdown("#### Download Results")
+                    with gr.Row():
+                        csv_download = gr.File(label="CSV Results")
+                        json_download = gr.File(label="JSON Results")
+                        zip_download = gr.File(label="All Clips (ZIP)")
+
+            # Update queue size when inputs change
+            queue_inputs = [batch_videos, batch_domains, batch_durations, batch_no_prompt, batch_prompt1, batch_prompt2, batch_prompt3]
+            for inp in queue_inputs:
+                inp.change(
+                    fn=calculate_queue_size,
+                    inputs=queue_inputs,
+                    outputs=queue_info
                 )
 
-            process_btn = gr.Button(
-                "🚀 Extract Highlights",
-                variant="primary",
-                size="lg"
+            # Connect batch processing
+            batch_start_btn.click(
+                fn=run_batch_tests,
+                inputs=[
+                    batch_videos,
+                    batch_domains,
+                    batch_durations,
+                    batch_num_clips,
+                    batch_ref_image,
+                    batch_no_prompt,
+                    batch_prompt1,
+                    batch_prompt2,
+                    batch_prompt3,
+                ],
+                outputs=[
+                    batch_status,
+                    batch_results_table,
+                    batch_log,
+                    batch_json,
+                    csv_download,
+                    json_download,
+                    zip_download,
+                ],
+                show_progress="full"
             )
 
-        # Right column - Outputs
-        with gr.Column(scale=1):
-            gr.Markdown("### 📥 Output")
-
-            status_output = gr.Textbox(
-                label="Status",
-                lines=2,
-                interactive=False
+            batch_cancel_btn.click(
+                fn=cancel_batch,
+                inputs=[],
+                outputs=[batch_status]
             )
 
-            gr.Markdown("#### Extracted Clips")
-            clip1_output = gr.Video(label="Clip 1", elem_classes=["output-video"])
-            clip2_output = gr.Video(label="Clip 2", elem_classes=["output-video"])
-            clip3_output = gr.Video(label="Clip 3", elem_classes=["output-video"])
-
-            with gr.Accordion("📋 Processing Log", open=True):
-                log_output = gr.Textbox(
-                    label="Log",
-                    lines=10,
-                    interactive=False,
-                    show_copy_button=True
-                )
-
-            with gr.Accordion("📊 Automated Metrics (System-Generated)", open=True):
-                metrics_output = gr.Textbox(
-                    label="Metrics for Testing",
-                    lines=20,
-                    interactive=False,
-                    show_copy_button=True,
-                    info="Copy these metrics for evaluation spreadsheets"
-                )
-
     gr.Markdown("""
     ---
     **ShortSmith v2** | Powered by Qwen2-VL, InsightFace, and Librosa |
     [GitHub](https://github.com) | Built with Gradio
     """)
 
-    # Connect the button to the processing function
-    process_btn.click(
-        fn=process_video,
-        inputs=[
-            video_input,
-            domain_dropdown,
-            num_clips_slider,
-            duration_slider,
-            reference_image,
-            custom_prompt
-        ],
-        outputs=[
-            status_output,
-            clip1_output,
-            clip2_output,
-            clip3_output,
-            log_output,
-            metrics_output
-        ],
-        show_progress="full"
-    )
-
 # Launch the app
 if __name__ == "__main__":
     demo.queue()