Add to HF Spaces

.gitignore

@@ -0,0 +1 @@
+/manimator/.env

Dockerfile

@@ -0,0 +1,63 @@
+# Build stage
+FROM python:3.11-slim as builder
+
+# Configure apt and install build dependencies
+RUN rm -f /etc/apt/apt.conf.d/docker-clean \
+    && echo "deb https://deb.debian.org/debian/ stable main" > /etc/apt/sources.list \
+    && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \
+    && apt-get update \
+    && apt-get install -y --no-install-recommends \
+    gcc \
+    g++ \
+    pkg-config \
+    ffmpeg \
+    libcairo2-dev \
+    libpango1.0-dev \
+    python3-dev \
+    texlive \
+    texlive-latex-extra \
+    make \
+    libpangocairo-1.0-0 \
+    dvisvgm \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Poetry
+RUN pip install --no-cache-dir poetry==1.7.1
+
+WORKDIR /app
+COPY pyproject.toml poetry.lock ./
+
+# Install dependencies without project installation
+RUN poetry config virtualenvs.create false \
+    && poetry install --no-root
+
+# Runtime stage
+FROM python:3.11-slim
+
+# Install runtime dependencies
+RUN apt-get update \
+    && echo "deb https://deb.debian.org/debian/ stable main" > /etc/apt/sources.list \
+    && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    libcairo2 \
+    libpango1.0-0 \
+    libpangocairo-1.0-0 \
+    texlive \
+    texlive-latex-extra \
+    dvisvgm \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy built packages and application
+COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
+COPY --from=builder /usr/local/bin/poetry /usr/local/bin/poetry
+COPY manimator ./manimator
+
+ENV PYTHONPATH=/app/manimator
+# EXPOSE 8000
+EXPOSE 7860
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+
+# CMD ["python", "-m", "uvicorn", "manimator.main:app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["python", "manimator/gradio_app.py"]

manimator/.env.example

@@ -0,0 +1,3 @@
+SAMBANOVA_API_KEY=
+DEEPSEEK_API_KEY=
+GEMINI_API_KEY=

manimator/.gradio/cached_examples/15/log.csv

@@ -0,0 +1,4 @@
+Generated Animation,Status,timestamp
+"{""video"": {""path"": "".gradio/cached_examples/15/Generated Animation/94011f1ecb91ed97cf66/tmpri1hckr7.mp4"", ""url"": ""/gradio_api/file=/private/var/folders/6f/cjjq9y_d46q4s10zy4v3d3y00000gn/T/gradio/d3ce242f1241773003ed1ab4326e5690081b12121c4755d8e697dffb42396acd/tmpri1hckr7.mp4"", ""size"": null, ""orig_name"": ""tmpri1hckr7.mp4"", ""mime_type"": null, ""is_stream"": false, ""meta"": {""_type"": ""gradio.FileData""}}, ""subtitles"": null}",Animation generated successfully!,2025-01-05 23:30:10.138786
+"{""video"": {""path"": "".gradio/cached_examples/15/Generated Animation/76b8f850c8e0823ff349/tmp_fgj4jjz.mp4"", ""url"": ""/gradio_api/file=/private/var/folders/6f/cjjq9y_d46q4s10zy4v3d3y00000gn/T/gradio/5778050647cd0c3e4cd3d3e5bce21fd1fd81ee9b4e052d8a76eb188d437d9feb/tmp_fgj4jjz.mp4"", ""size"": null, ""orig_name"": ""tmp_fgj4jjz.mp4"", ""mime_type"": null, ""is_stream"": false, ""meta"": {""_type"": ""gradio.FileData""}}, ""subtitles"": null}",Animation generated successfully!,2025-01-05 23:30:45.353879
+"{""video"": {""path"": "".gradio/cached_examples/15/Generated Animation/828914a7c2fcce16af8a/tmpy_f7knhq.mp4"", ""url"": ""/gradio_api/file=/private/var/folders/6f/cjjq9y_d46q4s10zy4v3d3y00000gn/T/gradio/12a8840f0085cde86eecf8309c03ed2fda3aa656b34139cdd354b30542be4ace/tmpy_f7knhq.mp4"", ""size"": null, ""orig_name"": ""tmpy_f7knhq.mp4"", ""mime_type"": null, ""is_stream"": false, ""meta"": {""_type"": ""gradio.FileData""}}, ""subtitles"": null}",Animation generated successfully!,2025-01-05 23:31:25.217428

