import gradio as gr
import os
import tempfile
import subprocess
import shutil
import logging
import time
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def get_client():
return OpenAI(
api_key=os.environ.get("TOGETHER_API_KEY"),
base_url="https://api.together.xyz/v1"
)
AVAILABLE_MODELS = [
"meta-llama/Llama-3.3-70B-Instruct-Turbo",
"deepseek-ai/DeepSeek-V3",
"deepseek-ai/DeepSeek-R1",
"Qwen/QwQ-32B-Preview",
"meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
"Qwen/Qwen2.5-Coder-32B-Instruct"
]
def generate_manim_code(prompt, model_name, temperature=0.7, max_tokens=8192):
try:
client = get_client()
system_prompt = """
You are an expert in creating mathematical and physics visualizations using Manim (Mathematical Animation Engine).
Your task is to convert a text prompt into valid, executable Manim Python code.
IMPORTANT RULES FOR COMPILATION SUCCESS:
1. Only return valid Python code that works with the latest version of Manim Community edition
2. Do NOT include any explanations outside of code comments
3. Use ONLY the Scene class as the base class
4. Include ALL necessary imports at the top (from manim import *)
5. Use descriptive variable names that follow Python conventions
6. Include helpful comments for complex parts of the visualization
7. The class name MUST be "Screen" - always use this exact name
8. Always implement the construct method correctly
9. Ensure all objects are properly added to the scene with self.play() or self.add()
10. Do not create custom classes other than the main Scene class
11. Include proper self.wait() calls after animations for better viewing
12. Check all mathematical expressions are valid LaTeX syntax
13. Avoid advanced or experimental Manim features that might not be widely available
14. Keep animations under 20 seconds total for better performance
15. Ensure all coordinates and dimensions are appropriate for the default canvas size
16. DO NOT include any backticks (```) or markdown formatting in your response
RESPOND WITH ONLY THE EXECUTABLE PYTHON CODE, NO INTRODUCTION OR EXPLANATION, NO MARKDOWN FORMATTING.
"""
final_prompt = f"Create a Manim visualization that explains: {prompt}"
logger.info(f"Generating code with model: {model_name}")
response = client.chat.completions.create(
model=model_name,
temperature=temperature,
max_tokens=max_tokens,
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": final_prompt}
]
)
generated_code = response.choices[0].message.content
# Strip markdown formatting if it appears in the response
if "```python" in generated_code:
generated_code = generated_code.split("```python")[1]
if "```" in generated_code:
generated_code = generated_code.split("```")[0]
elif "```" in generated_code:
generated_code = generated_code.split("```")[1]
if "```" in generated_code:
generated_code = generated_code.split("```")[0]
# Remove any additional backticks that might cause syntax errors
generated_code = generated_code.replace('```', '')
# Ensure code starts with proper import
if not generated_code.strip().startswith('from manim import'):
generated_code = 'from manim import *\n\n' + generated_code
return generated_code.strip()
except Exception as e:
logger.error(f"Error generating code: {e}")
return f"Error generating code: {str(e)}"
def render_manim_video(code, quality="medium_quality"):
try:
temp_dir = tempfile.mkdtemp()
script_path = os.path.join(temp_dir, "manim_script.py")
with open(script_path, "w") as f:
f.write(code)
class_name = None
for line in code.split("\n"):
if line.startswith("class ") and "Scene" in line:
class_name = line.split("class ")[1].split("(")[0].strip()
break
if not class_name:
return "Error: Could not identify the Scene class in the generated code."
if quality == "high_quality":
command = ["manim", "-qh", script_path, class_name]
quality_dir = "1080p60"
elif quality == "low_quality":
command = ["manim", "-ql", script_path, class_name]
quality_dir = "480p15"
else:
command = ["manim", "-qm", script_path, class_name]
quality_dir = "720p30"
logger.info(f"Executing command: {' '.join(command)}")
result = subprocess.run(command, cwd=temp_dir, capture_output=True, text=True)
logger.info(f"Manim stdout: {result.stdout}")
logger.error(f"Manim stderr: {result.stderr}")
if result.returncode != 0:
logger.error(f"Manim execution failed: {result.stderr}")
return f"Error rendering video: {result.stderr}"
media_dir = os.path.join(temp_dir, "media")
videos_dir = os.path.join(media_dir, "videos")
if not os.path.exists(videos_dir):
return "Error: No video was generated. Check if Manim is installed correctly."
scene_dirs = [d for d in os.listdir(videos_dir) if os.path.isdir(os.path.join(videos_dir, d))]
if not scene_dirs:
return "Error: No scene directory found in the output."
scene_dir = max([os.path.join(videos_dir, d) for d in scene_dirs], key=os.path.getctime)
mp4_files = [f for f in os.listdir(os.path.join(scene_dir, quality_dir)) if f.endswith(".mp4")]
if not mp4_files:
return "Error: No MP4 file was generated."
video_file = max([os.path.join(scene_dir, quality_dir, f) for f in mp4_files], key=os.path.getctime)
output_dir = os.path.join(os.getcwd(), "generated_videos")
os.makedirs(output_dir, exist_ok=True)
timestamp = int(time.time())
output_file = os.path.join(output_dir, f"manim_video_{timestamp}.mp4")
shutil.copy2(video_file, output_file)
logger.info(f"Video generated: {output_file}")
return output_file
except Exception as e:
logger.error(f"Error rendering video: {e}")
return f"Error rendering video: {str(e)}"
finally:
if 'temp_dir' in locals():
try:
shutil.rmtree(temp_dir)
except Exception as e:
logger.error(f"Error cleaning up temporary directory: {e}")
def placeholder_for_examples(prompt, model, quality):
code = """
from manim import *
class PythagoreanTheorem(Scene):
def construct(self):
# This is placeholder code for examples
# Creating a right triangle
triangle = Polygon(
ORIGIN,
RIGHT * 3,
UP * 4,
color=WHITE
)
# Adding labels
a = Text("a", font_size=30).next_to(triangle, DOWN)
b = Text("b", font_size=30).next_to(triangle, RIGHT)
c = Text("c", font_size=30).next_to(
triangle.get_center(),
UP + LEFT
)
# Add to scene
self.play(Create(triangle))
self.play(Write(a), Write(b), Write(c))
# Wait at the end
self.wait(2)
"""
return code, None, "Example mode: Click 'Generate Video' to actually process this example"
def process_prompt(prompt, model_name, quality="medium_quality"):
try:
code = generate_manim_code(prompt, model_name)
video_path = render_manim_video(code, quality)
return code, video_path
except Exception as e:
logger.error(f"Error processing prompt: {e}")
return f"Error: {str(e)}", None
def process_prompt_with_status(prompt, model, quality, progress=gr.Progress()):
try:
progress(0, desc="Starting...")
progress(0.3, desc="Generating Manim code using AI...")
code = generate_manim_code(prompt, model)
progress(0.6, desc="Rendering video with Manim (this may take a few minutes)...")
video_path = render_manim_video(code, quality)
progress(1.0, desc="Complete")
if not video_path or video_path.startswith("Error"):
status = video_path if video_path else "Error: Failed to generate video."
return code, None, status
else:
status = "Video generated successfully!"
return code, video_path, status
except Exception as e:
logger.error(f"Error in processing: {e}")
return (code if 'code' in locals() else "Error generating code"), None, f"Error: {str(e)}"
def create_interface():
with gr.Blocks(title="Math & Physics Video Generator") as app:
gr.Markdown("# Interactive Math & Physics Video Generator")
gr.Markdown("Generate educational videos from text prompts using AI and Manim")
with gr.Row():
with gr.Column():
model_dropdown = gr.Dropdown(
choices=AVAILABLE_MODELS,
value=AVAILABLE_MODELS[1],
label="Select AI Model"
)
quality_radio = gr.Radio(
choices=["low_quality", "medium_quality", "high_quality"],
value="medium_quality",
label="Output Quality (affects rendering time)"
)
prompt_input = gr.Textbox(
placeholder="Enter a mathematical or physics concept to visualize...",
label="Prompt",
lines=3
)
submit_btn = gr.Button("Generate Video", variant="primary")
with gr.Accordion("Generated Manim Code", open=False):
code_output = gr.Code(
language="python",
label="Generated Manim Code",
lines=20
)
with gr.Column():
video_output = gr.Video(
label="Generated Animation",
width="100%",
height=500
)
status_output = gr.Textbox(
label="Status",
value="Ready. Enter a prompt and click 'Generate Video'.",
interactive=False
)
submit_btn.click(
fn=process_prompt_with_status,
inputs=[prompt_input, model_dropdown, quality_radio],
outputs=[code_output, video_output, status_output]
)
gr.Examples(
examples=[
["Explain the Pythagorean theorem", AVAILABLE_MODELS[1], "medium_quality"],
["Show how a pendulum works with damping", AVAILABLE_MODELS[1], "medium_quality"],
["Demonstrate the concept of derivatives in calculus", AVAILABLE_MODELS[1], "medium_quality"],
["Visualize the wave function of a particle in a box", AVAILABLE_MODELS[1], "medium_quality"],
["Explain how a capacitor charges and discharges", AVAILABLE_MODELS[1], "medium_quality"]
],
inputs=[prompt_input, model_dropdown, quality_radio],
fn=placeholder_for_examples
)
return app
if __name__ == "__main__":
app = create_interface()
app.launch(share=True)