Update app.py

app.py

@@ -14,9 +14,9 @@ def modify_animation_times(code: str, factor: float = 1.0, for_precheck: bool =
     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.
+       - Sets self.wait(...) to self.wait(0).
+       - Sets run_time=... to run_time=0.01.
+       - This attempts to make the validation run instantly.
        
     2. If for_precheck=False (Preview Mode):
        - Scales animation speed by 'factor'.
@@ -27,10 +27,9 @@ def modify_animation_times(code: str, factor: float = 1.0, for_precheck: bool =
     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.01
+        # Regex: Find run_time=ANYTHING and set to 0.01 to avoid "run_time <= 0" error
         code = re.sub(r"run_time\s*=\s*[^,)]+", "run_time=0.01", code)
         return code
 
@@ -59,16 +58,20 @@ def modify_animation_times(code: str, factor: float = 1.0, for_precheck: bool =
 
 def run_manim_pre_check(code_str: str) -> (bool, str):
     """
-    Runs Manim with the '-s' flag to perform a fast, reliable pre-check.
-    Uses the 'Speed Hack' (modify_animation_times) to ensure heavy loops 
-    don't cause a timeout.
+    Runs Manim with the '-s' flag to perform a fast pre-check.
+    
+    CRITICAL BEHAVIOR:
+    1. Tries to run quickly using 'modify_animation_times'.
+    2. If it catches a SyntaxError or NameError, it FAILS (Returns False).
+    3. If it runs for >30 seconds (Timeout), it PASSES (Returns True), assuming
+       the code is valid but just computationally heavy.
     """
     print("🕵️ Running fast pre-check with 'manim -s'...", flush=True)
     
-    # Apply the speed hack: waits become 0s
+    # Apply the speed hack
     fast_code = modify_animation_times(code_str, for_precheck=True)
     
-    # Write the modified code to a temporary file
+    # Write to temp file
     with open("scene_pre_check.py", "w", encoding="utf-8") as f:
         f.write(fast_code)
 
@@ -78,26 +81,27 @@ def run_manim_pre_check(code_str: str) -> (bool, str):
         "--progress_bar", "none",
         "--disable_caching",
         "scene_pre_check.py", "GenScene",
-        "-s", # Save last frame only (no video encoding)
+        "-s", # Save last frame only
         "-o", "pre_check_output"
     ]
 
     try:
-        # 30s is now plenty of time because we removed all waits
+        # Run for max 30 seconds
         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:
+            # Code finished but failed (e.g. Syntax Error)
             stderr_log = process.stderr.decode('utf-8', 'ignore')
             print(f"❌ Pre-check failed.\n{stderr_log}", flush=True)
             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)
-        # 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."
+        # Code ran for 30s without crashing. likely valid but heavy.
+        print("⌛ Pre-check timed out (30s). Assuming code is valid but heavy.", flush=True)
+        return True, "⚠️ Warning: Pre-check timed out (30s). The code seems valid but is very heavy. Proceeding to full render..."
 
 def cleanup_media_directory():
     """Wipes the media directory to prevent caching issues."""
@@ -164,17 +168,20 @@ def run_manim(code_str, orientation, quality, timeout):
 def render_video_from_code(code, orientation, quality, timeout, preview_factor):
     """Renders a video from a given Manim code string."""
     try:
-        # --- 1. Pre-Check (With Speed Hack) ---
+        # --- 1. Pre-Check (With Speed Hack & Soft Pass) ---
         is_valid, logs = run_manim_pre_check(code)
+        
+        # If is_valid is False, it means there was a real Error (Syntax, NameError, etc.)
         if not is_valid:
             return None, logs, gr.Button(visible=True)
         
+        # If is_valid is True, we proceed (even if it timed out)
+        
         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)
         
-        # --- 2. Prepare Code for Render ---
-        # If quality is Preview, we scale time. If not, we use original code.
+        # --- 2. Prepare Code for Real Render ---
         if quality == "Preview (360p)":
             code_to_render = modify_animation_times(code, factor=float(preview_factor) or 0.5, for_precheck=False)
         else: