Fifth commit

app.py

@@ -1,355 +1,347 @@
 import gradio as gr
-import tempfile
-import os
 import subprocess
-import json
-import traceback
+import os
+import tempfile
 import shutil
 from pathlib import Path
 import time
-import threading
-import queue
-import matplotlib.pyplot as plt
-import matplotlib.animation as animation
-import numpy as np
-from io import StringIO
-import sys
 
-class LightweightAnimationServer:
+class ManimAnimationGenerator:
     def __init__(self):
+        self.temp_dir = None
+        self.output_dir = None
+    
+    def setup_directories(self):
+        """Setup temporary directories for Manim execution"""
         self.temp_dir = tempfile.mkdtemp()
-        self.max_execution_time = 30  # 30 seconds timeout
+        self.output_dir = os.path.join(self.temp_dir, "media", "videos", "480p15")
+        os.makedirs(self.output_dir, exist_ok=True)
+        return self.temp_dir
+    
+    def cleanup_directories(self):
+        """Clean up temporary directories"""
+        if self.temp_dir and os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+            self.temp_dir = None
+            self.output_dir = None
+    
+    def validate_manim_code(self, code):
+        """Basic validation of Manim code"""
+        required_imports = ["from manim import *", "import manim"]
+        has_import = any(imp in code for imp in required_imports)
         
-    def validate_animation_code(self, code):
-        """Basic validation of animation code"""
-        dangerous_imports = [
-            'subprocess', 'os.system', 'eval', 'exec', 'open',
-            'compile', 'globals', 'locals', 'input', 'raw_input',
-            'file', '__import__'
-        ]
+        if not has_import:
+            return False, "Code must include 'from manim import *' or 'import manim'"
         
-        for dangerous in dangerous_imports:
-            if dangerous in code:
-                return False, f"Dangerous operation detected: {dangerous}"
+        if "class" not in code:
+            return False, "Code must contain at least one class definition"
         
-        # More flexible validation - just check if it looks like animation code
-        has_matplotlib = ('matplotlib' in code or 'plt' in code)
-        has_animation_logic = ('animate' in code or 'FuncAnimation' in code or 'save(' in code)
+        if "Scene" not in code:
+            return False, "Class must inherit from Scene or a Scene subclass"
         
-        if not has_matplotlib:
-            return False, "Code should use matplotlib for animations"
-            
-        if not has_animation_logic:
-            return False, "Code should contain animation logic (animate function, FuncAnimation, or save call)"
-            
-        return True, "Valid"
+        return True, "Code validation passed"
     
-    def execute_animation_code(self, code):
-        """Execute animation code safely"""
+    def execute_manim_code(self, code, quality="low", format_type="gif"):
+        """Execute Manim code and return the generated animation"""
         try:
             # Validate code
-            is_valid, message = self.validate_animation_code(code)
+            is_valid, message = self.validate_manim_code(code)
             if not is_valid:
-                return None, f"Code validation failed: {message}"
+                return None, f"❌ Validation Error: {message}", ""
+            
+            # Setup directories
+            temp_dir = self.setup_directories()
             
-            # Create output file path
-            output_path = os.path.join(self.temp_dir, "animation.mp4")
+            # Create Python file
+            python_file = os.path.join(temp_dir, "animation.py")
+            with open(python_file, "w") as f:
+                f.write(code)
             
-            # Create a safe execution environment with pre-imported modules
-            import matplotlib
-            import matplotlib.pyplot as plt
-            import matplotlib.animation as animation
-            import numpy as np
+            # Extract class name for Manim command
+            class_name = self.extract_class_name(code)
+            if not class_name:
+                self.cleanup_directories()
+                return None, "❌ Error: Could not find a valid Scene class in the code", ""
             
-            # Create globals dictionary with all necessary modules
-            execution_globals = {
-                # Standard Python builtins
-                '__builtins__': {
-                    'range': range, 'len': len, 'enumerate': enumerate, 'zip': zip,
-                    'min': min, 'max': max, 'abs': abs, 'round': round, 'sum': sum,
-                    'print': print, 'int': int, 'float': float, 'str': str,
-                    'list': list, 'dict': dict, 'tuple': tuple, 'set': set,
-                    'bool': bool, 'type': type,
-                },
-                # Pre-imported modules
-                'matplotlib': matplotlib,
-                'plt': plt,
-                'animation': animation,
-                'np': np,
-                'numpy': np,
-                'output_path': output_path,
+            # Quality settings
+            quality_map = {
+                "low": "-ql",
+                "medium": "-qm", 
+                "high": "-qh"
             }
+            quality_flag = quality_map.get(quality, "-ql")
             
-            # Execute the code
-            exec(code, execution_globals)
+            # Format settings
+            format_flag = "--format=gif" if format_type == "gif" else ""
             
-            # Check if animation was created
-            if os.path.exists(output_path):
-                return output_path, "Animation created successfully!"
-            else:
-                return None, "No animation file was generated. Make sure your code saves to 'output_path'."
-                
+            # Build Manim command
+            cmd = [
+                "manim",
+                quality_flag,
+                python_file,
+                class_name
+            ]
+            
+            if format_flag:
+                cmd.append(format_flag)
+            
+            # Execute Manim
+            result = subprocess.run(
+                cmd,
+                cwd=temp_dir,
+                capture_output=True,
+                text=True,
+                timeout=120  # 2 minute timeout
+            )
+            
+            if result.returncode != 0:
+                error_msg = f"❌ Manim execution failed:\n{result.stderr}"
+                self.cleanup_directories()
+                return None, error_msg, result.stdout
+            
+            # Find generated file
+            output_file = self.find_output_file(temp_dir, class_name, format_type)
+            if not output_file:
+                self.cleanup_directories()
+                return None, "❌ Error: Could not find generated animation file", result.stdout
+            
+            # Copy to a permanent location for Gradio
+            permanent_file = f"/tmp/{class_name}_{int(time.time())}.{format_type}"
+            shutil.copy2(output_file, permanent_file)
+            
+            success_msg = f"✅ Animation generated successfully!\nClass: {class_name}\nQuality: {quality}\nFormat: {format_type}"
+            
+            self.cleanup_directories()
+            return permanent_file, success_msg, result.stdout
+            
+        except subprocess.TimeoutExpired:
+            self.cleanup_directories()
+            return None, "❌ Error: Animation generation timed out (2 minutes)", ""
         except Exception as e:
-            return None, f"Execution error: {str(e)}\n{traceback.format_exc()}"
+            self.cleanup_directories()
+            return None, f"❌ Error: {str(e)}", ""
     
-    def cleanup(self):
-        """Clean up temporary files"""
-        try:
-            shutil.rmtree(self.temp_dir)
-        except:
-            pass
-
-# Initialize the server
-animation_server = LightweightAnimationServer()
-
-# Example animation scripts
-EXAMPLE_SCRIPTS = {
-    "Sine Wave": '''import matplotlib.pyplot as plt
-import matplotlib.animation as animation
-import numpy as np
-
-# Create figure and axis
-fig, ax = plt.subplots(figsize=(10, 6))
-ax.set_xlim(0, 4*np.pi)
-ax.set_ylim(-2, 2)
-ax.set_xlabel('x')
-ax.set_ylabel('sin(x)')
-ax.set_title('Animated Sine Wave')
-
-x = np.linspace(0, 4*np.pi, 1000)
-line, = ax.plot([], [], 'b-', linewidth=2)
-
-def animate(frame):
-    y = np.sin(x + frame/10)
-    line.set_data(x, y)
-    return line,
-
-# Create animation
-anim = animation.FuncAnimation(fig, animate, frames=200, interval=50, blit=True)
-anim.save(output_path, writer='ffmpeg', fps=20)
-plt.close()''',
-
-    "Growing Circle": '''import matplotlib.pyplot as plt
-import matplotlib.animation as animation
-import numpy as np
-
-fig, ax = plt.subplots(figsize=(8, 8))
-ax.set_xlim(-2, 2)
-ax.set_ylim(-2, 2)
-ax.set_aspect('equal')
-ax.set_title('Growing Circle')
-
-circle = plt.Circle((0, 0), 0, fill=False, color='red', linewidth=3)
-ax.add_patch(circle)
-
-def animate(frame):
-    radius = (frame / 100) * 1.5
-    circle.set_radius(radius)
-    return circle,
-
-anim = animation.FuncAnimation(fig, animate, frames=150, interval=100, blit=True)
-anim.save(output_path, writer='ffmpeg', fps=10)
-plt.close()''',
-
-    "Rotating Plot": '''import matplotlib.pyplot as plt
-import matplotlib.animation as animation
-import numpy as np
-
-fig = plt.figure(figsize=(10, 8))
-ax = fig.add_subplot(111, projection='3d')
-
-# Generate data
-t = np.linspace(0, 2*np.pi, 100)
-x = np.cos(t)
-y = np.sin(t)
-z = t
-
-line, = ax.plot(x, y, z, 'b-', linewidth=2)
-ax.set_xlabel('X')
-ax.set_ylabel('Y')
-ax.set_zlabel('Z')
-ax.set_title('Rotating 3D Helix')
-
-def animate(frame):
-    ax.view_init(elev=30, azim=frame*2)
-    return line,
-
-anim = animation.FuncAnimation(fig, animate, frames=180, interval=100, blit=False)
-anim.save(output_path, writer='ffmpeg', fps=10)
-plt.close()''',
-
-    "Bar Chart Race": '''import matplotlib.pyplot as plt
-import matplotlib.animation as animation
-import numpy as np
+    def extract_class_name(self, code):
+        """Extract the first Scene class name from the code"""
+        lines = code.split('\n')
+        for line in lines:
+            if line.strip().startswith('class ') and 'Scene' in line:
+                # Extract class name
+                class_def = line.strip().split('class ')[1].split('(')[0].strip()
+                return class_def
+        return None
+    
+    def find_output_file(self, temp_dir, class_name, format_type):
+        """Find the generated output file"""
+        # Common Manim output paths
+        possible_paths = [
+            os.path.join(temp_dir, "media", "videos", "480p15", f"{class_name}.{format_type}"),
+            os.path.join(temp_dir, "media", "videos", "720p30", f"{class_name}.{format_type}"),
+            os.path.join(temp_dir, "media", "videos", "1080p60", f"{class_name}.{format_type}"),
+            os.path.join(temp_dir, "media", "images", f"{class_name}.png"),
+        ]
+        
+        # Also search recursively
+        for root, dirs, files in os.walk(temp_dir):
+            for file in files:
+                if file.startswith(class_name) and file.endswith(f".{format_type}"):
+                    return os.path.join(root, file)
+        
+        # Check specific paths
+        for path in possible_paths:
+            if os.path.exists(path):
+                return path
+        
+        return None
 
-fig, ax = plt.subplots(figsize=(12, 8))
+# Initialize the generator
+generator = ManimAnimationGenerator()
 
-# Sample data
-categories = ['A', 'B', 'C', 'D', 'E']
-colors = ['red', 'blue', 'green', 'orange', 'purple']
+# Example Manim codes for users
+example_codes = {
+    "Simple Square": '''from manim import *
 
-def animate(frame):
-    ax.clear()
-    
-    # Generate some dynamic data
-    values = np.random.rand(5) * (frame + 1) * 10
+class CreateSquare(Scene):
+    def construct(self):
+        square = Square()
+        square.set_fill(BLUE, opacity=0.5)
+        square.set_stroke(WHITE, width=2)
+        
+        self.play(Create(square))
+        self.play(square.animate.rotate(PI/4))
+        self.wait()''',
     
-    bars = ax.bar(categories, values, color=colors, alpha=0.7)
-    ax.set_ylim(0, 100)
-    ax.set_title(f'Animated Bar Chart - Frame {frame}')
-    ax.set_ylabel('Values')
+    "Moving Circle": '''from manim import *
+
+class MovingCircle(Scene):
+    def construct(self):
+        circle = Circle()
+        circle.set_fill(RED, opacity=0.5)
+        
+        self.play(Create(circle))
+        self.play(circle.animate.shift(RIGHT * 2))
+        self.play(circle.animate.shift(UP * 2))
+        self.play(circle.animate.shift(LEFT * 2))
+        self.play(circle.animate.shift(DOWN * 2))
+        self.wait()''',
     
-    # Add value labels on bars
-    for bar, value in zip(bars, values):
-        height = bar.get_height()
-        ax.text(bar.get_x() + bar.get_width()/2., height + 1,
-                f'{value:.1f}', ha='center', va='bottom')
+    "Text Animation": '''from manim import *
+
+class TextAnimation(Scene):
+    def construct(self):
+        text = Text("Hello Manim!", font_size=48)
+        text2 = Text("Animated Math!", font_size=48)
+        
+        self.play(Write(text))
+        self.wait()
+        self.play(Transform(text, text2))
+        self.wait()''',
     
-    return bars
+    "Mathematical Formula": '''from manim import *
 
-anim = animation.FuncAnimation(fig, animate, frames=50, interval=200, blit=False)
-anim.save(output_path, writer='ffmpeg', fps=5)
-plt.close()'''
+class MathFormula(Scene):
+    def construct(self):
+        formula = MathTex(r"\\frac{d}{dx}(x^2) = 2x")
+        formula.scale(2)
+        
+        self.play(Write(formula))
+        self.wait()
+        
+        formula2 = MathTex(r"\\int_0^1 x^2 dx = \\frac{1}{3}")
+        formula2.scale(2)
+        
+        self.play(Transform(formula, formula2))
+        self.wait()'''
 }
 
-def create_animation(code, animation_type):
-    """Gradio interface function for creating animations"""
+def generate_animation(code, quality, format_type, progress=gr.Progress()):
+    """Main function to generate animation"""
+    progress(0, desc="Starting animation generation...")
+    
     if not code.strip():
-        return None, "Please provide animation code"
+        return None, "❌ Please enter some Manim code", ""
     
-    try:
-        video_path, message = animation_server.execute_animation_code(code)
-        
-        if video_path:
-            return video_path, f"✅ {message}"
-        else:
-            return None, f"❌ {message}"
-            
-    except Exception as e:
-        return None, f"❌ Error: {str(e)}"
+    progress(0.3, desc="Validating code...")
+    result = generator.execute_manim_code(code, quality, format_type)
+    
+    progress(0.7, desc="Generating animation...")
+    
+    if result[0]:  # Success
+        progress(1.0, desc="Animation generated successfully!")
+        return result[0], result[1], result[2]
+    else:  # Error
+        return None, result[1], result[2]
 
 def load_example(example_name):
-    """Load example script"""
-    return EXAMPLE_SCRIPTS.get(example_name, "")
-
-def clear_all():
-    """Clear all fields"""
-    return "", None, ""
-
-# Try to install manim if not available, fallback to matplotlib-only mode
-try:
-    import manim
-    MANIM_AVAILABLE = True
-except ImportError:
-    MANIM_AVAILABLE = False
+    """Load example code"""
+    return example_codes.get(example_name, "")
 
 # Create Gradio interface
-with gr.Blocks(title="Animation MCP Server", theme=gr.themes.Soft()) as demo:
-    if not MANIM_AVAILABLE:
-        gr.Markdown("""
-        # 🎬 Animation MCP Server (Lightweight Mode)
-        
-        **Note**: Full Manim is not available in this environment. This is a lightweight version using Matplotlib animations.
-        
-        Create animated plots, charts, and visualizations using matplotlib's animation capabilities!
-        """)
-    else:
-        gr.Markdown("""
-        # 🎬 Animation MCP Server
-        
-        Create animations using matplotlib or Manim Community Edition!
-        """)
-    
+with gr.Blocks(title="Manim Animation Generator", theme=gr.themes.Soft()) as app:
     gr.Markdown("""
-    ## How to use:
-    1. Write or select an animation script
-    2. Make sure your code saves the animation to `output_path`
-    3. Click "Create Animation"
+    # 🎬 Manim Animation Generator
     
-    ### Key Requirements:
-    - Import matplotlib: `import matplotlib.pyplot as plt`
-    - Create animation: Use `matplotlib.animation.FuncAnimation`
-    - Save to output: `anim.save(output_path, writer='ffmpeg', fps=10)`
+    Create beautiful mathematical animations using [Manim](https://www.manim.community/)!
+    Enter your Python code below and watch it come to life.
+    
+    ## 📝 How to use:
+    1. Write or select example Manim code
+    2. Choose quality and format settings
+    3. Click "Generate Animation"
+    4. Wait for your animation to render
+    
+    ## 💡 Tips:
+    - Your code must include `from manim import *`
+    - Create a class that inherits from `Scene`
+    - Use the `construct` method to define your animation
     """)
     
     with gr.Row():
         with gr.Column(scale=2):
-            gr.Markdown("### 📝 Animation Code")
-            
-            with gr.Row():
-                example_dropdown = gr.Dropdown(
-                    choices=list(EXAMPLE_SCRIPTS.keys()),
-                    label="Load Example",
-                    value=None
-                )
-                clear_btn = gr.Button("Clear All", size="sm")
-            
             code_input = gr.Code(
-                label="Animation Script",
+                label="Manim Code",
                 language="python",
-                lines=25,
-                value=EXAMPLE_SCRIPTS["Sine Wave"]
+                placeholder="Enter your Manim code here...",
+                lines=20,
+                value=example_codes["Simple Square"]
             )
             
-            animation_type = gr.Dropdown(
-                choices=["matplotlib", "manim"] if MANIM_AVAILABLE else ["matplotlib"],
-                label="Animation Type",
-                value="matplotlib"
-            )
-            
-            create_btn = gr.Button("🎬 Create Animation", variant="primary", size="lg")
+            with gr.Row():
+                quality = gr.Dropdown(
+                    choices=["low", "medium", "high"],
+                    value="low",
+                    label="Quality"
+                )
+                format_type = gr.Dropdown(
+                    choices=["gif", "mp4"],
+                    value="gif",
+                    label="Format"
+                )
             
-        with gr.Column(scale=1):
-            gr.Markdown("### 🎥 Output")
+            generate_btn = gr.Button("🎬 Generate Animation", variant="primary", size="lg")
             
-            status_output = gr.Textbox(
-                label="Status",
-                lines=4,
-                interactive=False
+            gr.Markdown("### 📚 Example Codes:")
+            example_dropdown = gr.Dropdown(
+                choices=list(example_codes.keys()),
+                label="Load Example",
+                value="Simple Square"
             )
+            load_example_btn = gr.Button("📂 Load Example")
+        
+        with gr.Column(scale=2):
+            output_video = gr.File(label="Generated Animation", file_types=[".gif", ".mp4"])
+            status_output = gr.Textbox(label="Status", lines=5, max_lines=10)
+            logs_output = gr.Textbox(label="Manim Logs", lines=8, max_lines=15, visible=False)
             
-            video_output = gr.Video(
-                label="Generated Animation",
-                height=400
-            )
+            with gr.Row():
+                show_logs_btn = gr.Button("Show Logs", size="sm")
+                hide_logs_btn = gr.Button("Hide Logs", size="sm")
     
-    gr.Markdown("""
-    ### 📋 Tips for Matplotlib Animations:
-    - Use `fig, ax = plt.subplots()` to create your plot
-    - Define an `animate(frame)` function that updates your plot
-    - Use `FuncAnimation(fig, animate, frames=N, interval=ms)`
-    - Always save with `anim.save(output_path, writer='ffmpeg')`
-    - Call `plt.close()` at the end to free memory
+    # Event handlers
+    generate_btn.click(
+        fn=generate_animation,
+        inputs=[code_input, quality, format_type],
+        outputs=[output_video, status_output, logs_output]
+    )
     
-    ### ⚠️ Limitations:
-    - 30-second execution timeout
-    - No file I/O operations
-    - Limited to safe Python operations
-    - Matplotlib animations only (unless full Manim is available)
-    """)
+    load_example_btn.click(
+        fn=load_example,
+        inputs=[example_dropdown],
+        outputs=[code_input]
+    )
     
-    # Event handlers
     example_dropdown.change(
         fn=load_example,
         inputs=[example_dropdown],
         outputs=[code_input]
     )
     
-    clear_btn.click(
-        fn=clear_all,
-        outputs=[code_input, video_output, status_output]
+    show_logs_btn.click(
+        fn=lambda: gr.update(visible=True),
+        outputs=[logs_output]
     )
     
-    create_btn.click(
-        fn=create_animation,
-        inputs=[code_input, animation_type],
-        outputs=[video_output, status_output]
+    hide_logs_btn.click(
+        fn=lambda: gr.update(visible=False),
+        outputs=[logs_output]
     )
+    
+    gr.Markdown("""
+    ## 🔧 Troubleshooting:
+    - **Timeout errors**: Try simpler animations or lower quality
+    - **Import errors**: Make sure to include `from manim import *`
+    - **Class errors**: Your class must inherit from `Scene`
+    - **No output**: Check that your `construct` method has animation commands
+    
+    ## 🎯 Common Manim Objects:
+    - **Shapes**: `Circle()`, `Square()`, `Triangle()`, `Rectangle()`
+    - **Text**: `Text("Hello")`, `MathTex(r"x^2")`
+    - **Animations**: `Create()`, `Write()`, `Transform()`, `FadeIn()`, `FadeOut()`
+    - **Colors**: `RED`, `BLUE`, `GREEN`, `YELLOW`, `WHITE`, `BLACK`
+    
+    ---
+    Made with ❤️ using [Manim](https://www.manim.community/) and [Gradio](https://gradio.app/)
+    """)
 
-# Launch the app
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True
-    )
+    app.launch(debug=True, share=True)

requirements.txt

@@ -1,6 +1,5 @@
 gradio>=4.0.0
-matplotlib>=3.5.0
+manim>=0.18.0
 numpy
-scipy
 pillow
 ffmpeg-python