Update app.py

app.py

@@ -1,184 +1,406 @@
-import streamlit as st
+import gradio as gr
 import subprocess
-import tempfile
+import os
 import re
 from pathlib import Path
-import google.generativeai as genai
-import os
+import tempfile
+
+try:
+    from google import genai
+    from google.genai import types
+    GENAI_AVAILABLE = True
+except ImportError:
+    GENAI_AVAILABLE = False
 
 GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")
 
-st.set_page_config(page_title="Manim Video Generator", page_icon="🎬")
+# Video templates for different content types
+TEMPLATES = {
+    "Problem Solver": {
+        "structure": "Title → Problem Statement → Step-by-Step Solution → Final Answer",
+        "style": "Clean, focused, educational",
+        "duration": "Focus on clear problem-solving steps"
+    },
+    "Concept Explainer": {
+        "structure": "Title → What is it? → Visual Example → Key Points → Summary",
+        "style": "Visual, intuitive, smooth transitions",
+        "duration": "Build understanding gradually"
+    },
+    "Formula Breakdown": {
+        "structure": "Title → Formula Display → What Each Part Means → Example → Application",
+        "style": "Clear labeling, color-coded parts",
+        "duration": "Thorough explanation of components"
+    },
+    "Quick Trick": {
+        "structure": "Title → Normal Method → Shortcut Method → Why It Works → Practice",
+        "style": "Fast-paced, attention-grabbing",
+        "duration": "Efficient and memorable"
+    }
+}
 
-def fix_code(code):
-    """Fix common Manim errors"""
+def fix_all_known_errors(code):
+    """Fix ALL known Manim errors"""
+    
+    # Fix colors to base 10 only
     color_map = {
-        'ORANGE_A': 'ORANGE', 'GRAY_A': 'WHITE', 'GREY': 'WHITE',
-        'PURPLE_A': 'PURPLE', 'RED_A': 'RED', 'BLUE_A': 'BLUE',
-        'BROWN': 'ORANGE', 'GOLD': 'YELLOW'
+        'ORANGE_A': 'ORANGE', 'ORANGE_B': 'ORANGE', 'ORANGE_C': 'ORANGE',
+        'GRAY_A': 'WHITE', 'GRAY_B': 'WHITE', 'GREY': 'WHITE', 'GRAY': 'WHITE',
+        'PURPLE_A': 'PURPLE', 'RED_A': 'RED', 'BLUE_A': 'BLUE', 'GREEN_A': 'GREEN',
+        'BROWN': 'ORANGE', 'GOLD': 'YELLOW', 'CYAN': 'TEAL', 'MAGENTA': 'PINK',
     }
     for old, new in color_map.items():
         code = re.sub(rf'\b{old}\b', new, code)
     
+    # Fix invalid objects
+    code = re.sub(r'Checkmark\([^)]*\)', 'Circle(radius=0.3, color=GREEN, fill_opacity=1)', code)
+    code = re.sub(r'SVGMobject\([^)]+\)', 'Circle(radius=0.8, color=PINK, fill_opacity=0.8)', code)
+    code = re.sub(r'ImageMobject\([^)]+\)', 'Square(side_length=2, color=BLUE, fill_opacity=0.5)', code)
+    
+    # Remove problematic methods
+    code = re.sub(r'\.add_prefix\([^)]+\)', '', code)
+    code = re.sub(r'\.add_suffix\([^)]+\)', '', code)
     code = re.sub(r'\.get_x_axis_label\([^)]+\)', '', code)
     code = re.sub(r'\.get_y_axis_label\([^)]+\)', '', code)
-    code = re.sub(r'Checkmark\([^)]*\)', 'Circle(radius=0.3, color=GREEN)', code)
-    code = re.sub(r'font_size=(\d+)', lambda m: f'font_size={min(int(m.group(1)), 36)}', code)
     
-    # Add color=BLACK to Text without color
-    def add_color(match):
+    # Remove Table usage - too error-prone
+    if 'Table(' in code:
+        code = re.sub(r'(\s+)(.*Table\(.*)', r'\1# \2  # Removed', code)
+        code = re.sub(r'(\s+)(.*\.get_entries\(.*)', r'\1# \2', code)
+    
+    # STRICT limits
+    code = re.sub(r'font_size=(\d+)', lambda m: f'font_size={min(int(m.group(1)), 32)}', code)
+    code = re.sub(r'\.shift\(UP\s*\*\s*\d+\.?\d*\)', '.shift(UP*1)', code)
+    code = re.sub(r'\.shift\(DOWN\s*\*\s*\d+\.?\d*\)', '.shift(DOWN*1)', code)
+    code = re.sub(r'\.shift\(LEFT\s*\*\s*\d+\.?\d*\)', '.shift(LEFT*2)', code)
+    code = re.sub(r'\.shift\(RIGHT\s*\*\s*\d+\.?\d*\)', '.shift(RIGHT*2)', code)
+    code = re.sub(r'\.to_edge\((UP|DOWN|LEFT|RIGHT)\)(?!\s*,)', r'.to_edge(\1, buff=0.8)', code)
+    
+    # Add color=BLACK to Text/MathTex without color
+    def add_black(match):
         text = match.group(0)
         if 'color=' not in text:
             text = text[:-1] + ', color=BLACK)'
         return text
-    code = re.sub(r'Text\([^)]+\)', add_color, code)
+    
+    code = re.sub(r'Text\([^)]+\)', add_black, code)
+    code = re.sub(r'MathTex\([^)]+\)', add_black, code)
     
     return code
 
-def generate_code(prompt):
-    """Generate Manim code using Gemini"""
-    if not GEMINI_API_KEY:
-        return None, "❌ GEMINI_API_KEY not set in secrets"
+def generate_code_with_gemini(prompt, template, duration, quality):
+    """Generate Manim code using Gemini API"""
+    
+    if not GENAI_AVAILABLE or not GEMINI_API_KEY:
+        return None, "❌ Setup GEMINI_API_KEY in Settings → Secrets"
     
     try:
-        genai.configure(api_key=GEMINI_API_KEY)
-        # Get available models and use the first flash model
-        models = [m.name for m in genai.list_models() if 'generateContent' in m.supported_generation_methods]
-        model_name = next((m for m in models if 'flash' in m.lower()), models[0] if models else 'gemini-pro')
-        model = genai.GenerativeModel(model_name)
-        
-        full_prompt = f"""Generate simple Manim code.
-
-RULES:
-1. Use ONLY: BLUE, RED, GREEN, YELLOW, ORANGE, PURPLE, PINK, TEAL, WHITE, BLACK
-2. Background is WHITE - ALL Text MUST have color=BLACK
-3. Always FadeOut before new text:
-   text = Text("Hello", color=BLACK)
-   self.play(Write(text))
-   self.wait(1)
-   self.play(FadeOut(text))
-4. Keep simple, 10-15 seconds max
-5. MUST include: from manim import *
-
-User request: {prompt}
-
-Generate complete working code:"""
-        
-        response = model.generate_content(full_prompt)
-        return response.text, None
+        client = genai.Client(api_key=GEMINI_API_KEY)
+        
+        # Duration guidance
+        duration_guide = {
+            "Short (30-60s)": "Keep it concise - 3-4 key points max, quick transitions",
+            "Medium (2-5 min)": "Detailed explanation - 5-8 steps, smooth pacing",
+            "Long (5-10 min)": "Comprehensive - 10+ steps, thorough breakdown, multiple examples"
+        }
+        
+        template_info = TEMPLATES[template]
+        duration_info = duration_guide[duration]
+        
+        full_prompt = f"""You are creating a YOUTUBE MATH VIDEO for government exam preparation (SSC, Banking, Railways).
+
+TEMPLATE: {template}
+STRUCTURE: {template_info['structure']}
+STYLE: {template_info['style']} (inspired by 3Blue1Brown)
+TARGET DURATION: {duration} - {duration_info}
+
+USER REQUEST: {prompt}
+
+CRITICAL RULES:
+
+1. YOUTUBE QUALITY:
+   - Professional, clean, smooth animations
+   - Clear visual hierarchy (title → content → conclusion)
+   - Engaging pacing with proper timing
+   - Everything centered and visible
+
+2. STRUCTURE (Follow {template} template):
+   - Start with BOLD title card (2 seconds)
+   - Present problem/concept clearly
+   - Step-by-step visual explanation
+   - Highlight key insights/shortcuts
+   - End with summary or practice prompt
+
+3. COLORS & VISIBILITY:
+   - Background: WHITE
+   - ALL Text/MathTex: color=BLACK (MANDATORY!)
+   - Use vibrant accent colors: BLUE (trust), GREEN (correct), RED (important), ORANGE (highlight)
+   - Color-code different elements (formulas=BLUE, steps=GREEN, answers=RED)
+
+4. PREVENT OVERLAP (CRITICAL):
+   - ALWAYS FadeOut before new content
+   - Pattern:
+   ```python
+   step1 = Text("Step 1: ...", font_size=28, color=BLACK).to_edge(UP, buff=0.8)
+   self.play(Write(step1), run_time=1)
+   self.wait(2)  # Let viewers read
+   self.play(FadeOut(step1))
+   self.wait(0.3)  # Small pause
+   
+   step2 = Text("Step 2: ...", font_size=28, color=BLACK).to_edge(UP, buff=0.8)
+   self.play(Write(step2), run_time=1)
+   self.wait(2)
+   self.play(FadeOut(step2))
+   ```
+
+5. TIMING (YouTube pacing):
+   - Title card: 2 seconds
+   - Each explanation step: 2-3 seconds
+   - Complex calculations: 3-4 seconds
+   - Final answer highlight: 2 seconds
+   - Total should match {duration}
+
+6. VISUAL ELEMENTS:
+   - Use boxes/rectangles to group related info
+   - Arrows to show relationships
+   - Underlines for emphasis
+   - Fade transitions between sections
+   - Scale/rotate for dynamic interest
+
+7. STAY IN FRAME:
+   - Font: MAX 32 (title), 28 (content), 24 (details)
+   - Safe zone: X[-2.5, 2.5], Y[-1.5, 1.5]
+   - Use .to_edge() with buff=0.8
+   - Center main content with .move_to(ORIGIN)
+
+8. NEVER use:
+   - Table, DecimalTable (use VGroup instead)
+   - get_x_axis_label/get_y_axis_label
+   - Checkmark, SVGMobject, ImageMobject
+   - Complex grids
+
+9. QUALITY SETTINGS:
+   - Use run_time for smooth animations (1-2 seconds)
+   - Add fill_opacity=0.8 for shapes
+   - Use stroke_width=2 for emphasis
+
+10. CODE STRUCTURE:
+```python
+from manim import *
+
+class MathExplainer(Scene):
+    def construct(self):
+        self.camera.background_color = WHITE
+        
+        # Title Card (2 sec)
+        title = Text("Topic Title", font_size=32, color=BLACK, weight=BOLD)
+        self.play(Write(title), run_time=1)
+        self.wait(2)
+        self.play(FadeOut(title))
+        
+        # Main Content (follow template structure)
+        # ... your explanation with proper FadeOuts
+        
+        # Conclusion
+        conclusion = Text("Key Takeaway", font_size=28, color=GREEN, weight=BOLD)
+        self.play(Write(conclusion), run_time=1)
+        self.wait(2)
+        self.play(FadeOut(conclusion))
+```
+
+Generate professional, YouTube-ready code following the {template} template for: {prompt}"""
+        
+        response = client.models.generate_content(
+            model='gemini-1.5-flash',
+            contents=full_prompt
+        )
+        code = response.text
+        
+        return code, None
+        
     except Exception as e:
-        return None, str(e)
+        return None, f"❌ Error: {str(e)}"
 
-def render_video(prompt):
-    """Render Manim video"""
-    temp_dir = Path(tempfile.mkdtemp())
+def render_video_from_code(code, quality):
+    """Render video from code"""
+    if not code or not code.strip():
+        return "❌ No code!", None
     
-    # Generate code
-    with st.spinner("🤖 Generating code..."):
-        code, error = generate_code(prompt)
+    try:
+        temp_dir = Path(tempfile.mkdtemp(prefix="manim_"))
+        code = fix_all_known_errors(code)
+        
+        match = re.search(r'class\s+(\w+)\s*\(Scene\)', code)
+        if not match:
+            return "❌ No Scene class!", None
+        
+        class_name = match.group(1)
+        code_file = temp_dir / "animation.py"
+        code_file.write_text(code)
+        
+        quality_map = {'Low (fast)': '-ql', 'Medium': '-qm', 'High (1080p)': '-qh'}
+        quality_flag = quality_map.get(quality, '-qm')
+        
+        cmd = f"manim {code_file} {class_name} {quality_flag} --disable_caching --media_dir {temp_dir}/media"
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=300)
+        
+        if result.returncode == 0:
+            videos = list((temp_dir / "media").rglob("*.mp4"))
+            if videos:
+                return "✅ Rendered!", str(videos[0])
+        return f"❌ Failed:\n{result.stderr[-500:]}", None
+    except Exception as e:
+        return f"❌ {e}", None
+
+def render_video(prompt, template, duration, quality):
+    """Generate and render video"""
+    if not prompt:
+        yield "❌ Enter a prompt!", None, None
+        return
+    
+    try:
+        temp_dir = Path(tempfile.mkdtemp(prefix="manim_"))
+        
+        yield f"🤖 Generating {template} video ({duration})...", None, None
+        
+        code, error = generate_code_with_gemini(prompt, template, duration, quality)
         
         if error:
-            st.error(error)
-            return None, None
+            yield error, None, None
+            return
         
-        # Extract Python code
         if "```python" in code:
             code = code.split("```python")[1].split("```")[0]
         elif "```" in code:
             code = code.split("```")[1].split("```")[0]
         code = code.strip()
         
-        # Fix code
-        code = fix_code(code)
-    
-    # Find Scene class
-    match = re.search(r'class\s+(\w+)\s*\(Scene\)', code)
-    if not match:
-        st.error("No Scene class found!")
-        return None, code
-    
-    class_name = match.group(1)
-    
-    # Save code
-    code_file = temp_dir / "animation.py"
-    code_file.write_text(code)
-    
-    # Render video
-    with st.spinner(f"🎬 Rendering {class_name}... (this takes 1-2 minutes)"):
-        cmd = f"manim {code_file} {class_name} -ql --disable_caching --media_dir {temp_dir}/media"
-        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=180)
+        code = fix_all_known_errors(code)
+        
+        match = re.search(r'class\s+(\w+)\s*\(Scene\)', code)
+        if not match:
+            yield "❌ No Scene class!", code, None
+            return
+        
+        class_name = match.group(1)
+        code_file = temp_dir / "animation.py"
+        code_file.write_text(code)
+        
+        yield f"🎬 Rendering {class_name}...", code, None
+        
+        quality_map = {'Low (fast)': '-ql', 'Medium': '-qm', 'High (1080p)': '-qh'}
+        quality_flag = quality_map.get(quality, '-qm')
+        
+        cmd = f"manim {code_file} {class_name} {quality_flag} --disable_caching --media_dir {temp_dir}/media"
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=300)
         
         if result.returncode == 0:
-            # Find video
             videos = list((temp_dir / "media").rglob("*.mp4"))
             if videos:
-                return videos[0], code
+                yield "✅ YouTube-ready video rendered! 🎉", code, str(videos[0])
             else:
-                st.error("Video file not found after rendering")
-                st.code(result.stdout, language="text")
-                return None, code
+                yield "❌ Video not found", code, None
         else:
-            st.error("Rendering failed!")
-            st.code(result.stderr, language="text")
-            return None, code
-
-# UI
-st.title("🎬 Manim Video Generator")
-st.markdown("Create mathematical animations using AI!")
-
-if not GEMINI_API_KEY:
-    st.error("⚠️ GEMINI_API_KEY not set! Add it in Settings → Secrets")
-    st.markdown("Get your free API key: https://aistudio.google.com/app/apikey")
-    st.stop()
-
-# Input
-prompt = st.text_area(
-    "What animation do you want?",
-    placeholder="e.g., Show a blue circle morphing into a red square",
-    height=100
-)
-
-# Examples
-st.markdown("**Examples:**")
-col1, col2, col3 = st.columns(3)
-with col1:
-    if st.button("🔵 Circle → Square"):
-        prompt = "Show a blue circle morphing into a red square"
-with col2:
-    if st.button("📐 Pythagorean"):
-        prompt = "Animate the Pythagorean theorem: a² + b² = c²"
-with col3:
-    if st.button("〰️ Sine Wave"):
-        prompt = "Show a sine wave moving"
-
-# Generate button
-if st.button("🎬 Generate Video", type="primary", use_container_width=True):
-    if not prompt:
-        st.warning("Please enter a prompt!")
-    else:
-        video_path, code = render_video(prompt)
-        
-        if video_path:
-            st.success("✅ Video rendered successfully!")
+            yield f"❌ Failed:\n{result.stderr[-500:]}", code, None
+            
+    except Exception as e:
+        yield f"❌ {e}", None, None
+
+# Gradio Interface
+with gr.Blocks(title="YouTube Math Explainer") as demo:
+    gr.Markdown("""
+    # 🎬 YouTube Math Video Generator (Govt Exam Prep)
+    
+    **Professional Manim animations for your YouTube channel!**  
+    Perfect for SSC, Banking, Railways exam preparation videos.
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            prompt_input = gr.Textbox(
+                label="📝 Video Topic",
+                placeholder="e.g., Solve percentage problem: If 20% of 500 is increased by 40%, find the result",
+                lines=4
+            )
             
-            # Display video
-            st.video(str(video_path))
+            template_input = gr.Dropdown(
+                choices=list(TEMPLATES.keys()),
+                value="Problem Solver",
+                label="🎨 Video Template",
+                info="Choose content structure"
+            )
             
-            # Download button
-            with open(video_path, 'rb') as f:
-                st.download_button(
-                    label="📥 Download Video",
-                    data=f.read(),
-                    file_name=f"manim_{video_path.stem}.mp4",
-                    mime="video/mp4"
-                )
+            duration_input = gr.Radio(
+                choices=["Short (30-60s)", "Medium (2-5 min)", "Long (5-10 min)"],
+                value="Short (30-60s)",
+                label="⏱️ Target Duration"
+            )
             
-            # Show code
-            with st.expander("📝 View Generated Code"):
-                st.code(code, language="python")
-        elif code:
-            st.warning("Video rendering failed, but here's the generated code:")
-            st.code(code, language="python")
-
-st.markdown("---")
-st.markdown("💡 **Tips:** Start with simple prompts • Rendering takes 1-2 minutes • Be specific about what you want")
+            quality_input = gr.Radio(
+                choices=["Low (fast)", "Medium", "High (1080p)"],
+                value="Medium",
+                label="🎥 Quality"
+            )
+            
+            with gr.Row():
+                generate_btn = gr.Button("🚀 Generate Video", variant="primary", size="lg")
+                render_btn = gr.Button("🔄 Render Edited", variant="secondary")
+        
+        with gr.Column(scale=1):
+            status_output = gr.Textbox(label="📊 Status", lines=3)
+            video_output = gr.Video(label="🎥 Your Video")
+    
+    code_output = gr.Code(
+        label="💻 Generated Code (Editable)",
+        language="python",
+        lines=15,
+        interactive=True
+    )
+    
+    gr.Markdown("""
+    ### 📚 Templates Explained:
+    
+    - **Problem Solver**: Step-by-step solution for math problems
+    - **Concept Explainer**: Visual explanation of mathematical concepts
+    - **Formula Breakdown**: Detailed formula explanation with examples
+    - **Quick Trick**: Shortcuts and time-saving techniques
+    
+    ### 🎯 Tips for YouTube Success:
+    - Use **Problem Solver** for numerical questions
+    - Use **Quick Trick** for shortcuts (great for Shorts!)
+    - Use **Concept Explainer** for theory topics
+    - Start with **Short videos** to test, then go longer
+    - **High (1080p)** quality for main channel, **Low** for testing
+    
+    ### ✨ Features:
+    ✅ 3Blue1Brown inspired style  
+    ✅ Professional animations  
+    ✅ No text overlap  
+    ✅ Everything stays in frame  
+    ✅ Exam-focused content  
+    ✅ Edit & re-render support
+    """)
+    
+    generate_btn.click(
+        fn=render_video,
+        inputs=[prompt_input, template_input, duration_input, quality_input],
+        outputs=[status_output, code_output, video_output]
+    )
+    
+    render_btn.click(
+        fn=render_video_from_code,
+        inputs=[code_output, quality_input],
+        outputs=[status_output, video_output]
+    )
+    
+    gr.Examples(
+        examples=[
+            ["Solve: If 25% of a number is 75, find the number", "Problem Solver", "Short (30-60s)", "Medium"],
+            ["Explain Pythagoras theorem with visual proof", "Concept Explainer", "Medium (2-5 min)", "Medium"],
+            ["Quick trick: Calculate 15% of any number mentally", "Quick Trick", "Short (30-60s)", "Medium"],
+            ["Break down the quadratic formula: x = (-b ± √(b²-4ac))/2a", "Formula Breakdown", "Medium (2-5 min)", "Medium"],
+        ],
+        inputs=[prompt_input, template_input, duration_input, quality_input]
+    )
+
+if __name__ == "__main__":
+    demo.launch()