Create app.py

app.py

@@ -0,0 +1,246 @@
+import gradio as gr
+import subprocess
+import os
+import re
+import shutil
+from pathlib import Path
+import requests
+
+# Hugging Face Inference API (Free!)
+HF_API_URL = "https://api-inference.huggingface.co/models/meta-llama/Llama-3.2-3B-Instruct"
+HF_TOKEN = os.environ.get("HF_TOKEN", "")  # Set this in Space secrets
+
+def generate_code_with_hf(prompt):
+    """Generate Manim code using HF's free inference API"""
+    
+    system_prompt = """Generate Manim code. CRITICAL RULES:
+
+1. COLORS - ONLY these 10: BLUE, RED, GREEN, YELLOW, ORANGE, PURPLE, PINK, TEAL, WHITE, BLACK
+   NO variants (_A, _B, _C, _D, _E)
+
+2. TEXT OVERLAP PREVENTION:
+   - ALWAYS FadeOut text before showing new text
+   - Pattern:
+   ```python
+   title = Text("Title", font_size=36).to_edge(UP, buff=1)
+   self.play(Write(title))
+   self.wait(1.5)
+   self.play(FadeOut(title))
+   ```
+
+3. SAFE BOUNDARIES:
+   - Font size: MAX 36
+   - Shifts: UP*1.5, DOWN*1.5, LEFT*3, RIGHT*3
+   - Always use buff=1 with to_edge()
+
+4. NEVER use:
+   - get_x_axis_label(), get_y_axis_label()
+   - Checkmark, SVGMobject, ImageMobject
+   - .add_prefix(), .add_suffix()
+
+5. STRUCTURE:
+   ```python
+   from manim import *
+   
+   class MyScene(Scene):
+       def construct(self):
+           self.camera.background_color = WHITE
+           
+           text1 = Text("First", font_size=36, color=BLACK).to_edge(UP, buff=1)
+           self.play(Write(text1))
+           self.wait(1.5)
+           self.play(FadeOut(text1))
+   ```
+
+Generate COMPLETE working code for: """ + prompt
+
+    headers = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+    
+    payload = {
+        "inputs": system_prompt,
+        "parameters": {
+            "max_new_tokens": 2000,
+            "temperature": 0.7,
+            "return_full_text": False
+        }
+    }
+    
+    try:
+        response = requests.post(HF_API_URL, headers=headers, json=payload, timeout=30)
+        response.raise_for_status()
+        result = response.json()
+        
+        if isinstance(result, list) and len(result) > 0:
+            return result[0].get('generated_text', '')
+        return str(result)
+    except Exception as e:
+        return f"# Error generating code: {str(e)}\n# Using fallback template\n\nfrom manim import *\n\nclass MyScene(Scene):\n    def construct(self):\n        text = Text('Animation', color=BLACK)\n        self.play(Write(text))\n        self.wait(2)"
+
+def fix_all_known_errors(code):
+    """Fix common Manim errors"""
+    
+    # Fix colors to base 10 only
+    color_map = {
+        'ORANGE_A': 'ORANGE', 'ORANGE_B': 'ORANGE', 'ORANGE_C': 'ORANGE',
+        'GRAY_A': 'WHITE', 'GRAY_B': 'WHITE', 'GRAY_C': 'WHITE', 'GRAY': 'WHITE', 'GREY': 'WHITE',
+        'PURPLE_A': 'PURPLE', 'PURPLE_B': 'PURPLE', 'PURPLE_C': 'PURPLE',
+        'RED_A': 'RED', 'RED_B': 'RED', 'RED_C': 'RED',
+        'BLUE_A': 'BLUE', 'BLUE_B': 'BLUE', 'BLUE_C': 'BLUE',
+        'GREEN_A': 'GREEN', 'GREEN_B': 'GREEN', 'GREEN_C': '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)
+    
+    # Remove problematic methods
+    code = re.sub(r'\.get_x_axis_label\([^)]+\)', '', code)
+    code = re.sub(r'\.get_y_axis_label\([^)]+\)', '', code)
+    code = re.sub(r'\.add_prefix\([^)]+\)', '', code)
+    code = re.sub(r'\.add_suffix\([^)]+\)', '', code)
+    
+    # Replace 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)
+    
+    # Limit font sizes
+    code = re.sub(r'font_size=(\d+)', lambda m: f'font_size={min(int(m.group(1)), 36)}', code)
+    
+    # Fix shifts
+    code = re.sub(r'\.shift\(UP\s*\*\s*\d+\.?\d*\)', '.shift(UP*1.5)', code)
+    code = re.sub(r'\.shift\(DOWN\s*\*\s*\d+\.?\d*\)', '.shift(DOWN*1.5)', code)
+    
+    return code
+
+def render_video(prompt, quality="low"):
+    """Main function to generate and render Manim video"""
+    
+    try:
+        # Create temp directory
+        temp_dir = Path("temp_manim")
+        temp_dir.mkdir(exist_ok=True)
+        
+        yield "🤖 Generating code...", None, None
+        
+        # Generate code
+        code = generate_code_with_hf(prompt)
+        
+        # Extract Python code if wrapped in markdown
+        if "```python" in code:
+            code = code.split("```python")[1].split("```")[0]
+        elif "```" in code:
+            code = code.split("```")[1].split("```")[0]
+        code = code.strip()
+        
+        # Apply fixes
+        code = fix_all_known_errors(code)
+        
+        # Find Scene class
+        match = re.search(r'class\s+(\w+)\s*\(Scene\)', code)
+        if not match:
+            yield "❌ No Scene class found in generated code!", code, None
+            return
+        
+        class_name = match.group(1)
+        
+        # Save code
+        code_file = temp_dir / "animation.py"
+        with open(code_file, 'w', encoding='utf-8') as f:
+            f.write(code)
+        
+        yield f"✓ Code generated (Scene: {class_name})\n🎬 Rendering video...", code, None
+        
+        # Render video
+        quality_map = {'low': '-ql', 'medium': '-qm', 'high': '-qh'}
+        quality_flag = quality_map.get(quality, '-ql')
+        
+        command = f"manim {code_file} {class_name} {quality_flag} --disable_caching --media_dir {temp_dir}/media"
+        
+        process = subprocess.Popen(
+            command, shell=True,
+            stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+            text=True, cwd=temp_dir
+        )
+        
+        output_lines = []
+        for line in process.stdout:
+            output_lines.append(line)
+        
+        process.wait()
+        
+        if process.returncode == 0:
+            # Find the generated video
+            video_files = list((temp_dir / "media" / "videos" / "animation").rglob("*.mp4"))
+            
+            if video_files:
+                video_path = str(video_files[0])
+                yield f"✅ Video rendered successfully!", code, video_path
+            else:
+                yield "❌ Video file not found after rendering", code, None
+        else:
+            error_msg = ''.join(output_lines[-20:])  # Last 20 lines
+            yield f"❌ Rendering failed:\n{error_msg}", code, None
+            
+    except Exception as e:
+        yield f"❌ Error: {str(e)}", None, None
+
+# Gradio Interface
+def create_interface():
+    with gr.Blocks(title="Manim Video Generator", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 🎬 Manim Video Generator
+        Create mathematical animations using AI! Describe what you want to see animated.
+        
+        **Examples:**
+        - "Explain Pythagorean theorem with animation"
+        - "Show a sine wave transforming into a cosine wave"
+        - "Animate the concept of derivatives"
+        """)
+        
+        with gr.Row():
+            with gr.Column():
+                prompt_input = gr.Textbox(
+                    label="What animation do you want?",
+                    placeholder="e.g., Show a circle morphing into a square",
+                    lines=3
+                )
+                quality_input = gr.Radio(
+                    choices=["low", "medium", "high"],
+                    value="low",
+                    label="Quality (low is faster)"
+                )
+                generate_btn = gr.Button("🎬 Generate Video", variant="primary")
+                
+            with gr.Column():
+                status_output = gr.Textbox(label="Status", lines=3)
+                video_output = gr.Video(label="Generated Animation")
+        
+        code_output = gr.Code(label="Generated Manim Code", language="python")
+        
+        gr.Markdown("""
+        ### 💡 Tips:
+        - Start with simple prompts
+        - Low quality renders faster (recommended for testing)
+        - Complex animations may timeout on free tier
+        """)
+        
+        generate_btn.click(
+            fn=render_video,
+            inputs=[prompt_input, quality_input],
+            outputs=[status_output, code_output, video_output]
+        )
+        
+        # Examples
+        gr.Examples(
+            examples=[
+                ["Show a circle morphing into a square", "low"],
+                ["Animate the number pi appearing", "low"],
+                ["Show three dots moving in a triangle pattern", "low"],
+            ],
+            inputs=[prompt_input, quality_input]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch()