Update app.py

app.py

@@ -3,55 +3,101 @@ import os
 import subprocess
 import re
 import time
-import glob
 import shutil
 
 # ---------------------------------------------------------
-# 1. Helper Functions (Dependencies for Rendering)
+# 1. Helper Functions
 # ---------------------------------------------------------
 
+def modify_animation_times(code: str, factor: float = 1.0, for_precheck: bool = False) -> str:
+    """
+    Modifies wait() and run_time in the code.
+    
+    1. If for_precheck=True: 
+       - Sets all self.wait(...) to self.wait(0).
+       - Sets all run_time=... to run_time=0.
+       - This makes heavy simulation loops execute instantly during the 'manim -s' check.
+       
+    2. If for_precheck=False (Preview Mode):
+       - Scales animation speed by 'factor'.
+       - Enforces a minimum run_time of 0.1s to prevent rendering crashes.
+    """
+    
+    # --- MODE 1: PRE-CHECK (Zero Latency) ---
+    if for_precheck:
+        print("⚡ Optimizing code for Pre-check (Zero Latency)...", flush=True)
+        # Regex: Find self.wait(ANYTHING) and replace with self.wait(0)
+        # We use [^)]* to match any content inside the parenthesis (numbers, math, variables)
+        code = re.sub(r"self\.wait\s*\([^)]*\)", "self.wait(0)", code)
+        
+        # Regex: Find run_time=ANYTHING (until a comma or parenthesis) and set to 0
+        code = re.sub(r"run_time\s*=\s*[^,)]+", "run_time=0", code)
+        return code
+
+    # --- MODE 2: PREVIEW SCALING (Safe Speedup) ---
+    print(f"⚡ Scaling animation times by a factor of {factor} for preview.", flush=True)
+    MIN_RUN_TIME = 0.1
+    
+    def scale_match(m, is_wait):
+        # m.group(1) is the prefix (e.g. "run_time=")
+        # m.group(2) is the number value
+        try:
+            val = float(m.group(2))
+            new_val = val * factor
+            # If it's a wait, we can go low. If it's an animation, keep 0.1 safety.
+            final_val = new_val if is_wait else max(new_val, MIN_RUN_TIME)
+            return f"{m.group(1)}{final_val:.3f}"
+        except ValueError:
+            return m.group(0)
+
+    # Scale run_time=1.5 -> run_time=0.75
+    code = re.sub(r"(run_time\s*=\s*)(\d+\.?\d*)", lambda m: scale_match(m, False), code)
+    # Scale self.wait(2) -> self.wait(1.0)
+    code = re.sub(r"(self\.wait\s*\(\s*)(\d+\.?\d*)", lambda m: scale_match(m, True), code)
+    
+    return code
+
 def run_manim_pre_check(code_str: str) -> (bool, str):
     """
     Runs Manim with the '-s' flag to perform a fast, reliable pre-check.
-    This executes the Python code without rendering the full video.
-    Returns (True, "Success") if the code is valid.
-    Returns (False, "Error Log") if any Python error (like NameError) occurs.
+    Uses the 'Speed Hack' (modify_animation_times) to ensure heavy loops 
+    don't cause a timeout.
     """
     print("🕵️ Running fast pre-check with 'manim -s'...", flush=True)
     
-    # Write the code to a temporary file for the pre-check
+    # Apply the speed hack: waits become 0s
+    fast_code = modify_animation_times(code_str, for_precheck=True)
+    
+    # Write the modified code to a temporary file
     with open("scene_pre_check.py", "w", encoding="utf-8") as f:
-        f.write(code_str)
+        f.write(fast_code)
 
-    # Use low quality and '-s' flag for maximum speed. Output is discarded.
     cmd = [
         "manim",
         "-ql",
         "--progress_bar", "none",
         "--disable_caching",
         "scene_pre_check.py", "GenScene",
-        "-s", # This is the key: save last frame only.
-        "-o", "pre_check_output" # Output is temporary and will be overwritten
+        "-s", # Save last frame only (no video encoding)
+        "-o", "pre_check_output"
     ]
 
     try:
-        # We don't need a long timeout for a pre-check
+        # 30s is now plenty of time because we removed all waits
         process = subprocess.run(cmd, capture_output=True, timeout=30, check=False)
         
         if process.returncode == 0:
             print("✅ Pre-check passed. Code is valid.", flush=True)
             return True, "Pre-check successful."
         else:
-            # An error occurred, capture the logs
             stderr_log = process.stderr.decode('utf-8', 'ignore')
             print(f"❌ Pre-check failed.\n{stderr_log}", flush=True)
-            # Format a clean error message for the user
-            error_message = f"⚠️ ERROR: Your code failed the pre-check.\n\n--- ERROR LOG ---\n{stderr_log}"
-            return False, error_message
+            return False, f"⚠️ ERROR: Your code failed the pre-check.\n\n--- ERROR LOG ---\n{stderr_log}"
             
     except subprocess.TimeoutExpired:
         print("⌛ Pre-check timed out.", flush=True)
-        return False, "❌ ERROR: The pre-check timed out. The code may contain an infinite loop."
+        # Even with the speed hack, if it times out, it's likely a true infinite loop (while True)
+        return False, "❌ ERROR: The pre-check timed out. The code likely contains an infinite loop."
 
 def cleanup_media_directory():
     """Wipes the media directory to prevent caching issues."""
@@ -73,17 +119,6 @@ def get_resolution_flags(orientation, quality):
         width, height = make_even(base_h), make_even(base_h * (16/9))
     return f"{width},{height}"
 
-def scale_animation_times(code, factor):
-    """Scales run_time and wait() calls."""
-    print(f"⚡ Scaling animation times by a factor of {factor} for preview.", flush=True)
-    MIN_RUN_TIME = 0.1
-    def scale(m, is_wait):
-        val = float(m.group(2)) * factor
-        return f"{m.group(1)}{val if is_wait else max(val, MIN_RUN_TIME)}"
-    code = re.sub(r"(run_time\s*=\s*)(\d+\.?\d*)", lambda m: scale(m, False), code)
-    code = re.sub(r"(self\.wait\s*\(\s*)(\d+\.?\d*)", lambda m: scale(m, True), 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 Full Render: {orientation} @ {quality} (Timeout: {timeout_sec}s)...", flush=True)
@@ -97,8 +132,7 @@ def run_manim(code_str, orientation, quality, timeout):
     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, stderr_log = process.stdout.decode('utf-8', 'ignore'), process.stderr.decode('utf-8', 'ignore')
@@ -124,30 +158,36 @@ def run_manim(code_str, orientation, quality, timeout):
     return None, f"Video file not created despite success code. Check logs:\n{full_logs}", False
 
 # ---------------------------------------------------------
-# 3. Main API Function
+# 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:
-        # --- START: New '-s' Pre-Check ---
+        # --- 1. Pre-Check (With Speed Hack) ---
         is_valid, logs = run_manim_pre_check(code)
         if not is_valid:
             return None, logs, gr.Button(visible=True)
-        # --- END: New '-s' Pre-Check ---
-
+        
         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)" else scale_animation_times(code, float(preview_factor) or 0.5)
+        # --- 2. Prepare Code for Render ---
+        # If quality is Preview, we scale time. If not, we use original code.
+        if quality == "Preview (360p)":
+            code_to_render = modify_animation_times(code, factor=float(preview_factor) or 0.5, for_precheck=False)
+        else:
+            code_to_render = code
+
+        # --- 3. Execute Render ---
         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)
 
 # ---------------------------------------------------------
-# 4. Gradio Interface (API Definition)
+# 3. Gradio Interface
 # ---------------------------------------------------------
 
 DEFAULT_CODE = """from manim import *
@@ -165,6 +205,7 @@ with gr.Blocks(title="Manim Render API") as demo:
     quality_opt = gr.Dropdown(choices=["Preview (360p)", "480p", "720p", "1080p", "4k"], value="Preview (360p)", label="Quality", visible=True)
     timeout_input = gr.Number(label="Render Timeout (seconds)", value=60, visible=True)
     preview_speed_factor_input = gr.Number(label="Preview Speed Factor", value=0.5, visible=True)
+    
     video_output = gr.Video(label="Result")
     status_output = gr.Textbox(label="Status/Logs")
     fix_btn_output = gr.Button("Fix Error & Re-render", variant="stop", visible=True)