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)