making the app in direct mode

start.sh

@@ -1,13 +1,29 @@
 #!/bin/bash
 
-# Start the API server in the background
-echo "Starting API Server on port 8003..."
-python api_server.py &
+# ============================================================================
+# Vidsimplify Startup Script for Hugging Face Spaces
+# ============================================================================
+# 
+# This script starts only the Streamlit app in DIRECT_MODE.
+# In DIRECT_MODE, the app executes video generation directly without
+# needing a separate API server, which is ideal for Hugging Face Spaces.
+#
+# For local development with the API server, set DIRECT_MODE=false
+# and run: python api_server.py & streamlit run streamlit_app.py
+# ============================================================================
 
-# Wait a few seconds for the API to initialize
-sleep 5
+# Ensure DIRECT_MODE is enabled for Hugging Face
+export DIRECT_MODE=true
+
+# Ensure all required directories exist
+mkdir -p media/voiceover/elevenlabs
+mkdir -p media/voiceover/gtts
+mkdir -p media/videos
 
 # Start Streamlit
 # Hugging Face Spaces expects the app to run on port 7860
-echo "Starting Streamlit on port 7860..."
+echo "🎬 Starting Vidsimplify in Direct Mode..."
+echo "   Port: 7860"
+echo "   Mode: Direct (no API server needed)"
+echo ""
 streamlit run streamlit_app.py --server.port 7860 --server.address 0.0.0.0

streamlit_app.py

@@ -1,8 +1,25 @@
+"""
+Vidsimplify Streamlit Application
+
+Supports two modes:
+1. DIRECT MODE (for Hugging Face) - directly executes generation code
+2. API MODE (for local development) - uses the FastAPI server
+
+Set DIRECT_MODE=true in environment to use direct execution.
+"""
+
 import streamlit as st
-import requests
+import os
 import time
 import base64
+import uuid
+import subprocess
+import asyncio
 from pathlib import Path
+from datetime import datetime
+
+# Check if we're in direct mode (for Hugging Face deployment)
+DIRECT_MODE = os.getenv("DIRECT_MODE", "true").lower() == "true"
 
 # Page config
 st.set_page_config(
@@ -41,25 +58,240 @@ st.markdown("""
     .css-1d391kg {
         padding-top: 3rem;
     }
+    .status-box {
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+    }
+    .status-generating {
+        background-color: #1e3a5f;
+        border-left: 4px solid #3b82f6;
+    }
+    .status-rendering {
+        background-color: #1e3a5f;
+        border-left: 4px solid #f59e0b;
+    }
+    .status-complete {
+        background-color: #1a3d2e;
+        border-left: 4px solid #10b981;
+    }
+    .status-error {
+        background-color: #3d1a1a;
+        border-left: 4px solid #ef4444;
+    }
 </style>
 """, unsafe_allow_html=True)
 
+
+# ============================================================================
+# Direct Mode Functions (No API needed)
+# ============================================================================
+
+def generate_video_direct(input_type: str, input_data: str, quality: str, category: str, progress_callback=None):
+    """
+    Generate video directly without API.
+    Used for Hugging Face deployment.
+    """
+    from manimator.api.animation_generation import generate_animation_response
+    from manimator.utils.code_fixer import CodeFixer
+    
+    job_id = str(uuid.uuid4())
+    base_dir = Path(__file__).parent
+    
+    # Quality flags for Manim
+    quality_flags = {
+        "low": "-pql",
+        "medium": "-pqm", 
+        "high": "-pqh",
+        "ultra": "-pqk"
+    }
+    
+    quality_dirs = {
+        "low": "480p15",
+        "medium": "720p30",
+        "high": "1080p60",
+        "ultra": "2160p60"
+    }
+    
+    try:
+        # Stage 1: Generate code
+        if progress_callback:
+            progress_callback("generating_code", 20, "Generating Manim code with AI...")
+        
+        code = generate_animation_response(
+            input_data=input_data,
+            input_type=input_type,
+            category=category,
+            job_id=job_id
+        )
+        
+        # Save code to file
+        scene_name = f"Scene_{uuid.uuid4().hex[:8]}"
+        code_file = base_dir / f"scene_{job_id}.py"
+        
+        # Replace class name in code
+        import re
+        code = re.sub(r'class\s+\w+\s*\(\s*VoiceoverScene\s*\)', f'class {scene_name}(VoiceoverScene)', code)
+        
+        with open(code_file, 'w') as f:
+            f.write(code)
+        
+        if progress_callback:
+            progress_callback("code_generated", 40, "Code generated successfully!")
+        
+        # Stage 2: Render video with retry loop
+        fixer = CodeFixer()
+        max_retries = 3
+        video_path = None
+        
+        # Ensure media directories exist
+        media_dir = base_dir / "media"
+        (media_dir / "voiceover" / "elevenlabs").mkdir(parents=True, exist_ok=True)
+        (media_dir / "voiceover" / "gtts").mkdir(parents=True, exist_ok=True)
+        (media_dir / "videos").mkdir(parents=True, exist_ok=True)
+        
+        for attempt in range(max_retries):
+            try:
+                if progress_callback:
+                    progress_callback("rendering", 50 + (attempt * 10), f"Rendering video (attempt {attempt + 1}/{max_retries})...")
+                
+                # Run Manim
+                cmd = [
+                    "manim",
+                    quality_flags[quality],
+                    "--media_dir", str(media_dir),
+                    str(code_file),
+                    scene_name
+                ]
+                
+                env = os.environ.copy()
+                env["MEDIA_DIR"] = str(media_dir.resolve())
+                
+                result = subprocess.run(
+                    cmd,
+                    capture_output=True,
+                    text=True,
+                    cwd=str(base_dir),
+                    env=env,
+                    timeout=300  # 5 minute timeout
+                )
+                
+                if result.returncode != 0:
+                    error_msg = result.stderr[-500:] if result.stderr else "Unknown render error"
+                    raise Exception(f"Manim rendering failed: {error_msg}")
+                
+                # Find video file
+                video_dir = media_dir / "videos" / code_file.stem / quality_dirs[quality]
+                video_files = list(video_dir.glob("*.mp4"))
+                
+                if not video_files:
+                    raise Exception(f"No video file found in {video_dir}")
+                
+                video_path = video_files[0]
+                break  # Success!
+                
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    # Try to fix code
+                    if progress_callback:
+                        progress_callback("fixing", 50 + (attempt * 10), "Fixing rendering error...")
+                    
+                    with open(code_file, 'r') as f:
+                        current_code = f.read()
+                    
+                    fixed_code = fixer.fix_runtime_error(current_code, str(e))
+                    
+                    with open(code_file, 'w') as f:
+                        f.write(fixed_code)
+                else:
+                    raise e
+        
+        # Cleanup code file
+        try:
+            code_file.unlink()
+        except:
+            pass
+        
+        if progress_callback:
+            progress_callback("completed", 100, "Video generation completed!")
+        
+        return video_path
+        
+    except Exception as e:
+        if progress_callback:
+            progress_callback("failed", 0, f"Error: {str(e)}")
+        raise e
+
+
+def generate_via_api(api_url: str, input_type: str, input_data: str, quality: str, category: str, progress_callback=None):
+    """
+    Generate video via API (for local development).
+    """
+    import requests
+    
+    payload = {
+        "input_type": input_type,
+        "input_data": input_data,
+        "quality": quality,
+        "category": category
+    }
+    
+    response = requests.post(f"{api_url}/api/videos", json=payload, timeout=30)
+    
+    if response.status_code != 200:
+        raise Exception(f"Failed to start job: {response.text}")
+    
+    job_data = response.json()
+    job_id = job_data["job_id"]
+    
+    # Poll for status
+    while True:
+        status_response = requests.get(f"{api_url}/api/jobs/{job_id}", timeout=10)
+        if status_response.status_code == 200:
+            status_data = status_response.json()
+            status = status_data["status"]
+            progress = status_data.get("progress", {})
+            percentage = progress.get("percentage", 0)
+            message = progress.get("message", "Processing...")
+            
+            if progress_callback:
+                progress_callback(status, percentage, message)
+            
+            if status == "completed":
+                return f"{api_url}/api/videos/{job_id}"
+            elif status == "failed":
+                raise Exception(status_data.get("error", "Unknown error"))
+        
+        time.sleep(2)
+
+
+# ============================================================================
 # Sidebar
+# ============================================================================
+
 with st.sidebar:
     st.title("🎬 Vidsimplify")
     st.markdown("---")
-    st.markdown("### Configuration")
-    api_url = st.text_input("API URL", value="http://localhost:8003")
+    
+    # Show mode indicator
+    if DIRECT_MODE:
+        st.success("🚀 Direct Mode (Hugging Face)")
+    else:
+        st.info("🔌 API Mode")
+        api_url = st.text_input("API URL", value="http://localhost:8000")
     
     st.markdown("### Settings")
-    quality = st.selectbox("Quality", ["low", "medium", "high", "ultra"], index=2)
+    quality = st.selectbox("Quality", ["low", "medium", "high"], index=1)
     category = st.selectbox("Category", ["tech_system", "product_startup", "mathematical"], index=0)
     
     st.markdown("---")
     st.markdown("### About")
     st.info("Generate educational animation videos from text, blogs, or PDFs using Manim and AI.")
 
-# Main content
+# ============================================================================
+# Main Content
+# ============================================================================
+
 st.title("AI Video Generator")
 st.markdown("Turn your content into engaging animations in minutes.")
 
@@ -91,72 +323,105 @@ with tab3:
     uploaded_file = st.file_uploader("Choose a PDF file", type="pdf")
     if uploaded_file:
         input_type = "pdf"
-        # Convert PDF to base64
         bytes_data = uploaded_file.getvalue()
         base64_pdf = base64.b64encode(bytes_data).decode('utf-8')
         input_data = base64_pdf
 
-# Generate button
+
+# ============================================================================
+# Generate Button & Logic
+# ============================================================================
+
 if st.button("Generate Video", type="primary", use_container_width=True):
     if not input_data:
         st.error("Please provide input data.")
     else:
+        # Create status containers
+        progress_bar = st.progress(0)
+        status_container = st.empty()
+        video_container = st.empty()
+        
+        def update_progress(status, percentage, message):
+            progress_bar.progress(min(percentage / 100, 1.0))
+            
+            status_class = {
+                "generating_code": "status-generating",
+                "code_generated": "status-generating",
+                "rendering": "status-rendering",
+                "fixing": "status-rendering",
+                "completed": "status-complete",
+                "failed": "status-error"
+            }.get(status, "status-generating")
+            
+            status_container.markdown(
+                f'<div class="status-box {status_class}">📊 <strong>{status.upper()}</strong>: {message}</div>',
+                unsafe_allow_html=True
+            )
+        
         try:
-            with st.spinner("Submitting job to API..."):
-                payload = {
-                    "input_type": input_type,
-                    "input_data": input_data,
-                    "quality": quality,
-                    "category": category
-                }
-                
-                response = requests.post(f"{api_url}/api/videos", json=payload)
-                
-                if response.status_code == 200:
-                    job_data = response.json()
-                    job_id = job_data["job_id"]
-                    st.success(f"Job started! ID: {job_id}")
-                    
-                    # Polling for status
-                    progress_bar = st.progress(0)
-                    status_text = st.empty()
-                    video_placeholder = st.empty()
-                    
-                    while True:
-                        status_response = requests.get(f"{api_url}/api/jobs/{job_id}")
-                        if status_response.status_code == 200:
-                            status_data = status_response.json()
-                            status = status_data["status"]
-                            progress = status_data.get("progress", {})
-                            percentage = progress.get("percentage", 0)
-                            message = progress.get("message", "Processing...")
-                            
-                            progress_bar.progress(percentage / 100)
-                            status_text.info(f"Status: {status.upper()} - {message}")
-                            
-                            if status == "completed":
-                                st.balloons()
-                                status_text.success("Video generation completed!")
-                                
-                                # Display video
-                                video_url = f"{api_url}/api/videos/{job_id}"
-                                st.video(video_url)
-                                break
-                            
-                            elif status == "failed":
-                                error_msg = status_data.get("error", "Unknown error")
-                                status_text.error(f"Job failed: {error_msg}")
-                                break
-                            
-                        time.sleep(2)
-                else:
-                    st.error(f"Failed to start job: {response.text}")
-                    
-        except requests.exceptions.ConnectionError:
-            st.error(f"Could not connect to API at {api_url}. Is the server running?")
+            if DIRECT_MODE:
+                # Direct execution (Hugging Face)
+                update_progress("starting", 5, "Initializing video generation...")
+                
+                video_path = generate_video_direct(
+                    input_type=input_type,
+                    input_data=input_data,
+                    quality=quality,
+                    category=category,
+                    progress_callback=update_progress
+                )
+                
+                # Display video from local file
+                st.balloons()
+                with open(video_path, 'rb') as video_file:
+                    video_bytes = video_file.read()
+                    video_container.video(video_bytes)
+                
+                # Offer download
+                st.download_button(
+                    label="📥 Download Video",
+                    data=video_bytes,
+                    file_name=f"vidsimplify_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4",
+                    mime="video/mp4"
+                )
+                
+            else:
+                # API mode (local development)
+                import requests
+                
+                update_progress("submitting", 5, "Submitting job to API...")
+                
+                video_url = generate_via_api(
+                    api_url=api_url,
+                    input_type=input_type,
+                    input_data=input_data,
+                    quality=quality,
+                    category=category,
+                    progress_callback=update_progress
+                )
+                
+                st.balloons()
+                video_container.video(video_url)
+                
         except Exception as e:
-            st.error(f"An error occurred: {str(e)}")
+            error_msg = str(e)
+            st.error(f"❌ Generation failed: {error_msg}")
+            
+            # Show helpful message for common errors
+            if "Could not connect" in error_msg or "Connection" in error_msg:
+                st.warning("💡 If running locally, make sure the API server is running: `python api_server.py`")
+
 
+# ============================================================================
 # Footer
+# ============================================================================
+
 st.markdown("---")
-st.markdown("Built with Streamlit and Manimator")
+col1, col2, col3 = st.columns(3)
+with col1:
+    st.markdown("Built with ❤️ using Streamlit")
+with col2:
+    st.markdown("Powered by Manim & AI")
+with col3:
+    mode_text = "Direct Mode" if DIRECT_MODE else "API Mode"
+    st.markdown(f"Running in: **{mode_text}**")