Refactor: Send video URL as JSON to backend to fix 413 error

app.py

@@ -108,164 +108,109 @@ def process_video_input(input_string: str) -> Dict[str, Any]:
         }
 
     video_path_to_process = None
-    created_temp_dir = None  # To store path of temp directory if created for download
+    # 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}")
-            created_temp_dir = tempfile.mkdtemp()
-            print(f"Created temporary directory for download: {created_temp_dir}")
-            downloaded_path = download_video(input_string, created_temp_dir)
-            
-            if downloaded_path and os.path.exists(downloaded_path):
-                video_path_to_process = downloaded_path
-            else:
-                # Error message is already printed by download_video or this block
-                print(f"Failed to download or locate video from URL: {input_string}")
-                # Cleanup is handled in finally, so just return error
-                return {
-                    "status": "error",
-                    "error_details": {
-                        "message": "Failed to download video from URL.",
-                        "input_received": input_string
-                    }
-                }
+            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}")
-            video_path_to_process = input_string
-        else:
-            return {
-                "status": "error",
-                "error_details": {
-                    "message": f"Input '{input_string}' is not a valid URL or an existing file path.",
-                    "input_received": input_string
-                }
-            }
-
-        if video_path_to_process:
-            print(f"Processing video: {video_path_to_process}")
-            print(f"Video path to process: {video_path_to_process}")
+            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:
-                print("Reading video file into bytes...")
                 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.")
-
-                # Ensure MODAL_TOKEN_ID and MODAL_TOKEN_SECRET are set as environment variables
-                # in your Hugging Face Space. For local `python app.py` runs, Modal CLI's
-                # authenticated state is usually used.
-                # os.environ["MODAL_TOKEN_ID"] = "your_modal_token_id" # Replace or set in HF Space
-                # os.environ["MODAL_TOKEN_SECRET"] = "your_modal_token_secret" # Replace or set in HF Space
-
-                print("Preparing to call Modal FastAPI endpoint for comprehensive analysis...")
-                # IMPORTANT: Replace this with your actual Modal app's deployed FastAPI endpoint URL
-                # This URL is typically found in your Modal deployment logs or dashboard.
-                # It will look something like: https://YOUR_MODAL_WORKSPACE--video-analysis-gradio-pipeline-process-video-for-analysis.modal.run/analyze_video
-                # Or, if the FastAPI endpoint function itself is not separately deployed but part of the main app deployment:
-                # https://YOUR_MODAL_WORKSPACE--video-analysis-gradio-pipeline-fastapi-app.modal.run/analyze_video 
-                # (The exact name depends on how Modal names the deployed web endpoint for the FastAPI app)
-                # For now, using a placeholder. This MUST be configured.
-                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"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')}
-                
-                print(f"Calling Modal endpoint: {modal_endpoint_url}")
-                try:
-                    response = requests.post(modal_endpoint_url, files=files, timeout=1860) # Timeout slightly longer than Modal function
-                    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]}...")
-                    return {
-                        "status": "success",
-                        "data": analysis_results
-                    }
-                except requests.exceptions.Timeout:
-                    print(f"Request to Modal endpoint {modal_endpoint_url} timed out.")
-                    return {
-                        "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}")
-                    return {
-                        "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:
-                    print(f"Error calling Modal endpoint {MODAL_ENDPOINT_URL}: {e}")
-                    return {
-                        "status": "error",
-                        "error_details": {
-                            "message": "Failed to connect to video analysis service.",
-                            "details": str(e),
-                            "endpoint_url": MODAL_ENDPOINT_URL
-                        }
-                    }
-            except FileNotFoundError:
-                print(f"Error: Video file not found at {video_path_to_process} before sending to Modal.")
-                return {
+                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 processing.",
+                        "message": "Video file disappeared before it could be read for upload.",
                         "path_attempted": video_path_to_process
                     }
                 }
-            except modal.Error as e: # Using modal.Error as the base Modal exception
-                print(f"Modal specific error: {e}")
-                return {
-                    "status": "error",
-                    "error_details": {
-                        "message": f"Error during Modal operation: {str(e)}",
-                        "exception_type": type(e).__name__
-                    }
-                }
-            except Exception as e:
-                print(f"An unexpected error occurred while calling Modal: {e}")
-                import traceback
-                traceback.print_exc()
-                return {
-                    "status": "error",
-                    "error_details": {
-                        "message": f"Failed to get transcription: {str(e)}",
-                        "exception_type": type(e).__name__
-                    }
-                }
         else:
-            # This case should ideally be caught by earlier checks
-            return {
+            # 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": "No video available to process after input handling.",
+                    "message": f"Input '{input_string}' is not a valid URL or an existing file path.",
                     "input_received": input_string
                 }
             }
-            
-    finally:
-        if created_temp_dir and os.path.exists(created_temp_dir):
-            print(f"Cleaning up temporary directory: {created_temp_dir}")
-            try:
-                shutil.rmtree(created_temp_dir)
-                print(f"Successfully removed temporary directory: {created_temp_dir}")
-            except Exception as e:
-                print(f"Error removing temporary directory {created_temp_dir}: {e}")
+
+        # 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__
+            }
+        }
+    
+    return response_json
 
 # Gradio Interface for the API endpoint
 api_interface = gr.Interface(