Update app.py

app.py

@@ -1,15 +1,7 @@
 """
-ShortSmith v2 - Gradio Application
+ShortSmith v2 - Gradio Application (Simplified)
 
 Hugging Face Space interface for video highlight extraction.
-
-Features:
-- Video upload and processing
-- Domain selection for optimized scoring
-- Reference image for person-specific filtering
-- Custom prompt/instructions
-- Progress tracking
-- Output clip gallery with download
 """
 
 import os
@@ -17,7 +9,6 @@ import sys
 import tempfile
 import shutil
 from pathlib import Path
-from typing import Optional, List, Tuple, Generator
 import time
 
 import gradio as gr
@@ -25,62 +16,14 @@ import gradio as gr
 # Add project root to path
 sys.path.insert(0, str(Path(__file__).parent))
 
+# Initialize logging first
 from utils.logger import setup_logging, get_logger
-from utils.helpers import format_duration, validate_video_file, validate_image_file
-from config import get_config, set_config, AppConfig
-from scoring.domain_presets import list_domains, Domain
-from pipeline.orchestrator import PipelineOrchestrator, PipelineResult, PipelineProgress
-
-# Initialize logging
 setup_logging(log_level="INFO", log_to_console=True)
 logger = get_logger("app")
 
-# Global state
-_current_pipeline: Optional[PipelineOrchestrator] = None
-_progress_state: dict = {"stage": "", "progress": 0, "message": "Ready"}
-
-
-def update_progress(progress: PipelineProgress) -> None:
-    """Update global progress state."""
-    global _progress_state
-    _progress_state = {
-        "stage": progress.stage.value,
-        "progress": progress.progress,
-        "message": progress.message,
-        "elapsed": progress.elapsed_time,
-        "remaining": progress.estimated_remaining,
-    }
-
-
-def process_video(
-    video_file,
-    api_key,
-    domain,
-    num_clips,
-    clip_duration,
-    reference_image,
-    custom_prompt,
-    progress=None,
-):
-    """
-    Main processing function for Gradio interface.
-
-    Args:
-        video_file: Path to uploaded video
-        api_key: API key (for future use)
-        domain: Content domain selection
-        num_clips: Number of clips to extract
-        clip_duration: Target clip duration
-        reference_image: Reference image for person filtering
-        custom_prompt: Custom instructions
-
-    Returns:
-        Tuple of (clip_paths, status_message, log_output)
-    """
-    global _current_pipeline, _progress_state
-
-    # Reset progress
-    _progress_state = {"stage": "starting", "progress": 0, "message": "Starting..."}
+
+def process_video(video_file, api_key, domain, num_clips, clip_duration, reference_image, custom_prompt):
+    """Main processing function."""
 
     log_messages = []
 
