Force update with corrected Gradio function

app.py

@@ -1,4 +1,6 @@
+# Updated to fix Gradio mount function
 import gradio as gr
+# ... rest of the file
 import uuid
 import subprocess
 import threading
@@ -13,7 +15,7 @@ import asyncio
 # For a production system, you'd use a database or Redis.
 tasks = {}
 
-def run_video_generation(task_id: str, topic: str, context: str):
+def run_video_generation(task_id: str, topic: str, context: str, model: str):
     """
     This function runs the main generation script in a separate process.
     """
@@ -25,25 +27,24 @@ def run_video_generation(task_id: str, topic: str, context: str):
     
     command = [
         "python", "generate_video.py",
-        "--model", "openai/o3-mini",      # Or get from request
+        "--model", model,
         "--topic", topic,
         "--context", context,
         "--output_dir", "output",
-        "--use_langfuse" # Assuming you have secrets set
+        "--use_langfuse"
     ]
 
     try:
         # Using subprocess to run the existing script
         process = subprocess.run(command, check=True, capture_output=True, text=True)
         
-        # Assume the final video is named based on the topic
-        # Note: The actual video path might differ. This is an assumption.
-        # You may need to parse the stdout from generate_video.py to get the exact path.
+        # Look for the output video in the directory
         video_path = None
-        for file in os.listdir(output_dir):
-            if file.endswith("_combined.mp4"):
-                video_path = os.path.join(output_dir, file)
-                break
+        if os.path.exists(output_dir):
+            for file in os.listdir(output_dir):
+                if file.endswith("_combined.mp4"):
+                    video_path = os.path.join(output_dir, file)
+                    break
 
         if video_path and os.path.exists(video_path):
             tasks[task_id]['status'] = 'completed'
@@ -51,34 +52,29 @@ def run_video_generation(task_id: str, topic: str, context: str):
         else:
             tasks[task_id]['status'] = 'failed'
             tasks[task_id]['error'] = "Video file not found after generation."
-            tasks[task_id]['stdout'] = process.stdout
-            tasks[task_id]['stderr'] = process.stderr
             
     except subprocess.CalledProcessError as e:
         tasks[task_id]['status'] = 'failed'
         tasks[task_id]['error'] = str(e)
-        tasks[task_id]['stdout'] = e.stdout
-        tasks[task_id]['stderr'] = e.stderr
     except Exception as e:
         tasks[task_id]['status'] = 'failed'
         tasks[task_id]['error'] = str(e)
 
-def start_generation_thread(topic: str, context: str):
-    if not topic or not context:
-        return "Topic and Context cannot be empty.", "", None
+def start_generation(topic: str, context: str, model: str):
+    if not all([topic, context, model]):
+        return "Topic, Context, and Model cannot be empty.", ""
 
     task_id = str(uuid.uuid4())
-    tasks[task_id] = {'status': 'queued'}
+    tasks[task_id] = {'status': 'queued', 'model': model}
 
     # Use a background thread to run the time-consuming task
     thread = threading.Thread(
         target=run_video_generation,
-        args=(task_id, topic, context)
+        args=(task_id, topic, context, model)
     )
     thread.start()
     
-    return f"Task started. Your Task ID is: {task_id}", task_id, None
-
+    return f"Task started with model {model}. Your Task ID is: {task_id}", task_id
 
 def check_status(task_id: str):
     if not task_id:
@@ -89,79 +85,88 @@ def check_status(task_id: str):
         return "Task not found.", None
     
     status = task.get('status')
+    model = task.get('model', 'Unknown')
+    
     if status == 'completed':
         video_path = task.get('video_path')
-        return f"Status: {status}", video_path
+        return f"Status: {status} (Model: {model})", video_path
     elif status == 'failed':
         error = task.get('error', 'Unknown error')
-        stdout = task.get('stdout', '')
-        stderr = task.get('stderr', '')
-        return f"Status: {status}\nError: {error}\nOutput: {stdout}\nStderr: {stderr}", None
-    
-    return f"Status: {status}", None
-
-# We need a lightweight FastAPI app in the background to serve the video files.
-# Gradio can't serve files directly from arbitrary paths in a secure way.
-fastapi_app = FastAPI()
-
-@fastapi_app.get("/videos/{task_id}")
-def get_video(task_id: str):
-    """
-    Serves the final generated video file.
-    """
-    task = tasks.get(task_id)
-    if not task or task.get('status') != 'completed':
-        return {"error": "Task not completed or not found"}
+        return f"Status: {status} (Model: {model})\nError: {error}", None
     
