diff --git "a/app.py" "b/app.py" new file mode 100644--- /dev/null +++ "b/app.py" @@ -0,0 +1,2799 @@ +import streamlit as st +import tempfile +import os +import logging +from pathlib import Path +from PIL import Image +import io +import numpy as np +import sys +import subprocess +import json +from pygments import highlight +from pygments.lexers import PythonLexer +from pygments.formatters import HtmlFormatter +import base64 +from transformers import pipeline +import torch +import re +import shutil +import time +from datetime import datetime, timedelta +import streamlit.components.v1 as components +import uuid +import platform +import pandas as pd +import plotly.express as px +import markdown +import zipfile + +# Set up enhanced logging +logging.basicConfig( + level=logging.INFO, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + handlers=[ + logging.StreamHandler() + ] +) +logger = logging.getLogger(__name__) + +# Try to import Streamlit Ace +try: + from streamlit_ace import st_ace + ACE_EDITOR_AVAILABLE = True +except ImportError: + ACE_EDITOR_AVAILABLE = False + logger.warning("streamlit-ace not available, falling back to standard text editor") + +def ensure_packages(): + required_packages = { + 'manim': '0.17.3', + 'Pillow': '9.0.0', + 'numpy': '1.22.0', + 'transformers': '4.30.0', + 'torch': '2.0.0', + 'pygments': '2.15.1', + 'streamlit-ace': '0.1.1', + 'pydub': '0.25.1', # For audio processing + 'plotly': '5.14.0', # For timeline editor + 'pandas': '2.0.0', # For data manipulation + 'python-pptx': '0.6.21', # For PowerPoint export + 'markdown': '3.4.3', # For markdown processing + 'fpdf': '1.7.2', # For PDF generation + 'matplotlib': '3.5.0', # For Python script runner + 'seaborn': '0.11.2', # For enhanced visualizations + 'scipy': '1.7.3', # For scientific computations + } + + with st.spinner("Checking required packages..."): + # First, quickly check if packages are already installed + missing_packages = {} + for package, version in required_packages.items(): + try: + # Try to import the package to check if it's available + if package == 'manim': + import manim + elif package == 'Pillow': + import PIL + elif package == 'numpy': + import numpy + elif package == 'transformers': + import transformers + elif package == 'torch': + import torch + elif package == 'pygments': + import pygments + elif package == 'streamlit-ace': + # This one is trickier, we already handle it with ACE_EDITOR_AVAILABLE flag + pass + elif package == 'pydub': + import pydub + elif package == 'plotly': + import plotly + elif package == 'pandas': + import pandas + elif package == 'python-pptx': + import pptx + elif package == 'markdown': + import markdown + elif package == 'fpdf': + import fpdf + elif package == 'matplotlib': + import matplotlib + elif package == 'seaborn': + import seaborn + elif package == 'scipy': + import scipy + except ImportError: + missing_packages[package] = version + + # If no packages are missing, return success immediately + if not missing_packages: + logger.info("All required packages already installed.") + return True + + # If there are missing packages, install them with progress reporting + progress_bar = st.progress(0) + status_text = st.empty() + + for i, (package, version) in enumerate(missing_packages.items()): + try: + progress = (i / len(missing_packages)) + progress_bar.progress(progress) + status_text.text(f"Installing {package}...") + + result = subprocess.run( + [sys.executable, "-m", "pip", "install", f"{package}>={version}"], + capture_output=True, + text=True + ) + + if result.returncode != 0: + st.error(f"Failed to install {package}: {result.stderr}") + logger.error(f"Package installation failed: {package}") + return False + + except Exception as e: + st.error(f"Error installing {package}: {str(e)}") + logger.error(f"Package installation error: {str(e)}") + return False + + progress_bar.progress(1.0) + status_text.text("All packages installed successfully!") + time.sleep(0.5) + progress_bar.empty() + status_text.empty() + return True + +def install_custom_packages(package_list): + """Install custom packages specified by the user without page refresh""" + if not package_list.strip(): + return True, "No packages specified" + + # Split and clean package list + packages = [pkg.strip() for pkg in package_list.split(',') if pkg.strip()] + + if not packages: + return True, "No valid packages specified" + + status_placeholder = st.sidebar.empty() + progress_bar = st.sidebar.progress(0) + + results = [] + success = True + + for i, package in enumerate(packages): + try: + progress = (i / len(packages)) + progress_bar.progress(progress) + status_placeholder.text(f"Installing {package}...") + + result = subprocess.run( + [sys.executable, "-m", "pip", "install", package], + capture_output=True, + text=True + ) + + if result.returncode != 0: + error_msg = f"Failed to install {package}: {result.stderr}" + results.append(error_msg) + logger.error(error_msg) + success = False + else: + results.append(f"Successfully installed {package}") + logger.info(f"Successfully installed custom package: {package}") + + except Exception as e: + error_msg = f"Error installing {package}: {str(e)}" + results.append(error_msg) + logger.error(error_msg) + success = False + + progress_bar.progress(1.0) + status_placeholder.text("Installation complete!") + time.sleep(0.5) + progress_bar.empty() + status_placeholder.empty() + + return success, "\n".join(results) + +@st.cache_resource(ttl=3600) +def init_ai_models(): + try: + with st.spinner("Loading AI models - this may take a moment..."): + code_model = pipeline( + "text-generation", + model="deepseek-ai/deepseek-coder-1.3b-base", + trust_remote_code=True + ) + if code_model is None: + st.error("Failed to initialize code model") + return None + return { + "code_model": code_model, + "last_loaded": datetime.now().isoformat() + } + except Exception as e: + st.error(f"Failed to load AI models: {str(e)}") + logger.error(f"AI model initialization error: {str(e)}") + return None + +def check_model_freshness(): + """Check if models need to be reloaded based on TTL""" + if 'ai_models' not in st.session_state or st.session_state.ai_models is None: + return False + + if 'last_loaded' not in st.session_state.ai_models: + return False + + last_loaded = datetime.fromisoformat(st.session_state.ai_models['last_loaded']) + ttl_hours = 1 # 1 hour TTL + + return datetime.now() - last_loaded < timedelta(hours=ttl_hours) + +def extract_scene_class_name(python_code): + """Extract the scene class name from Python code.""" + import re + scene_classes = re.findall(r'class\s+(\w+)\s*\([^)]*Scene[^)]*\)', python_code) + + if scene_classes: + # Return the first scene class found + return scene_classes[0] + else: + # If no scene class is found, use a default name + return "MyScene" + +def suggest_code_completion(code_snippet, models): + if not models or "code_model" not in models: + st.error("AI models not properly initialized") + return None + + try: + prompt = f"""Write a complete Manim animation scene based on this code or idea: +{code_snippet} + +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: +```python +""" + with st.spinner("AI is generating your animation code..."): + response = models["code_model"]( + prompt, + max_length=1024, + do_sample=True, + temperature=0.2, + top_p=0.95, + top_k=50, + num_return_sequences=1, + truncation=True, + pad_token_id=50256 + ) + + if not response or not response[0].get('generated_text'): + st.error("No valid completion generated") + return None + + completed_code = response[0]['generated_text'] + if "```python" in completed_code: + completed_code = completed_code.split("```python")[1].split("```")[0] + + if "Scene" not in completed_code: + completed_code = f"""from manim import * + +class MyScene(Scene): + def construct(self): + {completed_code}""" + + return completed_code + except Exception as e: + st.error(f"Error suggesting code: {str(e)}") + logger.error(f"Code suggestion error: {str(e)}") + return None + +# Quality presets +QUALITY_PRESETS = { + "480p": {"resolution": "480p", "fps": "30"}, + "720p": {"resolution": "720p", "fps": "30"}, + "1080p": {"resolution": "1080p", "fps": "60"}, + "4K": {"resolution": "2160p", "fps": "60"}, + "8K": {"resolution": "4320p", "fps": "60"} +} + +# Animation speeds +ANIMATION_SPEEDS = { + "Slow": 0.5, + "Normal": 1.0, + "Fast": 2.0, + "Very Fast": 3.0 +} + +# Export formats +EXPORT_FORMATS = { + "MP4 Video": "mp4", + "GIF Animation": "gif", + "WebM Video": "webm", + "PNG Image Sequence": "png_sequence", + "SVG Image": "svg" +} + +def highlight_code(code): + formatter = HtmlFormatter(style='monokai') + highlighted = highlight(code, PythonLexer(), formatter) + return highlighted, formatter.get_style_defs() + +def generate_manim_preview(python_code): + """Generate a lightweight preview of the Manim animation""" + try: + # Extract scene components for preview + scene_objects = [] + if "Circle" in python_code: + scene_objects.append("circle") + if "Square" in python_code: + scene_objects.append("square") + if "MathTex" in python_code or "Tex" in python_code: + scene_objects.append("equation") + if "Text" in python_code: + scene_objects.append("text") + if "Axes" in python_code: + scene_objects.append("graph") + if "ThreeDScene" in python_code or "ThreeDAxes" in python_code: + scene_objects.append("3D scene") + if "Sphere" in python_code: + scene_objects.append("sphere") + if "Cube" in python_code: + scene_objects.append("cube") + + # Generate a more detailed visual preview based on extracted objects + object_icons = { + "circle": "β­•", + "square": "πŸ”²", + "equation": "πŸ“Š", + "text": "πŸ“", + "graph": "πŸ“ˆ", + "3D scene": "🧊", + "sphere": "🌐", + "cube": "🧊" + } + + icon_html = "" + for obj in scene_objects: + if obj in object_icons: + icon_html += f'{object_icons[obj]}' + + preview_html = f""" +
+

Animation Preview

+
+ {icon_html if icon_html else '🎬'} +
+

Scene contains: {', '.join(scene_objects) if scene_objects else 'No detected objects'}

+
Full rendering required for accurate preview
+
+ """ + return preview_html + except Exception as e: + logger.error(f"Preview generation error: {str(e)}") + return f""" +
+
+

Preview Error

+

{str(e)}

+
+
+ """ + +def render_latex_preview(latex_formula): + """Generate HTML for LaTeX preview using MathJax""" + if not latex_formula: + return """ +
+
Enter LaTeX formula to see preview
+
+ """ + + # Create a dark-themed preview with MathJax + html = f""" +
+ + +
+
LaTeX Preview
+
+ $$ + {latex_formula} + $$ +
+
Use MathTex(r"{latex_formula}") in your Manim code
+
+
+ """ + return html + +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 + +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 + +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 + + 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_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": "-qu" # Ultra quality (8K) + } + 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 + + while True: + line = process.stdout.readline() + if not line and process.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)}" + + 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)}") + +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 + +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)}" + + return result + +def display_python_script_results(result): + """Display the results from the Python script execution""" + if not result: + st.error("No results to display.") + return + + # Display execution time + st.info(f"Execution completed in {result['execution_time']:.2f} seconds") + + # Display any errors + if result["exception"]: + st.error(f"Exception occurred: {result['exception']}") + + if result["stderr"]: + st.error("Errors:") + st.code(result["stderr"], language="bash") + + # Display plots if any + if result["plots"]: + st.markdown("### Plots") + cols = st.columns(min(3, len(result["plots"]))) + for i, plot_data in enumerate(result["plots"]): + cols[i % len(cols)].image(plot_data, use_column_width=True) + + # Display dataframes if any + if result["dataframes"]: + st.markdown("### DataFrames") + for df_info in result["dataframes"]: + with st.expander(f"{df_info['name']} - {df_info['shape'][0]} rows Γ— {df_info['shape'][1]} columns"): + st.markdown(df_info["preview_html"], unsafe_allow_html=True) + + # Display standard output + if result["stdout"]: + st.markdown("### Standard Output") + st.code(result["stdout"], language="bash") + +def parse_animation_steps(python_code): + """Parse Manim code to extract animation steps for timeline editor""" + animation_steps = [] + + # Look for self.play calls in the code + play_calls = re.findall(r'self\.play\((.*?)\)', python_code, re.DOTALL) + wait_calls = re.findall(r'self\.wait\((.*?)\)', python_code, re.DOTALL) + + # Extract animation objects from play calls + for i, play_call in enumerate(play_calls): + # Parse the arguments to self.play() + animations = [arg.strip() for arg in play_call.split(',')] + + # Get wait time after this animation if available + wait_time = 1.0 # Default wait time + if i < len(wait_calls): + wait_match = re.search(r'(\d+\.?\d*)', wait_calls[i]) + if wait_match: + wait_time = float(wait_match.group(1)) + + # Add to animation steps + animation_steps.append({ + "id": i+1, + "type": "play", + "animations": animations, + "duration": wait_time, + "start_time": sum([step.get("duration", 1.0) for step in animation_steps]), + "code": f"self.play({play_call})" + }) + + return animation_steps + +def generate_code_from_timeline(animation_steps, original_code): + """Generate Manim code from the timeline data""" + # Extract the class definition and setup + class_match = re.search(r'(class\s+\w+\s*\([^)]*\)\s*:.*?def\s+construct\s*\(\s*self\s*\)\s*:)', original_code, re.DOTALL) + + if not class_match: + return original_code # Can't find proper structure to modify + + setup_code = class_match.group(1) + + # Build the new construct method + new_code = [setup_code] + indent = " " # Standard Manim indentation + + # Add each animation step in order + for step in sorted(animation_steps, key=lambda x: x["id"]): + new_code.append(f"{indent}{step['code']}") + if "duration" in step and step["duration"] > 0: + new_code.append(f"{indent}self.wait({step['duration']})") + + # Add any code that might come after animations + end_match = re.search(r'(#\s*End\s+of\s+animations.*?$)', original_code, re.DOTALL) + if end_match: + new_code.append(end_match.group(1)) + + # Combine the code parts with proper indentation + return "\n".join(new_code) + +def create_timeline_editor(code): + """Create an interactive timeline editor for animation sequences""" + st.markdown("### 🎞️ Animation Timeline Editor") + + if not code: + st.warning("Add animation code first to use the timeline editor.") + return code + + # Parse animation steps from the code + animation_steps = parse_animation_steps(code) + + if not animation_steps: + st.warning("No animation steps detected in your code.") + return code + + # Convert to DataFrame for easier manipulation + df = pd.DataFrame(animation_steps) + + # Create an interactive Gantt chart with plotly + st.markdown("#### Animation Timeline") + st.markdown("Drag timeline elements to reorder or resize to change duration") + + # Create the Gantt chart + fig = px.timeline( + df, + x_start="start_time", + x_end=df["start_time"] + df["duration"], + y="id", + color="type", + hover_name="animations", + labels={"id": "Step", "start_time": "Time (seconds)"} + ) + + # Make it interactive + fig.update_layout( + height=400, + xaxis=dict( + title="Time (seconds)", + rangeslider_visible=True + ) + ) + + # Add buttons and interactivity + timeline_chart = st.plotly_chart(fig, use_container_width=True) + + # Control panel + st.markdown("#### Timeline Controls") + controls_col1, controls_col2, controls_col3 = st.columns(3) + + with controls_col1: + selected_step = st.selectbox( + "Select Step to Edit:", + options=list(range(1, len(animation_steps) + 1)), + format_func=lambda x: f"Step {x}" + ) + + with controls_col2: + new_duration = st.number_input( + "Duration (seconds):", + min_value=0.1, + max_value=10.0, + value=float(df[df["id"] == selected_step]["duration"].values[0]), + step=0.1 + ) + + with controls_col3: + step_action = st.selectbox( + "Action:", + options=["Update Duration", "Move Up", "Move Down", "Delete Step"] + ) + + apply_btn = st.button("Apply Change", key="apply_timeline_change") + + # Handle timeline modifications + if apply_btn: + modified = False + + if step_action == "Update Duration": + # Update the duration of the selected step + idx = df[df["id"] == selected_step].index[0] + df.at[idx, "duration"] = new_duration + modified = True + + elif step_action == "Move Up" and selected_step > 1: + # Swap with the step above + idx1 = df[df["id"] == selected_step].index[0] + idx2 = df[df["id"] == selected_step - 1].index[0] + + # Swap IDs to maintain order + df.at[idx1, "id"], df.at[idx2, "id"] = selected_step - 1, selected_step + modified = True + + elif step_action == "Move Down" and selected_step < len(animation_steps): + # Swap with the step below + idx1 = df[df["id"] == selected_step].index[0] + idx2 = df[df["id"] == selected_step + 1].index[0] + + # Swap IDs to maintain order + df.at[idx1, "id"], df.at[idx2, "id"] = selected_step + 1, selected_step + modified = True + + elif step_action == "Delete Step": + # Remove the selected step + df = df[df["id"] != selected_step] + # Reindex remaining steps + new_ids = list(range(1, len(df) + 1)) + df["id"] = new_ids + modified = True + + if modified: + # Recalculate start times + df = df.sort_values("id") + cumulative_time = 0 + for idx, row in df.iterrows(): + df.at[idx, "start_time"] = cumulative_time + cumulative_time += row["duration"] + + # Regenerate animation code + animation_steps = df.to_dict('records') + new_code = generate_code_from_timeline(animation_steps, code) + + st.success("Timeline updated! Click 'Refresh App' to see changes.") + return new_code + + # Visual keyframe editor + st.markdown("#### Visual Keyframe Editor") + st.markdown("Add keyframes for smooth property transitions") + + keyframe_obj = st.selectbox( + "Select object to animate:", + options=[f"Object {i+1}" for i in range(5)] # Placeholder for actual objects + ) + + keyframe_prop = st.selectbox( + "Select property:", + options=["position", "scale", "rotation", "opacity", "color"] + ) + + # Keyframe timeline visualization + keyframe_times = [0, 1, 2, 3, 4] # Placeholder + keyframe_values = [0, 0.5, 0.8, 0.2, 1.0] # Placeholder + + keyframe_df = pd.DataFrame({ + "time": keyframe_times, + "value": keyframe_values + }) + + keyframe_fig = px.line( + keyframe_df, + x="time", + y="value", + markers=True, + title=f"{keyframe_prop.capitalize()} Keyframes" + ) + + keyframe_fig.update_layout( + xaxis_title="Time (seconds)", + yaxis_title="Value", + height=250 + ) + + st.plotly_chart(keyframe_fig, use_container_width=True) + + keyframe_col1, keyframe_col2, keyframe_col3 = st.columns(3) + with keyframe_col1: + keyframe_time = st.number_input("Time (s)", min_value=0.0, max_value=10.0, value=0.0, step=0.1) + with keyframe_col2: + keyframe_value = st.number_input("Value", min_value=0.0, max_value=1.0, value=0.0, step=0.1) + with keyframe_col3: + add_keyframe = st.button("Add Keyframe") + + # Return the original code or modified code + return code + +def export_to_educational_format(video_data, format_type, animation_title, explanation_text, temp_dir): + """Export animation to various educational formats""" + try: + if format_type == "powerpoint": + # Make sure python-pptx is installed + try: + import pptx + from pptx.util import Inches + except ImportError: + logger.error("python-pptx not installed") + subprocess.run([sys.executable, "-m", "pip", "install", "python-pptx"], check=True) + import pptx + from pptx.util import Inches + + # Create PowerPoint presentation + prs = pptx.Presentation() + + # Title slide + title_slide = prs.slides.add_slide(prs.slide_layouts[0]) + title_slide.shapes.title.text = animation_title + title_slide.placeholders[1].text = "Created with Manim Animation Studio" + + # Video slide + video_slide = prs.slides.add_slide(prs.slide_layouts[5]) + video_slide.shapes.title.text = "Animation" + + # Save video to temp file + video_path = os.path.join(temp_dir, "animation.mp4") + with open(video_path, "wb") as f: + f.write(video_data) + + # Add video to slide + try: + left = Inches(1) + top = Inches(1.5) + width = Inches(8) + height = Inches(4.5) + video_slide.shapes.add_movie(video_path, left, top, width, height) + except Exception as e: + logger.error(f"Error adding video to PowerPoint: {str(e)}") + # Fallback to adding a picture with link + img_path = os.path.join(temp_dir, "thumbnail.png") + # Generate thumbnail with ffmpeg + subprocess.run([ + "ffmpeg", "-i", video_path, "-ss", "00:00:01.000", + "-vframes", "1", img_path + ], check=True) + + if os.path.exists(img_path): + pic = video_slide.shapes.add_picture(img_path, left, top, width, height) + video_slide.shapes.add_textbox(left, top + height + Inches(0.5), width, Inches(0.5)).text_frame.text = "Click to play video (exported separately)" + + # Explanation slide + if explanation_text: + text_slide = prs.slides.add_slide(prs.slide_layouts[1]) + text_slide.shapes.title.text = "Explanation" + text_slide.placeholders[1].text = explanation_text + + # Save presentation + output_path = os.path.join(temp_dir, f"{animation_title.replace(' ', '_')}.pptx") + prs.save(output_path) + + # Read the file to return it + with open(output_path, "rb") as f: + return f.read(), "powerpoint" + + elif format_type == "html": + # Create interactive HTML animation + html_template = """ + + + + {title} + + + + + + +