@@ -88,27 +31,25 @@ def process_video(
         log_messages.append(f"[{time.strftime('%H:%M:%S')}] {msg}")
         logger.info(msg)
 
-    def update_prog(val, desc=""):
-        if progress is not None:
-            try:
-                progress(val, desc=desc)
-            except:
-                pass
-
     try:
         # Validate inputs
         log("Validating inputs...")
-        update_prog(0.02, "Validating inputs...")
 
         if not video_file:
             return [], "❌ Error: No video file provided", "\n".join(log_messages)
 
+        video_path = Path(video_file)
+        log(f"Video: {video_path.name}")
+
+        # Import here to avoid schema issues at startup
+        from utils.helpers import validate_video_file, validate_image_file, format_duration
+        from pipeline.orchestrator import PipelineOrchestrator
+
         validation = validate_video_file(video_file)
         if not validation.is_valid:
             return [], f"❌ Error: {validation.error_message}", "\n".join(log_messages)
 
-        video_path = Path(video_file)
-        log(f"Video: {video_path.name} ({validation.file_size / (1024*1024):.1f} MB)")
+        log(f"Video size: {validation.file_size / (1024*1024):.1f} MB")
 
         # Validate reference image if provided
         ref_path = None
@@ -120,7 +61,7 @@ def process_video(
             else:
                 log(f"Warning: Invalid reference image - {ref_validation.error_message}")
 
-        # Map domain string to enum
+        # Map domain string
         domain_map = {
             "Sports": "sports",
             "Vlogs": "vlogs",
@@ -130,246 +71,135 @@ def process_video(
             "General": "general",
         }
         domain_value = domain_map.get(domain, "general")
-        log(f"Domain: {domain} -> {domain_value}")
+        log(f"Domain: {domain_value}")
 
         # Create output directory
         output_dir = Path(tempfile.mkdtemp(prefix="shortsmith_output_"))
         log(f"Output directory: {output_dir}")
 
-        # Initialize pipeline with progress callback
-        def progress_callback(p):
-            update_progress(p)
-            update_prog(p.progress, p.message)
-
+        # Initialize pipeline
         log("Initializing pipeline...")
-        update_prog(0.05, "Initializing pipeline...")
-
-        _current_pipeline = PipelineOrchestrator(
-            progress_callback=progress_callback
-        )
+        pipeline = PipelineOrchestrator()
 
         # Process video
-        log(f"Processing video: {num_clips} clips @ {clip_duration}s each")
+        log(f"Processing: {num_clips} clips @ {clip_duration}s each")
 
-        result = _current_pipeline.process(
+        result = pipeline.process(
             video_path=video_path,
             num_clips=int(num_clips),
             clip_duration=float(clip_duration),
             domain=domain_value,
             reference_image=ref_path,
-            custom_prompt=custom_prompt if custom_prompt.strip() else None,
-            api_key=api_key if api_key.strip() else None,
+            custom_prompt=custom_prompt if custom_prompt and custom_prompt.strip() else None,
+            api_key=api_key if api_key and api_key.strip() else None,
         )
 
         # Handle result
         if result.success:
             log(f"✅ Processing complete in {result.processing_time:.1f}s")
 
-            # Copy clips to output directory
             clip_paths = []
             for i, clip in enumerate(result.clips):
                 if clip.clip_path.exists():
-                    # Copy to output dir
                     output_path = output_dir / f"highlight_{i+1}.mp4"
                     shutil.copy2(clip.clip_path, output_path)
                     clip_paths.append(str(output_path))
-                    log(f"  Clip {i+1}: {format_duration(clip.start_time)} - {format_duration(clip.end_time)} "
-                        f"(score: {clip.hype_score:.2f})")
+                    log(f"  Clip {i+1}: {format_duration(clip.start_time)} - {format_duration(clip.end_time)} (score: {clip.hype_score:.2f})")
 
-            status = (
-                f"✅ Successfully extracted {len(clip_paths)} highlight clips!\n"
-                f"Processing time: {result.processing_time:.1f}s\n"
-                f"Video duration: {format_duration(result.metadata.duration) if result.metadata else 'N/A'}"
-            )
-
-            # Cleanup pipeline temp files (but keep output)
-            if result.temp_dir and result.temp_dir != output_dir:
-                _current_pipeline.cleanup()
+            status = f"✅ Successfully extracted {len(clip_paths)} highlight clips!\nProcessing time: {result.processing_time:.1f}s"
 
+            pipeline.cleanup()
             return clip_paths, status, "\n".join(log_messages)
-
         else:
             log(f"❌ Processing failed: {result.error_message}")
-            _current_pipeline.cleanup()
+            pipeline.cleanup()
             return [], f"❌ Error: {result.error_message}", "\n".join(log_messages)
 
     except Exception as e:
         error_msg = f"Unexpected error: {str(e)}"
         log(f"❌ {error_msg}")
         logger.exception("Pipeline error")
-
-        if _current_pipeline:
-            try:
-                _current_pipeline.cleanup()
-            except:
-                pass
-
         return [], f"❌ {error_msg}", "\n".join(log_messages)
 
 
-def create_interface() -> gr.Blocks:
+def create_interface():
     """Create the Gradio interface."""
 
-    # Get available domains
     domains = ["Sports", "Vlogs", "Music Videos", "Podcasts", "Gaming", "General"]
 
-    # Custom CSS
-    css = """
-    .container { max-width: 1200px; margin: auto; }
-    .output-video { max-height: 300px; }
-    .status-box { font-family: monospace; }
-    """
-
     with gr.Blocks(
-        title="ShortSmith v2 - AI Video Highlight Extractor",
-        css=css,
+        title="ShortSmith v2",
         theme=gr.themes.Soft(),
     ) as demo:
         gr.Markdown("""
         # 🎬 ShortSmith v2
         ### AI-Powered Video Highlight Extractor
 
-        Upload a video and let AI extract the most engaging highlight clips automatically.
-
-        **Features:**
-        - 🎯 Domain-optimized hype detection (Sports, Music, Vlogs, etc.)
-        - 👤 Person-specific filtering (optional)
-        - 🎵 Audio + Visual + Motion analysis
-        - ⚡ Fast hierarchical processing
+        Upload a video and extract the most engaging highlight clips automatically.
         """)
 
         with gr.Row():
-            # Left column: Inputs
             with gr.Column(scale=1):
                 gr.Markdown("### 📤 Input")
 
-                video_input = gr.Video(
-                    label="Upload Video",
-                    sources=["upload"],
-                )
+                video_input = gr.Video(label="Upload Video")
 
                 with gr.Accordion("⚙️ Settings", open=True):
                     domain_dropdown = gr.Dropdown(
                         choices=domains,
                         value="General",
                         label="Content Domain",
-                        info="Select the type of content for optimized detection",
                     )
 
                     with gr.Row():
                         num_clips_slider = gr.Slider(
-                            minimum=1,
-                            maximum=10,
-                            value=3,
-                            step=1,
+                            minimum=1, maximum=10, value=3, step=1,
                             label="Number of Clips",
                         )
-
                         duration_slider = gr.Slider(
-                            minimum=5,
-                            maximum=30,
-                            value=15,
-                            step=1,
+                            minimum=5, maximum=30, value=15, step=1,
                             label="Clip Duration (seconds)",
                         )
 
                 with gr.Accordion("👤 Person Filtering (Optional)", open=False):
-                    gr.Markdown(
-                        "Upload a reference image to extract only clips featuring a specific person."
-                    )
-                    reference_image = gr.Image(
-                        label="Reference Image",
-                        type="filepath",
-                    )
+                    reference_image = gr.Image(label="Reference Image", type="filepath")
 
                 with gr.Accordion("📝 Custom Instructions (Optional)", open=False):
                     custom_prompt = gr.Textbox(
                         label="Additional Instructions",
-                        placeholder="E.g., 'Focus on crowd reactions' or 'Prioritize close-up shots'",
-                        lines=3,
+                        placeholder="E.g., 'Focus on crowd reactions'",
+                        lines=2,
                     )
 
                 with gr.Accordion("🔑 API Key (Optional)", open=False):
                     api_key_input = gr.Textbox(
                         label="API Key",
                         type="password",
-                        placeholder="For future external service integrations",
+                        placeholder="For future integrations",
                     )
 
-                process_btn = gr.Button(
-                    "🚀 Extract Highlights",
-                    variant="primary",
-                    size="lg",
-                )
+                process_btn = gr.Button("🚀 Extract Highlights", variant="primary", size="lg")
 
-            # Right column: Outputs
             with gr.Column(scale=1):
                 gr.Markdown("### 📥 Output")
 
-                status_output = gr.Textbox(
-                    label="Status",
-                    lines=3,
-                    interactive=False,
-                    elem_classes=["status-box"],
-                )
-
-                clip_gallery = gr.Gallery(
-                    label="Extracted Clips",
-                    columns=3,
-                    height=400,
-                    object_fit="contain",
-                )
-
-                # Download all clips
-                download_btn = gr.DownloadButton(
-                    label="📦 Download All Clips",
-                    visible=False,
-                )
+                status_output = gr.Textbox(label="Status", lines=3, interactive=False)
+                clip_gallery = gr.Gallery(label="Extracted Clips", columns=3, height=400)
 
                 with gr.Accordion("📋 Processing Log", open=False):
-                    log_output = gr.Textbox(
-                        label="Log",
-                        lines=10,
-                        interactive=False,
-                        elem_classes=["status-box"],
-                    )
+                    log_output = gr.Textbox(label="Log", lines=10, interactive=False)
 
-        # Footer
-        gr.Markdown("""
-        ---
-        **ShortSmith v2** | Powered by Qwen2-VL, InsightFace, and Librosa
-
-        [GitHub](https://github.com/your-repo) | [Documentation](https://your-docs.com)
-        """)
+        gr.Markdown("---\n**ShortSmith v2** | Powered by Qwen2-VL, InsightFace, and Librosa")
 
-        # Event handlers
-        def on_process(video, api_key, domain, num_clips, duration, ref_img, prompt, progress=gr.Progress()):
-            """Handle process button click."""
-            try:
-                clips, status, logs = process_video(
-                    video, api_key, domain, num_clips, duration, ref_img, prompt, progress
-                )
-
-                # Convert clip paths to gallery format
-                gallery_items = []
-                for clip_path in clips:
-                    gallery_items.append((clip_path, f"Clip {len(gallery_items)+1}"))
-
-                return status, gallery_items, logs
-            except Exception as e:
-                return f"❌ Error: {str(e)}", [], f"Error: {str(e)}"
+        # Event handler
+        def on_process(video, api_key, domain, num_clips, duration, ref_img, prompt):
+            clips, status, logs = process_video(video, api_key, domain, num_clips, duration, ref_img, prompt)
+            gallery_items = [(clip, f"Clip {i+1}") for i, clip in enumerate(clips)]
+            return status, gallery_items, logs
 
         process_btn.click(
             fn=on_process,
-            inputs=[
-                video_input,
-                api_key_input,
-                domain_dropdown,
-                num_clips_slider,
-                duration_slider,
-                reference_image,
-                custom_prompt,
-            ],
+            inputs=[video_input, api_key_input, domain_dropdown, num_clips_slider, duration_slider, reference_image, custom_prompt],
             outputs=[status_output, clip_gallery, log_output],
         )
 
@@ -380,16 +210,11 @@ def main():
     """Main entry point."""
     logger.info("Starting ShortSmith v2 Gradio interface...")
 
-    # Create and launch interface
     demo = create_interface()
-
-    # Launch settings for Hugging Face Spaces
     demo.queue()
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
-        show_error=True,
     )