Fix: Add fn and outputs to gr.Examples to resolve ValueError

app.py

@@ -1,438 +1,144 @@
 import gradio as gr
 import os
-import requests
-import tempfile
-import subprocess
-import re
-import shutil # Added for rmtree
-import modal
-from typing import Dict, Any, Optional # Added for type hinting
-
-def is_youtube_url(url_string: str) -> bool:
-    """Checks if the given string is a YouTube URL."""
-    # More robust regex to find YouTube video ID, accommodating various URL formats
-    # and additional query parameters.
-    youtube_regex = (
-        r'(?:youtube(?:-nocookie)?\.com/(?:[^/\n\s]+/|watch(?:/|\?(?:[^&\n\s]+&)*v=)|embed(?:/|\?(?:[^&\n\s]+&)*feature=oembed)|shorts/|live/)|youtu\.be/)'
-        r'([a-zA-Z0-9_-]{11})' # This captures the 11-character video ID
-    )
-    # We use re.search because the video ID might not be at the start of the query string part of the URL.
-    # re.match only matches at the beginning of the string (or beginning of line in multiline mode).
-    # The regex now directly looks for the 'v=VIDEO_ID' or youtu.be/VIDEO_ID structure.
-    # The first part of the regex matches the domain and common paths, the second part captures the ID.
-    return bool(re.search(youtube_regex, url_string))
-
-def download_video(url_string: str, temp_dir: str) -> str | None:
-    """Downloads video from a URL (YouTube or direct link) to a temporary directory."""
-    if is_youtube_url(url_string):
-        print(f"Attempting to download YouTube video: {url_string}")
-        # Define a fixed output filename pattern within the temp_dir
-        output_filename_template = "downloaded_video.%(ext)s" # yt-dlp replaces %(ext)s
-        output_path_template = os.path.join(temp_dir, output_filename_template)
-
-        cmd = [
-            "yt-dlp",
-            "-f", "bestvideo[ext=mp4]+bestaudio[ext=m4a]/mp4/best", # Prefer mp4 format
-            "--output", output_path_template,
-            url_string
-        ]
-        print(f"Executing yt-dlp command: {' '.join(cmd)}")
-        
-        try:
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=300, check=False)
-
-            print(f"yt-dlp STDOUT:\n{result.stdout}")
-            print(f"yt-dlp STDERR:\n{result.stderr}")
-
-            if result.returncode == 0:
-                # Find the actual downloaded file based on the template
-                downloaded_file_path = None
-                for item in os.listdir(temp_dir):
-                    if item.startswith("downloaded_video."):
-                        potential_path = os.path.join(temp_dir, item)
-                        if os.path.isfile(potential_path):
-                            downloaded_file_path = potential_path
-                            print(f"YouTube video successfully downloaded to: {downloaded_file_path}")
-                            break
-                if downloaded_file_path:
-                    return downloaded_file_path
-                else:
-                    print(f"yt-dlp seemed to succeed (exit code 0) but the output file 'downloaded_video.*' was not found in {temp_dir}.")
-                    return None
-            else:
-                print(f"yt-dlp failed with return code {result.returncode}.")
-                return None
-        except subprocess.TimeoutExpired:
-            print(f"yt-dlp command timed out after 300 seconds for URL: {url_string}")
-            return None
-        except Exception as e:
-            print(f"An unexpected error occurred during yt-dlp execution for {url_string}: {e}")
-            return None
-
-    elif url_string.startswith(('http://', 'https://')) and url_string.lower().endswith(('.mp4', '.mov', '.avi', '.mkv', '.webm')):
-        print(f"Attempting to download direct video link: {url_string}")
-        try:
-            response = requests.get(url_string, stream=True, timeout=300) # 5 min timeout
-            response.raise_for_status() # Raises HTTPError for bad responses (4XX or 5XX)
-            
-            filename = os.path.basename(url_string) or "downloaded_video_direct.mp4"
-            video_file_path = os.path.join(temp_dir, filename)
-            
-            with open(video_file_path, 'wb') as f:
-                for chunk in response.iter_content(chunk_size=8192):
-                    f.write(chunk)
-            print(f"Direct video downloaded successfully to: {video_file_path}")
-            return video_file_path
-        except requests.exceptions.RequestException as e:
-            print(f"Error downloading direct video link {url_string}: {e}")
-            return None
-        except Exception as e:
-            print(f"An unexpected error occurred during direct video download for {url_string}: {e}")
-            return None
-    else:
-        print(f"Input '{url_string}' is not a recognized YouTube URL or direct video link for download.")
-        return None
-
-
-def process_video_input(input_string: str) -> Dict[str, Any]:
-    """
-    Processes the video (from URL or local file path) and returns its transcription status as a JSON object.
-    """
-    if not input_string:
-        return {
-            "status": "error",
-            "error_details": {
-                "message": "No video URL or file path provided.",
-                "input_received": input_string
-            }
-        }
-
-    video_path_to_process = None
-    # Get base_modal_url and construct modal_endpoint_url
-    base_modal_url = os.getenv("MODAL_APP_BASE_URL")
-    if not base_modal_url:
-        print("ERROR: MODAL_APP_BASE_URL environment variable not set.")
-        return {
-            "status": "error",
-            "error_details": {
-                "message": "Modal application base URL is not configured. Please set the MODAL_APP_BASE_URL environment variable.",
-                "input_received": input_string
-            }
-        }
-    modal_endpoint_url = f"{base_modal_url.rstrip('/')}/analyze_video"
-    print(f"Target Modal endpoint: {modal_endpoint_url}")
-
-    response_json = None # Initialize to ensure it's always defined before return
-
-    try:
-        if input_string.startswith(('http://', 'https://')):
-            print(f"Input is a URL: {input_string}. Sending URL to Modal endpoint as JSON.")
-            payload = {"video_url": input_string}
-            headers = {'Content-Type': 'application/json'}
-            response = requests.post(modal_endpoint_url, json=payload, headers=headers, timeout=1860)
-        
-        elif os.path.exists(input_string):
-            print(f"Input is a local file path: {input_string}. Sending file content to Modal endpoint.")
-            video_path_to_process = input_string # Use input_string as the path
-            try:
-                with open(video_path_to_process, "rb") as video_file:
-                    video_bytes_content = video_file.read()
-                print(f"Read {len(video_bytes_content)} bytes from video file '{video_path_to_process}'.")
-                files = {'video_file': (os.path.basename(video_path_to_process), video_bytes_content, 'video/mp4')}
-                response = requests.post(modal_endpoint_url, files=files, timeout=1860)
-            except FileNotFoundError: # Catch if file disappears just before open
-                print(f"Error: Video file not found at {video_path_to_process} when trying to read for upload.")
-                return { # Return immediately
-                    "status": "error",
-                    "error_details": {
-                        "message": "Video file disappeared before it could be read for upload.",
-                        "path_attempted": video_path_to_process
-                    }
-                }
-        else:
-            # This handles cases where input_string is neither a URL nor an existing file path
-            print(f"Input '{input_string}' is not a valid URL or an existing file path.")
-            return { # Return immediately
-                "status": "error",
-                "error_details": {
-                    "message": f"Input '{input_string}' is not a valid URL or an existing file path.",
-                    "input_received": input_string
-                }
-            }
-
-        # Common response handling
-        response.raise_for_status()  # Raise an exception for HTTP errors (4xx or 5xx)
-        analysis_results = response.json()
-        print(f"Received results from Modal endpoint: {str(analysis_results)[:200]}...")
-        response_json = {
-            "status": "success",
-            "data": analysis_results
-        }
-
-    except requests.exceptions.Timeout:
-        print(f"Request to Modal endpoint {modal_endpoint_url} timed out.")
-        response_json = {
-            "status": "error",
-            "error_details": {
-                "message": "Request to video analysis service timed out.",
-                "endpoint_url": modal_endpoint_url
-            }
-        }
-    except requests.exceptions.HTTPError as e:
-        print(f"HTTP error calling Modal endpoint {modal_endpoint_url}: {e.response.status_code} - {e.response.text}")
-        response_json = {
-            "status": "error",
-            "error_details": {
-                "message": f"Video analysis service returned an error: {e.response.status_code}",
-                "details": e.response.text,
-                "endpoint_url": modal_endpoint_url
-            }
-        }
-    except requests.exceptions.RequestException as e: # General request exception
-        print(f"Error calling Modal endpoint {modal_endpoint_url}: {e}") # Corrected MODAL_ENDPOINT_URL to modal_endpoint_url
-        response_json = {
-            "status": "error",
-            "error_details": {
-                "message": "Failed to connect to video analysis service.",
-                "details": str(e),
-                "endpoint_url": modal_endpoint_url # Corrected MODAL_ENDPOINT_URL to modal_endpoint_url
-            }
-        }
-    except Exception as e: # Catch-all for other unexpected errors
-        print(f"An unexpected error occurred in process_video_input: {e}")
-        import traceback
-        traceback.print_exc()
-        response_json = {
-            "status": "error",
-            "error_details": {
-                "message": f"An unexpected error occurred: {str(e)}",
-                "exception_type": type(e).__name__
-            }
-        }
+import httpx
+from typing import Dict, Any
+
+# --- Backend Client Functions ---
+# These functions call the Modal/backend endpoints.
+
+async def call_video_analysis_backend(video_url: str) -> Dict[str, Any]:
+    """Calls the backend to analyze a single video."""
+    # Default to a placeholder if the env var is not set, to avoid crashing.
+    backend_url = os.getenv("BACKEND_VIDEO_URL", "https://your-backend-hf-space-for-video/process_video_analysis")
+    if not video_url:
+        return {"status": "error", "message": "Video URL cannot be empty."}
     