{title}

+ +
+ + +
+ + + + + + +
+
+ +
+

Explanation

+ {explanation_html} +
+ + + + + """ + + # 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 "

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 + 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 + +def process_multiple_images(uploaded_images): + """Process multiple uploaded images and return information about them""" + processed_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) + + for img in uploaded_images: + # Generate a unique filename and save the image + file_extension = img.name.split(".")[-1] + unique_filename = f"image_{int(time.time())}_{len(processed_images)}.{file_extension}" + image_path = os.path.join(image_dir, unique_filename) + + with open(image_path, "wb") as f: + f.write(img.getvalue()) + + # Store image info + processed_images.append({ + "name": img.name, + "path": image_path, + "preview": img + }) + + return processed_images + +def main(): + # Initialize session state variables if they don't exist + if 'init' not in st.session_state: + st.session_state.init = True + st.session_state.video_data = None + st.session_state.status = None + st.session_state.ai_models = None + st.session_state.generated_code = "" + st.session_state.code = "" + st.session_state.temp_code = "" + st.session_state.editor_key = str(uuid.uuid4()) + st.session_state.packages_checked = False # Track if packages were already checked + st.session_state.latex_formula = "" + st.session_state.audio_path = None + st.session_state.image_paths = [] + st.session_state.custom_library_result = "" + st.session_state.python_script = "import matplotlib.pyplot as plt\nimport numpy as np\n\n# Example: Create a simple plot\nx = np.linspace(0, 10, 100)\ny = np.sin(x)\n\nplt.figure(figsize=(10, 6))\nplt.plot(x, y, 'b-', label='sin(x)')\nplt.title('Sine Wave')\nplt.xlabel('x')\nplt.ylabel('sin(x)')\nplt.grid(True)\nplt.legend()\n" + st.session_state.python_result = None + st.session_state.settings = { + "quality": "720p", + "format_type": "mp4", + "animation_speed": "Normal" + } + st.session_state.pending_changes = False # Track if there are changes that need refresh + st.session_state.pending_temp_code = "" # Store code changes before refresh + + # Page configuration with improved layout + st.set_page_config( + page_title="Manim Animation Studio", + page_icon="🎬", + layout="wide", + initial_sidebar_state="expanded" + ) + + # Custom CSS for improved UI + st.markdown(""" + + """, unsafe_allow_html=True) + + # Header + st.markdown(""" +
+ 🎬 Manim Animation Studio +
+

