Third commit

app.py

@@ -9,17 +9,22 @@ 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 ManimMCPServer:
+class LightweightAnimationServer:
     def __init__(self):
         self.temp_dir = tempfile.mkdtemp()
-        self.max_execution_time = 60  # 60 seconds timeout
+        self.max_execution_time = 30  # 30 seconds timeout
         
-    def validate_manim_code(self, code):
-        """ Basic validation of Manim code """
+    def validate_animation_code(self, code):
+        """Basic validation of animation code"""
         dangerous_imports = [
             'subprocess', 'os.system', 'eval', 'exec', 'open',
-            '__import__', 'compile', 'globals', 'locals'
+            '__import__', 'compile', 'globals', 'locals', 'input'
         ]
         
         for dangerous in dangerous_imports:
@@ -27,115 +32,66 @@ class ManimMCPServer:
                 return False, f"Dangerous operation detected: {dangerous}"
         
         # Check if it's a valid Python-like structure
-        if 'from manim import *' not in code and 'import manim' not in code:
-            return False, "Code must import manim"
+        if 'import matplotlib' not in code and 'from matplotlib' not in code:
+            return False, "Code must import matplotlib"
             
-        if 'class' not in code or 'Scene' not in code:
-            return False, "Code must contain a Scene class"
+        if 'def animate' not in code and 'def create_animation' not in code:
+            return False, "Code must contain an animate or create_animation function"
             
         return True, "Valid"
     
-    def execute_with_timeout(self, cmd, timeout):
-        """ Execute command with timeout """
-        result_queue = queue.Queue()
-        
-        def run_command():
-            try:
-                result = subprocess.run(
-                    cmd, 
-                    shell=True, 
-                    capture_output=True, 
-                    text=True,
-                    cwd=self.temp_dir
-                )
-                result_queue.put(('success', result))
-            except Exception as e:
-                result_queue.put(('error', str(e)))
-        
-        thread = threading.Thread(target=run_command)
-        thread.daemon = True
-        thread.start()
-        thread.join(timeout)
-        
-        if thread.is_alive():
-            return False, "Execution timed out"
-        
-        if result_queue.empty():
-            return False, "Execution failed"
-            
-        status, result = result_queue.get()
-        if status == 'error':
-            return False, result
-        
-        return True, result
-    
-    def render_manim_animation(self, code, scene_name=None, quality="medium_quality"):
-        """ Render Manim animation and return video path """
+    def execute_animation_code(self, code):
+        """Execute animation code safely"""
         try:
             # Validate code
-            is_valid, message = self.validate_manim_code(code)
+            is_valid, message = self.validate_animation_code(code)
             if not is_valid:
                 return None, f"Code validation failed: {message}"
             
-            # Create temporary Python file
-            script_path = os.path.join(self.temp_dir, "animation.py")
-            with open(script_path, 'w') as f:
-                f.write(code)
-            
-            # Auto-detect scene name if not provided
-            if not scene_name:
-                lines = code.split('\n')
-                for line in lines:
-                    if line.strip().startswith('class ') and 'Scene' in line:
-                        scene_name = line.split('class ')[1].split('(')[0].strip()
-                        break
-                
-                if not scene_name:
-                    return None, "Could not detect scene name. Please specify scene_name parameter."
-            
-            # Quality settings
-            quality_map = {
-                "low_quality": "-ql",
-                "medium_quality": "-qm", 
-                "high_quality": "-qh",
-                "production_quality": "-qp"
+            # Create a restricted execution environment
+            restricted_globals = {
+                '__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,
+                },
+                'np': np,
+                'plt': plt,
+                'animation': animation,
+                'matplotlib': plt.matplotlib,
             }
             
-            quality_flag = quality_map.get(quality, "-qm")
-            
-            # Render animation
-            cmd = f"manim {quality_flag} animation.py {scene_name}"
-            
-            success, result = self.execute_with_timeout(cmd, self.max_execution_time)
-            
-            if not success:
-                return None, f"Rendering failed: {result}"
+            # Create output file path
+            output_path = os.path.join(self.temp_dir, "animation.mp4")
             
-            if result.returncode != 0:
-                return None, f"Manim execution failed:\nSTDOUT: {result.stdout}\nSTDERR: {result.stderr}"
+            # Add the output path to the environment
+            restricted_globals['output_path'] = output_path
             
-            # Find generated video file
-            media_dir = os.path.join(self.temp_dir, "media", "videos", "animation")
+            # Execute the code
+            exec(code, restricted_globals)
             
-            if not os.path.exists(media_dir):
-                return None, "No output directory found. Animation may not have been generated."
-            
-            # Look for MP4 files
-            video_files = []
-            for root, dirs, files in os.walk(media_dir):
-                for file in files:
-                    if file.endswith('.mp4'):
-                        video_files.append(os.path.join(root, file))
-            
-            if not video_files:
-                return None, "No MP4 files generated. Check your scene code."
+            # 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'."
                 
-            # Return the most recent video file
-            latest_video = max(video_files, key=os.path.getctime)
-            return latest_video, "Animation rendered successfully!"
-            
         except Exception as e:
-            return None, f"Unexpected error: {str(e)}\n{traceback.format_exc()}"
+            return None, f"Execution error: {str(e)}\n{traceback.format_exc()}"
     
     def cleanup(self):
         """Clean up temporary files"""
@@ -145,58 +101,125 @@ class ManimMCPServer:
             pass
 
 # Initialize the server
-mcp_server = ManimMCPServer()
+animation_server = LightweightAnimationServer()
 
-# Example Manim scripts
+# Example animation scripts
 EXAMPLE_SCRIPTS = {
-    "Hello World": '''from manim import *
+    "Sine Wave": '''import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+import numpy as np
 
-class HelloWorld(Scene):
-    def construct(self):
-        text = Text("Hello, World!", font_size=72)
-        text.set_color(BLUE)
-        self.play(Write(text))
-        self.wait(2)
-        self.play(FadeOut(text))''',
-    
-    "Simple Animation": '''from manim import *
+# 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')
 
-class SimpleAnimation(Scene):
-    def construct(self):
-        circle = Circle()
-        circle.set_fill(PINK, opacity=0.5)
-        
-        square = Square()
-        square.set_fill(BLUE, opacity=0.5)
-        
-        self.play(Create(circle))
-        self.play(Transform(circle, square))
-        self.play(Rotate(square, PI/2))
-        self.wait()''',
-        
-    "Mathematical Formula": '''from manim import *
+x = np.linspace(0, 4*np.pi, 1000)
+line, = ax.plot([], [], 'b-', linewidth=2)
 
-class MathFormula(Scene):
-    def construct(self):
-        formula = MathTex(r"\\frac{d}{dx}\\left(\\frac{1}{x}\\right) = -\\frac{1}{x^2}")
-        formula.scale(2)
-        formula.set_color(YELLOW)
-        
-        self.play(Write(formula))
-        self.wait(2)
-        
-        box = SurroundingRectangle(formula, color=WHITE)
-        self.play(Create(box))
-        self.wait()'''
+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
+
+fig, ax = plt.subplots(figsize=(12, 8))
+
+# Sample data
+categories = ['A', 'B', 'C', 'D', 'E']
+colors = ['red', 'blue', 'green', 'orange', 'purple']
+
+def animate(frame):
+    ax.clear()
+    
+    # Generate some dynamic data
+    values = np.random.rand(5) * (frame + 1) * 10
+    
+    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')
+    
+    # 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')
+    
+    return bars
+
+anim = animation.FuncAnimation(fig, animate, frames=50, interval=200, blit=False)
+anim.save(output_path, writer='ffmpeg', fps=5)
+plt.close()'''
 }
 
-def render_animation(code, scene_name, quality):
-    """ Gradio interface function """
+def create_animation(code, animation_type):
+    """Gradio interface function for creating animations"""
     if not code.strip():
-        return None, "Please provide Manim code"
+        return None, "Please provide animation code"
     
     try:
-        video_path, message = mcp_server.render_manim_animation(code, scene_name, quality)
+        video_path, message = animation_server.execute_animation_code(code)
         
         if video_path:
             return video_path, f"✅ {message}"
@@ -207,31 +230,52 @@ def render_animation(code, scene_name, quality):
         return None, f"❌ Error: {str(e)}"
 
 def load_example(example_name):
-    """ Load example script """
+    """Load example script"""
     return EXAMPLE_SCRIPTS.get(example_name, "")
 
 def clear_all():
     """Clear all fields"""
-    return "", "", None, ""
+    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
 
 # Create Gradio interface
-with gr.Blocks(title="Manim MCP Server", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🎬 Manim MCP Server
-    
-    A Gradio-based MCP-like server for rendering Manim Community Edition animations.
-    Write your Manim code, specify the scene name, and get an MP4 video output!
+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!
+        """)
     
+    gr.Markdown("""
     ## How to use:
-    1. Write or select a Manim script
-    2. Specify the scene class name
-    3. Choose quality settings
-    4. Click "Render Animation"
+    1. Write or select an animation script
+    2. Make sure your code saves the animation to `output_path`
+    3. Click "Create Animation"
+    
+    ### 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)`
     """)
     
     with gr.Row():
         with gr.Column(scale=2):
-            gr.Markdown("### 📝 Manim Code")
+            gr.Markdown("### 📝 Animation Code")
             
             with gr.Row():
                 example_dropdown = gr.Dropdown(
@@ -242,32 +286,26 @@ with gr.Blocks(title="Manim MCP Server", theme=gr.themes.Soft()) as demo:
                 clear_btn = gr.Button("Clear All", size="sm")
             
             code_input = gr.Code(
-                label="Manim Script",
+                label="Animation Script",
                 language="python",
-                lines=20,
-                value=EXAMPLE_SCRIPTS["Hello World"]
+                lines=25,
+                value=EXAMPLE_SCRIPTS["Sine Wave"]
             )
             
-            with gr.Row():
-                scene_name_input = gr.Textbox(
-                    label="Scene Class Name",
-                    placeholder="e.g., HelloWorld",
-                    value="HelloWorld"
-                )
-                quality_input = gr.Dropdown(
-                    choices=["low_quality", "medium_quality", "high_quality", "production_quality"],
-                    label="Quality",
-                    value="medium_quality"
-                )
+            animation_type = gr.Dropdown(
+                choices=["matplotlib", "manim"] if MANIM_AVAILABLE else ["matplotlib"],
+                label="Animation Type",
+                value="matplotlib"
+            )
             
-            render_btn = gr.Button("🎬 Render Animation", variant="primary", size="lg")
+            create_btn = gr.Button("🎬 Create Animation", variant="primary", size="lg")
             
         with gr.Column(scale=1):
             gr.Markdown("### 🎥 Output")
             
             status_output = gr.Textbox(
                 label="Status",
-                lines=3,
+                lines=4,
                 interactive=False
             )
             
@@ -277,17 +315,18 @@ with gr.Blocks(title="Manim MCP Server", theme=gr.themes.Soft()) as demo:
             )
     
     gr.Markdown("""
-    ### 📋 Tips:
-    - Make sure your scene class inherits from `Scene`
-    - Import manim with `from manim import *`
-    - Use `self.play()` to animate objects
-    - End with `self.wait()` for a pause
-    - Keep animations short to avoid timeouts
+    ### 📋 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
     
     ### ⚠️ Limitations:
-    - 60-second execution timeout
-    - No dangerous operations allowed
-    - Medium quality by default to save processing time
+    - 30-second execution timeout
+    - No file I/O operations
+    - Limited to safe Python operations
+    - Matplotlib animations only (unless full Manim is available)
     """)
     
     # Event handlers
@@ -299,12 +338,12 @@ with gr.Blocks(title="Manim MCP Server", theme=gr.themes.Soft()) as demo:
     
     clear_btn.click(
         fn=clear_all,
-        outputs=[code_input, scene_name_input, video_output, status_output]
+        outputs=[code_input, video_output, status_output]
     )
     
-    render_btn.click(
-        fn=render_animation,
-        inputs=[code_input, scene_name_input, quality_input],
+    create_btn.click(
+        fn=create_animation,
+        inputs=[code_input, animation_type],
         outputs=[video_output, status_output]
     )