Create app.py

app.py

@@ -0,0 +1,194 @@
+import gradio as gr
+import os
+import subprocess
+import re
+import time
+import glob
+import shutil
+
+# ---------------------------------------------------------
+# 1. Helper Functions (Dependencies for Rendering)
+# ---------------------------------------------------------
+
+def cleanup_media_directory():
+    """Wipes the media/videos directory to prevent caching issues."""
+    media_dir = os.path.join('media', 'videos')
+    if os.path.exists(media_dir):
+        print(f"🧹 Cleaning up old media directory: {media_dir}", flush=True)
+        try:
+            shutil.rmtree(media_dir)
+        except OSError as e:
+            print(f"❌ Error during cleanup: {e}", flush=True)
+
+def make_even(n):
+    n = int(n)
+    return n if n % 2 == 0 else n + 1
+
+def get_resolution_flags(orientation, quality):
+    qual_map = {
+        "Preview (360p)": 360, "480p": 480, "720p": 720, "1080p": 1080, "4k": 2160
+    }
+    base_h = qual_map.get(quality, 1080)
+    if orientation == "Landscape (16:9)":
+        width = make_even(base_h * (16/9)); height = make_even(base_h)
+    else: # Portrait (9:16)
+        width = make_even(base_h); height = make_even(base_h * (16/9))
+    return f"{width},{height}"
+
+def scale_animation_times(code, factor):
+    """
+    Scales run_time and wait() calls, enforcing a minimum run_time to prevent render errors.
+    """
+    print(f"⚡ Scaling animation times by a factor of {factor} for preview.", flush=True)
+    MIN_RUN_TIME = 0.1  # A safe minimum duration for any animation clip.
+
+    def scale_runtime(m):
+        new_time = max(float(m.group(2)) * factor, MIN_RUN_TIME)
+        return f"{m.group(1)}{new_time}"
+
+    def scale_wait(m):
+        new_time = float(m.group(2)) * factor
+        return f"{m.group(1)}{new_time}"
+
+    code = re.sub(r"(run_time\s*=\s*)(\d+\.?\d*)", scale_runtime, code)
+    code = re.sub(r"(self\.wait\s*\(\s*)(\d+\.?\d*)", scale_wait, code)
+    return code
+
+def run_manim(code_str, orientation, quality, timeout):
+    timeout_sec = float(timeout) if timeout and float(timeout) > 0 else None
+    print(f"🎬 Starting Render: {orientation} @ {quality} (Timeout: {timeout_sec}s)...", flush=True)
+    with open("scene.py", "w", encoding="utf-8") as f: f.write(code_str)
+    
+    timestamp = int(time.time())
+    output_filename = f"video_{timestamp}.mp4"
+    res_str = get_resolution_flags(orientation, quality)
+    frame_rate_flags = ["--frame_rate", "15"] if quality == "Preview (360p)" else []
+    cmd = ["manim", "--resolution", res_str, *frame_rate_flags, "--disable_caching", "--progress_bar", "none", "scene.py", "GenScene", "-o", output_filename]
+    print(f"⚙️ Running command: {' '.join(cmd)}", flush=True)
+
+    try:
+        process = subprocess.run(cmd, capture_output=True, timeout=timeout_sec, check=False)
+        stdout_log = process.stdout.decode('utf-8', 'ignore')
+        stderr_log = process.stderr.decode('utf-8', 'ignore')
+        full_logs = f"--- MANIM STDOUT ---\n{stdout_log}\n\n--- MANIM STDERR ---\n{stderr_log}"
+        if process.returncode != 0:
+            print(f"❌ Render Failed.\n{stderr_log}", flush=True)
+            return None, f"⚠️ ERROR: Manim failed to render.\n{full_logs}", False
+
+    except subprocess.TimeoutExpired as e:
+        print(f"⌛ Render timed out after {timeout_sec} seconds. Attempting to recover partial video.", flush=True)
+        stdout_log = e.stdout.decode('utf-8', 'ignore') if e.stdout else ""
+        stderr_log = e.stderr.decode('utf-8', 'ignore') if e.stderr else ""
+        timeout_logs = f"--- MANIM STDOUT ---\n{stdout_log}\n\n--- MANIM STDERR ---\n{stderr_log}"
+        
+        combined_log = stdout_log + "\n" + stderr_log
+        path_matches = re.findall(r"movie file written in\s*'([^']+?)'", combined_log, flags=re.DOTALL)
+
+        all_paths = []
+        for raw_path in path_matches:
+            normalized = "".join(raw_path.split())
+            all_paths.append(normalized)
+
+        if all_paths:
+            last_path = all_paths[-1]
+            partial_files_dir = os.path.dirname(last_path)
+            print(f"✅ Successfully parsed partial files directory from logs: {partial_files_dir}", flush=True)
+        else:
+            print("❌ Could not parse partial file directory from Manim logs.", flush=True)
+            return None, (f"❌ ERROR: Timed out, and could not find path to partial files in log.\n{timeout_logs}"), False
+
+        if not os.path.exists(partial_files_dir):
+            return None, f"❌ ERROR: Timed out, and parsed directory does not exist: {partial_files_dir}\n{timeout_logs}", False
+
+        partial_files = sorted(glob.glob(os.path.join(partial_files_dir, 'uncached_*.mp4')), 
+                               key=lambda f: int(re.search(r'(\d+)\.mp4$', f).group(1)))
+
+        if not partial_files:
+            return None, f"❌ ERROR: Timed out, but no partial movie files were found in {partial_files_dir}.\n{timeout_logs}", False
+
+        list_file_path = os.path.join(partial_files_dir, "file_list.txt")
+        with open(list_file_path, 'w') as f:
+            for pf in partial_files:
+                f.write(f"file '{os.path.abspath(pf)}'\n")
+
+        combined_video_path = os.path.join(os.path.dirname(partial_files_dir), f"combined_partial_{timestamp}.mp4")
+        ffmpeg_cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file_path, "-c", "copy", combined_video_path]
+        
+        print(f"⚙️ Running ffmpeg to combine {len(partial_files)} chunks...", flush=True)
+        ffmpeg_process = subprocess.run(ffmpeg_cmd, capture_output=True, text=True, check=False)
+
+        if ffmpeg_process.returncode == 0 and os.path.exists(combined_video_path):
+            print(f"✅ Successfully combined partial video: {combined_video_path}", flush=True)
+            status_message = f"⚠️ WARNING: Rendering timed out. Recovered and combined {len(partial_files)} video chunks.\n\n{timeout_logs}"
+            return combined_video_path, status_message, True
+        else:
+            ffmpeg_logs = f"--- FFMPEG STDOUT ---\n{ffmpeg_process.stdout}\n--- FFMPEG STDERR ---\n{ffmpeg_process.stderr}"
+            return None, f"❌ ERROR: Timed out and failed to combine partial videos.\n{ffmpeg_logs}", False
+    
+    media_base_dir = "media/videos/scene"
+    for root, _, files in os.walk(media_base_dir):
+        if output_filename in files:
+            final_output_path = os.path.join(root, output_filename)
+            print(f"✅ Render Success: {final_output_path}", flush=True)
+            return final_output_path, f"✅ Rendering Successful\n\n{full_logs}", True
+
+    print(f"❌ Final video file '{output_filename}' not found after a successful render code.", flush=True)
+    return None, f"Video file not created despite success code. Check logs:\n{full_logs}", False
+
+# ---------------------------------------------------------
+# 2. Main API Function
+# ---------------------------------------------------------
+
+def render_video_from_code(code, orientation, quality, timeout, preview_factor):
+    """Renders a video from a given Manim code string."""
+    try:
+        # --- CACHING FIX: CLEANUP BEFORE EVERY RENDER ---
+        cleanup_media_directory()
+
+        if not code or "from manim import" not in code:
+            return None, "Error: No valid code to render.", gr.Button(visible=False)
+        
+        code_to_render = code
+        if quality == "Preview (360p)":
+            try:
+                factor = float(preview_factor)
+                if factor <= 0: factor = 0.5
+            except (ValueError, TypeError):
+                factor = 0.5
+            code_to_render = scale_animation_times(code, factor)
+
+        video_path, logs, success = run_manim(code_to_render, orientation, quality, timeout)
+        return video_path, logs, gr.Button(visible=not success)
+    except Exception as e:
+        return None, f"Rendering failed: {str(e)}", gr.Button(visible=True)
+
+# ---------------------------------------------------------
+# 3. Gradio Interface (API Definition)
+# ---------------------------------------------------------
+
+with gr.Blocks(title="Manim Render API") as demo:
+    # Hidden components to define the API signature
+    code_input = gr.Code(label="Python Code", language="python", value="from manim import *\nclass GenScene(Scene):\n    def construct(self):\n        self.add(Circle())")
+    orientation_opt = gr.Radio(choices=["Landscape (16:9)", "Portrait (9:16)"], value="Portrait (9:16)", label="Orientation")
+    quality_opt = gr.Dropdown(choices=["Preview (360p)", "480p", "720p", "1080p", "4k"], value="Preview (360p)", label="Quality")
+    timeout_input = gr.Number(label="Render Timeout (seconds)", value=60)
+    preview_speed_factor_input = gr.Number(label="Preview Speed Factor", value=0.5)
+
+    video_output = gr.Video(label="Result")
+    status_output = gr.Textbox(label="Status/Logs")
+    # This button output is required because the render function returns a button update (for UI logic)
+    # Even if used purely as API, we maintain the signature.
+    fix_btn_output = gr.Button("Fix Error & Re-render", variant="stop")
+
+    # The trigger
+    render_btn = gr.Button("Render")
+    
+    render_btn.click(
+        fn=render_video_from_code,
+        inputs=[code_input, orientation_opt, quality_opt, timeout_input, preview_speed_factor_input],
+        outputs=[video_output, status_output, fix_btn_output],
+        api_name="render"
+    )
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)