Create mathematical animations with Manim

+ """, unsafe_allow_html=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() + + # Initialize AI models if needed + if st.session_state.ai_models is None or not check_model_freshness(): + st.session_state.ai_models = init_ai_models() + + # Create main tabs + tabs = st.tabs(["✨ Editor", "πŸ€– AI Assistant", "πŸ“š LaTeX Formulas", "🎨 Assets", "🎞️ Timeline", "πŸŽ“ Educational Export", "🐍 Python Runner"]) + + # Sidebar for rendering settings, custom libraries, and refresh button + with st.sidebar: + # Add refresh button at the top of the sidebar + if st.button("πŸ”„ Refresh App", key="refresh_button", help="Refresh the app to apply all changes", use_container_width=True): + st.success("App refreshed!") + if st.session_state.pending_changes: + st.session_state.code = st.session_state.pending_temp_code + st.session_state.temp_code = st.session_state.pending_temp_code + st.session_state.pending_changes = False + + # 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 + 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" + ) + + 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.pending_temp_code = code_content + st.session_state.pending_changes = True + st.info("Code loaded from file. Click 'Refresh App' to apply changes.") + + # Code editor + if ACE_EDITOR_AVAILABLE: + current_code = st.session_state.code if hasattr(st.session_state, 'code') and st.session_state.code else "" + temp_code = st_ace( + value=current_code, + language="python", + theme="monokai", + min_lines=20, + key="ace_editor" + ) + if temp_code != current_code: + st.session_state.pending_temp_code = temp_code + st.session_state.pending_changes = True + st.info("Code changes detected. Click 'Refresh App' to apply changes.") + else: + current_code = st.session_state.code if hasattr(st.session_state, 'code') and st.session_state.code else "" + temp_code = st.text_area( + "Manim Python Code", + value=current_code, + height=400, + key="code_textarea" + ) + if temp_code != current_code: + st.session_state.pending_temp_code = temp_code + st.session_state.pending_changes = True + st.info("Code changes detected. Click 'Refresh App' to apply changes.") + + # 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.pending_temp_code = st.session_state.code + st.session_state.pending_changes = True + st.warning("No scene class found. Added a default scene. Click 'Refresh App' to see changes.") + + 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'animation', 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 or 8K 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) + + # AI ASSISTANT TAB + with tabs[1]: + st.markdown("### πŸ€– AI Animation Assistant") + + if st.session_state.ai_models: + # AI code generation + st.markdown("
", 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..."): + response = suggest_code_completion(code_input, st.session_state.ai_models) + if response: + st.session_state.generated_code = response + else: + st.warning("Please enter a description or prompt first") + + st.markdown("
", unsafe_allow_html=True) + + # AI generated code display and actions + if 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.pending_temp_code = st.session_state.generated_code + st.session_state.pending_changes = True + st.info("AI code ready to use. Click 'Refresh App' to apply it to the editor.") + + 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 failed to load. Generation features are unavailable.") + + # LATEX FORMULAS 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 without auto-refresh + if latex_input != st.session_state.latex_formula: + 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']}"): + st.session_state.latex_formula = formula["latex"] + # No automatic rerun - user needs to click refresh + st.info(f"Added '{formula['name']}'. Click 'Refresh App' to update the preview.") + + # 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"))) + + new_code = "\n".join(lines) + st.session_state.pending_temp_code = new_code + st.session_state.pending_changes = True + st.success("LaTeX formula prepared for insertion. Click 'Refresh App' to update the editor.") + 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.pending_temp_code = basic_scene + st.session_state.pending_changes = True + st.success("Created new scene with your LaTeX formula. Click 'Refresh App' to update the editor.") + + 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 + 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:") + + # Multiple image uploader + uploaded_images = st.file_uploader("Upload Images", type=["jpg", "png", "jpeg", "svg"], accept_multiple_files=True, key="image_uploader_tab") + + if uploaded_images: + # Process all uploaded images + with st.spinner("Processing uploaded images..."): + processed_images = process_multiple_images(uploaded_images) + + # Add to session state + if "image_paths" not in st.session_state: + st.session_state.image_paths = [] + + st.session_state.image_paths.extend(processed_images) + + # Show preview of uploaded images + st.success(f"Successfully uploaded {len(processed_images)} images") + + # Display image grid + st.markdown("#### New Images") + image_cols = st.columns(min(4, len(processed_images))) + for i, img_info in enumerate(processed_images): + with image_cols[i % len(image_cols)]: + st.image(img_info["preview"], caption=img_info["name"], width=150) + + # Show code to use images + if processed_images: + st.markdown("#### Code to use these images:") + image_code_samples = [] + for i, img_info in enumerate(processed_images): + image_code = f""" +# Load and display image {i+1}: {img_info['name']} +image{i+1} = ImageMobject(r"{img_info['path']}") +image{i+1}.scale(2) # Adjust size as needed +self.play(FadeIn(image{i+1})) +self.wait(1) +""" + image_code_samples.append(image_code) + + all_images_code = "\n".join(image_code_samples) + st.code(all_images_code, language="python") + + if st.button("Insert All Images Code", key="insert_images_code_btn"): + if not st.session_state.code: + base_code = """from manim import * + +class ImageScene(Scene): + def construct(self): +""" + indented_code = "\n ".join(all_images_code.split("\n")) + new_code = base_code + "\n " + indented_code + else: + new_code = st.session_state.code + "\n" + all_images_code + + st.session_state.pending_temp_code = new_code + st.session_state.pending_changes = True + st.success("Image code prepared for insertion. Click 'Refresh App' to update the editor.") + + # Display previously uploaded images + if st.session_state.image_paths: + st.markdown("#### All Available Images") + + # Display in a grid format + st.markdown('
', unsafe_allow_html=True) + + for idx, img_info in enumerate(st.session_state.image_paths): + st.markdown(f""" +
+

