Update app.py

app.py

@@ -1,148 +1,167 @@
-# Theorem Explain Agent - Video Generation App
-# Updated: 2025-06-12 - Fixed Gradio interface
+# app.py (Final version with live logging and corrections)
+
 import gradio as gr
 import uuid
 import subprocess
 import threading
 import os
 import time
-from fastapi import FastAPI
-from fastapi.responses import FileResponse
-import asyncio
 import sys
+import re
+import traceback
 
-
-# A simple in-memory dictionary to track task status.
-# For a production system, you'd use a database or Redis.
-tasks = {}
+# Add project root to Python path to fix any import issues
 sys.path.insert(0, os.getcwd())
+
 # --- Download Kokoro models if they don't exist ---
 model_dir = "models"
-if not os.path.exists(os.path.join(model_dir, "kokoro-v0_19.onnx")):
+kokoro_model_path = os.path.join(model_dir, "kokoro-v0_19.onnx")
+kokoro_voices_path = os.path.join(model_dir, "voices.bin")
+
+if not os.path.exists(kokoro_model_path) or not os.path.exists(kokoro_voices_path):
     print("Downloading Kokoro TTS models...")
     os.makedirs(model_dir, exist_ok=True)
-    os.system(f"wget -P {model_dir} https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files/kokoro-v0_19.onnx")
-    os.system(f"wget -P {model_dir} https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files/voices.bin")
+    # Using specific wget commands for clarity and robustness
+    os.system(f"wget -O {kokoro_model_path} https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files/kokoro-v0_19.onnx")
+    os.system(f"wget -O {kokoro_voices_path} https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files/voices.bin")
     print("Model download complete.")
 
+# In-memory dictionary to track task status.
+tasks = {}
+
 def run_video_generation(task_id: str, topic: str, context: str, model: str):
     """
-    This function runs the main generation script in a separate process.
+    Runs the main generation script in a separate process and captures output in real-time.
     """
     tasks[task_id]['status'] = 'running'
+    tasks[task_id]['log'] = 'Process started...\n'
     
-    # Sanitize topic to create a valid directory name
-    file_prefix = "".join(c if c.isalnum() else "_" for c in topic.lower())
+    # Sanitize topic name to create a valid directory/file prefix
+    file_prefix = re.sub(r'[^a-z0-9_]+', '_', topic.lower())
+    # The generate_video.py script will create this directory inside the general 'output' folder
     output_dir = os.path.join("output", file_prefix)
     
+    # --- IMPORTANT: Command points to the specific output directory for this topic ---
     command = [
-        "python", "generate_video.py",
+        "python", "-u", "generate_video.py", # '-u' for unbuffered output
         "--model", model,
         "--topic", topic,
         "--context", context,
-        "--output_dir", "output",
-        # "--use_langfuse"
+        "--output_dir", output_dir
+        # Langfuse is disabled by not including the --use_langfuse flag
     ]
 
     try:
-        # Using subprocess to run the existing script
-        process = subprocess.run(command, check=True, capture_output=True, text=True)
+        # Use Popen to run the process in the background and stream output
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            universal_newlines=True,
+        )
+        
+        # Read output line-by-line in real-time
+        for line in iter(process.stdout.readline, ''):
+            print(line, end='')  # Print to Hugging Face console logs
+            tasks[task_id]['log'] += line
         
-        # Look for the output video in the directory
-        video_path = None
-        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'
-            tasks[task_id]['video_path'] = video_path
+        process.wait() # Wait for the process to complete
+        
+        if process.returncode == 0:
+            # Check for the final combined video file
+            final_video_path = os.path.join(output_dir, f"{file_prefix}_combined.mp4")
+            
+            if os.path.exists(final_video_path):
+                tasks[task_id]['status'] = 'completed'
+                tasks[task_id]['video_path'] = final_video_path
+                tasks[task_id]['log'] += f"\n✅ Success! Video available at: {final_video_path}"
+            else:
+                tasks[task_id]['status'] = 'failed'
+                tasks[task_id]['error'] = "Script finished, but the final combined video file was not found."
+                tasks[task_id]['log'] += f"\n❌ Error: Output video not found at {final_video_path}"
         else:
             tasks[task_id]['status'] = 'failed'
-            tasks[task_id]['error'] = "Video file not found after generation."
-            
-    except subprocess.CalledProcessError as e:
-        tasks[task_id]['status'] = 'failed'
-        tasks[task_id]['error'] = str(e)
+            tasks[task_id]['error'] = f"Process failed with return code {process.returncode}."
+            tasks[task_id]['log'] += f"\n❌ Error: Process failed. Check logs for details."
+
     except Exception as e:
+        print(f"Caught an exception: {e}")
         tasks[task_id]['status'] = 'failed'
         tasks[task_id]['error'] = str(e)
+        tasks[task_id]['log'] += f"\n❌ An exception occurred: {traceback.format_exc()}"
 
 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', 'model': model}
+    tasks[task_id] = {'status': 'queued', 'model': model, 'log': ''}
 
-    # Use a background thread to run the time-consuming task
     thread = threading.Thread(
         target=run_video_generation,
         args=(task_id, topic, context, model)
     )
     thread.start()
     
-    return f"Task started with model {model}. Your Task ID is: {task_id}", task_id
+    return f"✅ Task started with ID: {task_id}. Go to 'Check Status' tab to monitor progress.", task_id
 
 def check_status(task_id: str):
     if not task_id:
-        return "Please provide a Task ID.", None
+        return "Please provide a Task ID.", None, "Please enter a Task ID above and click 'Check Status'."
         
     task = tasks.get(task_id)
     if not task:
-        return "Task not found.", None
+        return "Task not found.", None, f"No task found with ID: {task_id}"
     
     status = task.get('status')
     model = task.get('model', 'Unknown')
+    log = task.get('log', 'No logs yet...')
     
     if status == 'completed':
         video_path = task.get('video_path')
-        return f"Status: {status} (Model: {model})", video_path
+        status_message = f"✅ Status: {status} (Model: {model})"
+        return status_message, video_path, log
     elif status == 'failed':
         error = task.get('error', 'Unknown error')
-        return f"Status: {status} (Model: {model})\nError: {error}", None
+        status_message = f"❌ Status: {status} (Model: {model})"
+        return status_message, None, log
     
-    return f"Status: {status} (Model: {model})", None
+    status_message = f"🔄 Status: {status} (Model: {model})"
+    return status_message, None, log
 
 # 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.Blocks(css="footer {display: none !important}", title="Theorem Explain Agent") as demo:
+    gr.Markdown("# 🎓 Theorem Explain Agent: Video Generation")
+    gr.Markdown("Generate educational videos explaining mathematical theorems and concepts. This may take several minutes.")
 
     with gr.Tab("🚀 Start Generation"):
-        gr.Markdown("### Enter the details for your video:")
-        model_input = gr.Textbox(
+        gr.Markdown("### 1. Enter the details for your video")
+        model_input = gr.Dropdown(
             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
+            choices=["gemini/gemini-1.5-flash-001", "gemini/gemini-1.5-pro-002"],
+            value="gemini/gemini-1.5-flash-001",
+            info="Select the AI model for content 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.", lines=3)
         start_button = gr.Button("🎬 Generate Video", variant="primary")
         
+        gr.Markdown("### 2. Monitor your task")
         with gr.Row():
             status_output = gr.Textbox(label="Status", interactive=False)
             task_id_output = gr.Textbox(label="Task ID", interactive=False)
     
-    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.Tab("📊 Check Status & View Video"):
+        gr.Markdown("### Paste your Task ID to check progress and view the final video")
+        with gr.Row():
+            task_id_input = gr.Textbox(label="Task ID", placeholder="Enter the Task ID you received")
+            check_button = gr.Button("🔍 Check Status", variant="secondary")
         
-        status_display = gr.Textbox(label="Status", interactive=False)
-        video_output = gr.Video(label="Generated Video")
+        status_display = gr.Textbox(label="Current Status", interactive=False)
+        video_output = gr.Video(label="Generated Video", interactive=False)
+        log_display = gr.Textbox(label="Live Generation Logs", lines=15, interactive=False)
 
     # Connect the functions to the interface
     start_button.click(
@@ -154,29 +173,10 @@ with gr.Blocks(title="Theorem Explain Agent") as demo:
     check_button.click(
         fn=check_status,
         inputs=[task_id_input],
-        outputs=[status_display, video_output]
+        outputs=[status_display, video_output, log_display],
+        # Every 2 seconds, poll the status
+        every=2 
     )
 
-    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
-    ) 
+demo.launch()