-    return response_json
-
-def process_video_input_new(input_string: str) -> Dict[str, Any]:
-    """
-    Processes the video (from URL or local file path) and returns its transcription status as a JSON object.
-    """
-    if not input_string:
-        return {
-            "status": "error",
-            "error_details": {
-                "message": "No video URL or file path provided.",
-                "input_received": input_string
-            }
-        }
-
-    video_path_to_process = None
-    # Get base_modal_url and construct modal_endpoint_url
-    base_modal_url = os.getenv("MODAL_APP_BASE_URL")
-    if not base_modal_url:
-        print("ERROR: MODAL_APP_BASE_URL environment variable not set.")
-        return {
-            "status": "error",
-            "error_details": {
-                "message": "Modal application base URL is not configured. Please set the MODAL_APP_BASE_URL environment variable.",
-                "input_received": input_string
-            }
-        }
-    modal_endpoint_url = base_modal_url.rstrip('/')
-    print(f"Using Modal endpoint URL: {modal_endpoint_url}")
-
+    print(f"Sending request to backend for video: {video_url}")
+    payload = {"video_url": video_url}
     try:
-        if input_string.startswith("http://") or input_string.startswith("https://"):
-            # Send URL as JSON payload to the Modal backend
-            payload = {"video_url": input_string}
-            print(f"Sending video URL as JSON payload: {payload}")
-            response = requests.post(modal_endpoint_url, json=payload, timeout=1860)
-        else:
-            # Local file path - still need to send as JSON for now (until we support file uploads)
-            return {"status": "error", "error_details": {"message": "Local file upload not yet supported. Please provide a video URL."}}
-            
-        response.raise_for_status()
-        result = response.json()
-        print(f"Modal backend response: {result}")
-        return result
-        
-    except requests.exceptions.HTTPError as e:
-        error_msg = f"HTTP {e.response.status_code}: {e.response.text[:200] if e.response else 'Unknown error'}"
-        print(f"HTTP error: {error_msg}")
-        return {"status": "error", "error_details": {"message": f"Video analysis service returned an error: {e.response.status_code}", "details": error_msg, "endpoint_url": modal_endpoint_url}}
-    except requests.exceptions.RequestException as e:
-        print(f"Request error: {e}")
-        return {"status": "error", "error_details": {"message": "Failed to connect to video analysis service", "details": str(e), "endpoint_url": modal_endpoint_url}}
+        async with httpx.AsyncClient(timeout=1800.0) as client:
+            response = await client.post(backend_url, json=payload)
+            response.raise_for_status()
+            return response.json()
+    except httpx.HTTPStatusError as e:
+        return {"status": "error", "message": f"Backend Error: {e.response.status_code}", "details": e.response.text}
     except Exception as e:
-        print(f"Unexpected error: {e}")
-        return {"status": "error", "error_details": {"message": "Unexpected error during video analysis", "details": str(e), "endpoint_url": modal_endpoint_url}}
-
-# Gradio Interface for the API endpoint
-api_interface = gr.Interface(
-    fn=process_video_input_new,
-    inputs=gr.Textbox(lines=1, label="Video URL or Local File Path for Interpretation",
-                      placeholder="Enter YouTube URL, direct video URL (.mp4, .mov, etc.), or local file path..."),
-    outputs=gr.JSON(label="API Response"),
-    title="Video Interpretation Input",
-    description="Provide a video URL or local file path to get its interpretation status as JSON.",
-    flagging_options=None,
-    examples=[
-        ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
-        ["https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"]
-    ]
-)
+        return {"status": "error", "message": "Failed to connect to backend", "details": str(e)}
 
-# Gradio Interface for a simple user-facing demo
-def demo_process_video(input_string: str) -> tuple[str, Dict[str, Any]]:
-    """
-    A simple demo function for the Gradio UI.
-    It calls process_video_input and unpacks its result for separate display.
-    """
-    result = process_video_input(input_string)
-    status_str = result.get("status", "Unknown Status")
+async def call_topic_analysis_backend(topic: str, max_videos: int) -> Dict[str, Any]:
+    """Calls the backend to analyze videos for a topic."""
+    backend_url = os.getenv("BACKEND_TOPIC_URL", "https://your-backend-hf-space-for-topic/analyze_topic")
+    if not topic:
+        return {"status": "error", "message": "Topic cannot be empty."}
     
-    # The second part of the tuple should be the 'data' if successful, 
-    # or the 'error_details' (or the whole result) if there was an error.
-    if status_str == "success" and "data" in result:
-        details_json = result["data"]
-    elif "error_details" in result:
-        details_json = result["error_details"]
-    else: # Fallback, show the whole result
-        details_json = result
-        
-    return status_str, details_json
-
-
-def call_topic_analysis_endpoint(topic_str: str, max_vids: int) -> Dict[str, Any]:
-    """Calls the Modal FastAPI endpoint for topic-based video analysis."""
-    if not topic_str:
-        return {"status": "error", "error_details": {"message": "Topic cannot be empty."}}
-    if not (1 <= max_vids <= 10): # Max 10 as defined in FastAPI endpoint, can adjust
-        return {"status": "error", "error_details": {"message": "Max videos must be between 1 and 10."}}
-
-    base_modal_url = os.getenv("MODAL_APP_BASE_URL")
-    if not base_modal_url:
-        print("ERROR: MODAL_APP_BASE_URL environment variable not set.")
-        return {
-            "status": "error",
-            "error_details": {
-                "message": "Modal application base URL is not configured. Please set the MODAL_APP_BASE_URL environment variable."
-            }
-        }
-    topic_endpoint_url = f"{base_modal_url.rstrip('/')}/analyze_topic"
-
-    params = {"topic": topic_str, "max_videos": max_vids}
-    print(f"Calling Topic Analysis endpoint: {topic_endpoint_url} with params: {params}")
-
+    print(f"Sending request to backend for topic: {topic} ({max_videos} videos)")
+    payload = {"topic": topic, "max_videos": max_videos}
     try:
-        # Using POST as defined in modal_whisper_app.py for /analyze_topic
-        response = requests.post(topic_endpoint_url, params=params, timeout=3660) # Long timeout for multiple videos
-        response.raise_for_status()
-        results = response.json()
-        print(f"Received results from Topic Analysis endpoint: {str(results)[:200]}...")
-        return results # The endpoint should return the aggregated JSON directly
-    except requests.exceptions.Timeout:
-        print(f"Request to Topic Analysis endpoint {topic_endpoint_url} timed out.")
-        return {"status": "error", "error_details": {"message": "Request to topic analysis service timed out."}}
-    except requests.exceptions.HTTPError as e:
-        print(f"HTTP error calling Topic Analysis endpoint {topic_endpoint_url}: {e.response.status_code} - {e.response.text}")
-        return {"status": "error", "error_details": {"message": f"Topic analysis service returned an error: {e.response.status_code}", "details": e.response.text}}
-    except requests.exceptions.RequestException as e:
-        print(f"Error calling Topic Analysis endpoint {topic_endpoint_url}: {e}")
-        return {"status": "error", "error_details": {"message": "Failed to connect to topic analysis service.", "details": str(e)}}
+        async with httpx.AsyncClient(timeout=3600.0) as client:
+            response = await client.post(backend_url, json=payload)
+            response.raise_for_status()
+            return response.json()
+    except httpx.HTTPStatusError as e:
+        return {"status": "error", "message": f"Backend Error: {e.response.status_code}", "details": e.response.text}
     except Exception as e:
-        print(f"An unexpected error occurred: {e}")
-        return {"status": "error", "error_details": {"message": "An unexpected error occurred during topic analysis call.", "details": str(e)}}
+        return {"status": "error", "message": "Failed to connect to backend", "details": str(e)}
 