-    video_path = task.get('video_path')
-    if not os.path.exists(video_path):
-        return {"error": "Video file not found."}
+    return f"Status: {status} (Model: {model})", None
+
+# Create the Gradio interface
+with gr.Blocks(title="Theorem Explain Agent") as demo:
+    gr.Markdown("# 🎓 Theorem-Explain-Agent Video Generation")
+    gr.Markdown("Generate educational videos explaining mathematical theorems and concepts.")
+
+    with gr.Tab("🚀 Start Generation"):
+        gr.Markdown("### Enter the details for your video:")
+        model_input = gr.Textbox(
+            label="Model", 
+            placeholder="e.g., gemini/gemini-1.5-flash, openai/gpt-4o",
+            value="gemini/gemini-1.5-flash"
+        )
+        topic_input = gr.Textbox(
+            label="Topic", 
+            placeholder="e.g., The Pythagorean Theorem"
+        )
+        context_input = gr.Textbox(
+            label="Context", 
+            placeholder="A short explanation of the theorem.",
+            lines=3
+        )
+        start_button = gr.Button("🎬 Generate Video", variant="primary")
         
-    return FileResponse(video_path, media_type="video/mp4", filename=os.path.basename(video_path))
-
-
-# Gradio Interface
-with gr.Blocks() as demo:
-    gr.Markdown("# Theorem-Explain-Agent Video Generation")
-    gr.Markdown("Start a video generation task and check its status.")
-
-    with gr.Tab("Start Generation"):
-        topic_input = gr.Textbox(label="Topic", placeholder="e.g., The Pythagorean Theorem")
-        context_input = gr.Textbox(label="Context", placeholder="A short explanation of the theorem.")
-        start_button = gr.Button("Generate Video")
-        
-        with gr.Column():
+        with gr.Row():
+            status_output = gr.Textbox(label="Status", interactive=False)
             task_id_output = gr.Textbox(label="Task ID", interactive=False)
-            status_output_start = gr.Textbox(label="Status", interactive=False)
     
-    with gr.Tab("Check Status"):
-        task_id_input = gr.Textbox(label="Task ID", placeholder="Enter the Task ID you received.")
-        check_button = gr.Button("Check Status")
+    with gr.Tab("📊 Check Status"):
+        gr.Markdown("### Check the status of your video generation:")
+        task_id_input = gr.Textbox(
+            label="Task ID", 
+            placeholder="Enter the Task ID you received"
+        )
+        check_button = gr.Button("🔍 Check Status", variant="secondary")
         
-        with gr.Column():
-            status_output_check = gr.Textbox(label="Status", interactive=False)
-            video_output = gr.Video(label="Generated Video")
+        status_display = gr.Textbox(label="Status", interactive=False)
+        video_output = gr.Video(label="Generated Video")
 
-    # Actions
+    # Connect the functions to the interface
     start_button.click(
-        fn=start_generation_thread,
-        inputs=[topic_input, context_input],
-        outputs=[status_output_start, task_id_output, video_output] # Clear video on new task
+        fn=start_generation,
+        inputs=[topic_input, context_input, model_input],
+        outputs=[status_output, task_id_output]
     )
     
     check_button.click(
         fn=check_status,
         inputs=[task_id_input],
-        outputs=[status_output_check, video_output]
+        outputs=[status_display, video_output]
     )
 
-    gr.Markdown("### How to Use")
-    gr.Markdown(
-        "1.  Enter a `Topic` and `Context` in the 'Start Generation' tab and click 'Generate Video'.\n"
-        "2.  Copy the `Task ID` that appears.\n"
-        "3.  Go to the 'Check Status' tab, paste the `Task ID`, and click 'Check Status' periodically.\n"
-        "4.  When the generation is complete, the video will appear."
-    )
-
-# To run both Gradio and FastAPI, we mount the FastAPI app into Gradio's internal FastAPI app.
-app = gr.mount_ όπου(demo, fastapi_app, path="/") 
+    gr.Markdown("""
+    ### 📋 How to Use:
+    1. **Start Generation**: Enter a Model, Topic, and Context, then click 'Generate Video'
+    2. **Copy the Task ID** that appears
+    3. **Check Status**: Go to the 'Check Status' tab, paste your Task ID, and click 'Check Status'
+    4. **Wait**: Video generation can take several minutes. Check periodically until complete
+    5. **Download**: When complete, the video will appear and can be downloaded
+    
+    ### 🤖 Supported Models:
+    - `gemini/gemini-1.5-flash` (recommended)
+    - `gemini/gemini-1.5-pro`
+    - `openai/gpt-4o`
+    - `openai/o3-mini`
+    - `anthropic/claude-3-opus-20240229`
+    """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )