Update app.py

app.py

@@ -116,102 +116,62 @@
 #     interface = create_interface()
 #     interface.launch()
 
-
 import gradio as gr
-from pathlib import Path
 import os
+from pathlib import Path
+from gradio_client import Client
 from dotenv import load_dotenv
-import time
-import requests
-import traceback
 
 # Load environment variables
 load_dotenv()
 
-# Get Hugging Face token from environment
-HF_TOKEN = os.getenv("HF_TOKEN")
+def create_client():
+    """Create a client connection to the private space"""
+    hf_token = os.getenv("HF_TOKEN")
+    if not hf_token:
+        raise ValueError("HF_TOKEN environment variable not set")
+        
+    return Client(
+        "wxcyn/video-analysis",
+        hf_token=hf_token
+    )
 
 def process_video(video_file, question, password, progress=gr.Progress()):
+    """Process video by calling the private space API"""
     try:
         if video_file is None:
             return "Error: No video file uploaded.", None
-            
-        if not password:
-            return "Error: Password is required.", None
-
-        progress(0.2, desc="Preparing request...")
-
-        # Configure the API endpoint
-        SPACE_NAME = "wxcyn-video-analysis"  # Replace with your space name
-        api_url = f"https://{SPACE_NAME}.hf.space/run/predict"
-
-        headers = {
-            'Authorization': f'Bearer {HF_TOKEN}'
-        }
 
-        # Prepare the multipart form data exactly as your private space expects it
-        files = {
-            'video_file': ('video.mp4', open(video_file.name, 'rb'), 'video/mp4')
-        }
+        progress(0.2, desc="Connecting to video analysis service...")
+        client = create_client()
 
-        data = {
-            'question': question,
-            'password': password
-        }
-
-        progress(0.4, desc="Sending to analysis server...")
-
-        response = requests.post(
-            api_url,
-            headers=headers,
-            files=files,
-            data=data
+        progress(0.4, desc="Uploading and processing video...")
+        result = client.predict(
+            video_file.name,    # video_file path
+            question,           # question
+            password,           # password
+            api_name="/process_video"
         )
 
-        progress(0.8, desc="Processing response...")
-
-        if response.status_code == 200:
-            try:
-                result = response.json()
-                if isinstance(result, dict) and 'data' in result:
-                    # Handle the standard Gradio API response format
-                    analysis_text = result['data'][0]
-                    video_clip = result['data'][1] if len(result['data']) > 1 else None
-                else:
-                    # Handle direct response format
-                    analysis_text = result[0] if isinstance(result, list) else str(result)
-                    video_clip = result[1] if isinstance(result, list) and len(result) > 1 else None
-                return analysis_text, video_clip
-            except Exception as e:
-                print(f"Error parsing response: {str(e)}")
-                print(f"Response content: {response.text}")
-                return "Error: Invalid response format from server.", None
+        # Unpack results
+        if isinstance(result, tuple) and len(result) == 2:
+            analysis_text, video_clip = result
+            return analysis_text, video_clip
         else:
-            error_message = f"Error: Failed to process video. Status code: {response.status_code}"
-            try:
-                error_detail = response.json()
-                error_message += f"\nDetails: {error_detail}"
-            except:
-                error_message += f"\nResponse: {response.text}"
-            print(error_message)
-            return error_message, None
-            
+            return str(result), None
+
     except Exception as e:
-        print(f"Error processing video: {traceback.format_exc()}")
-        return f"An error occurred: {str(e)}", None
-    finally:
-        # Make sure to close any opened files
-        try:
-            files['video_file'][1].close()
-        except:
-            pass
+        print(f"Error processing video: {e}")
+        return f"Error processing video: {str(e)}", None
 
 def create_interface():
-    with gr.Blocks(title="Video Analysis Interface") as interface:
+    """Create the Gradio interface"""
+    with gr.Blocks(title="Public Video Analysis Interface") as interface:
         gr.Markdown("# Video Content Analysis (1 file under 2.5 minutes)")
         
         with gr.Row():
             with gr.Column(scale=2):
+                # Input components
                 password = gr.Textbox(
                     label="Password",
                     type="password",
@@ -219,7 +179,7 @@ def create_interface():
                     interactive=True
                 )
                 video_file = gr.File(
-                    label="Upload Video File (up to 30MB)",
+                    label="Upload Video File(up to 30MB)",
                     file_types=['video'],
                     interactive=True
                 )
@@ -231,6 +191,7 @@ def create_interface():
                 submit_btn = gr.Button("Analyze Video", variant="primary")
 
             with gr.Column(scale=3):
+                # Output components
                 output_text = gr.Textbox(
                     label="Analysis Result",
                     lines=15,
@@ -241,6 +202,7 @@ def create_interface():
                     interactive=False
                 )
 
+        # Connect components
         submit_btn.click(
             fn=process_video,
             inputs=[video_file, question, password],
@@ -249,19 +211,16 @@ def create_interface():
 
     return interface
 
-# Entry point
 if __name__ == "__main__":
-    if not HF_TOKEN:
-        raise ValueError("HF_TOKEN environment variable is not set")
-    
+    # Create required directories
     Path('data').mkdir(exist_ok=True)
     Path('temp').mkdir(exist_ok=True)
     
+    # Create and launch interface
     interface = create_interface()
-    interface.launch(server_name="0.0.0.0", server_port=7860)
-else:
-    # For Hugging Face Spaces deployment
-    Path('data').mkdir(exist_ok=True)
-    Path('temp').mkdir(exist_ok=True)
-    interface = create_interface()
-    interface.launch(server_name="0.0.0.0", server_port=7860)
+    interface.launch(
+        server_name="0.0.0.0", 
+        server_port=7860,
+        share=True,
+        show_error=True  # Enable verbose error reporting
+    )