initial test

app.py

@@ -3,10 +3,12 @@ import json
 import gradio as gr
 import tempfile
 from PIL import Image, ImageDraw, ImageFont
+import cv2
 from typing import Tuple, Optional
+import torch
 from pathlib import Path
+import time
 
-# Import your highlight detection code
 from video_highlight_detector import (
     load_model,
     BatchedVideoHighlightDetector,
@@ -14,12 +16,10 @@ from video_highlight_detector import (
 )
 
 def load_examples(json_path: str) -> dict:
-    """Load pre-computed examples from JSON file"""
     with open(json_path, 'r') as f:
         return json.load(f)
 
 def format_duration(seconds: int) -> str:
-    """Convert seconds to MM:SS or HH:MM:SS format"""
     hours = seconds // 3600
     minutes = (seconds % 3600) // 60
     secs = seconds % 60
@@ -28,7 +28,6 @@ def format_duration(seconds: int) -> str:
     return f"{minutes}:{secs:02d}"
 
 def add_watermark(video_path: str, output_path: str):
-    """Add watermark to video using ffmpeg"""
     watermark_text = "🤗 SmolVLM2 Highlight"
     command = f"""ffmpeg -i {video_path} -vf \
         "drawtext=text='{watermark_text}':fontcolor=white:fontsize=24:box=1:boxcolor=black@0.5:\
@@ -40,48 +39,33 @@ def process_video(
     video_path: str,
     progress = gr.Progress()
 ) -> Tuple[str, str, str, str]:
-    """
-    Process video and return paths to:
-    - Processed video with watermark
-    - Video description
-    - Highlight types
-    - Error message (if any)
-    """
     try:
-        # Check video duration
         duration = get_video_duration_seconds(video_path)
         if duration > 1200:  # 20 minutes
             return None, None, None, "Video must be shorter than 20 minutes"
 
-        # Load model (could be cached)
         progress(0.1, desc="Loading model...")
         model, processor = load_model()
         detector = BatchedVideoHighlightDetector(model, processor)
 
-        # Analyze video content
         progress(0.2, desc="Analyzing video content...")
         video_description = detector.analyze_video_content(video_path)
         
-        # Determine highlights
         progress(0.3, desc="Determining highlight types...")
         highlight_types = detector.determine_highlights(video_description)
 
-        # Create highlight video
         progress(0.4, desc="Detecting and extracting highlights...")
         with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as tmp_file:
             temp_output = tmp_file.name
         
         detector.create_highlight_video(video_path, temp_output)
         
-        # Add watermark
         progress(0.9, desc="Adding watermark...")
         output_path = temp_output.replace('.mp4', '_watermark.mp4')
         add_watermark(temp_output, output_path)
         
-        # Cleanup
         os.unlink(temp_output)
         
-        # Truncate description and highlights if too long
         video_description = video_description[:500] + "..." if len(video_description) > 500 else video_description
         highlight_types = highlight_types[:500] + "..." if len(highlight_types) > 500 else highlight_types
         
@@ -90,24 +74,20 @@ def process_video(
     except Exception as e:
         return None, None, None, f"Error processing video: {str(e)}"
 
-
 def create_ui(examples_path: str):
-    """Create the Gradio interface with optional thumbnails"""
     examples_data = load_examples(examples_path)
 
     with gr.Blocks() as app:
         gr.Markdown("# Video Highlight Generator")
         gr.Markdown("Upload a video (max 20 minutes) and get an automated highlight reel!")
         
-        # Pre-computed examples section
         with gr.Row():
             gr.Markdown("## Example Results")
         
         for example in examples_data["examples"]:
             with gr.Row():
                 with gr.Column():
-                    # Use thumbnail if available, otherwise default to video
-                    video_component = gr.Video(
+                    gr.Video(
                         example["original"]["url"],
                         label=f"Original ({format_duration(example['original']['duration_seconds'])})",
                     )
@@ -122,15 +102,13 @@ def create_ui(examples_path: str):
                         gr.Markdown(example["analysis"]["video_description"])
                         gr.Markdown(example["analysis"]["highlight_types"])
 
-        # Upload section
         gr.Markdown("## Try It Yourself!")
         with gr.Row():
             input_video = gr.Video(
                 label="Upload your video (max 20 minutes)",
-                source="upload"
+                interactive=True
             )
 
-        # Results section (initially hidden)
         with gr.Row(visible=False) as results_row:
             with gr.Column():
                 video_description = gr.Markdown(label="Video Analysis")
@@ -141,10 +119,8 @@ def create_ui(examples_path: str):
             output_video = gr.Video(label="Highlight Video")
             download_btn = gr.Button("Download Highlights")
 
-        # Error message
         error_msg = gr.Markdown(visible=False)
 
-        # Process video when uploaded
         def on_upload(video):
             results_row.visible = False
             output_row.visible = False
@@ -172,7 +148,6 @@ def create_ui(examples_path: str):
             outputs=[output_video, video_description, highlight_types, error_msg]
         )
 
-        # Download button
         download_btn.click(
             lambda x: x,
             inputs=[output_video],
@@ -183,4 +158,4 @@ def create_ui(examples_path: str):
 
 if __name__ == "__main__":
     app = create_ui("video_spec.json")
-    app.launch()
+    app.launch()