{img_info['name']}

+

Path: {img_info['path']}

+
+ """, unsafe_allow_html=True) + + st.markdown('
', 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""" +
+

Audio: {uploaded_audio.name}

+

Path: {audio_path}

+
+ """, 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 + 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.pending_temp_code = updated_code + st.session_state.pending_changes = True + + # EDUCATIONAL 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.") + 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: + st.session_state.python_script = example_scripts[selected_example] + + if ACE_EDITOR_AVAILABLE: + python_code = st_ace( + value=st.session_state.python_script, + language="python", + theme="monokai", + min_lines=15, + key="python_editor" + ) + else: + python_code = st.text_area( + "Python Code", + value=st.session_state.python_script, + height=400, + key="python_textarea" + ) + + # Update session state + 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}" + ) + user_inputs.append(user_input) + + # Options and execution + col1, col2 = st.columns([2, 1]) + + with col1: + timeout_seconds = st.slider("Execution Timeout (seconds)", 5, 120, 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: + new_code = st.session_state.code + "\n" + plot_code + st.session_state.pending_temp_code = new_code + st.session_state.pending_changes = True + st.success(f"Plot {i+1} added to your animation code! Click 'Refresh App' to update the editor.") + else: + basic_scene = f"""from manim import * + +class PlotScene(Scene): + def construct(self): +{plot_code} +""" + st.session_state.pending_temp_code = basic_scene + st.session_state.pending_changes = True + st.success(f"Created new scene with Plot {i+1}! Click 'Refresh App' to update the editor.") + + # 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) + ``` + """) + +if __name__ == "__main__": + main() \ No newline at end of file