-demo_interface = gr.Interface(
-    fn=demo_process_video,
-    inputs=gr.Textbox(lines=1, label="Video URL or Local File Path", placeholder="Enter YouTube URL, direct video URL, or local file path...", scale=3),
-    outputs=[gr.Textbox(label="Status"), gr.JSON(label="Comprehensive Analysis Output", scale=2)],
-    title="Video Interpretation Demo",
-    description="Provide a video URL or local file path to see its transcription status.",
-    flagging_options=None
-)
+# --- Gradio Tool Functions (Wrappers for MCP) ---
 
-js_code_for_head = """
-    console.log('[MCP Script] Initializing script to change API link text...');
-    let foundAndChangedGlobal = false; // Declare here to be accessible in setInterval
+async def analyze_video(video_url: str):
+    """
+    Triggers a comprehensive analysis of a single video from a URL.
 
-    function attemptChangeApiLinkText() {
-        const links = document.querySelectorAll('a');
-        // console.log('[MCP Script] Found ' + links.length + ' anchor tags on this attempt.');
-        for (let i = 0; i < links.length; i++) {
-            const linkText = links[i].textContent ? links[i].textContent.trim() : '';
-            if (linkText === 'Use via API' || linkText === 'Share via Link') { // Target both possible texts
-                links[i].textContent = 'Use as an MCP or via API';
-                console.log('[MCP Script] Successfully changed link text from: ' + linkText);
-                foundAndChangedGlobal = true;
-                return true; // Indicate success
-            }
-        }
-        return false; // Indicate not found/changed in this attempt
-    }
+    This tool calls a backend service to perform multiple analyses:
+    - Transcribes audio to text.
+    - Generates a descriptive caption for the video content.
+    - Recognizes main actions in the video.
+    - Detects objects in keyframes.
 
-    let attempts = 0;
-    const maxAttempts = 50; // Try for up to 5 seconds (50 * 100ms)
-    let initialScanDone = false;
+    :param video_url: The public URL of the video to be processed (e.g., a YouTube link).
+    :return: A JSON object containing the full analysis results from the backend.
+    """
+    status_update = f"Analyzing video: {video_url}..."
+    results = await call_video_analysis_backend(video_url)
+    if isinstance(results, dict) and results.get("analysis") is None:
+        status_update = f"Error analyzing video: {results.get('error', 'Unknown error')}"
+    else:
+        status_update = "Video analysis complete."
+    return status_update, results
 
-    const intervalId = setInterval(() => {
-        if (!initialScanDone && attempts === 0) {
-            console.log('[MCP Script] Performing initial scan for API link text.');
-            initialScanDone = true;
-        }
+async def analyze_topic(topic: str, max_videos: int):
+    """
+    Finds and analyzes multiple videos based on a given topic.
 
-        if (attemptChangeApiLinkText() || attempts >= maxAttempts) {
-            clearInterval(intervalId);
-            if (attempts >= maxAttempts && !foundAndChangedGlobal) {
-                console.log('[MCP Script] Max attempts reached. Target link was not found or changed. It might not be rendered or has a different initial text.');
-            }
-        }
-        attempts++;
-    }, 100);
-"""
+    This tool calls a backend service that searches for videos related to the topic,
+    then runs a comprehensive analysis on each video found.
 
-# Combine interfaces into a Blocks app
-with gr.Blocks(head=f"<script>{js_code_for_head}</script>") as app:
-    gr.Markdown("# LLM Video interpretation MCP")
-    gr.Markdown("This Hugging Face Space acts as a backend for processing video context for AI models.")
+    :param topic: The topic to search for (e.g., 'latest AI advancements').
+    :param max_videos: The maximum number of videos to find and analyze (1-5).
+    :return: A JSON object with the aggregated analysis results for all videos.
+    """
+    status_update = f"Analyzing topic '{topic}' with {max_videos} videos... this can take a very long time."
+    results = await call_topic_analysis_backend(topic, max_videos)
+    if isinstance(results, dict) and results.get("results") is None:
+        status_update = f"Error analyzing topic: {results.get('error', 'Unknown error')}"
+    else:
+        status_update = "Topic analysis complete."
+    return status_update, results
 
-    with gr.Tab("API Endpoint (for AI Models)"):
-        gr.Markdown("### Use this endpoint from another application (e.g., another Hugging Face Space).")
-        gr.Markdown("The `process_video_input` function (for video interpretation) is exposed here.")
-        api_interface.render()
-        gr.Markdown("**Note:** Some YouTube videos may fail to download if they require login or cookie authentication due to YouTube's restrictions. Direct video links are generally more reliable for automated processing.")
+# --- Gradio UI ---
 
-    with gr.Tab("Interactive Demo"):
-        gr.Markdown("### Test the Full Video Analysis Pipeline")
-        gr.Markdown("Enter a video URL or local file path to get a comprehensive JSON output including transcription, caption, actions, and objects.")
-        input_text = gr.Textbox(lines=1, label="Video URL or Local File Path", placeholder="Enter YouTube URL, direct video URL, or local file path...", scale=3)
-        output_json = gr.JSON(label="Comprehensive Analysis Output", scale=2)
-        
-        with gr.Column(scale=1):
-            submit_btn = gr.Button("Submit", variant="primary")
-            clear_btn = gr.Button("Clear")
-        
-        # Define functions for button actions
-        def handle_submit(input_text):
-            if not input_text.strip():
-                return "Please enter a video URL or file path."
-            return process_video_input_new(input_text.strip())
-        
-        def handle_clear():
-            return "", ""
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# LLM Video Interpretation MCP")
+    gr.Markdown("This Hugging Face Space provides tools for processing video context for AI agents. Use the tools below to analyze videos by URL or by topic.")
+
+    with gr.Tab("Single Video Analysis"):
+        gr.Markdown("## Analyze a single video from a URL")
+        with gr.Row():
+            video_url_input = gr.Textbox(label="Video URL", placeholder="Enter a YouTube or direct video URL...", scale=4)
+        submit_button = gr.Button("Analyze Video", variant="primary")
+        status_text = gr.Textbox(label="Status", interactive=False)
+        json_output = gr.JSON(label="Analysis Results")
         
-        # Connect button events
-        submit_btn.click(fn=handle_submit, inputs=input_text, outputs=output_json)
-        clear_btn.click(fn=handle_clear, outputs=[input_text, output_json])
+        submit_button.click(
+            analyze_video,
+            inputs=[video_url_input],
+            outputs=[status_text, json_output],
+            api_name="analyze_video"
+        )
+        gr.Examples(
+            examples=["https://www.youtube.com/watch?v=3wLg_t_H2Xw", "https://www.youtube.com/watch?v=h42dDpgE7g8"],
+            inputs=video_url_input,
+            fn=analyze_video,
+            outputs=[status_text, json_output]
+        )
+
+    with gr.Tab("Topic Video Analysis"):
+        gr.Markdown("## Analyze multiple videos based on a topic")
+        with gr.Row():
+            topic_input = gr.Textbox(label="Enter a topic", placeholder="e.g., 'Apple Vision Pro review'", scale=3)
+            max_videos_slider = gr.Slider(minimum=1, maximum=5, value=2, step=1, label="Number of Videos to Analyze")
+        topic_submit_button = gr.Button("Analyze Topic", variant="primary")
+        topic_status_text = gr.Textbox(label="Status", interactive=False)
+        topic_json_output = gr.JSON(label="Analysis Results")
         
-        # Example inputs
+        topic_submit_button.click(
+            analyze_topic,
+            inputs=[topic_input, max_videos_slider],
+            outputs=[topic_status_text, topic_json_output],
+            api_name="analyze_topic"
+        )
         gr.Examples(
-            examples=[
-                "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
-                "https://sample-videos.com/zip/10/mp4/SampleVideo_1280x720_1mb.mp4"
-            ],
-            inputs=input_text
+            examples=[["self-driving car technology", 2], ["open source large language models", 3]],
+            inputs=[topic_input, max_videos_slider],
+            fn=analyze_topic,
+            outputs=[topic_status_text, topic_json_output]
         )
+
+# Set environment variables in your Hugging Face Space settings, not here.
+# BACKEND_VIDEO_URL = "https://your-modal-or-backend-url/process_video_analysis"
+# BACKEND_TOPIC_URL = "https://your-modal-or-backend-url/analyze_topic"
+
+demo.launch()
         gr.Markdown("**Processing can take several minutes** depending on video length and model inference times. The cache on the Modal backend will speed up repeated requests for the same video.")
 
     with gr.Tab("Demo (for Manual Testing)"):