Update app.py

app.py

@@ -5,55 +5,60 @@ import re
 import time
 import glob
 import shutil
-# --- START: Corrected Ruff Integration ---
-# Note: You must run 'pip install ruff'
-import ruff
-# --- END: Corrected Ruff Integration ---
-
 
 # ---------------------------------------------------------
 # 1. Helper Functions (Dependencies for Rendering)
 # ---------------------------------------------------------
 
-def check_code_with_ruff(code_str: str) -> str:
+def run_manim_pre_check(code_str: str) -> (bool, str):
     """
-    Analyzes code using the high-performance Ruff linter.
-    This is configured to ignore warnings about star imports (`from manim import *`)
-    but will reliably catch definite NameErrors (e.g., 'Cirle', 'CENTER', 'BLE').
+    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.
     """
-    print("🕵️ Running fast pre-check with Ruff...", flush=True)
+    print("🕵️ Running fast pre-check with 'manim -s'...", flush=True)
     
-    # Configure Ruff to ignore star-import warnings (F403, F405)
-    # but to catch everything else, including undefined names (F821).
-    settings = {
-        "ignore": ["F403", "F405"]
-    }
+    # Write the code to a temporary file for the pre-check
+    with open("scene_pre_check.py", "w", encoding="utf-8") as f:
+        f.write(code_str)
+
+    # 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
+    ]
 
     try:
-        # Use the official 'ruff.check' API, passing the code as 'contents'
-        diagnostics = ruff.check(contents=code_str, settings=settings, filename="scene.py")
-        
-        if not diagnostics:
-            return ""  # No errors found
-
-        error_report = "Static analysis found potential errors:\n"
-        for diag in diagnostics:
-            # The diagnostic object has a slightly different structure
-            error_report += f"- Line {diag.location.row}: {diag.body} ({diag.code})\n"
+        # We don't need a long timeout for a pre-check
+        process = subprocess.run(cmd, capture_output=True, timeout=30, check=False)
         
-        return error_report
-
-    except Exception as e:
-        # Fallback in case Ruff itself has an issue
-        print(f"⚠️ Ruff pre-check encountered an internal error: {e}", flush=True)
-        return "" # Allow render to proceed, don't block on linter failure
+        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
+            
+    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."
 
 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 as e: print(f"⚠️ Warning during cleanup: {e}", flush=True)
 
 def make_even(n):
     n = int(n)
@@ -70,7 +75,7 @@ def get_resolution_flags(orientation, quality):
 
 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)
+    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
@@ -81,7 +86,7 @@ def scale_animation_times(code, factor):
 
 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)
+    print(f"🎬 Starting Full Render: {orientation} @ {quality} (Timeout: {timeout_sec}s)...", flush=True)
     
     with open("scene.py", "w", encoding="utf-8") as f: f.write(code_str)
     
@@ -92,7 +97,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)
+    print(f"⚙️ Running command: {' '.join(cmd)}", flush=True)
 
     try:
         process = subprocess.run(cmd, capture_output=True, timeout=timeout_sec, check=False)
@@ -100,22 +105,22 @@ def run_manim(code_str, orientation, quality, timeout):
         full_logs = f"--- MANIM STDOUT ---\n{stdout_log}\n\n--- MANIM STDERR ---\n{stderr_log}"
         
         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.\n{stderr_log}", flush=True)
+            return None, f"⚠️ ERROR: Manim failed to render.\n{full_logs}", False
     except subprocess.TimeoutExpired as e:
-        print(f"⌛ Render timed out after {timeout_sec} seconds.", flush=True)
+        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
+        return None, f"❌ ERROR: Timed out.\n--- MANIM STDOUT ---\n{stdout_log}\n\n--- MANIM STDERR ---\n{stderr_log}", False
 
     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):
             if output_filename in files:
                 found_video_path = os.path.join(root, output_filename)
-                print(f"✅ Video Render Success: {found_video_path}", flush=True)
-                return found_video_path, f"✅ Rendering Successful\n\n{full_logs}", True
+                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)
+    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
 
 # ---------------------------------------------------------
@@ -125,13 +130,11 @@ 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:
-        # --- START: New Ruff Pre-Check ---
-        ruff_errors = check_code_with_ruff(code)
-        if ruff_errors:
-            print(f"❌ Ruff pre-check failed:\n{ruff_errors}", flush=True)
-            return None, ruff_errors, gr.Button(visible=True)
-        print("✅ Ruff pre-check passed. Code is valid.", flush=True)
-        # --- END: New Ruff Pre-Check ---
+        # --- START: New '-s' Pre-Check ---
+        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: