Update app.py

app.py

@@ -4,6 +4,7 @@ import subprocess
 import re
 import time
 import shutil
+import glob
 
 # ---------------------------------------------------------
 # 1. Helper Functions
@@ -12,107 +13,67 @@ import shutil
 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 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'.
-       - Enforces a minimum run_time of 0.1s to prevent rendering crashes.
+    1. Pre-Check: Zero latency (wait(0), run_time=0.01).
+    2. Preview: Scales time by factor.
     """
-    
-    # --- 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)
         code = re.sub(r"self\.wait\s*\([^)]*\)", "self.wait(0)", code)
-        
-        # 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
 
-    # --- 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 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.
+    Runs Manim with '-s'.
+    - Speed Hack applied.
+    - Soft Pass: Timeouts return True.
+    - Errors return False.
     """
     print("🕵️ Running fast pre-check with 'manim -s'...", flush=True)
-    
-    # Apply the speed hack
     fast_code = modify_animation_times(code_str, for_precheck=True)
     
-    # Write to temp file
     with open("scene_pre_check.py", "w", encoding="utf-8") as f:
         f.write(fast_code)
 
-    cmd = [
-        "manim",
-        "-ql",
-        "--progress_bar", "none",
-        "--disable_caching",
-        "scene_pre_check.py", "GenScene",
-        "-s", # Save last frame only
-        "-o", "pre_check_output"
-    ]
+    cmd = ["manim", "-ql", "--progress_bar", "none", "--disable_caching", "scene_pre_check.py", "GenScene", "-s", "-o", "pre_check_output"]
 
     try:
-        # 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)
+            print("✅ Pre-check passed.", 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:
-        # 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..."
+        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():
-    """Wipes the media directory to prevent caching issues."""
     media_dir = 'media'
     if os.path.exists(media_dir):
         try: shutil.rmtree(media_dir)
-        except OSError as e: print(f"⚠️ Warning during cleanup: {e}", flush=True)
+        except OSError: pass
 
 def make_even(n):
-    n = int(n)
-    return n if n % 2 == 0 else n + 1
+    return int(n) if int(n) % 2 == 0 else int(n) + 1
 
 def get_resolution_flags(orientation, quality):
     qual_map = {"Preview (360p)": 360, "480p": 480, "720p": 720, "1080p": 1080, "4k": 2160}
@@ -124,6 +85,11 @@ def get_resolution_flags(orientation, quality):
     return f"{width},{height}"
 
 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.
+    """
     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)
     
@@ -132,24 +98,69 @@ def run_manim(code_str, orientation, quality, timeout):
     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]
     
+    full_logs = ""
+
     try:
+        # check=False prevents Python from raising exception on error code automatically.
+        # We handle returncode manually below.
         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')
+        
+        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}"
         
+        # --- STANDARD ERROR CHECK ---
         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
+            print(f"❌ Render Failed (Process Error). Return Code: {process.returncode}", flush=True)
+            # We do NOT stitch here. We just fall through to see if a file exists (unlikely).
+
     except subprocess.TimeoutExpired as e:
-        print(f"⌛ Render timed out after {timeout_sec} seconds.", flush=True)
-        stdout_log, stderr_log = (e.stdout.decode('utf-8', 'ignore') if e.stdout else ""), (e.stderr.decode('utf-8', 'ignore') if e.stderr else "")
-        return None, f"❌ ERROR: Timed out.\n--- MANIM STDOUT ---\n{stdout_log}\n\n--- MANIM STDERR ---\n{stderr_log}", False
+        # --- TIMEOUT LOGIC ONLY ---
+        print(f"⌛ Render timed out after {timeout_sec} seconds. Attempting recovery...", 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}"
+        full_logs = timeout_logs
+        
+        # 1. Parse logs for directory
+        combined_log = stdout_log + "\n" + stderr_log
+        path_matches = re.findall(r"movie file written in\s*'([^']+?)'", combined_log, flags=re.DOTALL)
+        
+        if path_matches:
+            partial_files_dir = os.path.dirname("".join(path_matches[-1].split()))
+            
+            if os.path.exists(partial_files_dir):
+                # 2. Find partial chunks
+                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 partial_files:
+                    print(f"⚡ Found {len(partial_files)} partial chunks. Stitching...", flush=True)
+                    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")
+
+                    # 3. Stitch
+                    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]
+                    
+                    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"✅ Recovery Successful: {combined_video_path}", flush=True)
+                        return combined_video_path, f"⚠️ WARNING: Render Timed Out. Recovered partial video.\n\n{timeout_logs}", True
+        
+        print("❌ Recovery failed or no partial files found.", flush=True)
+        # End of Timeout Logic. Falls through to final check.
 
+    # --- FINAL FILE CHECK ---
+    # Only returns success if the actual complete file exists.
     media_video_base = os.path.join("media", "videos", "scene")
     if os.path.exists(media_video_base):
         for root, _, files in os.walk(media_video_base):
@@ -158,36 +169,27 @@ def run_manim(code_str, orientation, quality, timeout):
                 print(f"✅ Video Render Success: {found_video_path}", flush=True)
                 return found_video_path, f"✅ Rendering Successful\n\n{full_logs}", True
     
-    print(f"❌ Final output file '{output_filename}' not found.", flush=True)
-    return None, f"Video file not created despite success code. Check logs:\n{full_logs}", False
+    return None, f"❌ Failure: Video file was not created.\n\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:
-        # --- 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)
+            return None, "Error: No valid code.", gr.Button(visible=False)
         
-        # --- 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:
             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: