Update app.py

app.py

@@ -1,357 +1,56 @@
-import gradio as gr
-import subprocess
-import os
-import shutil
-import tempfile
-import re
-import ast
-import sys
-import time
-from pathlib import Path
-
 # --- Configuration ---
-BASE_DIR = "./media"  # Use relative path in user home directory
-
-def ensure_permissions():
-    """Ensure the base directory exists and is writable."""
-    global BASE_DIR
-    
-    try:
-        # Create directories with proper permissions
-        os.makedirs(BASE_DIR, exist_ok=True, mode=0o755)
-        
-        # Try to create a test file to check permissions
-        test_file = os.path.join(BASE_DIR, "test_write.txt")
-        with open(test_file, 'w') as f:
-            f.write("test")
-        os.remove(test_file)
-        print(f"✅ Directory {BASE_DIR} is writable")
-        
-    except PermissionError as e:
-        print(f"❌ Permission denied for {BASE_DIR}: {e}")
-        # Try alternative directories
-        for alt_dir in ["./tmp_media", "/tmp/manim_render", "./output"]:
-            try:
-                BASE_DIR = alt_dir
-                os.makedirs(BASE_DIR, exist_ok=True, mode=0o755)
-                test_file = os.path.join(BASE_DIR, "test_write.txt")
-                with open(test_file, 'w') as f:
-                    f.write("test")
-                os.remove(test_file)
-                print(f"✅ Using alternative directory: {BASE_DIR}")
-                break
-            except:
-                continue
-        else:
-            raise gr.Error("Cannot create writable directory for video output")
-    except Exception as e:
-        print(f"⚠️ Warning: Issue with directory setup: {e}")
-        # Last resort: current directory
-        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 validate_manim_code(code):
-    """Validate Manim code for common issues."""
-    if not code.strip():
-        return False, "Code is empty."
-    
-    # Check for Scene class
-    if not get_scene_class_name(code):
-        return False, "No Scene class found. Make sure your class inherits from Scene."
-    
-    # Check for basic syntax
-    try:
-        ast.parse(code)
-    except SyntaxError as e:
-        return False, f"Syntax error: {e}"
-    
-    # Check for required construct method
-    if 'def construct(' not in code:
-        return False, "Scene class must have a construct() method."
-    
-    return True, "Code looks good!"
+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"
 
-def check_manim_installation():
-    """Check if Manim is properly installed."""
-    try:
-        result = subprocess.run(
-            ["manim", "--version"],
-            capture_output=True,
-            text=True,
-            timeout=10
-        )
-        if result.returncode == 0:
-            return True, result.stdout.strip()
-        else:
-            return False, "Manim command failed"
-    except Exception as e:
-        return False, f"Manim not found: {e}"
-
-def setup_environment():
-    """Set up the environment for Manim rendering."""
-    # Ensure permissions
-    ensure_permissions()
-    
-    # Check Manim installation
-    manim_ok, manim_info = check_manim_installation()
-    if not manim_ok:
-        print(f"⚠️ Manim issue: {manim_info}")
-    else:
-        print(f"✅ {manim_info}")
-    
-    # Set environment variables for better rendering
-    os.environ['MANIM_CONFIG_DIR'] = BASE_DIR
-    os.environ['MANIM_PLUGINS_DIR'] = os.path.join(BASE_DIR, 'plugins')
-    
-    return manim_ok
-
-def render_manim_video(manim_code):
+def render_manim_video():
     """
-    Runs the Manim command with dynamic code and returns the path to the rendered video.
+    Runs the Manim command and returns the path to the rendered video.
+
     """
-    # 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)
+    # 1. Clean up previous renders
+    if os.path.exists(BASE_DIR):
+        shutil.rmtree(BASE_DIR, ignore_errors=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)
+    # 2. Make sure the output path exists
+    os.makedirs(os.path.dirname(OUTPUT_VIDEO_PATH), exist_ok=True)
 
-        # 3. Construct the Manim command
-        command = [
-            "manim",
-            "-ql",  # Low quality for faster rendering
-            script_file,
-            scene_name
-        ]
+    # 3. Construct the Manim command
+    command = [
+        "manim",
+        "-ql",
+    ]
 
+    try:
         # Run the command
         process = subprocess.run(
             command,
             check=True,
-            capture_output=True,
-            text=True,
-            cwd=os.path.dirname(script_file)
         )
         print("Manim STDOUT:", process.stdout)
 
-        # 4. Find the output video (Manim creates it in media/videos/)
-        default_output = f"media/videos/{script_name}/480p15/{scene_name}.mp4"
-        
+        # 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"
         if os.path.exists(default_output):
-            # Move to our expected location
-            shutil.move(default_output, output_video_path)
-            return output_video_path
+            shutil.move(default_output, OUTPUT_VIDEO_PATH)
+            return OUTPUT_VIDEO_PATH
         else:
-            # 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.")
+            raise gr.Error("Video was not created. Check Manim output.")
 
     except subprocess.CalledProcessError as e:
-        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}")
+
+        print("Manim STDERR:", e.stderr)
+        raise gr.Error(f"Manim failed to render. Error: {e.stderr}")
     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 ---
-
-# 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")
+with gr.Blocks() as demo:
+    gr.Markdown("# Interactive Manim: Pythagorean Theorem Proof")
     gr.Markdown(
-        "Create beautiful mathematical animations with Manim! Write your scene code below and click render to generate a video."
-    )
-    
-    with gr.Row():
-        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=[code_input]
+        outputs=[output_video]
     )
 
 # --- Launch ---
-if __name__ == "__main__":
-    # Setup environment before launching
-    setup_environment()
-    demo.launch(
-        server_name="0.0.0.0", 
-        server_port=7860,
-        share=True,
-        show_error=True,
-        quiet=True
-    )
+demo.launch(server_name="0.0.0.0", share=True)