Update app.py

app.py

@@ -2,74 +2,268 @@ import gradio as gr
 import subprocess
 import os
 import shutil
+import tempfile
+import re
+import ast
 
 # --- Configuration ---
-MANIM_SCRIPT_FILE = "proof.py"
-MANIM_SCENE_NAME = "PythagoreanTheorem"
-BASE_DIR = "/tmp/media"
-OUTPUT_VIDEO_PATH = f"{BASE_DIR}/videos/proof/480p15/{MANIM_SCENE_NAME}.mp4"
+BASE_DIR = "./media"  # Use relative path in user home directory
 
-def render_manim_video():
+def ensure_permissions():
+    """Ensure the base directory exists and is writable."""
+    os.makedirs(BASE_DIR, exist_ok=True)
+    # Try to create a test file to check permissions
+    test_file = os.path.join(BASE_DIR, "test_write.txt")
+    try:
+        with open(test_file, 'w') as f:
+            f.write("test")
+        os.remove(test_file)
+    except Exception as e:
+        print(f"Warning: Permission issue with {BASE_DIR}: {e}")
+        # Fallback to current directory
+        global BASE_DIR
+        BASE_DIR = "./media"
+        os.makedirs(BASE_DIR, exist_ok=True)
+
+def get_scene_class_name(code):
+    """Extract the scene class name from the Manim code."""
+    try:
+        # Parse the AST to find class definitions
+        tree = ast.parse(code)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ClassDef):
+                # Check if the class inherits from Scene
+                for base in node.bases:
+                    if isinstance(base, ast.Name) and base.id == 'Scene':
+                        return node.name
+        return None
+    except:
+        # Fallback to regex if AST parsing fails
+        pattern = r'class\s+(\w+)\s*\([^)]*Scene[^)]*\):'
+        match = re.search(pattern, code)
+        return match.group(1) if match else None
+
+def render_manim_video(manim_code):
     """
-    Runs the Manim command and returns the path to the rendered video.
+    Runs the Manim command with dynamic code and returns the path to the rendered video.
     """
-    # 1. Clean up previous renders
-    if os.path.exists(BASE_DIR):
-        shutil.rmtree(BASE_DIR, ignore_errors=True)
+    # Ensure we have write permissions
+    ensure_permissions()
+    
+    if not manim_code.strip():
+        raise gr.Error("Please provide Manim code.")
+    
+    # Extract scene class name from the code
+    scene_name = get_scene_class_name(manim_code)
+    if not scene_name:
+        raise gr.Error("Could not find a Scene class in your code. Make sure your class inherits from Scene.")
+    
+    # Create a temporary Python file with the Manim code
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        # Add the necessary import if not present
+        if 'from manim import *' not in manim_code and 'import manim' not in manim_code:
+            f.write('from manim import *\n\n')
+        f.write(manim_code)
+        script_file = f.name
+    
+    try:
+        # 1. Clean up previous renders
+        if os.path.exists(BASE_DIR):
+            shutil.rmtree(BASE_DIR, ignore_errors=True)
 
-    # 2. Make sure the output path exists
-    os.makedirs(os.path.dirname(OUTPUT_VIDEO_PATH), exist_ok=True)
+        # 2. Set up output paths
+        script_name = os.path.basename(script_file).replace('.py', '')
+        output_video_path = f"{BASE_DIR}/videos/{script_name}/480p15/{scene_name}.mp4"
+        os.makedirs(os.path.dirname(output_video_path), exist_ok=True)
 
-    # 3. Construct the Manim command
-    command = [
-        "manim",
-        "-ql",
-        MANIM_SCRIPT_FILE,
-        MANIM_SCENE_NAME
-    ]
+        # 3. Construct the Manim command
+        command = [
+            "manim",
+            "-ql",  # Low quality for faster rendering
+            script_file,
+            scene_name
+        ]
 
-    try:
         # Run the command
         process = subprocess.run(
             command,
             check=True,
             capture_output=True,
-            text=True
+            text=True,
+            cwd=os.path.dirname(script_file)
         )
         print("Manim STDOUT:", process.stdout)
 
-        # 4. Move output video from default location to BASE_DIR
-        default_output = f"media/videos/{MANIM_SCRIPT_FILE.replace('.py', '')}/480p15/{MANIM_SCENE_NAME}.mp4"
+        # 4. Find the output video (Manim creates it in media/videos/)
+        default_output = f"media/videos/{script_name}/480p15/{scene_name}.mp4"
+        
         if os.path.exists(default_output):
-            shutil.move(default_output, OUTPUT_VIDEO_PATH)
-            return OUTPUT_VIDEO_PATH
+            # Move to our expected location
+            shutil.move(default_output, output_video_path)
+            return output_video_path
         else:
-            raise gr.Error("Video was not created. Check Manim output.")
+            # Try to find any mp4 file in the media directory
+            media_dir = "media"
+            if os.path.exists(media_dir):
+                for root, dirs, files in os.walk(media_dir):
+                    for file in files:
+                        if file.endswith('.mp4'):
+                            video_path = os.path.join(root, file)
+                            shutil.move(video_path, output_video_path)
+                            return output_video_path
+            
+            raise gr.Error("Video was not created. Check Manim output for errors.")
 
     except subprocess.CalledProcessError as e:
-        print("Manim STDERR:", e.stderr)
-        raise gr.Error(f"Manim failed to render. Error: {e.stderr}")
+        error_msg = e.stderr if e.stderr else str(e)
+        print("Manim STDERR:", error_msg)
+        raise gr.Error(f"Manim failed to render. Error: {error_msg}")
     except Exception as e:
         raise gr.Error(f"Unexpected error: {str(e)}")
+    finally:
+        # Clean up temporary file
+        try:
+            os.unlink(script_file)
+        except:
+            pass
+        # Clean up media directory
+        if os.path.exists("media"):
+            shutil.rmtree("media", ignore_errors=True)
 
 # --- Gradio UI ---
-with gr.Blocks() as demo:
-    gr.Markdown("# Interactive Manim: Pythagorean Theorem Proof")
+
+# Default example code (Pythagorean Theorem proof)
+DEFAULT_CODE = '''from manim import *
+
+class PythagoreanTheorem(Scene):
+    """
+    A Manim scene that visually proves the Pythagorean Theorem.
+    """
+    def construct(self):
+        # Define side lengths for the right triangle
+        a = 3.0
+        b = 4.0
+        
+        # Colors for visual clarity
+        tri_color = BLUE
+        sq_a_color = RED_C
+        sq_b_color = YELLOW_C
+        sq_c_color = GREEN_C
+        
+        # Set up the initial layout and title
+        self.camera.background_color = WHITE
+        Mobject.set_default(color=BLACK)
+        
+        title = Title("Visual Proof of the Pythagorean Theorem", color=BLACK)
+        equation = MathTex("a^2", "+", "b^2", "=", "c^2", color=BLACK).next_to(title, DOWN, buff=0.5)
+        self.play(Write(title), Write(equation))
+        self.wait(1)
+
+        self.play(equation.animate.to_corner(UR))
+        
+        p1 = np.array([a, 0, 0])
+        p2 = np.array([a + b, a, 0])
+        p3 = np.array([b, a + b, 0])
+        p4 = np.array([0, b, 0])
+        
+        c1 = np.array([0, 0, 0])
+        c2 = np.array([a + b, 0, 0])
+        c3 = np.array([a + b, a + b, 0])
+        c4 = np.array([0, a + b, 0])
+
+        T1 = Polygon(c1, p1, p4, color=tri_color, fill_opacity=0.7)
+        T2 = Polygon(c2, p2, p1, color=tri_color, fill_opacity=0.7)
+        T3 = Polygon(c3, p3, p2, color=tri_color, fill_opacity=0.7)
+        T4 = Polygon(c4, p4, p3, color=tri_color, fill_opacity=0.7)
+        sq_c = Polygon(p1, p2, p3, p4, color=sq_c_color, fill_opacity=0.7)
+        
+        arrangement1 = VGroup(T1, T2, T3, T4, sq_c).center()
+        self.play(Create(arrangement1))
+        
+        c_sq_label = MathTex("c^2", color=BLACK).move_to(sq_c.get_center())
+        self.play(Write(c_sq_label))
+        self.wait(2)
+        
+        T1_target = Polygon(np.array([b, 0, 0]), np.array([a+b, 0, 0]), np.array([b, b, 0]), color=tri_color, fill_opacity=0.7)
+        T2_target = Polygon(np.array([a+b, 0, 0]), np.array([a+b, b, 0]), np.array([b, b, 0]), color=tri_color, fill_opacity=0.7)
+        T3_target = Polygon(np.array([0, b, 0]), np.array([b, b, 0]), np.array([0, a+b, 0]), color=tri_color, fill_opacity=0.7)
+        T4_target = Polygon(np.array([b, b, 0]), np.array([b, a+b, 0]), np.array([0, a+b, 0]), color=tri_color, fill_opacity=0.7)
+
+        self.play(
+            Transform(T1, T1_target),
+            Transform(T2, T2_target),
+            Transform(T3, T3_target),
+            Transform(T4, T4_target),
+            FadeOut(sq_c),
+            FadeOut(c_sq_label)
+        )
+        self.wait(1)
+
+        sq_a = Square(side_length=a, color=sq_a_color, fill_opacity=0.7)
+        sq_b = Square(side_length=b, color=sq_b_color, fill_opacity=0.7)
+        
+        sq_a.align_to(T4_target, DOWN).align_to(T1_target, RIGHT)
+        sq_b.align_to(T1_target, UP).align_to(T4_target, LEFT)
+
+        a_sq_label = MathTex("a^2", color=BLACK).move_to(sq_a.get_center())
+        b_sq_label = MathTex("b^2", color=BLACK).move_to(sq_b.get_center())
+        
+        self.play(Create(sq_a), Create(sq_b), Write(a_sq_label), Write(b_sq_label))
+        self.wait(2)
+        self.play(Indicate(equation))
+        self.wait(3)
+'''
+
+with gr.Blocks(title="Manim Video Renderer", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🎬 Manim Video Renderer")
     gr.Markdown(
-        "Click the button below to render a Manim animation that visually proves "
-        "$a^2 + b^2 = c^2$. The render may take a minute."
+        "Create beautiful mathematical animations with Manim! Write your scene code below and click render to generate a video."
     )
-
+    
     with gr.Row():
-        render_button = gr.Button("Render Video", variant="primary")
-
-    output_video = gr.Video(label="Rendered Animation", interactive=False)
+        with gr.Column(scale=2):
+            code_input = gr.Code(
+                value=DEFAULT_CODE,
+                label="Manim Scene Code",
+                language="python",
+                lines=20,
+                interactive=True
+            )
+            
+            with gr.Row():
+                render_button = gr.Button("🎬 Render Video", variant="primary", size="lg")
+                clear_button = gr.Button("🗑️ Clear", variant="secondary")
+        
+        with gr.Column(scale=1):
+            output_video = gr.Video(
+                label="Rendered Animation", 
+                interactive=False,
+                height=400
+            )
+            
+            gr.Markdown("""
+            ### 💡 Tips:
+            - Your class must inherit from `Scene`
+            - The `from manim import *` import will be added automatically
+            - Use `self.play()` to animate objects
+            - Use `self.wait()` to add pauses
+            - Rendering may take 1-2 minutes
+            """)
 
+    # Event handlers
     render_button.click(
         fn=render_manim_video,
+        inputs=[code_input],
+        outputs=[output_video],
+        show_progress=True
+    )
+    
+    clear_button.click(
+        fn=lambda: DEFAULT_CODE,
         inputs=[],
-        outputs=[output_video]
+        outputs=[code_input]
     )
 
 # --- Launch ---
-demo.launch(server_name="0.0.0.0", share=True)
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)