Fix Modal deployment using correct FastAPI endpoint pattern and update frontend

app.py

@@ -212,9 +212,63 @@ def process_video_input(input_string: str) -> Dict[str, Any]:
     
     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}")
+
+    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}}
+    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,
+    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"),
@@ -291,7 +345,7 @@ def call_topic_analysis_endpoint(topic_str: str, max_vids: int) -> Dict[str, Any
 
 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..."),
+    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.",
@@ -351,33 +405,33 @@ with gr.Blocks(head=f"<script>{js_code_for_head}</script>") as app:
     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.")
-        with gr.Row():
-            text_input = gr.Textbox(lines=1, label="Video URL or Local File Path", placeholder="Enter YouTube URL, direct video URL, or local file path...", scale=3)
+        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)
         
-        analysis_output = 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")
         
-        with gr.Row():
-            submit_button = gr.Button("Get Comprehensive Analysis", variant="primary", scale=1)
-            clear_button = gr.Button("Clear", scale=1)
-
-        # The 'process_video_input' function returns a single dictionary.
-        submit_button.click(fn=process_video_input, inputs=[text_input], outputs=[analysis_output])
-
-        def clear_all():
-            return [None, None] # Clears text_input and analysis_output
-        clear_button.click(fn=clear_all, inputs=[], outputs=[text_input, analysis_output])
-
+        # 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 "", ""
+        
+        # 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])
+        
+        # Example inputs
         gr.Examples(
             examples=[
-                ["https://www.youtube.com/watch?v=dQw4w9WgXcQ"],
-                ["http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"],
-                # Add a local file path example if you have a common test video, e.g.:
-                # ["./sample_video.mp4"] # User would need this file locally
+                "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+                "https://sample-videos.com/zip/10/mp4/SampleVideo_1280x720_1mb.mp4"
             ],
-            inputs=text_input,
-            outputs=analysis_output, 
-            fn=process_video_input, 
-            cache_examples=False, 
+            inputs=input_text
         )
         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.")
 

modal_whisper_app.py

@@ -5,21 +5,21 @@ from starlette.routing import Mount
 import os
 import tempfile
 import io # Used by Whisper for BytesIO
-import hashlib # For generating cache keys
-import httpx # For downloading video from URL if needed by endpoint
-import gradio as gr
-import gradio.routes
-from typing import Dict, List, Any, Optional # For type hinting results and Optional in Pydantic
-from fastapi.responses import JSONResponse # For FastAPI endpoint
-from fastapi import File, Body, UploadFile, Query # For FastAPI file uploads, request body parts, and query parameters
+import httpx # For downloading videos from URLs
+from typing import Optional, List, Dict, Any
+import json
+import hashlib
+from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel # For FastAPI request body validation
-import re # For parsing search results
+from pydantic import BaseModel
+import re # For parsing search results  
 import asyncio # For concurrent video processing
 
-# --- Constants for Model Names ---
-WHISPER_MODEL_NAME = "openai/whisper-large-v3"
-CAPTION_MODEL_NAME = "Neleac/SpaceTimeGPT"
+import gradio as gr
+
+# Global Configuration (should be at the top of the file)
+WHISPER_MODEL_NAME = "openai/whisper-large-v3" # Use latest Whisper model
+CAPTION_MODEL_NAME = "microsoft/xclip-base-patch16" # For SpaceTimeGPT alternative
 CAPTION_PROCESSOR_NAME = "MCG-NJU/videomae-base" # For SpaceTimeGPT's video encoder
 # CAPTION_TOKENIZER_NAME = "gpt2" # For SpaceTimeGPT's text decoder (usually part of processor)
 ACTION_MODEL_NAME = "MCG-NJU/videomae-base-finetuned-kinetics"
@@ -49,29 +49,19 @@ video_analysis_image = (
 # --- Modal App Definition ---
 app = modal.App(name="video-analysis-gradio-pipeline") # New app name, using App
 
-fastapi_app = FastAPI() # Initialize FastAPI app
-
-@fastapi_app.get("/")
-async def read_root():
-    return {"message": "FastAPI root is alive!"}
-
-# Define allowed origins for CORS
-origins = [
-    "https://agents-mcp-hackathon-video-mcp.hf.space", # Your Hugging Face Space
-    "http://localhost",
-    "http://localhost:7860", # Default Gradio local port
-    "http://127.0.0.1:7860", # Default Gradio local port
-    # You can add other origins if needed, e.g., your Modal app's direct URL if you access it directly
-    "https://jomasego--video-analysis-gradio-pipeline-main-asgi.modal.run" 
-]
-
-fastapi_app.add_middleware(
-    CORSMiddleware,
-    allow_origins=origins,
-    allow_credentials=True,
-    allow_methods=["*"], # Allows all methods
-    allow_headers=["*"], # Allows all headers
-)
+# --- Pydantic model for web endpoint request ---
+class VideoAnalysisRequestPayload(BaseModel):
+    video_url: str
+
+# --- Constants for Model Names ---
+# WHISPER_MODEL_NAME = "openai/whisper-large-v3"
+# CAPTION_MODEL_NAME = "Neleac/SpaceTimeGPT"
+# CAPTION_PROCESSOR_NAME = "MCG-NJU/videomae-base" # For SpaceTimeGPT's video encoder
+# # CAPTION_TOKENIZER_NAME = "gpt2" # For SpaceTimeGPT's text decoder (usually part of processor)
+# ACTION_MODEL_NAME = "MCG-NJU/videomae-base-finetuned-kinetics"
+# ACTION_PROCESSOR_NAME = "MCG-NJU/videomae-base" # Or VideoMAEImageProcessor.from_pretrained(ACTION_MODEL_NAME)
+# OBJECT_DETECTION_MODEL_NAME = "facebook/detr-resnet-50"
+# OBJECT_DETECTION_PROCESSOR_NAME = "facebook/detr-resnet-50"
 
 # --- Modal Distributed Dictionary for Caching --- 
 video_analysis_cache = modal.Dict.from_name("video_analysis_cache", create_if_missing=True)
@@ -231,6 +221,7 @@ def generate_captions_with_spacetimegpt(video_bytes: bytes) -> str:
         if video_path and os.path.exists(video_path):
             os.remove(video_path)
 
+
 # === 3. Action Recognition with VideoMAE ===
 @app.function(
     image=video_analysis_image,
@@ -447,115 +438,45 @@ async def analyze_video_comprehensive(video_bytes: bytes) -> Dict[str, Any]:
     return results
 
 
-# --- Pydantic model for FastAPI request ---
-class VideoAnalysisRequestPayload(BaseModel):
-    video_url: Optional[str] = None # Reverted to optional
-
-
-# === FastAPI Endpoint for Comprehensive Analysis ===
-@fastapi_app.post("/analyze_video")
-async def process_video_for_analysis(
-    payload: Optional[VideoAnalysisRequestPayload] = Body(None),
-    video_file: Optional[UploadFile] = File(None) # Use UploadFile for type hint and async read
-):
-    print("[FastAPI Endpoint] Received request for comprehensive analysis.")
-    video_bytes_content: Optional[bytes] = None
-    video_source_description: str = "Unknown"
-
-    if video_file: # Prioritize file upload
-        print(f"[FastAPI Endpoint] Processing uploaded video file: {video_file.filename}")
-        video_bytes_content = await video_file.read()
-        await video_file.close() # Important to close the file
-        if not video_bytes_content:
-            print(f"[FastAPI Endpoint] Uploaded video file {video_file.filename} is empty.")
-            return JSONResponse(status_code=400, content={"error": "Uploaded video file is empty."})
-        video_source_description = f"direct file upload: {video_file.filename}"
-        print(f"[FastAPI Endpoint] Read {len(video_bytes_content)} bytes from uploaded file {video_file.filename}.")
-
-    elif payload and payload.video_url:
-        video_url = str(payload.video_url) # Ensure it's a string
-        print(f"[FastAPI Endpoint] Processing video_url: {video_url}")
-        video_source_description = f"URL: {video_url}"
-        try:
-            async with httpx.AsyncClient() as client:
-                response = await client.get(video_url, follow_redirects=True, timeout=60.0) # Download timeout
-                response.raise_for_status()
-                video_bytes_content = await response.aread()
-                if not video_bytes_content:
-                    print(f"[FastAPI Endpoint] Download failed: content was empty for URL: {video_url}")
-                    return JSONResponse(status_code=400, content={"error": f"Failed to download video from URL: {video_url}. Content was empty."})
-                print(f"[FastAPI Endpoint] Successfully downloaded {len(video_bytes_content)} bytes from {video_url}")
-        except httpx.TimeoutException: # Specific timeout exception
-            print(f"[FastAPI Endpoint] Timeout downloading video from URL: {video_url}")
-            return JSONResponse(status_code=408, content={"error": f"Timeout downloading video from URL: {video_url}."})
-        except httpx.RequestError as e:
-            print(f"[FastAPI Endpoint] httpx.RequestError downloading video: {e}")
-            return JSONResponse(status_code=400, content={"error": f"Error downloading video from URL: {video_url}. Details: {str(e)}"})
-        except Exception as e: # Catch any other unexpected error during download
-            print(f"[FastAPI Endpoint] Unexpected Exception downloading video: {e}")
-            return JSONResponse(status_code=500, content={"error": f"Unexpected error downloading video. Details: {str(e)}"})
-    else:
-        # Neither file nor URL provided
-        print("[FastAPI Endpoint] No video_url in payload and no video_file uploaded.")
-        return JSONResponse(status_code=400, content={"error": "Either 'video_url' in JSON payload or a 'video_file' in form-data must be provided."})
-
-    if not video_bytes_content:
-        print("[FastAPI Endpoint] Critical error: video_bytes_content is not populated after input processing.")
-        return JSONResponse(status_code=500, content={"error": "Internal server error: video data could not be obtained."})
-
-    print(f"[FastAPI Endpoint] Calling analyze_video_comprehensive for video from {video_source_description} ({len(video_bytes_content)} bytes).")
+# === FastAPI Endpoint for Video Analysis ===
+@app.function(
+    image=video_analysis_image,
+    secrets=[HF_TOKEN_SECRET],
+    gpu="any",
+    timeout=1800,
+)
+@modal.fastapi_endpoint(method="POST")
+def process_video_analysis(payload: VideoAnalysisRequestPayload):
+    """FastAPI endpoint for comprehensive video analysis."""
+    print(f"[FastAPI Endpoint] Received request for video analysis")
+    
+    video_url = payload.video_url
+    if not video_url:
+        return JSONResponse(status_code=400, content={"error": "video_url must be provided in JSON payload."})
+    
+    print(f"[FastAPI Endpoint] Processing video_url: {video_url}")
     try:
-        # Since process_video_for_analysis is an @app.function, it can .call() another @app.function
-        analysis_results = await analyze_video_comprehensive.call(video_bytes_content)
+        # Download video
+        import httpx
+        with httpx.Client() as client:
+            response = client.get(video_url, follow_redirects=True, timeout=60.0)
+            response.raise_for_status()
+            video_bytes = response.content
+            if not video_bytes:
+                return JSONResponse(status_code=400, content={"error": f"Failed to download video from URL: {video_url}. Content was empty."})
+            print(f"[FastAPI Endpoint] Successfully downloaded {len(video_bytes)} bytes from {video_url}")
+        
+        # Call comprehensive analysis
+        analysis_results = analyze_video_comprehensive.call(video_bytes)
         print("[FastAPI Endpoint] Comprehensive analysis finished.")
         return JSONResponse(status_code=200, content=analysis_results)
-    except modal.exception.ModalError as e:
-        print(f"[FastAPI Endpoint] ModalError during comprehensive analysis: {e}")
-        return JSONResponse(status_code=500, content={"error": f"Modal processing error: {str(e)}"})
-    except Exception as e:
-        print(f"[FastAPI Endpoint] Unexpected Exception during comprehensive analysis: {e}")
-        # import traceback # Uncomment for detailed server-side stack trace
-        # traceback.print_exc() # Uncomment for detailed server-side stack trace
-        return JSONResponse(status_code=500, content={"error": f"Unexpected server error during analysis: {str(e)}"})
-
-
-@fastapi_app.post("/analyze_topic")
-async def analyze_topic_endpoint(topic: str = Query(..., min_length=3, description="The topic to search videos for."), 
-                                 max_videos: Optional[int] = Query(3, ge=1, le=10, description="Maximum number of videos to find and analyze.")):
-    """Endpoint to find videos for a topic, analyze them, and return aggregated results."""
-    print(f"[FastAPI /analyze_topic] Received request for topic: '{topic}', max_videos: {max_videos}")
-    try:
-        print(f"[FastAPI /analyze_topic] Calling find_video_urls_for_topic for topic: '{topic}', max_videos: {max_videos}")
-        # find_video_urls_for_topic is a Modal function that internally calls search_web and extracts URLs
-        video_urls_dict = await find_video_urls_for_topic.call(topic=topic, max_results=max_videos)
-        
-        if "error" in video_urls_dict:
-            print(f"[FastAPI /analyze_topic] Error from find_video_urls_for_topic: {video_urls_dict}")
-            # Use status_code from the error dict if available, otherwise default (e.g., 500)
-            return JSONResponse(status_code=video_urls_dict.get("status_code", 500), content=video_urls_dict)
-
-        video_urls = video_urls_dict.get("video_urls", [])
-
-        if not video_urls:
-            print(f"[FastAPI /analyze_topic] No video URLs found by find_video_urls_for_topic for topic: '{topic}'")
-            return JSONResponse(status_code=404, content={"error": "No relevant video URLs found for the topic after search.", "details": video_urls_dict.get("search_provider_log", "No additional search details.")})
         
-        print(f"[FastAPI /analyze_topic] Found {len(video_urls)} URLs: {video_urls}. Calling analyze_videos_by_topic.")
-        # analyze_videos_by_topic is another Modal function
-        analysis_results = await analyze_videos_by_topic.call(video_urls=video_urls, topic=topic)
-        print(f"[FastAPI /analyze_topic] Analysis complete for topic: '{topic}'.")
-        return JSONResponse(status_code=200, content=analysis_results)
-
-    except modal.exception.ModalError as e:
-        print(f"[FastAPI /analyze_topic] ModalError during topic analysis: {e}")
-        return JSONResponse(status_code=500, content={"error": f"Modal processing error during topic analysis: {str(e)}"})
+    except httpx.RequestError as e:
+        print(f"[FastAPI Endpoint] httpx.RequestError downloading video: {e}")
+        return JSONResponse(status_code=400, content={"error": f"Error downloading video from URL: {video_url}. Details: {str(e)}"})
     except Exception as e:
-        print(f"[FastAPI /analyze_topic] Unexpected Exception during topic analysis: {e}")
-        # import traceback # For server-side debugging
-        # traceback.print_exc() # For server-side debugging
-        return JSONResponse(status_code=500, content={"error": f"Unexpected server error during topic analysis: {str(e)}"})
-
-
+        print(f"[FastAPI Endpoint] Unexpected Exception during analysis: {e}")
+        return JSONResponse(status_code=500, content={"error": f"Unexpected server error during analysis: {str(e)}"})
 
 # === 6. Topic-Based Video Search ===
 @app.function(
@@ -823,22 +744,3 @@ def video_analyzer_gradio_ui():
 
     print("[Gradio] UI definition complete.")
     return gr.routes.App.create_app(demo)
-
-
-# === Main ASGI App (FastAPI + Gradio) ===
-@modal.asgi_app()
-def main_asgi():
-    gradio_asgi_app = video_analyzer_gradio_ui()
-    
-    # fastapi_app is already defined globally and has its routes (@fastapi_app.post, @fastapi_app.get)
-    # We should not mount Gradio inside fastapi_app if we are mounting fastapi_app itself into a Starlette app.
-    # Ensure fastapi_app is 'clean' of the /gradio mount if it was done elsewhere, 
-    # or ensure it's not mounted if we are doing it at the Starlette level.
-    # For this change, we assume fastapi_app does NOT have /gradio mounted internally.
-
-    # Create a new top-level Starlette app
-    top_level_app = Starlette(routes=[
-        Mount("/api", app=fastapi_app),      # Mount FastAPI app under /api
-        Mount("/gradio", app=gradio_asgi_app) # Mount Gradio app under /gradio
-    ])
-    return top_level_app