manimator/.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

manimator/gradio_app.py

@@ -0,0 +1,186 @@
+import gradio as gr
+from main import (
+    generate_animation_response,
+    process_pdf_with_gemini,
+    process_prompt_scene,
+    ManimProcessor,
+)
+import re
+
+
+def process_prompt(prompt: str):
+    max_attempts = 2
+    attempts = 0
+
+    while attempts < max_attempts:
+        try:
+            processor = ManimProcessor()
+            with processor.create_temp_dir() as temp_dir:
+                scene_description = process_prompt_scene(prompt)
+                response = generate_animation_response(scene_description)
+                code = processor.extract_code(response)
+
+                if not code:
+                    attempts += 1
+                    if attempts < max_attempts:
+                        continue
+                    return None, "No valid Manim code generated after multiple attempts"
+
+                class_match = re.search(r"class (\w+)\(Scene\)", code)
+                if not class_match:
+                    attempts += 1
+                    if attempts < max_attempts:
+                        continue
+                    return None, "No Scene class found after multiple attempts"
+
+                scene_name = class_match.group(1)
+                scene_file = processor.save_code(code, temp_dir)
+                video_path = processor.render_scene(scene_file, scene_name, temp_dir)
+
+                if not video_path:
+                    return None, "Failed to render animation"
+
+                return video_path, "Animation generated successfully!"
+
+        except Exception as e:
+            attempts += 1
+            if attempts < max_attempts:
+                continue
+            return None, f"Error after multiple attempts: {str(e)}"
+
+
+def process_pdf(file_path: str):
+    print("file_path", file_path)
+    try:
+        if not file_path:
+            return "Error: No file uploaded"
+        with open(file_path, "rb") as file_path:
+            file_bytes = file_path.read()
+            scene_description = process_pdf_with_gemini(file_bytes)
+            print("scene_description", scene_description)
+        return scene_description
+    except Exception as e:
+        return f"Error processing PDF: {str(e)}"
+
+
+def interface_fn(prompt=None, pdf_file=None):
+    if prompt:
+        video_path, message = process_prompt(prompt)
+        if video_path:
+            return video_path, message
+        return None, message
+    elif pdf_file:
+        scene_description = process_pdf(pdf_file)
+        if scene_description:
+            video_path, message = process_prompt(scene_description)
+            if video_path:
+                return video_path, message
+            return None, message
+    return None, "Please provide either a prompt or upload a PDF file"
+
+
+description_md = """
+## 🎬 manimator
+
+This tool helps you create visualizations of complex concepts using natural language or PDF papers:
+
+- **Text Prompt**: Describe the concept you want to visualize
+- **PDF Upload**: Upload a research paper to extract key visualizations
+
+### Links
+- [Manim Documentation](https://docs.manim.community/)
+- [Project Repository](https://github.com/yourusername/manimator)
+"""
+
+with gr.Blocks(title="manimator") as demo:
+    gr.Markdown(description_md)
+
+    with gr.Tabs():
+        with gr.TabItem("✍️ Text Prompt"):
+            with gr.Column():
+                text_input = gr.Textbox(
+                    label="Describe the animation you want to create",
+                    placeholder="Explain the working of neural networks",
+                    lines=3,
+                )
+                text_button = gr.Button("Generate Animation from Text")
+
+            # Only show output UI elements here (not in the sample tab)
+            with gr.Row():
+                video_output = gr.Video(label="Generated Animation")
+            status_output = gr.Textbox(
+                label="Status", interactive=False, show_copy_button=True
+            )
+
+            text_button.click(
+                fn=interface_fn,
+                inputs=[text_input],
+                outputs=[video_output, status_output],
+            )
+
+        with gr.TabItem("📄 PDF Upload"):
+            with gr.Column():
+                file_input = gr.File(label="Upload a PDF paper", file_types=[".pdf"])
+                pdf_button = gr.Button("Generate Animation from PDF")
+
+            # Show output UI elements here as well
+            with gr.Row():
+                pdf_video_output = gr.Video(label="Generated Animation")
+            pdf_status_output = gr.Textbox(
+                label="Status", interactive=False, show_copy_button=True
+            )
+
+            pdf_button.click(
+                fn=lambda pdf: interface_fn(prompt=None, pdf_file=pdf),
+                inputs=[file_input],
+                outputs=[pdf_video_output, pdf_status_output],
+            )
+
+        with gr.TabItem("Sample Examples"):
+            sample_select = gr.Dropdown(
+                choices=[
+                    "What is a CNN?",
+                    "BitNet Paper",
+                    "Explain Fourier Transform",
+                    "How does backpropagation work in Neural Networks?",
+                    "What is SVM?",
+                ],
+                label="Choose an example to display",
+                value=None,
+            )
+            sample_video = gr.Video()
+            sample_markdown = gr.Markdown()
+
+            def show_sample(example):
+                if example == "What is a CNN?":
+                    return (
+                        "./manimator/few_shot/CNNExplanation.mp4",
+                        "Output: Example Output 1",
+                    )
+                elif example == "BitNet Paper":
+                    return "./manimator/few_shot/BitNet.mp4", "Output: Example Output 2"
+                elif example == "Explain Fourier Transform":
+                    return (
+                        "./manimator/few_shot/FourierTransformExplanation.mp4",
+                        "Output: Example Output 3",
+                    )
+                elif example == "How does backpropagation work in Neural Networks?":
+                    return (
+                        "./manimator/few_shot/NeuralNetworksBackPropagationExample.mp4",
+                        "Output: Example Output 4",
+                    )
+                elif example == "What is SVM?":
+                    return (
+                        "./manimator/few_shot/SVMExplanation.mp4",
+                        "Output: Example Output 5",
+                    )
+                return None, ""
+
+            sample_select.change(
+                fn=show_sample,
+                inputs=sample_select,
+                outputs=[sample_video, sample_markdown],
+            )
+
+if __name__ == "__main__":
+    demo.launch(share=True)

manimator/main.py

@@ -0,0 +1,285 @@
+from fastapi import FastAPI, HTTPException, File, UploadFile
+from fastapi.responses import FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+import re
+import litellm
+import base64
+import requests
+from dotenv import load_dotenv
+from utils.models import PromptRequest
+from utils.schema import ManimProcessor
+from utils.prompts import MANIM_SYSTEM_PROMPT, SCENE_SYSTEM_PROMPT
+from PyPDF2 import PdfReader, PdfWriter
+import io
+
+load_dotenv()
+
+few_shot_pdf_bytes = open("./manimator/few_shot/few_shot_1.pdf", "rb").read()
+few_shot_pdf = base64.b64encode(few_shot_pdf_bytes).decode("utf-8")
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+def compress_pdf(content: bytes, compression_level: int = 5) -> str:
+    try:
+        reader = PdfReader(io.BytesIO(content))
+        output = io.BytesIO()
+        writer = PdfWriter(output)
+
+        for page in reader.pages:
+            writer.add_page(page)
+
+        writer.set_compression(compression_level)
+        writer.write(output)
+
+        compressed_bytes = output.getvalue()
+        return base64.b64encode(compressed_bytes).decode("utf-8")
+    except Exception as e:
+        return base64.b64encode(content).decode("utf-8")
+
+
+def generate_animation_response(prompt: str) -> str:
+    try:
+        messages = [
+            {
+                "role": "system",
+                "content": MANIM_SYSTEM_PROMPT,
+            },
+            {
+                "role": "user",
+                "content": f"{prompt}\n\n NOTE!!!: Make sure the objects or text in the generated code are not overlapping at any point in the video. Make sure that each scene is properly cleaned up before transitioning to the next scene.",
+            },
+        ]
+        response = litellm.completion(
+            model="deepseek/deepseek-chat", messages=messages, num_retries=2
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to generate animation response: {str(e)}"
+        )
+
+
+def process_prompt_scene(prompt: str) -> str:
+    messages = [
+        {
+            "role": "system",
+            "content": SCENE_SYSTEM_PROMPT,
+        },
+        {
+            "role": "user",
+            "content": "Fourier Transform",
+        },
+        {
+            "role": "assistant",
+            "content": r"""### *Topic*: Fourier Transform
+*Key Points*:
+- Time domain vs frequency domain
+- Decomposing signals into sine waves: \( f(t) = \sum_{n} A_n \sin(2\pi n t + \phi_n) \)
+- Fourier Transform formula: \( \hat{f}(\xi) = \int_{-\infty}^{\infty} f(t) e^{-2\pi i \xi t} dt \)
+- Applications in signal processing
+*Visual Elements*:
+- Animate a complex signal being decomposed into sine waves.
+- Show the Fourier Transform as a graph in the frequency domain.
+*Style*: Smooth animations with mathematical formulas and graphs.""",
+        },
+        {
+            "role": "user",
+            "content": "Explain Gradient Descent",
+        },
+        {
+            "role": "assistant",
+            "content": r"""### *Topic*: Gradient Descent
+*Key Points*:
+- Loss function: \( L(\theta) = \frac{1}{N} \sum_{i=1}^{N} (y_i - f(x_i; \theta))^2 \)
+- Gradient calculation: \( \nabla L(\theta) = \frac{\partial L}{\partial \theta} \)
+- Update rule: \( \theta_{new} = \theta_{old} - \alpha \nabla L(\theta) \)
+- Convergence to the minimum
+*Visual Elements*:
+- 3D surface plot of the loss function.
+- Animate the gradient descent steps moving toward the minimum.
+*Style*: 3D visualizations with step-by-step explanations.""",
+        },
+        {
+            "role": "user",
+            "content": "How does backpropogation work in neural networks?",
+        },
+        {
+            "role": "assistant",
+            "content": r"""### *Topic*: Neural Networks (Backpropagation)
+*Key Points*:
+- Loss function: \( L(\theta) = \frac{1}{N} \sum_{i=1}^{N} (y_i - f(x_i; \theta))^2 \)
+- Chain rule: \( \frac{\partial L}{\partial f} \frac{\partial f}{\partial \theta} \)
+- Weight updates: \( \theta_{new} = \theta_{old} - \alpha \nabla L(\theta) \)
+*Visual Elements*:
+- Animate the flow of gradients through the network.
+- Show the loss surface and gradient descent steps.
+*Style*: Step-by-step, with clear visualizations of gradients and updates.""",
+        },
+        {
+            "role": "user",
+            "content": prompt,
+        },
+    ]
+    response = litellm.completion(
+        model="sambanova/Meta-Llama-3.3-70B-Instruct",
+        messages=messages,
+        num_retries=2,
+    )
+    return response.choices[0].message.content
+
+
+def process_pdf_with_gemini(
+    file_content: bytes, model="gemini/gemini-1.5-flash", retry=False
+) -> str:
+    encoded_pdf = compress_pdf(file_content)
+    try:
+        response = litellm.completion(
+            model=model,
+            messages=[
+                {"role": "system", "content": SCENE_SYSTEM_PROMPT},
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "image_url",
+                            "image_url": "data:application/pdf;base64,{}".format(
+                                few_shot_pdf
+                            ),
+                        },
+                    ],
+                },
+                {
+                    "role": "assistant",
+                    "content": r"""*Topic*: Deep Residual Learning for Image Recognition
+*Key Points*:
+1. *Degradation Problem*: Explain how deeper networks suffer from higher training error despite having more capacity.
+2. *Residual Learning*: Show how residual learning reformulates the problem by learning residual functions \( \mathcal{F}(\mathbf{x}) = \mathcal{H}(\mathbf{x}) - \mathbf{x} \) instead of direct mappings \( \mathcal{H}(\mathbf{x}) \).
+3. *Shortcut Connections*: Visualize how identity shortcuts (skip connections) are added to the network to enable residual learning.
+4. *Deep Residual Networks*: Demonstrate the architecture of deep residual networks (e.g., ResNet-34, ResNet-152) and how they outperform plain networks.
+5. *Bottleneck Design*: Explain the bottleneck design in deeper ResNets (e.g., ResNet-50/101/152) using \(1 \times 1\), \(3 \times 3\), and \(1 \times 1\) convolutions.
+
+*Style*: 3Blue1Brown style (clean, minimalistic, with smooth animations and clear labels)
+*Additional Requirements*:
+- Include mathematical formulas (e.g., \( \mathcal{F}(\mathbf{x}) = \mathcal{H}(\mathbf{x}) - \mathbf{x} \)) and graphs (e.g., training error vs. depth).
+- Use color coding to differentiate between plain networks and residual networks.
+- Animate the flow of data through shortcut connections and residual blocks.
+- Provide step-by-step explanations for each concept.""",
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "image_url",
+                            "image_url": "data:application/pdf;base64,{}".format(
+                                encoded_pdf
+                            ),
+                        },
+                    ],
+                },
+            ],
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        if retry == False:
+            return process_pdf_with_gemini(
+                file_content,
+                model="gemini/gemini-2.0-flash-exp",
+                retry=True,
+            )
+        else:
+            raise HTTPException(
+                status_code=500, detail=f"Failed to process PDF with Gemini: {str(e)}"
+            )
+
+
+def download_arxiv_pdf(url: str) -> bytes:
+    """Download PDF from arxiv URL"""
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+        return response.content
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to download arxiv PDF: {str(e)}"
+        )
+
+
+@app.get("/health-check")
+async def health_check():
+    return {"status": "ok"}
+
+
+@app.post("/generate-pdf-scene")
+async def generate_pdf_scene(file: UploadFile = File(...)):
+    try:
+        content = await file.read()
+        scene_description = process_pdf_with_gemini(content)
+        return {"scene_description": scene_description}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/generate-prompt-scene")
+async def generate_prompt_scene(request: PromptRequest):
+    try:
+        return {"scene_description": process_prompt_scene(request.prompt)}
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Error generating scene descriptions: {str(e)}"
+        )
+
+
+@app.get("/pdf/{arxiv_id}")
+async def process_arxiv_by_id(arxiv_id: str):
+    """Process arxiv paper by ID"""
+    try:
+        arxiv_url = f"https://arxiv.org/pdf/{arxiv_id}"
+        pdf_content = download_arxiv_pdf(arxiv_url)
+        scene_description = process_pdf_with_gemini(pdf_content)
+        return {"scene_description": scene_description}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/generate-animation")
+async def generate_animation(request: PromptRequest):
+    processor = ManimProcessor()
+
+    try:
+        with processor.create_temp_dir() as temp_dir:
+            response = generate_animation_response(request.prompt)
+            code = processor.extract_code(response)
+            if not code:
+                raise HTTPException(
+                    status_code=400, detail="No valid Manim code generated"
+                )
+            class_match = re.search(r"class (\w+)\(Scene\)", code)
+            if not class_match:
+                raise HTTPException(
+                    status_code=400, detail="No Scene class found in code"
+                )
+            scene_name = class_match.group(1)
+            scene_file = processor.save_code(code, temp_dir)
+            video_path = processor.render_scene(scene_file, scene_name, temp_dir)
+            if not video_path:
+                raise HTTPException(
+                    status_code=500, detail="Failed to render animation"
+                )
+            return FileResponse(video_path, media_type="video/mp4")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)

manimator/utils/models.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+
+class PromptRequest(BaseModel):
+    prompt: str

manimator/utils/prompts.py

@@ -0,0 +1,279 @@
+MANIM_SYSTEM_PROMPT = """```You are an expert in creating educational animations using Manim. Your task is to generate Python code for a Manim animation that visually explains a given topic or concept. Follow these steps:
+
+1. **Understand the Topic**:
+   - Analyze the user's topic to identify the key concepts that need to be visualized.
+   - Break down the topic into smaller, digestible components (e.g., steps, mechanisms, equations).
+
+2. **Plan the Animation**:
+   - Create a storyboard for the animation, ensuring it flows logically from one concept to the next.
+   - Decide on the visual elements (e.g., shapes, graphs, text) that will represent each concept.
+   - Ensure all elements stay within the screen's aspect ratio (-7.5 to 7.5 on x-axis, -4 to 4 on y-axis).
+   - Plan proper spacing between elements to avoid overlap.
+   - Make sure the objects or text in the generated code are not overlapping at any point in the video. 
+   - Make sure that each scene is properly cleaned up before transitioning to the next scene.
+
+3. **Write the Manim Code**:
+   - Use Manim's library to create the animation. Include comments in the code to explain each step.
+   - Ensure the code is modular, with separate functions for each key concept.
+   - Use a consistent style (e.g., 3Blue1Brown style) with appropriate colors, labels, and animations.
+   - Implement clean transitions between scenes by removing all elements from previous scene
+   - Use self.play(FadeOut(*self.mobjects)) at the end of each scene.
+   - Add wait() calls after important animations for better pacing.
+   - Make sure the objects or text in the generated code are not overlapping at any point in the video. 
+   - Make sure that each scene is properly cleaned up before transitioning to the next scene.
+
+4. **Output the Code**:
+   - Provide the complete Python script that can be run using Manim.
+   - Include instructions on how to run the script (e.g., command to render the animation).
+   - Verify all scenes have proper cleanup and transitions.
+
+**Example Input**:
+- Topic: "Neural Networks"
+- Key Points: "neurons and layers, weights and biases, activation functions"
+- Style: "3Blue1Brown style"
+
+**Example Output** (only for your reference, do not use this exact code in your outputs):
+```python
+from manim import *
+
+class NeuralNetworkExplanation(Scene):
+    def construct(self):
+        # Title
+        title = Text("Neural Networks Explained", font_size=40, color=BLUE)
+        self.play(Write(title))
+        self.wait(2)
+        self.play(FadeOut(title))
+
+        # Introduction to Neural Networks
+        intro = Text("Key Components of a Neural Network", font_size=35)
+        self.play(Write(intro))
+        self.wait(2)
+        self.play(FadeOut(intro))
+
+        # Show the overall structure of a neural network
+        self.show_neural_network_structure()
+        self.wait(2)
+
+        # Explain neurons and layers
+        self.explain_neurons_and_layers()
+        self.wait(2)
+
+        # Explain weights and biases
+        self.explain_weights_and_biases()
+        self.wait(2)
+
+        # Explain activation functions
+        self.explain_activation_functions()
+        self.wait(2)
+
+    def show_neural_network_structure(self):
+        # Create layers
+        input_layer = self.create_layer(3, "Input Layer", BLUE)
+        hidden_layer = self.create_layer(4, "Hidden Layer", GREEN)
+        output_layer = self.create_layer(2, "Output Layer", RED)
+
+        # Arrange layers horizontally
+        layers = VGroup(input_layer, hidden_layer, output_layer).arrange(RIGHT, buff=2)
+        self.play(Create(layers))
+        self.wait(1)
+
+        # Add connections between layers
+        connections = self.create_connections(input_layer, hidden_layer) + self.create_connections(hidden_layer, output_layer)
+        self.play(Create(connections))
+        self.wait(2)
+
+        # Cleanup
+        self.play(FadeOut(layers), FadeOut(connections))
+
+    def create_layer(self, num_neurons, label, color):
+        # Create a layer of neurons.
+        neurons = VGroup(*[Circle(radius=0.3, color=color) for _ in range(num_neurons)])
+        neurons.arrange(DOWN, buff=0.5)
+        layer_label = Text(label, font_size=20).next_to(neurons, UP)
+        return VGroup(neurons, layer_label)
+
+    def create_connections(self, layer1, layer2):
+        # Create connections between two layers.
+        connections = VGroup()
+        for neuron1 in layer1[0]:
+            for neuron2 in layer2[0]:
+                connection = Line(neuron1.get_right(), neuron2.get_left(), color=WHITE, stroke_width=1)
+                connections.add(connection)
+        return connections
+
+    def explain_neurons_and_layers(self):
+        # Title
+        title = Text("Neurons and Layers", font_size=35, color=BLUE)
+        self.play(Write(title))
+        self.wait(1)
+        self.play(FadeOut(title))
+
+        # Create a single neuron
+        neuron = Circle(radius=0.5, color=GREEN)
+        neuron_label = Text("Neuron", font_size=20).next_to(neuron, DOWN)
+
+        # Create a layer of neurons
+        layer = self.create_layer(3, "Layer", BLUE)
+
+        # Arrange
+        group = VGroup(neuron, layer).arrange(RIGHT, buff=2)
+        self.play(Create(neuron), Write(neuron_label))
+        self.play(Create(layer))
+        self.wait(2)
+
+        # Cleanup
+        self.play(FadeOut(neuron), FadeOut(neuron_label), FadeOut(layer))
+
+    def explain_weights_and_biases(self):
+        # Title
+        title = Text("Weights and Biases", font_size=35, color=BLUE)
+        self.play(Write(title))
+        self.wait(1)
+        self.play(FadeOut(title))
+
+        # Create two neurons
+        neuron1 = Circle(radius=0.3, color=GREEN)
+        neuron2 = Circle(radius=0.3, color=GREEN)
+        neurons = VGroup(neuron1, neuron2).arrange(RIGHT, buff=2)
+
+        # Add a connection with weight and bias
+        connection = Line(neuron1.get_right(), neuron2.get_left(), color=WHITE)
+        weight_label = Text("Weight (w)", font_size=16).next_to(connection, UP)
+        bias_label = Text("Bias (b)", font_size=16).next_to(neuron2, DOWN)
+
+        self.play(Create(neurons))
+        self.play(Create(connection), Write(weight_label), Write(bias_label))
+        self.wait(2)
+
+        # Cleanup
+        self.play(FadeOut(neurons), FadeOut(connection), FadeOut(weight_label), FadeOut(bias_label))
+
+    def explain_activation_functions(self):
+        # Title
+        title = Text("Activation Functions", font_size=35, color=BLUE)
+        self.play(Write(title))
+        self.wait(1)
+        self.play(FadeOut(title))
+
+        # Create axes
+        axes = Axes(x_range=[-3, 3], y_range=[-1, 3], axis_config={"color": BLUE})
+
+        # Plot ReLU
+        relu_graph = axes.plot(lambda x: max(0, x), color=GREEN)
+        relu_label = Text("ReLU(x) = max(0, x)", font_size=20).next_to(axes, UP)
+
+        # Plot Sigmoid
+        sigmoid_graph = axes.plot(lambda x: 1 / (1 + np.exp(-x)), color=RED)
+        sigmoid_label = Text("Sigmoid(x) = 1 / (1 + e^-x)", font_size=20).next_to(axes, UP)
+
+        # Animate
+        self.play(Create(axes))
+        self.play(Create(relu_graph), Write(relu_label))
+        self.wait(1)
+        self.play(Transform(relu_graph, sigmoid_graph), Transform(relu_label, sigmoid_label))
+        self.wait(2)
+
+        # Cleanup
+        self.play(FadeOut(axes), FadeOut(sigmoid_graph), FadeOut(sigmoid_label))
+
+# Run the animation
+if __name__ == "__main__":
+    scene = NeuralNetworkExplanation()
+    scene.render()```
+    
+NOTE!!!: Make sure the objects or text in the generated code are not overlapping at any point in the video. Make sure that each scene is properly cleaned up before transitioning to the next scene."""
+
+
+SCENE_SYSTEM_PROMPT = """# Content Structure System
+
+When presented with any research paper, topic, question, or material, transform it into the following structured format:
+
+## Basic Structure
+For each topic or concept, organize the information as follows:
+
+1. **Topic**: [Main subject or concept name]
+   
+**Key Points**:
+* 3-4 core concepts or fundamental principles
+* Include relevant mathematical formulas where applicable
+* Each point should be substantive and detailed
+* Focus on foundational understanding
+
+**Visual Elements**:
+* 2-3 suggested visualizations or animations
+* Emphasis on dynamic representations where appropriate
+* Clear connection to key points
+
+**Style**:
+* Brief description of visual presentation approach
+* Tone and aesthetic guidelines
+* Specific effects or animation suggestions
+
+## Formatting Rules
+
+1. Mathematical Formulas:
+   - Use proper mathematical notation
+   - Include both symbolic and descriptive forms
+   - Ensure formulas are relevant to key concepts
+
+2. Visual Elements:
+   - Start each bullet with an action verb (Show, Animate, Demonstrate)
+   - Focus on dynamic rather than static representations
+   - Include specific details about what should be visualized
+
+3. Style Guidelines:
+   - Keep to 1-2 sentences
+   - Include both visual and presentational elements
+   - Match style to content type (e.g., "geometric" for math, "organic" for biology)
+
+## Content Guidelines
+
+1. Key Points Selection:
+   - Choose foundational concepts over advanced applications
+   - Include quantitative elements where relevant
+   - Balance theory with practical understanding
+   - Prioritize interconnected concepts
+
+2. Visual Elements Selection:
+   - Focus on elements that clarify complex concepts
+   - Emphasize dynamic processes over static states
+   - Include both macro and micro level visualizations
+   - Suggest interactive elements where appropriate
+
+3. Style Development:
+   - Match aesthetic to subject matter
+   - Consider audience engagement
+   - Incorporate field-specific conventions
+   - Balance technical accuracy with visual appeal
+
+## Example Format:
+
+
+*Topic*: [Subject Name]
+*Key Points*:
+* [Core concept with mathematical formula if applicable]
+* [Fundamental principle]
+* [Essential relationship or process]
+* [Key application or implication]
+
+*Visual Elements*:
+* [Primary visualization with specific details]
+* [Secondary visualization with animation suggestions]
+* [Supporting visual element]
+
+*Style*: [Visual approach and specific effects]
+
+## Implementation Notes:
+
+1. Maintain consistency in depth and detail across all topics
+2. Ensure mathematical notation is precise and relevant
+3. Make visual suggestions specific and actionable
+4. Keep style descriptions concise but informative
+5. Adapt format based on subject matter while maintaining structure
+
+When processing input:
+1. First identify core concepts
+2. Organize into key points with relevant formulas
+3. Develop appropriate visual representations
+4. Define suitable style approach
+5. Review for completeness and consistency"""

manimator/utils/schema.py

@@ -0,0 +1,71 @@
+import os
+import re
+import subprocess
+import tempfile
+from contextlib import contextmanager
+from typing import Optional
+import logging
+from fastapi import HTTPException
+
+
+# logging.basicConfig(level=logging.DEBUG)
+# logger = logging.getLogger(__name__)
+
+
+class ManimProcessor:
+    @contextmanager
+    def create_temp_dir(self):
+        temp_dir = tempfile.mkdtemp()
+        try:
+            yield temp_dir
+        finally:
+            if os.path.exists(temp_dir):
+                for root, dirs, files in os.walk(temp_dir, topdown=False):
+                    for name in files:
+                        os.remove(os.path.join(root, name))
+                    for name in dirs:
+                        os.rmdir(os.path.join(root, name))
+                os.rmdir(temp_dir)
+
+    def extract_code(self, rag_response: str) -> Optional[str]:
+        pattern = r"```python\n(.*?)```"
+        match = re.search(pattern, rag_response, re.DOTALL)
+        return match.group(1).strip() if match else None
+
+    def save_code(self, code: str, temp_dir: str) -> str:
+        scene_file = os.path.join(temp_dir, "scene.py")
+        with open(scene_file, "w") as f:
+            f.write("from manim import *\n\n")
+            f.write(code)
+        return scene_file
+
+    def render_scene(
+        self, scene_file: str, scene_name: str, temp_dir: str
+    ) -> Optional[str]:
+        cmd = [
+            "python",
+            "-m",
+            "manim",
+            "-pql",
+            "--media_dir",
+            temp_dir,
+            scene_file,
+            scene_name,
+        ]
+
+        try:
+            subprocess.run(cmd, check=True, capture_output=True, text=True)
+            video_path = os.path.join(
+                temp_dir, "videos", "scene", "480p15", f"{scene_name}.mp4"
+            )
+
+            if not os.path.exists(video_path):
+                return None
+
+            temp_video = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
+            with open(video_path, "rb") as f:
+                temp_video.write(f.read())
+            return temp_video.name
+
+        except subprocess.CalledProcessError as e:
+            raise HTTPException(status_code=500, detail=f"Render error: {e.stderr}")

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.115.6
+uvicorn==0.34.0
+python-dotenv==1.0.1
+litellm==1.56.10
+python-multipart==0.0.20
+tenacity==9.0.0
+manim==0.18.1
+pypdf2==3.0.1
+gradio==5.9.1