Update app.py

app.py

@@ -15,13 +15,20 @@ import tempfile
 def modify_animation_times(code: str, factor: float = 1.0, for_precheck: bool = False) -> str:
     """
     Modifies wait() and run_time in the code.
-    1. Pre-Check: Zero latency (wait(0), run_time=0.01).
-    2. Preview: Scales time by factor.
+    - Pre-Check: Uses a robust regex to replace any run_time value with 0.01.
+    - Preview: Scales numeric times by a factor.
     """
     if for_precheck:
         print("⚡ Optimizing code for Pre-check (Zero Latency)...", flush=True)
-        code = re.sub(r"self\.wait\s*\([^)]*\)", "self.wait(0)", code)
-        code = re.sub(r"run_time\s*=\s*[^,)]+", "run_time=0.01", code)
+        # 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)
@@ -34,7 +41,7 @@ def modify_animation_times(code: str, factor: float = 1.0, for_precheck: bool =
             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)
+            return m.group(0) # Ignore if it's not a number (e.g., a variable)
 
     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)
@@ -43,9 +50,8 @@ 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'.
-    - Speed Hack applied.
-    - Soft Pass: Timeouts return True.
-    - Errors return False.
+    - 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.
     """
     print("🕵️ Running fast pre-check with 'manim -s'...", flush=True)
     fast_code = modify_animation_times(code_str, for_precheck=True)
@@ -62,12 +68,14 @@ def run_manim_pre_check(code_str: str) -> (bool, str):
             return True, "Pre-check successful."
         else:
             stderr_log = process.stderr.decode('utf-8', 'ignore')
-            print(f"❌ Pre-check failed.\n{stderr_log}", flush=True)
+            print(f"❌ Pre-check failed with a critical error.\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 (30s). Soft Pass.", flush=True)
         return True, "⚠️ Warning: Pre-check timed out. Proceeding to full render..."
 
+
 def cleanup_media_directory():
     media_dir = 'media'
     if os.path.exists(media_dir):
@@ -88,9 +96,7 @@ def get_resolution_flags(orientation, quality):
 
 def run_manim(code_str, orientation, quality, timeout):
     """
-    Executes Manim.
-    - RECOVERY: Partial stitching ONLY happens inside 'except subprocess.TimeoutExpired'.
-    - ERRORS: Standard errors do NOT trigger recovery.
+    Executes Manim. Partial stitching on Timeout. No recovery on other errors.
     """
     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)
@@ -109,7 +115,6 @@ 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}"
@@ -187,7 +192,7 @@ def render_video_from_code(code, orientation, quality, timeout, preview_factor):
         return None, f"Rendering failed: {str(e)}", gr.Button(visible=True)
 
 # ---------------------------------------------------------
-# NEW: Audio Merging Functions (API-Safe)
+# 3. Audio Merging Functions (API-Safe)
 # ---------------------------------------------------------
 
 def get_media_duration(file_path):
@@ -213,8 +218,7 @@ def build_atempo_filter(factor):
 
 def decode_base64_to_tempfile(data_obj):
     """Decodes a base64 string from a Gradio file object and saves to a temp file."""
-    if not data_obj or 'data' not in data_obj:
-        return None
+    if not data_obj or 'data' not in data_obj: return None
     
     header, encoded_data = data_obj['data'].split(",", 1)
     file_extension = header.split('/')[1].split(';')[0]
@@ -291,17 +295,14 @@ def merge_audio_to_video(video_input, audio_input):
     finally:
         print(f"Cleaning up {len(temp_files_to_clean)} temporary files...", flush=True)
         for f in temp_files_to_clean:
-            try:
-                os.remove(f)
-            except OSError as e:
-                print(f"Error removing temp file {f}: {e}", flush=True)
+            try: os.remove(f)
+            except OSError as e: print(f"Error removing temp file {f}: {e}", flush=True)
 
 # ---------------------------------------------------------
-# 3. Gradio Interface
+# 4. Gradio Interface
 # ---------------------------------------------------------
 
-# --- THIS IS THE FIX ---
-# Define the default code before it is used in the UI.
+# Define the default code here to be used in the UI
 DEFAULT_CODE = """from manim import *
 
 class GenScene(Scene):
@@ -315,8 +316,8 @@ with gr.Blocks(title="Manim Render & Audio Tool") as demo:
     with gr.Tab("🎬 Manim Video Renderer"):
         with gr.Row():
             with gr.Column(scale=1):
-                # The 'value' parameter now has a defined variable to reference.
-                code_input = gr.Code(label="Python Code", language="python", value=DEFAULT_CODE, visible=True)
+                # 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)
                 timeout_input = gr.Number(label="Render Timeout (seconds)", value=60, visible=True)
@@ -354,4 +355,6 @@ 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)