Add application file

Dockerfile

@@ -0,0 +1,34 @@
+FROM python:3.10-slim
+
+# Install system dependencies required for Manim
+RUN apt-get update && apt-get install -y \
+    libcairo2-dev \
+    libpango1.0-dev \
+    libgirepository1.0-dev \
+    libxml2-dev \
+    libxslt1-dev \
+    libffi-dev \
+    libssl-dev \
+    pkg-config \
+    build-essential \
+    ffmpeg \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "paste.txt"]

app.py

@@ -0,0 +1,424 @@
+import gradio as gr
+import subprocess
+import os
+import tempfile
+import shutil
+from pathlib import Path
+import time
+import sys
+
+# Check if Manim is available
+try:
+    import manim
+    MANIM_AVAILABLE = True
+except ImportError:
+    MANIM_AVAILABLE = False
+
+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.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)
+        
+        if not has_import:
+            return False, "Code must include 'from manim import *' or 'import manim'"
+        
+        if "class" not in code:
+            return False, "Code must contain at least one class definition"
+        
+        if "Scene" not in code:
+            return False, "Class must inherit from Scene or a Scene subclass"
+        
+        return True, "Code validation passed"
+    
+    def install_system_dependencies(self):
+        """Install required system dependencies"""
+        try:
+            # Install system dependencies for Manim
+            subprocess.check_call([
+                "apt-get", "update"
+            ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            
+            subprocess.check_call([
+                "apt-get", "install", "-y",
+                "libcairo2-dev", "libpango1.0-dev", "libgirepository1.0-dev",
+                "libxml2-dev", "libxslt1-dev", "libffi-dev", "libssl-dev",
+                "pkg-config", "build-essential"
+            ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            
+            return True, "System dependencies installed"
+        except subprocess.CalledProcessError as e:
+            return False, f"Failed to install system dependencies: {str(e)}"
+        except Exception as e:
+            return False, f"Error installing dependencies: {str(e)}"
+    
+    def install_manim(self):
+        """Try to install Manim if not available"""
+        try:
+            # Try to install Manim first
+            subprocess.check_call([
+                sys.executable, "-m", "pip", "install", 
+                "manim", "--quiet"
+            ])
+            
+            # Try to install manimpango separately if needed
+            try:
+                subprocess.check_call([
+                    sys.executable, "-m", "pip", "install", 
+                    "manimpango", "--quiet"
+                ])
+            except subprocess.CalledProcessError:
+                # manimpango might fail, but manim might still work
+                pass
+                
+            return True, "Manim installed successfully"
+        except subprocess.CalledProcessError as e:
+            return False, f"Failed to install Manim: {str(e)}"
+    
+    def execute_manim_code(self, code, quality="low", format_type="gif"):
+        """Execute Manim code and return the generated animation"""
+        global MANIM_AVAILABLE
+        
+        # Check if Manim is available, try to install if not
+        if not MANIM_AVAILABLE:
+            success, message = self.install_manim()
+            if not success:
+                return None, f"❌ Manim Installation Error: {message}", ""
+            MANIM_AVAILABLE = True
+        
+        try:
+            # Validate code
+            is_valid, message = self.validate_manim_code(code)
+            if not is_valid:
+                return None, f"❌ Validation Error: {message}", ""
+            
+            # Setup directories
+            temp_dir = self.setup_directories()
+            
+            # Create Python file
+            python_file = os.path.join(temp_dir, "animation.py")
+            with open(python_file, "w") as f:
+                f.write(code)
+            
+            # 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", ""
+            
+            # Quality settings
+            quality_map = {
+                "low": "-ql",
+                "medium": "-qm", 
+                "high": "-qh"
+            }
+            quality_flag = quality_map.get(quality, "-ql")
+            
+            # Format settings
+            format_flag = "--format=gif" if format_type == "gif" else ""
+            
+            # Build Manim command
+            cmd = [
+                sys.executable, "-m", "manim",
+                quality_flag,
+                python_file,
+                class_name
+            ]
+            
+            if format_flag:
+                cmd.append(format_flag)
+            
+            # Set environment variables to help with rendering
+            env = os.environ.copy()
+            env['MPLBACKEND'] = 'Agg'  # Use non-interactive backend
+            
+            # Execute Manim
+            result = subprocess.run(
+                cmd,
+                cwd=temp_dir,
+                capture_output=True,
+                text=True,
+                timeout=120,  # 2 minute timeout
+                env=env
+            )
+            
+            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:
+            self.cleanup_directories()
+            return None, f"❌ Error: {str(e)}", ""
+    
+    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"""
+        # Search recursively for the output file
+        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)
+        
+        return None
+
+# Initialize the generator
+generator = ManimAnimationGenerator()
+
+# Example Manim codes for users
+example_codes = {
+    "Simple Square": '''from manim import *
+
+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()''',
+    
+    "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()''',
+    
+    "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()''',
+    
+    "Mathematical Formula": '''from manim import *
+
+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 check_manim_installation():
+    """Check if Manim is properly installed"""
+    try:
+        result = subprocess.run([
+            sys.executable, "-c", "import manim; print('Manim version:', manim.__version__)"
+        ], capture_output=True, text=True, timeout=10)
+        
+        if result.returncode == 0:
+            return True, f"✅ Manim is available: {result.stdout.strip()}"
+        else:
+            return False, f"❌ Manim import failed: {result.stderr}"
+    except Exception as e:
+        return False, f"❌ Error checking Manim: {str(e)}"
+
+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 enter some Manim code", ""
+    
+    progress(0.2, desc="Checking Manim installation...")
+    manim_ok, manim_status = check_manim_installation()
+    
+    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 code"""
+    return example_codes.get(example_name, "")
+
+# Create Gradio interface
+with gr.Blocks(title="Manim Animation Generator", theme=gr.themes.Soft()) as app:
+    gr.Markdown("""
+    # 🎬 Manim Animation Generator
+    
+    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
+    
+    ## ⚠️ Note:
+    This app will automatically install Manim if it's not available. First run may take longer.
+    
+    ## 💡 Tips:
+    - Your code must include `from manim import *`
+    - Create a class that inherits from `Scene`
+    - Use the `construct` method to define your animation
+    """)
+    
+    # System status
+    manim_available, status_msg = check_manim_installation()
+    gr.Markdown(f"**System Status:** {status_msg}")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            code_input = gr.Code(
+                label="Manim Code",
+                language="python",
+                lines=20,
+                value=example_codes["Simple Square"]
+            )
+            
+            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"
+                )
+            
+            generate_btn = gr.Button("🎬 Generate Animation", variant="primary", size="lg")
+            
+            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)
+            
+            with gr.Row():
+                show_logs_btn = gr.Button("Show Logs", size="sm")
+                hide_logs_btn = gr.Button("Hide Logs", size="sm")
+    
+    # Event handlers
+    generate_btn.click(
+        fn=generate_animation,
+        inputs=[code_input, quality, format_type],
+        outputs=[output_video, status_output, logs_output]
+    )
+    
+    load_example_btn.click(
+        fn=load_example,
+        inputs=[example_dropdown],
+        outputs=[code_input]
+    )
+    
+    example_dropdown.change(
+        fn=load_example,
+        inputs=[example_dropdown],
+        outputs=[code_input]
+    )
+    
+    show_logs_btn.click(
+        fn=lambda: gr.update(visible=True),
+        outputs=[logs_output]
+    )
+    
+    hide_logs_btn.click(
+        fn=lambda: gr.update(visible=False),
+        outputs=[logs_output]
+    )
+    
+    gr.Markdown("""
+    ## 🔧 Troubleshooting:
+    - **Installation errors**: The app will try to install Manim automatically
+    - **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/)
+    """)
+
+if __name__ == "__main__":
+    app.launch(debug=True, share=True)

packages.txt

@@ -0,0 +1,5 @@
+libcairo2-dev
+libpango1.0-dev
+libgirepository1.0-dev
+pkg-config
+build-essential

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+manim
+numpy
+matplotlib
+Pillow