-
+ LaTeX Preview
-
- $$
- {latex_formula}
- $$
-
- Use MathTex(r"{latex_formula}") in your Manim code
-
+
"""
return html
+# ──────────────────────────────────────────────────────────────────────────────
+# 12. render_latex_preview
+# ──────────────────────────────────────────────────────────────────────────────
+def render_latex_preview(latex_formula):
+ """Return HTML snippet with MathJax preview for LaTeX."""
+ if not latex_formula:
+ return """
+ Animation Preview
+{''.join(icons)}
+ Accurate preview requires full render
+ Enter a LaTeX formula above.
+
"""
+ return f"""
+
+
+
+
"""
+
+# ──────────────────────────────────────────────────────────────────────────────
+# 13. prepare_audio_for_manim
+# ──────────────────────────────────────────────────────────────────────────────
def prepare_audio_for_manim(audio_file, target_dir):
- """Process audio file and return path for use in Manim"""
- try:
- # Create audio directory if it doesn't exist
- audio_dir = os.path.join(target_dir, "audio")
- os.makedirs(audio_dir, exist_ok=True)
-
- # Generate a unique filename
- filename = f"audio_{int(time.time())}.mp3"
- output_path = os.path.join(audio_dir, filename)
-
- # Save audio file
- with open(output_path, "wb") as f:
- f.write(audio_file.getvalue())
-
- return output_path
- except Exception as e:
- logger.error(f"Audio processing error: {str(e)}")
- return None
-
+ """Save uploaded audio and return filesystem path."""
+ os.makedirs(target_dir, exist_ok=True)
+ filename = f"audio_{int(time.time())}.mp3"
+ out = os.path.join(target_dir, filename)
+ with open(out, "wb") as f:
+ f.write(audio_file.getvalue())
+ return out
+
+# ──────────────────────────────────────────────────────────────────────────────
+# 14. mp4_to_gif
+# ──────────────────────────────────────────────────────────────────────────────
def mp4_to_gif(mp4_path, output_path, fps=15):
- """Convert MP4 to GIF using ffmpeg as a backup when Manim fails"""
- try:
- # Use ffmpeg for conversion with optimized settings
- command = [
- "ffmpeg",
- "-i", mp4_path,
- "-vf", f"fps={fps},scale=640:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse",
- "-loop", "0",
- output_path
- ]
-
- # Run the conversion
- result = subprocess.run(command, capture_output=True, text=True)
-
- if result.returncode != 0:
- logger.error(f"FFmpeg conversion error: {result.stderr}")
- return None
-
- return output_path
-
- except Exception as e:
- logger.error(f"GIF conversion error: {str(e)}")
- return None
+ """Use ffmpeg to convert an MP4 to a looping GIF."""
+ cmd = [
+ "ffmpeg","-i",mp4_path,
+ "-vf",f"fps={fps},scale=640:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse",
+ "-loop","0",output_path
+ ]
+ res = subprocess.run(cmd, capture_output=True, text=True)
+ return output_path if res.returncode==0 else None
+# ──────────────────────────────────────────────────────────────────────────────
+# 15. generate_manim_video
+# ──────────────────────────────────────────────────────────────────────────────
def generate_manim_video(python_code, format_type, quality_preset, animation_speed=1.0, audio_path=None):
- temp_dir = None
- progress_placeholder = st.empty()
- status_placeholder = st.empty()
- log_placeholder = st.empty()
- video_data = None # Initialize video data variable
-
+ """Render code via Manim CLI; fallback for GIF via ffmpeg."""
+ temp_dir = tempfile.mkdtemp(prefix="manim_")
try:
- if not python_code or not format_type:
- raise ValueError("Missing required parameters")
-
- # Create temporary directory
- temp_dir = tempfile.mkdtemp(prefix="manim_render_")
-
- # Extract the scene class name from the code
- scene_class = extract_scene_class_name(python_code)
- logger.info(f"Detected scene class: {scene_class}")
-
- # If audio is provided, we need to modify the code to include it
- if audio_path:
- # Check if the code already has a with_sound decorator
- if "with_sound" not in python_code:
- # Add the necessary import
- if "from manim.scene.scene_file_writer import SceneFileWriter" not in python_code:
- python_code = "from manim.scene.scene_file_writer import SceneFileWriter\n" + python_code
-
- # Add sound to the scene
- scene_def_pattern = f"class {scene_class}\\(.*?\\):"
- scene_def_match = re.search(scene_def_pattern, python_code)
-
- if scene_def_match:
- scene_def = scene_def_match.group(0)
- scene_def_with_sound = f"@with_sound(\"{audio_path}\")\n{scene_def}"
- python_code = python_code.replace(scene_def, scene_def_with_sound)
- else:
- logger.warning("Could not find scene definition to add audio")
-
- # Write the code to a file
+ scene = extract_scene_class_name(python_code)
scene_file = os.path.join(temp_dir, "scene.py")
with open(scene_file, "w", encoding="utf-8") as f:
f.write(python_code)
-
- # Map quality preset to Manim quality flag
- quality_map = {
- "480p": "-ql", # Low quality
- "720p": "-qm", # Medium quality
- "1080p": "-qh", # High quality
- "4K": "-qk", # 4K quality
- "8K": "-qp" # 8K quality (production quality)
- }
- quality_flag = quality_map.get(quality_preset, "-qm")
-
- # Handle special formats
- if format_type == "png_sequence":
- # For PNG sequence, we need additional flags
- format_arg = "--format=png"
- extra_args = ["--save_pngs"]
- elif format_type == "svg":
- # For SVG, we need a different format
- format_arg = "--format=svg"
- extra_args = []
- else:
- # Standard video formats
- format_arg = f"--format={format_type}"
- extra_args = []
-
- # Show status and create progress bar
- status_placeholder.info(f"Rendering {scene_class} with {quality_preset} quality...")
- progress_bar = progress_placeholder.progress(0)
-
- # Build command
- command = [
- "manim",
- scene_file,
- scene_class,
- quality_flag,
- format_arg
- ]
- command.extend(extra_args)
-
- logger.info(f"Running command: {' '.join(command)}")
-
- # Execute the command
- process = subprocess.Popen(
- command,
- stdout=subprocess.PIPE,
- stderr=subprocess.STDOUT,
- text=True
- )
-
- # Track output
- full_output = []
- output_file_path = None
- mp4_output_path = None # Track MP4 output for GIF fallback
-
+ flag = QUALITY_PRESETS[quality_preset]["flag"]
+ cmd = ["manim", scene_file, scene, flag, f"--format={format_type}"]
+ proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+ output = []
while True:
- line = process.stdout.readline()
- if not line and process.poll() is not None:
+ line = proc.stdout.readline()
+ if not line and proc.poll() is not None:
break
-
- full_output.append(line)
- log_placeholder.code("".join(full_output[-10:]))
-
- # Update progress bar based on output
- if "%" in line:
- try:
- percent = float(line.split("%")[0].strip().split()[-1])
- progress_bar.progress(min(0.99, percent / 100))
- except:
- pass
-
- # Try to capture the output file path from Manim's output
- if "File ready at" in line:
- try:
- # Combine next few lines to get the full path
- path_parts = []
- path_parts.append(line.split("File ready at")[-1].strip())
-
- # Read up to 5 more lines to get the complete path
- for _ in range(5):
- additional_line = process.stdout.readline()
- if additional_line:
- full_output.append(additional_line)
- path_parts.append(additional_line.strip())
- if additional_line.strip().endswith(('.mp4', '.gif', '.webm', '.svg')):
- break
-
- # Join all parts and clean up
- potential_path = ''.join(path_parts).replace("'", "").strip()
- # Look for path pattern surrounded by quotes
- path_match = re.search(r'([\'"]?)((?:/|[a-zA-Z]:\\).*?\.(?:mp4|gif|webm|svg))(\1)', potential_path)
- if path_match:
- output_file_path = path_match.group(2)
- logger.info(f"Found output path in logs: {output_file_path}")
-
- # Track MP4 file for potential GIF fallback
- if output_file_path.endswith('.mp4'):
- mp4_output_path = output_file_path
- except Exception as e:
- logger.error(f"Error parsing output path: {str(e)}")
-
- # Wait for the process to complete
- process.wait()
- progress_bar.progress(1.0)
-
- # IMPORTANT: Wait a moment for file system to catch up
- time.sleep(3)
-
- # Special handling for GIF format - if Manim failed to generate a GIF but we have an MP4
- if format_type == "gif" and (not output_file_path or not os.path.exists(output_file_path)) and mp4_output_path and os.path.exists(mp4_output_path):
- status_placeholder.info("GIF generation via Manim failed. Trying FFmpeg conversion...")
-
- # Generate a GIF using FFmpeg
- gif_output_path = os.path.join(temp_dir, f"{scene_class}_converted.gif")
- gif_path = mp4_to_gif(mp4_output_path, gif_output_path)
-
- if gif_path and os.path.exists(gif_path):
- output_file_path = gif_path
- logger.info(f"Successfully converted MP4 to GIF using FFmpeg: {gif_path}")
-
- # For PNG sequence, we need to collect the PNGs
- if format_type == "png_sequence":
- # Find the PNG directory
- png_dirs = []
- search_dirs = [
- os.path.join(os.getcwd(), "media", "images", scene_class, "Animations"),
- os.path.join(temp_dir, "media", "images", scene_class, "Animations"),
- "/tmp/media/images",
- ]
-
- for search_dir in search_dirs:
- if os.path.exists(search_dir):
- for root, dirs, _ in os.walk(search_dir):
- for d in dirs:
- if os.path.exists(os.path.join(root, d)):
- png_dirs.append(os.path.join(root, d))
-
- if png_dirs:
- # Get the newest directory
- newest_dir = max(png_dirs, key=os.path.getctime)
-
- # Create a zip file with all PNGs
- png_files = [f for f in os.listdir(newest_dir) if f.endswith('.png')]
- if png_files:
- zip_path = os.path.join(temp_dir, f"{scene_class}_pngs.zip")
-
- with zipfile.ZipFile(zip_path, 'w') as zipf:
- for png in png_files:
- png_path = os.path.join(newest_dir, png)
- zipf.write(png_path, os.path.basename(png_path))
-
- with open(zip_path, 'rb') as f:
- video_data = f.read()
-
- logger.info(f"Created PNG sequence zip: {zip_path}")
- else:
- logger.error("No PNG files found in directory")
- else:
- logger.error("No PNG directories found")
- elif output_file_path and os.path.exists(output_file_path):
- # For other formats, read the output file directly
- with open(output_file_path, 'rb') as f:
- video_data = f.read()
- logger.info(f"Read output file from path: {output_file_path}")
- else:
- # If we didn't find the output path, search for files
- search_paths = [
- os.path.join(os.getcwd(), "media", "videos"),
- os.path.join(os.getcwd(), "media", "videos", "scene"),
- os.path.join(os.getcwd(), "media", "videos", scene_class),
- "/tmp/media/videos",
- temp_dir,
- os.path.join(temp_dir, "media", "videos"),
- ]
-
- # Add quality-specific paths
- for quality in ["480p30", "720p30", "1080p60", "2160p60", "4320p60"]:
- search_paths.append(os.path.join(os.getcwd(), "media", "videos", "scene", quality))
- search_paths.append(os.path.join(os.getcwd(), "media", "videos", scene_class, quality))
-
- # For SVG format
- if format_type == "svg":
- search_paths.extend([
- os.path.join(os.getcwd(), "media", "designs"),
- os.path.join(os.getcwd(), "media", "designs", scene_class),
- ])
-
- # Find all output files in the search paths
- output_files = []
- for search_path in search_paths:
- if os.path.exists(search_path):
- for root, _, files in os.walk(search_path):
- for file in files:
- if file.endswith(f".{format_type}") and "partial" not in file:
- file_path = os.path.join(root, file)
- if os.path.exists(file_path):
- output_files.append(file_path)
- logger.info(f"Found output file: {file_path}")
-
- if output_files:
- # Get the newest file
- latest_file = max(output_files, key=os.path.getctime)
- with open(latest_file, 'rb') as f:
- video_data = f.read()
- logger.info(f"Read output from file search: {latest_file}")
-
- # If the format is GIF but we got an MP4, try to convert it
- if format_type == "gif" and latest_file.endswith('.mp4'):
- gif_output_path = os.path.join(temp_dir, f"{scene_class}_converted.gif")
- gif_path = mp4_to_gif(latest_file, gif_output_path)
-
- if gif_path and os.path.exists(gif_path):
- with open(gif_path, 'rb') as f:
- video_data = f.read()
- logger.info(f"Successfully converted MP4 to GIF using FFmpeg: {gif_path}")
-
- # If we got output data, return it
- if video_data:
- file_size_mb = len(video_data) / (1024 * 1024)
-
- # Clear placeholders
- progress_placeholder.empty()
- status_placeholder.empty()
- log_placeholder.empty()
-
- return video_data, f"✅ Animation generated successfully! ({file_size_mb:.1f} MB)"
- else:
- output_str = ''.join(full_output)
- logger.error(f"No output files found. Full output: {output_str}")
-
- # Check if we have an MP4 but need a GIF (special handling for GIF issues)
- if format_type == "gif":
- # Try one more aggressive search for any MP4 file
- mp4_files = []
- for search_path in [os.getcwd(), temp_dir, "/tmp"]:
- for root, _, files in os.walk(search_path):
- for file in files:
- if file.endswith('.mp4') and scene_class.lower() in file.lower():
- mp4_path = os.path.join(root, file)
- if os.path.exists(mp4_path) and os.path.getsize(mp4_path) > 0:
- mp4_files.append(mp4_path)
-
- if mp4_files:
- newest_mp4 = max(mp4_files, key=os.path.getctime)
- logger.info(f"Found MP4 for GIF conversion: {newest_mp4}")
-
- # Convert to GIF
- gif_output_path = os.path.join(temp_dir, f"{scene_class}_converted.gif")
- gif_path = mp4_to_gif(newest_mp4, gif_output_path)
-
- if gif_path and os.path.exists(gif_path):
- with open(gif_path, 'rb') as f:
- video_data = f.read()
-
- # Clear placeholders
- progress_placeholder.empty()
- status_placeholder.empty()
- log_placeholder.empty()
-
- file_size_mb = len(video_data) / (1024 * 1024)
- return video_data, f"✅ Animation converted to GIF successfully! ({file_size_mb:.1f} MB)"
-
- return None, f"❌ Error: No output files were generated.\n\nMakim output:\n{output_str[:500]}..."
-
- except Exception as e:
- logger.error(f"Error: {str(e)}")
- import traceback
- logger.error(traceback.format_exc())
-
- if progress_placeholder:
- progress_placeholder.empty()
- if status_placeholder:
- status_placeholder.error(f"Rendering Error: {str(e)}")
- if log_placeholder:
- log_placeholder.empty()
-
- return None, f"❌ Error: {str(e)}"
-
+ output.append(line)
+ proc.wait()
+ # find output file
+ matches = list(Path(temp_dir).rglob(f"*.{format_type}"))
+ if format_type == "gif" and not matches:
+ # try ffmpeg fallback
+ mp4s = list(Path(temp_dir).rglob("*.mp4"))
+ if mp4s:
+ gif = os.path.join(temp_dir, f"{scene}.gif")
+ mp4_to_gif(str(mp4s[-1]), gif)
+ matches = [Path(gif)]
+ if not matches:
+ return None, "❌ No output file found"
+ data = matches[-1].read_bytes()
+ return data, f"✅ Generated ({len(data)/(1024*1024):.1f} MB)"
finally:
- # CRITICAL: Only cleanup after we've captured the output data
- if temp_dir and os.path.exists(temp_dir) and video_data is not None:
- try:
- shutil.rmtree(temp_dir)
- logger.info(f"Cleaned up temp dir: {temp_dir}")
- except Exception as e:
- logger.error(f"Failed to clean temp dir: {str(e)}")
+ shutil.rmtree(temp_dir, ignore_errors=True)
+# ──────────────────────────────────────────────────────────────────────────────
+# 16. detect_input_calls
+# ──────────────────────────────────────────────────────────────────────────────
def detect_input_calls(code):
- """Detect input() calls in Python code to prepare for handling"""
- input_calls = []
- lines = code.split('\n')
- for i, line in enumerate(lines):
- if 'input(' in line and not line.strip().startswith('#'):
- # Try to extract the prompt if available
- prompt_match = re.search(r'input\([\'"](.+?)[\'"]\)', line)
- prompt = prompt_match.group(1) if prompt_match else f"Input for line {i+1}"
- input_calls.append({"line": i+1, "prompt": prompt})
- return input_calls
-
+ """Scan for input() calls and extract prompts."""
+ calls = []
+ for i, line in enumerate(code.splitlines(), 1):
+ if "input(" in line and not line.strip().startswith("#"):
+ m = re.search(r'input\(["\'](.+?)["\']\)', line)
+ prompt = m.group(1) if m else f"Input at line {i}"
+ calls.append({"line": i, "prompt": prompt})
+ return calls
+
+# ──────────────────────────────────────────────────────────────────────────────
+# 17. run_python_script
+# ──────────────────────────────────────────────────────────────────────────────
def run_python_script(code, inputs=None, timeout=60):
- """Execute a Python script and capture output, handling input calls"""
- result = {
- "stdout": "",
- "stderr": "",
- "exception": None,
- "plots": [],
- "dataframes": [],
- "execution_time": 0
- }
-
- # Replace input() calls with predefined values if provided
- if inputs and len(inputs) > 0:
- # Modify the code to use predefined inputs instead of waiting for user input
- modified_code = """
-# Input values provided by the user
-__INPUT_VALUES = {}
-__INPUT_INDEX = 0
-
-# Override the built-in input function
-def input(prompt=''):
- global __INPUT_INDEX
- print(prompt, end='')
- if __INPUT_INDEX < len(__INPUT_VALUES):
- value = __INPUT_VALUES[__INPUT_INDEX]
- __INPUT_INDEX += 1
- print(value) # Echo the input
- return value
- else:
- print("\\n[WARNING] No more predefined inputs available, using empty string")
- return ""
-
-""".format(inputs)
-
- code = modified_code + code
-
- # Create a tempdir for script execution
- with tempfile.TemporaryDirectory() as temp_dir:
- # Path for saving plots
- plot_dir = os.path.join(temp_dir, 'plots')
- os.makedirs(plot_dir, exist_ok=True)
-
- # Files for capturing stdout and stderr
- stdout_file = os.path.join(temp_dir, 'stdout.txt')
- stderr_file = os.path.join(temp_dir, 'stderr.txt')
-
- # Add plot saving code
- if 'matplotlib' in code or 'plt' in code:
- if 'import matplotlib.pyplot as plt' not in code and 'from matplotlib import pyplot as plt' not in code:
- code = "import matplotlib.pyplot as plt\n" + code
-
- # Add code to save plots
- save_plots_code = """
-# Save all figures
-import matplotlib.pyplot as plt
-import os
-
-__figures = plt.get_fignums()
-for __i, __num in enumerate(__figures):
- __fig = plt.figure(__num)
- __fig.savefig(os.path.join('{}', f'plot_{{__i}}.png'))
-""".format(plot_dir.replace('\\', '\\\\'))
-
- code += "\n" + save_plots_code
-
- # Add dataframe display code if pandas is used
- if 'pandas' in code or 'pd.' in code or 'DataFrame' in code:
- if 'import pandas as pd' not in code and 'from pandas import' not in code:
- code = "import pandas as pd\n" + code
-
- # Add code to save dataframe info
- dataframes_code = """
-# Capture DataFrames
-import pandas as pd
-import json
-import io
-import os
-
-__globals_dict = globals()
-__dataframes = []
-for __var_name, __var_val in __globals_dict.items():
- if isinstance(__var_val, pd.DataFrame) and not __var_name.startswith('__'):
- try:
- # Save basic info
- __df_info = {
- "name": __var_name,
- "shape": __var_val.shape,
- "columns": list(__var_val.columns),
- "preview_html": __var_val.head().to_html()
- }
- with open(os.path.join('{}', f'df_{{__var_name}}.json'), 'w') as __f:
- json.dump(__df_info, __f)
- except:
- pass
-""".format(temp_dir.replace('\\', '\\\\'))
-
- code += "\n" + dataframes_code
-
- # Create the script file
- script_path = os.path.join(temp_dir, 'script.py')
- with open(script_path, 'w') as f:
- f.write(code)
-
- # Execute with timeout
- start_time = time.time()
- try:
- # Run the script with stdout and stderr redirection
- with open(stdout_file, 'w') as stdout_f, open(stderr_file, 'w') as stderr_f:
- process = subprocess.Popen(
- [sys.executable, script_path],
- stdout=stdout_f,
- stderr=stderr_f,
- cwd=temp_dir
- )
-
- try:
- process.wait(timeout=timeout)
- except subprocess.TimeoutExpired:
- process.kill()
- result["stderr"] += f"\nScript execution timed out after {timeout} seconds."
- result["exception"] = "TimeoutError"
- return result
-
- # Read the output
- with open(stdout_file, 'r') as f:
- result["stdout"] = f.read()
-
- with open(stderr_file, 'r') as f:
- result["stderr"] = f.read()
-
- # Collect plots
- if os.path.exists(plot_dir):
- plot_files = sorted([f for f in os.listdir(plot_dir) if f.endswith('.png')])
- for plot_file in plot_files:
- with open(os.path.join(plot_dir, plot_file), 'rb') as f:
- result["plots"].append(f.read())
-
- # Collect dataframes
- df_files = [f for f in os.listdir(temp_dir) if f.startswith('df_') and f.endswith('.json')]
- for df_file in df_files:
- with open(os.path.join(temp_dir, df_file), 'r') as f:
- result["dataframes"].append(json.load(f))
-
- # Calculate execution time
- result["execution_time"] = time.time() - start_time
-
- except Exception as e:
- result["exception"] = str(e)
- result["stderr"] += f"\nError executing script: {str(e)}"
-
+ """Execute arbitrary Python code, capturing stdout/stderr, plots, DataFrames."""
+ tmp = tempfile.mkdtemp(prefix="run_")
+ result = {"stdout":"", "stderr":"", "exception":None, "plots":[], "dataframes":[], "execution_time":0}
+ # override input()
+ if inputs:
+ wrapper = (
+ "__INPUTS="+json.dumps(inputs)+"\n"
+ "__IDX=0\n"
+ "def input(prompt=''):\n"
+ " global __IDX\n"
+ " val = __INPUTS[__IDX] if __IDXLaTeX Preview
+$$ {latex_formula} $$
+ {title}
- -
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- """
-
- # Convert video data to base64
- video_base64 = base64.b64encode(video_data).decode('utf-8')
-
- # Convert markdown explanation to HTML
- explanation_html = markdown.markdown(explanation_text) if explanation_text else "Explanation
- {explanation_html} -No explanation provided.
" - - # Format the HTML template - html_content = html_template.format( - title=animation_title, - video_base64=video_base64, - explanation_html=explanation_html - ) - - # Save to file - output_path = os.path.join(temp_dir, f"{animation_title.replace(' ', '_')}.html") - with open(output_path, "w", encoding="utf-8") as f: - f.write(html_content) - - # Read the file to return it - with open(output_path, "rb") as f: - return f.read(), "html" - - elif format_type == "sequence": - # Generate animation sequence with explanatory text - # Make sure FPDF is installed - try: - from fpdf import FPDF - except ImportError: - logger.error("fpdf not installed") - subprocess.run([sys.executable, "-m", "pip", "install", "fpdf"], check=True) - from fpdf import FPDF - - # Save video temporarily - temp_video_path = os.path.join(temp_dir, "temp_video.mp4") - with open(temp_video_path, "wb") as f: - f.write(video_data) - - # Create frames directory - frames_dir = os.path.join(temp_dir, "frames") - os.makedirs(frames_dir, exist_ok=True) - - # Extract frames using ffmpeg (assuming it's installed) - frame_count = 5 # Number of key frames to extract - try: - subprocess.run([ - "ffmpeg", - "-i", temp_video_path, - "-vf", f"select=eq(n\\,0)+eq(n\\,{frame_count//4})+eq(n\\,{frame_count//2})+eq(n\\,{frame_count*3//4})+eq(n\\,{frame_count-1})", - "-vsync", "0", - os.path.join(frames_dir, "frame_%03d.png") - ], check=True) - except Exception as e: - logger.error(f"Error extracting frames: {str(e)}") - # Try a simpler approach - subprocess.run([ - "ffmpeg", - "-i", temp_video_path, - "-r", "1", # 1 frame per second - os.path.join(frames_dir, "frame_%03d.png") - ], check=True) - - # Parse explanation text into segments (assuming sections divided by ##) - explanation_segments = explanation_text.split("##") if explanation_text else ["No explanation provided."] - - # Create a PDF with frames and explanations - pdf = FPDF() - pdf.set_auto_page_break(auto=True, margin=15) - - # Title page + """Export the existing video_data to PPTX, HTML, or PDF sequence.""" + if format_type=="powerpoint": + from pptx import Presentation + from pptx.util import Inches + prs = Presentation() + slide = prs.slides.add_slide(prs.slide_layouts[0]) + slide.shapes.title.text = animation_title + video_path = os.path.join(temp_dir,"video.mp4") + with open(video_path,"wb") as f: f.write(video_data) + slide2 = prs.slides.add_slide(prs.slide_layouts[5]) + slide2.shapes.title.text="Animation" + slide2.shapes.add_movie(video_path, Inches(1),Inches(1.5),Inches(8),Inches(4.5)) + if explanation_text: + txt_sl = prs.slides.add_slide(prs.slide_layouts[1]) + txt_sl.shapes.title.text="Explanation" + txt_sl.placeholders[1].text=explanation_text + out = os.path.join(temp_dir,f"{animation_title}.pptx") + prs.save(out) + return open(out,"rb").read(), "pptx" + + elif format_type=="html": + html_template = """{title}
+{explanation}
"""
+ b64 = base64.b64encode(video_data).decode()
+ expl = markdown.markdown(explanation_text or "")
+ content = html_template.format(title=animation_title,b64=b64,explanation=expl)
+ out = os.path.join(temp_dir,f"{animation_title}.html")
+ with open(out,"w",encoding="utf-8") as f: f.write(content)
+ return open(out,"rb").read(), "html"
+
+ elif format_type=="sequence":
+ from fpdf import FPDF
+ video_path = os.path.join(temp_dir,"video.mp4")
+ with open(video_path,"wb") as f: f.write(video_data)
+ frames_dir = os.path.join(temp_dir,"frames")
+ os.makedirs(frames_dir, exist_ok=True)
+ # extract 5 key frames
+ subprocess.run(["ffmpeg","-i",video_path,"-vf","select=not(mod(n\\,10))","-vsync","vfr",
+ os.path.join(frames_dir,"frame_%03d.png")], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+ pdf = FPDF()
+ segments = explanation_text.split("##") if explanation_text else []
+ for i, img in enumerate(sorted(os.listdir(frames_dir))):
pdf.add_page()
- pdf.set_font("Arial", "B", 20)
- pdf.cell(190, 10, animation_title, ln=True, align="C")
- pdf.ln(10)
- pdf.set_font("Arial", "", 12)
- pdf.cell(190, 10, "Animation Sequence with Explanations", ln=True, align="C")
-
- # Add each frame with explanation
- frame_files = sorted([f for f in os.listdir(frames_dir) if f.endswith('.png')])
-
- for i, frame_file in enumerate(frame_files):
- pdf.add_page()
-
- # Add frame image
- frame_path = os.path.join(frames_dir, frame_file)
- pdf.image(frame_path, x=10, y=10, w=190)
-
- # Add explanation text
- pdf.ln(140) # Move below the image
- pdf.set_font("Arial", "B", 12)
- pdf.cell(190, 10, f"Step {i+1}", ln=True)
- pdf.set_font("Arial", "", 10)
-
- # Use the corresponding explanation segment if available
- explanation = explanation_segments[min(i, len(explanation_segments)-1)]
- pdf.multi_cell(190, 5, explanation.strip())
-
- # Save PDF
- output_path = os.path.join(temp_dir, f"{animation_title.replace(' ', '_')}_sequence.pdf")
- pdf.output(output_path)
-
- # Read the file to return it
- with open(output_path, "rb") as f:
- return f.read(), "pdf"
-
- return None, None
-
- except Exception as e:
- logger.error(f"Educational export error: {str(e)}")
- import traceback
- logger.error(traceback.format_exc())
- return None, None
-
+ pdf.image(os.path.join(frames_dir,img), x=10,y=10,w=190)
+ pdf.ln(100)
+ txt = segments[i] if i
- 🎬 Manim Animation Studio
-
- Create mathematical animations with Manim
- """, unsafe_allow_html=True) + # Ensure packages installed once + if 'packages_checked' not in st.session_state: + ensure_packages() + st.session_state.packages_checked = True - # Check for packages ONLY ONCE per session - if not st.session_state.packages_checked: - if ensure_packages(): - st.session_state.packages_checked = True - else: - st.error("Failed to install required packages. Please try again.") - st.stop() - - # Create main tabs - tab_names = ["✨ Editor", "🤖 AI Assistant", "📚 LaTeX Formulas", "🎨 Assets", "🎞️ Timeline", "🎓 Educational Export", "🐍 Python Runner"] - tabs = st.tabs(tab_names) - - # Sidebar for rendering settings and custom libraries + # Sidebar with st.sidebar: - # Rendering settings section - st.markdown("## ⚙️ Rendering Settings") - - col1, col2 = st.columns(2) - with col1: - quality = st.selectbox( - "🎯 Quality", - options=list(QUALITY_PRESETS.keys()), - index=list(QUALITY_PRESETS.keys()).index(st.session_state.settings["quality"]), - key="quality_select" - ) - - with col2: - format_type_display = st.selectbox( - "📦 Format", - options=list(EXPORT_FORMATS.keys()), - index=list(EXPORT_FORMATS.values()).index(st.session_state.settings["format_type"]) - if st.session_state.settings["format_type"] in EXPORT_FORMATS.values() else 0, - key="format_select_display" - ) - # Convert display name to actual format value - format_type = EXPORT_FORMATS[format_type_display] - - animation_speed = st.selectbox( - "⚡ Speed", - options=list(ANIMATION_SPEEDS.keys()), - index=list(ANIMATION_SPEEDS.keys()).index(st.session_state.settings["animation_speed"]), - key="speed_select" - ) - - # Apply the settings without requiring a button - st.session_state.settings = { - "quality": quality, - "format_type": format_type, - "animation_speed": animation_speed - } - - # Custom libraries section - st.markdown("## 📚 Custom Libraries") - st.markdown("Enter additional Python packages needed for your animations (comma-separated):") - - custom_libraries = st.text_area( - "Libraries to install", - placeholder="e.g., scipy, networkx, matplotlib", - key="custom_libraries" - ) - - if st.button("Install Libraries", key="install_libraries_btn"): - success, result = install_custom_packages(custom_libraries) - st.session_state.custom_library_result = result - - if success: - st.success("Installation complete!") - else: - st.error("Installation failed for some packages.") - - if st.session_state.custom_library_result: - with st.expander("Installation Results"): - st.code(st.session_state.custom_library_result) - - # EDITOR TAB + st.header("⚙️ Settings") + with st.expander("Render Settings", True): + st.selectbox("Quality", list(QUALITY_PRESETS.keys()), key="quality") + st.selectbox("Format", list(EXPORT_FORMATS.keys()), key="format") + st.selectbox("Speed", list(ANIMATION_SPEEDS.keys()), key="speed") + with st.expander("Custom Libraries"): + txt = st.text_area("pip install …", help="e.g. scipy,networkx") + if st.button("Install"): + ok,msg = install_custom_packages(txt) + st.code(msg) + st.markdown("---") + st.markdown("Manim Studio • Powered by Streamlit") + + # Tabs + tabs = st.tabs(["✨ Editor","🤖 AI","📚 LaTeX","🎨 Assets","🎞️ Timeline","🎓 Export","🐍 Python"]) + + # --- Editor Tab --- with tabs[0]: - col1, col2 = st.columns([3, 2]) - - with col1: - st.markdown("### 📝 Animation Editor") - - # Toggle between upload and type - editor_mode = st.radio( - "Choose how to input your code:", - ["Type Code", "Upload File"], - key="editor_mode" + st.markdown("✨ Animation Editor
", unsafe_allow_html=True)
+ code = st.text_area("Python code", height=300, key="editor_code")
+ st.markdown(generate_manim_preview(code), unsafe_allow_html=True)
+ if st.button("🚀 Generate Animation"):
+ data, status = generate_manim_video(
+ code,
+ EXPORT_FORMATS[st.session_state.format],
+ st.session_state.quality,
+ ANIMATION_SPEEDS[st.session_state.speed]
)
-
- if editor_mode == "Upload File":
- uploaded_file = st.file_uploader("Upload Manim Python File", type=["py"], key="code_uploader")
- if uploaded_file:
- code_content = uploaded_file.getvalue().decode("utf-8")
- if code_content.strip(): # Only update if file has content
- st.session_state.code = code_content
- st.session_state.temp_code = code_content
-
- # Code editor
- if ACE_EDITOR_AVAILABLE:
- current_code = st.session_state.code if hasattr(st.session_state, 'code') and st.session_state.code else ""
- st.session_state.temp_code = st_ace(
- value=current_code,
- language="python",
- theme="monokai",
- min_lines=20,
- key=f"ace_editor_{st.session_state.editor_key}"
- )
+ if data:
+ st.video(data)
+ st.success(status)
+ st.session_state.last_video = data
else:
- current_code = st.session_state.code if hasattr(st.session_state, 'code') and st.session_state.code else ""
- st.session_state.temp_code = st.text_area(
- "Manim Python Code",
- value=current_code,
- height=400,
- key=f"code_textarea_{st.session_state.editor_key}"
- )
-
- # Update code in session state if it changed
- if st.session_state.temp_code != st.session_state.code:
- st.session_state.code = st.session_state.temp_code
-
- # Generate button (use a form to prevent page reloads)
- generate_btn = st.button("🚀 Generate Animation", use_container_width=True, key="generate_btn")
- if generate_btn:
- if not st.session_state.code:
- st.error("Please enter some code before generating animation")
- else:
- # Extract scene class name
- scene_class = extract_scene_class_name(st.session_state.code)
-
- # If no valid scene class found, add a basic one
- if scene_class == "MyScene" and "class MyScene" not in st.session_state.code:
- default_scene = """
-class MyScene(Scene):
- def construct(self):
- text = Text("Default Scene")
- self.play(Write(text))
- self.wait(2)
-"""
- st.session_state.code += default_scene
- st.session_state.temp_code = st.session_state.code
- st.warning("No scene class found. Added a default scene.")
-
- with st.spinner("Generating animation..."):
- video_data, status = generate_manim_video(
- st.session_state.code,
- st.session_state.settings["format_type"],
- st.session_state.settings["quality"],
- ANIMATION_SPEEDS[st.session_state.settings["animation_speed"]],
- st.session_state.audio_path
- )
- st.session_state.video_data = video_data
- st.session_state.status = status
-
- with col2:
- st.markdown("### 🖥️ Preview & Output")
-
- # Preview container
- if st.session_state.code:
- with st.container():
- st.markdown("", unsafe_allow_html=True)
- preview_html = generate_manim_preview(st.session_state.code)
- components.html(preview_html, height=250)
- st.markdown("
", unsafe_allow_html=True)
-
- # Generated output display
- if st.session_state.video_data:
- # Different handling based on format type
- format_type = st.session_state.settings["format_type"]
-
- if format_type == "png_sequence":
- st.info("PNG sequence generated successfully. Use the download button to get the ZIP file.")
-
- # Add download button for ZIP
- st.download_button(
- label="⬇️ Download PNG Sequence (ZIP)",
- data=st.session_state.video_data,
- file_name=f"manim_pngs_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip",
- mime="application/zip",
- use_container_width=True
- )
- elif format_type == "svg":
- # Display SVG preview
- try:
- svg_data = st.session_state.video_data.decode('utf-8')
- components.html(svg_data, height=400)
- except Exception as e:
- st.error(f"Error displaying SVG: {str(e)}")
-
- # Download button for SVG
- st.download_button(
- label="⬇️ Download SVG",
- data=st.session_state.video_data,
- file_name=f"manim_animation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.svg",
- mime="image/svg+xml",
- use_container_width=True
- )
- else:
- # Standard video display for MP4, GIF, WebM
- try:
- st.video(st.session_state.video_data, format=format_type)
- except Exception as e:
- st.error(f"Error displaying video: {str(e)}")
- # Fallback for GIF if st.video fails
- if format_type == "gif":
- st.markdown("GIF preview:")
- gif_b64 = base64.b64encode(st.session_state.video_data).decode()
- st.markdown(f'
', unsafe_allow_html=True)
-
- # Add download button
- st.download_button(
- label=f"⬇️ Download {format_type.upper()}",
- data=st.session_state.video_data,
- file_name=f"manim_animation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.{format_type}",
- mime=f"{'image' if format_type == 'gif' else 'video'}/{format_type}",
- use_container_width=True
- )
-
- if st.session_state.status:
- if "Error" in st.session_state.status:
- st.error(st.session_state.status)
-
- # Show troubleshooting tips
- with st.expander("🔍 Troubleshooting Tips"):
- st.markdown("""
- ### Common Issues:
- 1. **Syntax Errors**: Check your Python code for any syntax issues
- 2. **Missing Scene Class**: Ensure your code contains a scene class that extends Scene
- 3. **High Resolution Issues**: Try a lower quality preset for complex animations
- 4. **Memory Issues**: For 4K animations, reduce complexity or try again
- 5. **Format Issues**: Some formats require specific Manim configurations
- 6. **GIF Generation**: If GIF doesn't work, try MP4 and we'll convert it automatically
-
- ### Example Code:
- ```python
- from manim import *
-
- class MyScene(Scene):
- def construct(self):
- circle = Circle(color=RED)
- self.play(Create(circle))
- self.wait(1)
- ```
- """)
- else:
- st.success(st.session_state.status)
+ st.error(status)
+ if st.session_state.get("last_video"):
+ st.download_button("⬇️ Download Animation", st.session_state.last_video,
+ f"manim_animation.{EXPORT_FORMATS[st.session_state.format]}", use_container_width=True)
- # AI ASSISTANT TAB
+ # --- AI Tab ---
with tabs[1]:
- st.markdown("### 🤖 AI Animation Assistant")
-
- # Check password before allowing access
- if check_password():
- # Debug section
- with st.expander("🔧 Debug Connection"):
- st.markdown("Test the AI model connection directly")
-
- if st.button("Test API Connection", key="test_api_btn"):
- with st.spinner("Testing API connection..."):
- try:
- # Get token from secrets
- token = get_secret("github_token_api")
- if not token:
- st.error("GitHub token not found in secrets")
- st.stop()
-
- # Get model details
- model_name = st.session_state.custom_model
- base_model_name = model_name.split('/')[-1] if '/' in model_name else model_name
- config = MODEL_CONFIGS.get(base_model_name, MODEL_CONFIGS["default"])
- category = config.get("category", "Other")
-
- if category == "OpenAI":
- # Use OpenAI client for GitHub AI models
- try:
- from openai import OpenAI
- except ImportError:
- st.error("OpenAI package not installed. Please run 'pip install openai'")
- st.stop()
-
- # Create OpenAI client with GitHub AI endpoint
- client = OpenAI(
- base_url="https://models.github.ai/inference",
- api_key=token,
- )
-
- # For GitHub AI models, ensure the model_name includes the publisher
- # If it doesn't have a publisher prefix, add "openai/"
- if "/" not in model_name:
- full_model_name = f"openai/{model_name}"
- st.info(f"Using full model name: {full_model_name}")
- else:
- full_model_name = model_name
-
- # Prepare parameters based on model configuration
- params = {
- "messages": [
- {"role": "developer", "content": "You are a helpful assistant."},
- {"role": "user", "content": "Hello, this is a connection test."}
- ],
- "model": full_model_name
- }
-
- # Add appropriate token parameter
- token_param = config["param_name"]
- params[token_param] = config[token_param]
-
- # Make API call
- response = client.chat.completions.create(**params)
-
- # Check if response is valid
- if response and response.choices and len(response.choices) > 0:
- test_response = response.choices[0].message.content
- st.success(f"✅ Connection successful! Response: {test_response[:50]}...")
-
- # Save working connection to session state
- st.session_state.ai_models = {
- "openai_client": client,
- "model_name": full_model_name, # Store the full model name
- "endpoint": "https://models.github.ai/inference",
- "last_loaded": datetime.now().isoformat(),
- "category": category
- }
- else:
- st.error("❌ API returned an empty response")
-
- elif category == "Azure" or category in ["DeepSeek", "Meta", "Microsoft", "Mistral", "Other"]:
- # Use Azure client for Azure API models
- try:
- from azure.ai.inference import ChatCompletionsClient
- from azure.ai.inference.models import SystemMessage, UserMessage
- from azure.core.credentials import AzureKeyCredential
- except ImportError:
- st.error("Azure AI packages not installed. Please run 'pip install azure-ai-inference azure-core'")
- st.stop()
-
- # Define endpoint
- endpoint = "https://models.inference.ai.azure.com"
-
- # Prepare API parameters
- messages = [UserMessage("Hello, this is a connection test.")]
- api_params, config = prepare_api_params(messages, model_name)
-
- # Create client with appropriate API version
- api_version = config.get("api_version")
- if api_version:
- client = ChatCompletionsClient(
- endpoint=endpoint,
- credential=AzureKeyCredential(token),
- api_version=api_version
- )
- else:
- client = ChatCompletionsClient(
- endpoint=endpoint,
- credential=AzureKeyCredential(token),
- )
-
- # Test with the prepared parameters
- response = client.complete(**api_params)
-
- # Check if response is valid
- if response and response.choices and len(response.choices) > 0:
- test_response = response.choices[0].message.content
- st.success(f"✅ Connection successful! Response: {test_response[:50]}...")
-
- # Save working connection to session state
- st.session_state.ai_models = {
- "client": client,
- "model_name": model_name,
- "endpoint": endpoint,
- "last_loaded": datetime.now().isoformat(),
- "category": category,
- "api_version": api_version
- }
- else:
- st.error("❌ API returned an empty response")
-
- else:
- st.error(f"Unsupported model category: {category}")
-
- except ImportError as ie:
- st.error(f"Module import error: {str(ie)}")
- st.info("Try installing required packages: openai, azure-ai-inference and azure-core")
- except Exception as e:
- st.error(f"❌ API test failed: {str(e)}")
- import traceback
- st.code(traceback.format_exc())
-
- # Model selection with enhanced UI
- st.markdown("### 🤖 Model Selection")
- st.markdown("Select an AI model for generating animation code:")
-
- # Group models by category for better organization
- model_categories = {}
- for model_name in MODEL_CONFIGS:
- if model_name != "default":
- category = MODEL_CONFIGS[model_name].get("category", "Other")
- if category not in model_categories:
- model_categories[category] = []
- model_categories[category].append(model_name)
-
- # Create tabbed interface for model categories
- category_tabs = st.tabs(sorted(model_categories.keys()))
-
- for i, category in enumerate(sorted(model_categories.keys())):
- with category_tabs[i]:
- for model_name in sorted(model_categories[category]):
- config = MODEL_CONFIGS[model_name]
- is_selected = model_name == st.session_state.custom_model
- warning = config.get("warning")
-
- # Create styled card for each model
- warning_html = f'⚠️ {warning}
' if warning else "" - - st.markdown(f""" -
-
- """, unsafe_allow_html=True)
-
- # Button to select this model
- button_label = "Selected ✓" if is_selected else "Select Model"
- if st.button(button_label, key=f"model_{model_name}", disabled=is_selected):
- st.session_state.custom_model = model_name
- if st.session_state.ai_models and 'model_name' in st.session_state.ai_models:
- st.session_state.ai_models['model_name'] = model_name
- st.rerun()
-
- # Display current model selection
- st.info(f"🤖 **Currently using: {st.session_state.custom_model}**")
-
- # Add a refresh button to update model connection
- if st.button("🔄 Refresh Model Connection", key="refresh_model_connection"):
- if st.session_state.ai_models:
- try:
- # Get model details
- model_name = st.session_state.custom_model
- base_model_name = model_name.split('/')[-1] if '/' in model_name else model_name
- config = MODEL_CONFIGS.get(base_model_name, MODEL_CONFIGS["default"])
- category = config.get("category", "Other")
-
- if category == "OpenAI":
- # Get token
- token = get_secret("github_token_api")
-
- # Create new OpenAI client
- from openai import OpenAI
- client = OpenAI(
- base_url="https://models.github.ai/inference",
- api_key=token
- )
-
- # Add openai/ prefix if not present
- if "/" not in model_name:
- full_model_name = f"openai/{model_name}"
- else:
- full_model_name = model_name
-
- # Test with minimal prompt
- response = client.chat.completions.create(
- messages=[
- {"role": "developer", "content": "You are a helpful assistant."},
- {"role": "user", "content": "Hello, this is a test."}
- ],
- model=full_model_name,
- **{config["param_name"]: config[config["param_name"]]}
- )
-
- # Update session state
- st.session_state.ai_models = {
- "openai_client": client,
- "model_name": full_model_name,
- "endpoint": "https://models.github.ai/inference",
- "last_loaded": datetime.now().isoformat(),
- "category": category
- }
-
- st.success(f"✅ Connection to {full_model_name} refreshed successfully!")
- else:
- # Test connection with minimal prompt for Azure models
- from azure.ai.inference.models import UserMessage
-
- # Prepare parameters
- messages = [UserMessage("Hello")]
- api_params, config = prepare_api_params(messages, model_name)
-
- # Check if we need a new client with specific API version
- if config["api_version"] and config["api_version"] != st.session_state.ai_models.get("api_version"):
- # Create version-specific client if needed
- token = get_secret("github_token_api")
- from azure.ai.inference import ChatCompletionsClient
- from azure.core.credentials import AzureKeyCredential
-
- client = ChatCompletionsClient(
- endpoint=st.session_state.ai_models["endpoint"],
- credential=AzureKeyCredential(token),
- api_version=config["api_version"]
- )
- response = client.complete(**api_params)
-
- # Update session state with the new client
- st.session_state.ai_models["client"] = client
- st.session_state.ai_models["api_version"] = config["api_version"]
- else:
- response = st.session_state.ai_models["client"].complete(**api_params)
-
- st.success(f"✅ Connection to {model_name} successful!")
- st.session_state.ai_models["model_name"] = model_name
-
- except Exception as e:
- st.error(f"❌ Connection error: {str(e)}")
- st.info("Please try the Debug Connection section to re-initialize the API connection.")
-
- # AI code generation
- if st.session_state.ai_models:
- st.markdown("{model_name}
-
-
- Max Tokens: {config.get(config['param_name'], 'Unknown')}
-Category: {config['category']}
-API Version: {config['api_version'] if config['api_version'] else 'Default'}
- {warning_html} -", unsafe_allow_html=True)
- st.markdown("#### Generate Animation from Description")
- st.write("Describe the animation you want to create, or provide partial code to complete.")
-
- # Predefined animation ideas dropdown
- animation_ideas = [
- "Select an idea...",
- "Create a 3D animation showing a sphere morphing into a torus",
- "Show a visual proof of the Pythagorean theorem",
- "Visualize a Fourier transform converting a signal from time domain to frequency domain",
- "Create an animation explaining neural network forward propagation",
- "Illustrate the concept of integration with area under a curve"
- ]
-
- selected_idea = st.selectbox(
- "Try one of these ideas",
- options=animation_ideas
- )
-
- prompt_value = selected_idea if selected_idea != "Select an idea..." else ""
-
- code_input = st.text_area(
- "Your Prompt or Code",
- value=prompt_value,
- placeholder="Example: Create an animation that shows a circle morphing into a square while changing color from red to blue",
- height=150
- )
-
- if st.button("Generate Animation Code", key="gen_ai_code"):
- if code_input:
- with st.spinner("AI is generating your animation code..."):
- try:
- # Get model details
- model_name = st.session_state.ai_models["model_name"]
- base_model_name = model_name.split('/')[-1] if '/' in model_name else model_name
- config = MODEL_CONFIGS.get(base_model_name, MODEL_CONFIGS["default"])
- category = config.get("category", "Other")
-
- # Create the prompt
- prompt = f"""Write a complete Manim animation scene based on this code or idea:
-{code_input}
-
-The code should be a complete, working Manim animation that includes:
-- Proper Scene class definition
-- Constructor with animations
-- Proper use of self.play() for animations
-- Proper wait times between animations
-
-Here's the complete Manim code:
-"""
-
- if category == "OpenAI":
- # Use OpenAI client
- client = st.session_state.ai_models["openai_client"]
-
- # Use developer role instead of system
- messages = [
- {"role": "developer", "content": "You are an expert in Manim animations."},
- {"role": "user", "content": prompt}
- ]
-
- # Create params
- params = {
- "messages": messages,
- "model": model_name,
- config["param_name"]: config[config["param_name"]]
- }
-
- # Call API
- response = client.chat.completions.create(**params)
- completed_code = response.choices[0].message.content
- else:
- # Use Azure client for non-OpenAI models
- from azure.ai.inference.models import UserMessage
- client = st.session_state.ai_models["client"]
-
- # Convert message format for Azure
- messages = [UserMessage(prompt)]
- api_params, _ = prepare_api_params(messages, model_name)
-
- # Make API call with Azure client
- response = client.complete(**api_params)
- completed_code = response.choices[0].message.content
-
- # Process the response
- if completed_code:
- # Extract code from markdown if present
- if "```python" in completed_code:
- completed_code = completed_code.split("```python")[1].split("```")[0]
- elif "```" in completed_code:
- completed_code = completed_code.split("```")[1].split("```")[0]
-
- # Add Scene class if missing
- if "Scene" not in completed_code:
- completed_code = f"""from manim import *
-
-class MyScene(Scene):
- def construct(self):
- {completed_code}"""
-
- # Store the generated code
- st.session_state.generated_code = completed_code
- else:
- st.error("Failed to generate code. API returned an empty response.")
- except Exception as e:
- st.error(f"Error generating code: {str(e)}")
- import traceback
- st.code(traceback.format_exc())
- else:
- st.warning("Please enter a description or prompt first")
-
-
- # AI generated code display and actions
- if "generated_code" in st.session_state and st.session_state.generated_code:
- st.markdown("
", unsafe_allow_html=True)
- st.markdown("#### Generated Animation Code")
- st.code(st.session_state.generated_code, language="python")
-
- col_ai1, col_ai2 = st.columns(2)
- with col_ai1:
- if st.button("Use This Code", key="use_gen_code"):
- st.session_state.code = st.session_state.generated_code
- st.session_state.temp_code = st.session_state.generated_code
- # Set pending tab switch to editor tab
- st.session_state.pending_tab_switch = 0
- st.rerun()
-
- with col_ai2:
- if st.button("Render Preview", key="render_preview"):
- with st.spinner("Rendering preview..."):
- video_data, status = generate_manim_video(
- st.session_state.generated_code,
- "mp4",
- "480p", # Use lowest quality for preview
- ANIMATION_SPEEDS["Normal"]
- )
-
- if video_data:
- st.video(video_data)
- st.download_button(
- label="Download Preview",
- data=video_data,
- file_name=f"manim_preview_{int(time.time())}.mp4",
- mime="video/mp4"
- )
- else:
- st.error(f"Failed to generate preview: {status}")
- st.markdown("
", unsafe_allow_html=True)
- else:
- st.warning("AI models not initialized. Please use the Debug Connection section to test API connectivity.")
- else:
- st.info("Please enter the correct password to access AI features")
-
- # LATEX FORMULAS TAB
+ st.markdown("🤖 AI Animation Assistant
", unsafe_allow_html=True)
+ if not check_password():
+ return
+ if "ai_models" not in st.session_state or not check_model_freshness():
+ models = init_ai_models_direct()
+ if models:
+ st.session_state.ai_models = {**models, "last_loaded": datetime.now().isoformat()}
+ st.markdown("### Describe your animation or paste code stub")
+ prompt = st.text_area("Prompt / stub", height=150)
+ if st.button("✨ Generate Code"):
+ models = st.session_state.ai_models
+ gen = suggest_code_completion(prompt, models)
+ if gen:
+ st.code(gen, language="python")
+ if st.button("Use This Code"):
+ st.session_state.editor_code = gen
+ st.experimental_rerun()
+
+ # --- LaTeX Tab ---
with tabs[2]:
- st.markdown("### 📚 LaTeX Formula Builder")
-
- col_latex1, col_latex2 = st.columns([3, 2])
-
- with col_latex1:
- # LaTeX formula input
- st.markdown("#### Enter LaTeX Formula")
- latex_input = st.text_area(
- "LaTeX Formula",
- value=st.session_state.latex_formula,
- height=100,
- placeholder=r"e^{i\pi} + 1 = 0",
- key="latex_input"
- )
-
- # Update session state
- st.session_state.latex_formula = latex_input
-
- # Common LaTeX formulas library
- st.markdown("#### Formula Library")
-
- # Categorized formulas
- latex_categories = {
- "Basic Math": [
- {"name": "Fractions", "latex": r"\frac{a}{b}"},
- {"name": "Square Root", "latex": r"\sqrt{x}"},
- {"name": "Nth Root", "latex": r"\sqrt[n]{x}"},
- {"name": "Powers", "latex": r"x^{n}"},
- {"name": "Subscript", "latex": r"x_{i}"},
- ],
- "Algebra": [
- {"name": "Quadratic Formula", "latex": r"x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}"},
- {"name": "Binomial Coefficient", "latex": r"\binom{n}{k}"},
- {"name": "Sum", "latex": r"\sum_{i=1}^{n} i = \frac{n(n+1)}{2}"},
- {"name": "Product", "latex": r"\prod_{i=1}^{n} i = n!"},
- ],
- "Calculus": [
- {"name": "Derivative", "latex": r"\frac{d}{dx}f(x)"},
- {"name": "Partial Derivative", "latex": r"\frac{\partial f}{\partial x}"},
- {"name": "Integral", "latex": r"\int_{a}^{b} f(x) \, dx"},
- {"name": "Double Integral", "latex": r"\iint_{D} f(x,y) \, dx \, dy"},
- {"name": "Limit", "latex": r"\lim_{x \to \infty} f(x)"},
- ],
- "Linear Algebra": [
- {"name": "Matrix", "latex": r"\begin{pmatrix} a & b \\ c & d \end{pmatrix}"},
- {"name": "Determinant", "latex": r"\begin{vmatrix} a & b \\ c & d \end{vmatrix}"},
- {"name": "Vector", "latex": r"\vec{v} = (v_1, v_2, v_3)"},
- {"name": "Dot Product", "latex": r"\vec{a} \cdot \vec{b} = |a||b|\cos\theta"},
- ],
- "Famous Equations": [
- {"name": "Euler's Identity", "latex": r"e^{i\pi} + 1 = 0"},
- {"name": "Einstein's Mass-Energy", "latex": r"E = mc^2"},
- {"name": "Schrödinger Equation", "latex": r"i\hbar\frac{\partial}{\partial t}\Psi = \hat{H}\Psi"},
- {"name": "Maxwell's Equations", "latex": r"\nabla \cdot \vec{E} = \frac{\rho}{\varepsilon_0}"},
- ]
- }
-
- # Create tabs for formula categories
- formula_tabs = st.tabs(list(latex_categories.keys()))
-
- for i, (category, formulas) in enumerate(latex_categories.items()):
- with formula_tabs[i]:
- for formula in formulas:
- if st.button(formula["name"], key=f"latex_{formula['name']}"):
- # Insert formula into the text area
- st.session_state.latex_formula = formula["latex"]
- # Refresh without full page rerun
- st.rerun()
-
- # LaTeX code snippet
- st.markdown("#### Manim Code Snippet")
- if latex_input:
- manim_latex_code = f"""
-# LaTeX formula
-formula = MathTex(r"{latex_input}")
-self.play(Write(formula))
-self.wait(2)
-"""
- st.code(manim_latex_code, language="python")
-
- if st.button("Insert into Editor", key="insert_latex_btn"):
- if st.session_state.code:
- # Find the construct method and insert after it
- if "def construct(self):" in st.session_state.code:
- lines = st.session_state.code.split("\n")
- construct_index = -1
-
- for i, line in enumerate(lines):
- if "def construct(self):" in line:
- construct_index = i
- break
-
- if construct_index >= 0:
- # Find the first line with non-whitespace content after construct
- for i in range(construct_index + 1, len(lines)):
- if lines[i].strip() and not lines[i].strip().startswith("#"):
- # Insert before this line
- indent = re.match(r"(\s*)", lines[i]).group(1)
- indented_code = "\n".join([indent + line for line in manim_latex_code.strip().split("\n")])
- lines.insert(i, indented_code)
- break
- else:
- # If we didn't find content, append to the end with default indentation
- lines.append(" " + "\n ".join(manim_latex_code.strip().split("\n")))
-
- st.session_state.code = "\n".join(lines)
- st.session_state.temp_code = st.session_state.code
- st.success("LaTeX formula inserted into the editor!")
-
- # Set pending tab switch to editor tab
- st.session_state.pending_tab_switch = 0
- st.rerun()
- else:
- st.warning("Could not find 'construct' method in your code. Please add a scene class first.")
- else:
- # Create a new basic scene with the LaTeX formula
- basic_scene = f"""from manim import *
-
-class LatexScene(Scene):
- def construct(self):
- # LaTeX formula
- formula = MathTex(r"{latex_input}")
- self.play(Write(formula))
- self.wait(2)
-"""
- st.session_state.code = basic_scene
- st.session_state.temp_code = basic_scene
- st.success("Created new scene with your LaTeX formula!")
-
- # Set pending tab switch to editor tab
- st.session_state.pending_tab_switch = 0
- st.rerun()
-
- with col_latex2:
- # LaTeX preview
- st.markdown("#### Formula Preview")
- latex_preview_html = render_latex_preview(latex_input)
- components.html(latex_preview_html, height=300)
-
- # LaTeX tips
- with st.expander("LaTeX Tips & Tricks"):
- st.markdown("""
- ### LaTeX Tips
-
- - Use `\\frac{a}{b}` for fractions
- - Use `\\sum_{i=1}^{n}` for summation
- - Use `\\int_{a}^{b}` for integration
- - Use `\\{` and `\\}` for curly braces
- - Enclose equations in `$...$` or `\\[...\\]`
-
- ### Manim LaTeX
-
- In Manim, use `MathTex` for inline math and `Tex` for text with LaTeX:
-
- ```python
- formula = MathTex(r"\\sum_{i=1}^{n} i = \\frac{n(n+1)}{2}")
- text = Tex(r"This is a binomial coefficient: $\\binom{n}{k}$")
- ```
-
- The `r` before the string creates a raw string, which is recommended to avoid escaping backslashes.
- """)
-
- # ASSETS TAB
+ st.markdown("📚 LaTeX Formula Builder
", unsafe_allow_html=True)
+ latex_input = st.text_input("LaTeX", key="latex_input", help="Raw string, e.g. r\"e^{i\\pi}+1=0\"")
+ st.markdown(render_latex_preview(latex_input), unsafe_allow_html=True)
+ if latex_input and st.button("Insert into Editor"):
+ snippet = f"""formula = MathTex(r"{latex_input}")\nself.play(Write(formula))\nself.wait(2)"""
+ st.session_state.editor_code += "\n " + snippet
+ st.success("Inserted into editor")
+ st.experimental_rerun()
+
+ # --- Assets Tab ---
with tabs[3]:
- st.markdown("### 🎨 Asset Management")
-
- asset_col1, asset_col2 = st.columns([1, 1])
-
- with asset_col1:
- # Image uploader section
- st.markdown("#### 📸 Image Assets")
- st.markdown("Upload images to use in your animations:")
-
- # Allow multiple image uploads
- uploaded_images = st.file_uploader(
- "Upload Images",
- type=["jpg", "png", "jpeg", "svg"],
- accept_multiple_files=True,
- key="image_uploader_tab"
- )
-
- if uploaded_images:
- # Create a unique image directory if it doesn't exist
- image_dir = os.path.join(os.getcwd(), "manim_assets", "images")
- os.makedirs(image_dir, exist_ok=True)
-
- # Process each uploaded image
- for uploaded_image in uploaded_images:
- # Generate a unique filename and save the image
- file_extension = uploaded_image.name.split(".")[-1]
- unique_filename = f"image_{int(time.time())}_{uuid.uuid4().hex[:8]}.{file_extension}"
- image_path = os.path.join(image_dir, unique_filename)
-
- with open(image_path, "wb") as f:
- f.write(uploaded_image.getvalue())
-
- # Store the path in session state
- if "image_paths" not in st.session_state:
- st.session_state.image_paths = []
-
- # Check if this image was already added
- image_already_added = False
- for img in st.session_state.image_paths:
- if img["name"] == uploaded_image.name:
- image_already_added = True
- break
-
- if not image_already_added:
- st.session_state.image_paths.append({
- "name": uploaded_image.name,
- "path": image_path
- })
-
- # Display uploaded images in a grid
- st.markdown("##### Uploaded Images:")
- image_cols = st.columns(3)
-
- for i, img_info in enumerate(st.session_state.image_paths[-len(uploaded_images):]):
- with image_cols[i % 3]:
- try:
- img = Image.open(img_info["path"])
- st.image(img, caption=img_info["name"], width=150)
-
- # Show code snippet for this specific image
- if st.button(f"Use {img_info['name']}", key=f"use_img_{i}"):
- image_code = f"""
-# Load and display image
-image = ImageMobject(r"{img_info['path']}")
-image.scale(2) # Adjust size as needed
-self.play(FadeIn(image))
-self.wait(1)
-"""
- if not st.session_state.code:
- base_code = """from manim import *
-
-class ImageScene(Scene):
- def construct(self):
-"""
- st.session_state.code = base_code + "\n " + image_code.replace("\n", "\n ")
- else:
- st.session_state.code += "\n" + image_code
-
- st.session_state.temp_code = st.session_state.code
- st.success(f"Added {img_info['name']} to your code!")
-
- # Set pending tab switch to editor tab
- st.session_state.pending_tab_switch = 0
- st.rerun()
- except Exception as e:
- st.error(f"Error loading image {img_info['name']}: {e}")
-
- # Display previously uploaded images
- if st.session_state.image_paths:
- with st.expander("Previously Uploaded Images"):
- # Group images by 3 in each row
- for i in range(0, len(st.session_state.image_paths), 3):
- prev_cols = st.columns(3)
- for j in range(3):
- if i+j < len(st.session_state.image_paths):
- img_info = st.session_state.image_paths[i+j]
- with prev_cols[j]:
- try:
- img = Image.open(img_info["path"])
- st.image(img, caption=img_info["name"], width=100)
- st.markdown(f"Path: {img_info['path']}
", unsafe_allow_html=True)
- except:
- st.markdown(f"**{img_info['name']}**")
- st.markdown(f"Path: {img_info['path']}
", unsafe_allow_html=True)
-
- with asset_col2:
- # Audio uploader section
- st.markdown("#### 🎵 Audio Assets")
- st.markdown("Upload audio files for background or narration:")
-
- uploaded_audio = st.file_uploader("Upload Audio", type=["mp3", "wav", "ogg"], key="audio_uploader")
-
- if uploaded_audio:
- # Create a unique audio directory if it doesn't exist
- audio_dir = os.path.join(os.getcwd(), "manim_assets", "audio")
- os.makedirs(audio_dir, exist_ok=True)
-
- # Generate a unique filename and save the audio
- file_extension = uploaded_audio.name.split(".")[-1]
- unique_filename = f"audio_{int(time.time())}.{file_extension}"
- audio_path = os.path.join(audio_dir, unique_filename)
-
- with open(audio_path, "wb") as f:
- f.write(uploaded_audio.getvalue())
-
- # Store the path in session state
- st.session_state.audio_path = audio_path
-
- # Display audio player
- st.audio(uploaded_audio)
-
- st.markdown(f"""
-
-
- """, unsafe_allow_html=True)
-
- # Two options for audio usage
- st.markdown("#### Add Audio to Your Animation")
-
- option = st.radio(
- "Choose how to use audio:",
- ["Background Audio", "Generate Audio from Text"]
- )
-
- if option == "Background Audio":
- st.markdown("##### Code to add background audio:")
-
- # For with_sound decorator
- audio_code1 = f"""
-# Add this import at the top of your file
-from manim.scene.scene_file_writer import SceneFileWriter
-
-# Add this decorator before your scene class
-@with_sound("{audio_path}")
-class YourScene(Scene):
- def construct(self):
- # Your animation code here
-"""
- st.code(audio_code1, language="python")
-
- if st.button("Use This Audio in Animation", key="use_audio_btn"):
- st.success("Audio set for next render!")
-
- elif option == "Generate Audio from Text":
- # Text-to-speech input
- tts_text = st.text_area(
- "Enter text for narration",
- placeholder="Type the narration text here...",
- height=100
- )
-
- if st.button("Create Narration", key="create_narration_btn"):
- try:
- # Use basic TTS (placeholder for actual implementation)
- st.warning("Text-to-speech feature requires additional setup. Using uploaded audio instead.")
- st.session_state.audio_path = audio_path
- st.success("Audio set for next render!")
- except Exception as e:
- st.error(f"Error creating narration: {str(e)}")
-
- # TIMELINE EDITOR TAB
+ st.markdown("Audio: {uploaded_audio.name}
-Path: {audio_path}
-🎨 Asset Management
", unsafe_allow_html=True)
+ imgs = st.file_uploader("Upload images", accept_multiple_files=True)
+ for img in imgs:
+ st.image(img, width=150, caption=img.name)
+ if st.button(f"Use {img.name}"):
+ code_snip = f"""from manim import ImageMobject\nimg = ImageMobject(r"{img.name}")\nself.play(FadeIn(img))"""
+ st.session_state.editor_code += "\n " + code_snip
+ st.success(f"Added {img.name} to code")
+ st.experimental_rerun()
+ audio = st.file_uploader("Upload audio", type=["mp3","wav"])
+ if audio:
+ path = prepare_audio_for_manim(audio, "manim_assets/audio")
+ st.audio(audio)
+ st.code(f"@with_sound(r\"{path}\")\nclass YourScene(Scene):\n ...")
+
+ # --- Timeline Tab ---
with tabs[4]:
- # New code for reordering animation steps
- updated_code = create_timeline_editor(st.session_state.code)
-
- # If code was modified by the timeline editor, update the session state
- if updated_code != st.session_state.code:
- st.session_state.code = updated_code
- st.session_state.temp_code = updated_code
+ st.markdown("🎞️ Timeline Editor
", unsafe_allow_html=True)
+ new_code = create_timeline_editor(st.session_state.get("editor_code",""))
+ if new_code != st.session_state.get("editor_code",""):
+ st.session_state.editor_code = new_code
- # EDUCATIONAL EXPORT TAB
+ # --- Export Tab ---
with tabs[5]:
- st.markdown("### 🎓 Educational Export Options")
-
- # Check if we have an animation to export
- if not st.session_state.video_data:
- st.warning("Generate an animation first before using educational export features.")
+ st.markdown("🎓 Educational Export
", unsafe_allow_html=True)
+ if not st.session_state.get("last_video"):
+ st.warning("Generate an animation first")
else:
- st.markdown("Create various educational assets from your animation:")
-
- # Animation title and explanation
- animation_title = st.text_input("Animation Title", value="Manim Animation", key="edu_title")
-
- st.markdown("#### Explanation Text")
- st.markdown("Add explanatory text to accompany your animation. Use markdown formatting.")
- st.markdown("Use ## to separate explanation sections for step-by-step sequence export.")
-
- explanation_text = st.text_area(
- "Explanation (markdown supported)",
- height=150,
- placeholder="Explain your animation here...\n\n## Step 1\nIntroduction to the concept...\n\n## Step 2\nNext, we demonstrate..."
- )
-
- # Export format selection
- edu_format = st.selectbox(
- "Export Format",
- options=["PowerPoint Presentation", "Interactive HTML", "Explanation Sequence PDF"]
- )
-
- # Format-specific options
- if edu_format == "PowerPoint Presentation":
- st.info("Creates a PowerPoint file with your animation and explanation text.")
-
- elif edu_format == "Interactive HTML":
- st.info("Creates an interactive HTML webpage with playback controls and explanation.")
- include_controls = st.checkbox("Include interactive controls", value=True)
-
- elif edu_format == "Explanation Sequence PDF":
- st.info("Creates a PDF with key frames and step-by-step explanations.")
- frame_count = st.slider("Number of key frames", min_value=3, max_value=10, value=5)
-
- # Export button
- if st.button("Export Educational Material", key="export_edu_btn"):
- with st.spinner(f"Creating {edu_format}..."):
- # Map selected format to internal format type
- format_map = {
- "PowerPoint Presentation": "powerpoint",
- "Interactive HTML": "html",
- "Explanation Sequence PDF": "sequence"
- }
-
- # Create a temporary directory for export
- temp_export_dir = tempfile.mkdtemp(prefix="manim_edu_export_")
-
- # Process the export
- exported_data, file_type = export_to_educational_format(
- st.session_state.video_data,
- format_map[edu_format],
- animation_title,
- explanation_text,
- temp_export_dir
- )
-
- if exported_data:
- # File extension mapping
- ext_map = {
- "powerpoint": "pptx",
- "html": "html",
- "pdf": "pdf"
- }
-
- # Download button
- ext = ext_map.get(file_type, "zip")
- filename = f"{animation_title.replace(' ', '_')}.{ext}"
-
- st.success(f"{edu_format} created successfully!")
- st.download_button(
- label=f"⬇️ Download {edu_format}",
- data=exported_data,
- file_name=filename,
- mime=f"application/{ext}",
- use_container_width=True
- )
-
- # For HTML, also offer to open in browser
- if file_type == "html":
- html_path = os.path.join(temp_export_dir, filename)
- st.markdown(f"[🌐 Open in browser](file://{html_path})", unsafe_allow_html=True)
- else:
- st.error(f"Failed to create {edu_format}. Check logs for details.")
-
- # Show usage examples and tips
- with st.expander("Usage Tips"):
- st.markdown("""
- ### Educational Export Tips
-
- **PowerPoint Presentations**
- - Great for lectures and classroom presentations
- - Animation will autoplay when clicked
- - Add detailed explanations in notes section
-
- **Interactive HTML**
- - Perfect for websites and online learning platforms
- - Students can control playback speed and navigation
- - Mobile-friendly for learning on any device
-
- **Explanation Sequence**
- - Ideal for printed materials and study guides
- - Use ## headers to mark different explanation sections
- - Each section will be paired with a key frame
- """)
-
- # PYTHON RUNNER TAB
- with tabs[6]:
- st.markdown("### 🐍 Python Script Runner")
- st.markdown("Execute Python scripts and visualize the results directly.")
-
- # Predefined example scripts
- example_scripts = {
- "Select an example...": "",
- "Basic Matplotlib Plot": """import matplotlib.pyplot as plt
-import numpy as np
-
-# Create data
-x = np.linspace(0, 10, 100)
-y = np.sin(x)
-
-# Create plot
-plt.figure(figsize=(10, 6))
-plt.plot(x, y, 'b-', label='sin(x)')
-plt.title('Sine Wave')
-plt.xlabel('x')
-plt.ylabel('sin(x)')
-plt.grid(True)
-plt.legend()
-""",
- "User Input Example": """# This example demonstrates how to handle user input
-name = input("Enter your name: ")
-age = int(input("Enter your age: "))
-
-print(f"Hello, {name}! In 10 years, you'll be {age + 10} years old.")
-
-# Let's get some numbers and calculate the average
-num_count = int(input("How many numbers would you like to average? "))
-total = 0
-
-for i in range(num_count):
- num = float(input(f"Enter number {i+1}: "))
- total += num
-
-average = total / num_count
-print(f"The average of your {num_count} numbers is: {average}")
-""",
- "Pandas DataFrame": """import pandas as pd
-import numpy as np
-
-# Create a sample dataframe
-data = {
- 'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Emma'],
- 'Age': [25, 30, 35, 40, 45],
- 'Salary': [50000, 60000, 70000, 80000, 90000],
- 'Department': ['HR', 'IT', 'Finance', 'Marketing', 'Engineering']
-}
-
-df = pd.DataFrame(data)
-
-# Display the dataframe
-print("Sample DataFrame:")
-print(df)
-
-# Basic statistics
-print("\\nSummary Statistics:")
-print(df.describe())
-
-# Filtering
-print("\\nEmployees older than 30:")
-print(df[df['Age'] > 30])
-""",
- "Seaborn Visualization": """import matplotlib.pyplot as plt
-import seaborn as sns
-import numpy as np
-import pandas as pd
-
-# Set the style
-sns.set_style("whitegrid")
-
-# Create sample data
-np.random.seed(42)
-data = np.random.randn(100, 3)
-df = pd.DataFrame(data, columns=['A', 'B', 'C'])
-df['category'] = pd.Categorical(['Group 1'] * 50 + ['Group 2'] * 50)
-
-# Create a paired plot
-sns.pairplot(df, hue='category', palette='viridis')
-
-# Create another plot
-plt.figure(figsize=(10, 6))
-sns.violinplot(x='category', y='A', data=df, palette='magma')
-plt.title('Distribution of A by Category')
-""",
- "NumPy Computation": """import numpy as np
-
-# Create arrays
-arr1 = np.array([1, 2, 3, 4, 5])
-arr2 = np.array([5, 4, 3, 2, 1])
-
-print("Array 1:", arr1)
-print("Array 2:", arr2)
-
-# Basic operations
-print("\\nBasic Operations:")
-print("Addition:", arr1 + arr2)
-print("Multiplication:", arr1 * arr2)
-print("Division:", arr1 / arr2)
-
-# Statistics
-print("\\nStatistics:")
-print("Mean of arr1:", np.mean(arr1))
-print("Standard deviation of arr2:", np.std(arr2))
-print("Correlation coefficient:", np.corrcoef(arr1, arr2)[0, 1])
-
-# Create a 2D array
-matrix = np.random.rand(3, 3)
-print("\\nRandom 3x3 Matrix:")
-print(matrix)
-print("Determinant:", np.linalg.det(matrix))
-print("Inverse:")
-print(np.linalg.inv(matrix))
-""",
- "SciPy Example": """import numpy as np
-from scipy import optimize
-import matplotlib.pyplot as plt
-
-# Define a function to find the root of
-def f(x):
- return x**3 - 2*x**2 - 5*x + 6
-
-# Find the roots
-roots = optimize.root_scalar(f, bracket=[-5, 5], method='brentq')
-print(f"Root found: {roots.root}")
-
-# Plot the function
-x = np.linspace(-5, 5, 1000)
-y = f(x)
-
-plt.figure(figsize=(10, 6))
-plt.plot(x, y, 'b-')
-plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)
-plt.axvline(x=roots.root, color='r', linestyle='--', label=f'Root: {roots.root:.2f}')
-plt.grid(True)
-plt.title('Finding roots of a cubic function')
-plt.xlabel('x')
-plt.ylabel('f(x)')
-plt.legend()
-
-# Optimization example
-def g(x):
- return (x - 2) ** 2 + 1
-
-result = optimize.minimize(g, x0=0)
-print(f"Minimum found at x = {result.x[0]}, with value {result.fun}")
-
-# Plot the optimization
-x = np.linspace(-1, 5, 1000)
-y = g(x)
-
-plt.figure(figsize=(10, 6))
-plt.plot(x, y, 'g-')
-plt.plot(result.x, result.fun, 'ro', label=f'Minimum: ({result.x[0]:.2f}, {result.fun:.2f})')
-plt.grid(True)
-plt.title('Function Optimization')
-plt.xlabel('x')
-plt.ylabel('g(x)')
-plt.legend()
-"""
- }
-
- # Select example script
- selected_example = st.selectbox("Select an example script:", options=list(example_scripts.keys()))
-
- # Python code editor
- if selected_example != "Select an example..." and selected_example in example_scripts:
- python_code = example_scripts[selected_example]
- else:
- python_code = st.session_state.python_script
-
- if ACE_EDITOR_AVAILABLE:
- python_code = st_ace(
- value=python_code,
- language="python",
- theme="monokai",
- min_lines=15,
- key=f"python_editor_{st.session_state.editor_key}"
- )
- else:
- python_code = st.text_area(
- "Python Code",
- value=python_code,
- height=400,
- key=f"python_textarea_{st.session_state.editor_key}"
- )
-
- # Store script in session state (without clearing existing code)
- st.session_state.python_script = python_code
-
- # Check for input() calls
- input_calls = detect_input_calls(python_code)
- user_inputs = []
-
- if input_calls:
- st.markdown("### Input Values")
- st.info(f"This script contains {len(input_calls)} input() calls. Please provide values below:")
-
- for i, input_call in enumerate(input_calls):
- user_input = st.text_input(
- f"{input_call['prompt']} (Line {input_call['line']})",
- key=f"input_{i}"
+ title = st.text_input("Animation Title", "My Animation")
+ expl = st.text_area("Explanation (use ## for steps)")
+ fmt = st.selectbox("Export Format", ["PowerPoint","HTML","PDF Sequence"])
+ if st.button("📤 Export"):
+ fmt_key = {"PowerPoint":"powerpoint","HTML":"html","PDF Sequence":"sequence"}[fmt]
+ data,ft = export_to_educational_format(
+ st.session_state.last_video, fmt_key, title, expl, tempfile.mkdtemp()
)
- user_inputs.append(user_input)
-
- # Options and execution
- col1, col2 = st.columns([2, 1])
-
- with col1:
- timeout_seconds = st.slider("Execution Timeout (seconds)", 5, 3600, 30)
-
- with col2:
- run_btn = st.button("▶️ Run Script", use_container_width=True)
-
- if run_btn:
- with st.spinner("Executing Python script..."):
- result = run_python_script(python_code, inputs=user_inputs, timeout=timeout_seconds)
- st.session_state.python_result = result
-
- # Display results
- if st.session_state.python_result:
- display_python_script_results(st.session_state.python_result)
-
- # Option to insert plots into Manim animation
- if st.session_state.python_result["plots"]:
- with st.expander("Add Plots to Manim Animation"):
- st.markdown("Select a plot to include in your Manim animation:")
-
- plot_cols = st.columns(min(3, len(st.session_state.python_result["plots"])))
-
- for i, plot_data in enumerate(st.session_state.python_result["plots"]):
- # Create a unique temporary file for each plot
- with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
- tmp.write(plot_data)
- plot_path = tmp.name
-
- # Display the plot with selection button
- with plot_cols[i % len(plot_cols)]:
- st.image(plot_data, use_column_width=True)
- if st.button(f"Use Plot {i+1}", key=f"use_plot_{i}"):
- # Create code to include this plot in Manim
- plot_code = f"""
-# Import the plot image
-plot_image = ImageMobject(r"{plot_path}")
-plot_image.scale(2) # Adjust size as needed
-self.play(FadeIn(plot_image))
-self.wait(1)
-"""
- # Insert into editor code
- if st.session_state.code:
- st.session_state.code += "\n" + plot_code
- st.session_state.temp_code = st.session_state.code
- st.success(f"Plot {i+1} added to your animation code!")
- # Set pending tab switch to editor tab
- st.session_state.pending_tab_switch = 0
- st.rerun()
- else:
- basic_scene = f"""from manim import *
+ if data:
+ ext = {"pptx":"pptx","html":"html","pdf":"pdf"}[ft]
+ st.success(f"{fmt} created")
+ st.download_button(f"⬇️ Download {fmt}", data, f"{title}.{ext}")
-class PlotScene(Scene):
- def construct(self):
- {plot_code}
-"""
- st.session_state.code = basic_scene
- st.session_state.temp_code = basic_scene
- st.success(f"Created new scene with Plot {i+1}!")
- # Set pending tab switch to editor tab
- st.session_state.pending_tab_switch = 0
- st.rerun()
-
- # Provide option to save the script
- if st.button("📄 Save This Script", key="save_script_btn"):
- # Generate a unique filename
- timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
- script_filename = f"script_{timestamp}.py"
-
- # Offer download button for the script
- st.download_button(
- label="⬇️ Download Script",
- data=python_code,
- file_name=script_filename,
- mime="text/plain"
- )
-
- # Show advanced examples and tips
- with st.expander("Python Script Runner Tips"):
- st.markdown("""
- ### Python Script Runner Tips
-
- **What can I run?**
- - Any Python code that doesn't require direct UI interaction
- - Libraries like Matplotlib, NumPy, Pandas, SciPy, etc.
- - Data processing and visualization code
- - Scripts that ask for user input (now supported!)
-
- **What can't I run?**
- - Streamlit, Gradio, Dash, or other web UIs
- - Long-running operations (timeout will occur)
- - Code that requires file access outside the temporary environment
-
- **Working with visualizations:**
- - All Matplotlib/Seaborn plots will be automatically captured
- - Pandas DataFrames are detected and displayed as tables
- - Use `print()` to show text output
-
- **Handling user input:**
- - The app detects input() calls and automatically creates text fields
- - Input values you provide will be passed to the script when it runs
- - Type conversion (like int(), float()) is preserved
-
- **Adding to animations:**
- - Charts and plots can be directly added to your Manim animations
- - Generated images will be properly scaled for your animation
- - Perfect for educational content combining data and animations
- """)
-
- # Help section
- with st.sidebar.expander("ℹ️ Help & Info"):
- st.markdown("""
- ### About Manim Animation Studio
-
- This app allows you to create mathematical animations using Manim,
- an animation engine for explanatory math videos.
-
- ### Example Code
-
- ```python
- from manim import *
-
- class SimpleExample(Scene):
- def construct(self):
- circle = Circle(color=BLUE)
- self.play(Create(circle))
-
- square = Square(color=RED).next_to(circle, RIGHT)
- self.play(Create(square))
-
- text = Text("Manim Animation").next_to(VGroup(circle, square), DOWN)
- self.play(Write(text))
-
- self.wait(2)
- ```
- """)
-
- # Handle tab switching with session state to prevent refresh loop
- if st.session_state.pending_tab_switch is not None:
- st.session_state.active_tab = st.session_state.pending_tab_switch
- st.session_state.pending_tab_switch = None
-
- # Set tabs active state
- for i, tab in enumerate(tabs):
- if i == st.session_state.active_tab:
- tab.active = True
-
- # Mark first load as complete to prevent unnecessary refreshes
- if not st.session_state.first_load_complete:
- st.session_state.first_load_complete = True
+ # --- Python Tab ---
+ with tabs[6]:
+ st.markdown("🐍 Python Script Runner
", unsafe_allow_html=True)
+ script = st.text_area("Script", height=200, key="python_script")
+ calls = detect_input_calls(script)
+ inputs = []
+ if calls:
+ st.info("Detected input() calls – please provide values:")
+ for c in calls:
+ v = st.text_input(f"{c['prompt']} (line {c['line']})")
+ inputs.append(v)
+ if st.button("▶️ Run Script"):
+ res = run_python_script(script, inputs)
+ display_python_script_results(res)
if __name__ == "__main__":
- main()
\ No newline at end of file
+ main()