Update app.py

app.py

@@ -12,37 +12,27 @@ import tempfile
 # 1. Helper Functions
 # ---------------------------------------------------------
 
-def modify_animation_times(code: str, factor: float = 1.0, for_precheck: bool = False) -> str:
+def modify_animation_times(code: str, factor: float) -> str:
     """
-    Modifies wait() and run_time in the code.
-    - Pre-Check: Uses a robust regex to replace any run_time value with 0.01.
-    - Preview: Scales numeric times by a factor.
+    Scales all numeric run_time and wait() values by a given factor.
+    This single, safe function is now used for both Pre-check and Preview modes.
     """
-    if for_precheck:
-        print("⚡ Optimizing code for Pre-check (Zero Latency)...", flush=True)
-        # Use a tiny non-zero value to prevent ZeroDivisionError
-        replacement_time = "0.01"
-        
-        # This robust regex handles: run_time=2.0, run_time=my_var, run_time=(some_function(a, b))
-        run_time_pattern = re.compile(r"(run_time\s*=\s*)(\(.*\)|[a-zA-Z_]\w*|\d+\.?\d*)")
-        code = run_time_pattern.sub(fr"\g<1>{replacement_time}", code)
-
-        # The wait regex is simpler and can remain as is
-        code = re.sub(r"self\.wait\s*\([^)]*\)", f"self.wait({replacement_time})", code)
-        return code
-
-    print(f"⚡ Scaling animation times by a factor of {factor} for preview.", flush=True)
-    MIN_RUN_TIME = 0.1
+    print(f"⚡ Scaling animation times by a factor of {factor}...", flush=True)
+    # A safe minimum to prevent Manim from crashing with run_time=0
+    MIN_RUN_TIME = 0.01 
     
     def scale_match(m, is_wait):
         try:
             val = float(m.group(2))
             new_val = val * factor
+            # For waits, we can go low. For run_time, we must stay above zero.
             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) # Ignore if it's not a number (e.g., a variable)
+            # This happens if run_time is a variable. We safely ignore it.
+            return m.group(0)
 
+    # This safe regex only matches explicit numbers, preventing SyntaxErrors.
     code = re.sub(r"(run_time\s*=\s*)(\d+\.?\d*)", lambda m: scale_match(m, False), code)
     code = re.sub(r"(self\.wait\s*\(\s*)(\d+\.?\d*)", lambda m: scale_match(m, True), code)
     return code
@@ -50,11 +40,14 @@ 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 '-s'.
-    - A strong regex now prevents speed-hack errors, so we don't need special error handling.
-    - Soft Pass on Timeout remains as a fallback for true infinite loops.
+    - Uses the safe `modify_animation_times` function with a small factor for a significant speedup.
+    - Errors are now always considered critical because the modification is safe.
+    - Soft Pass on Timeout remains as a fallback.
     """
     print("🕵️ Running fast pre-check with 'manim -s'...", flush=True)
-    fast_code = modify_animation_times(code_str, for_precheck=True)
+    # Using a factor of 0.2 makes a 10-second animation take 2 seconds in pre-check.
+    # This is a good balance of speed and reliability.
+    fast_code = modify_animation_times(code_str, factor=0.2)
     
     with open("scene_pre_check.py", "w", encoding="utf-8") as f:
         f.write(fast_code)
@@ -115,6 +108,7 @@ def run_manim(code_str, orientation, quality, timeout):
 
     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}"
@@ -182,7 +176,7 @@ def render_video_from_code(code, orientation, quality, timeout, preview_factor):
             return None, "Error: No valid code.", gr.Button(visible=False)
         
         if quality == "Preview (360p)":
-            code_to_render = modify_animation_times(code, factor=float(preview_factor) or 0.5, for_precheck=False)
+            code_to_render = modify_animation_times(code, factor=float(preview_factor) or 0.5)
         else:
             code_to_render = code
 
@@ -302,7 +296,6 @@ def merge_audio_to_video(video_input, audio_input):
 # 4. Gradio Interface
 # ---------------------------------------------------------
 
-# Define the default code here to be used in the UI
 DEFAULT_CODE = """from manim import *
 
 class GenScene(Scene):
@@ -316,7 +309,6 @@ with gr.Blocks(title="Manim Render & Audio Tool") as demo:
     with gr.Tab("🎬 Manim Video Renderer"):
         with gr.Row():
             with gr.Column(scale=1):
-                # Use the DEFAULT_CODE variable directly here
                 code_input = gr.Code(label="Python Code", language="python", value=DEFAULT_CODE, visible=True) 
                 orientation_opt = gr.Radio(choices=["Landscape (16:9)", "Portrait (9:16)"], value="Portrait (9:16)", label="Orientation", visible=True)
                 quality_opt = gr.Dropdown(choices=["Preview (360p)", "480p", "720p", "1080p", "4k"], value="Preview (360p)", label="Quality", visible=True)
@@ -355,6 +347,4 @@ with gr.Blocks(title="Manim Render & Audio Tool") as demo:
         )
 
 if __name__ == "__main__":
-    # The default code is now handled directly in the UI definition,
-    # so no extra logic is needed here.
     demo.launch(server_name="0.0.0.0", server_port=7860)