Update app.py

app.py

@@ -5,206 +5,121 @@ import re
 import time
 import glob
 import shutil
-# --- START: New Imports for Pyflakes Integration ---
-from pyflakes.api import check
-from pyflakes.reporter import Reporter
-import io
-# --- END: New Imports ---
 
 # ---------------------------------------------------------
 # 1. Helper Functions (Dependencies for Rendering)
 # ---------------------------------------------------------
 
-class ErrorReporter(Reporter):
-    """Custom reporter to capture pyflakes errors into a list."""
-    def __init__(self):
-        self.errors = []
-        # Suppress the default print-to-stdout behavior
-        super().__init__(io.StringIO(), io.StringIO())
-
-    def unexpectedError(self, filename, msg):
-        self.errors.append(f"Unexpected Error in {filename}: {msg}")
-
-    def syntaxError(self, filename, msg, lineno, offset, text):
-        self.errors.append(f"Syntax Error in {filename} (Line {lineno}): {msg}")
-
-    def flake(self, message):
-        self.errors.append(str(message))
-
-def check_code_with_pyflakes(code_str: str) -> str:
+def run_manim_pre_check(code_str: str) -> (bool, str):
     """
-    Analyzes a string of Python code using pyflakes and returns a formatted error report.
-    This version uses a robust blocklist to filter out all warnings related to star imports.
-    Returns an empty string if no definite errors are found.
+    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.
     """
-    reporter = ErrorReporter()
-    check(code_str, "scene.py", reporter=reporter)
+    print("🕵️ Running fast pre-check with 'manim -s'...", flush=True)
     
-    # A blocklist of warning substrings to completely ignore.
-    IGNORE_SUBSTRINGS = [
-        "may be undefined, or defined from star imports",
-        "undefined names"
+    # 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
     ]
-    
-    filtered_errors = []
-    for err in reporter.errors:
-        err_str = str(err)
-        # If the error message contains any of the substrings in our blocklist, we ignore it.
-        if not any(sub in err_str for sub in IGNORE_SUBSTRINGS):
-            filtered_errors.append(err_str)
 
-    if not filtered_errors:
-        return "" # No real errors found
+    try:
+        # We don't need a long timeout for a pre-check
+        process = subprocess.run(cmd, capture_output=True, timeout=30, check=False)
         
-    error_report = "Static analysis found potential errors:\n"
-    for err in filtered_errors:
-        # Use a simpler, more robust formatting logic
-        parts = err.split(':', 2)
-        if len(parts) == 3:
-            try:
-                line_num = parts[1]
-                message = parts[2].strip()
-                error_report += f"- Line {line_num}: {message}\n"
-            except:
-                error_report += f"- {err}\n" # Fallback for unexpected format
+        if process.returncode == 0:
+            print("✅ Pre-check passed. Code is valid.", flush=True)
+            return True, "Pre-check successful."
         else:
-            error_report += f"- {err}\n" # Fallback
+            # 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
             
-    return error_report
+    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)
+        try: shutil.rmtree(media_dir)
+        except OSError as e: print(f"⚠️ Warning during cleanup: {e}", flush=True)
 
 def make_even(n):
     n = int(n)
     return n if n % 2 == 0 else n + 1
 
 def get_resolution_flags(orientation, quality):
-    qual_map = {
-        "Preview (360p)": 360, "480p": 480, "720p": 720, "1080p": 1080, "4k": 2160
-    }
+    qual_map = {"Preview (360p)": 360, "480p": 480, "720p": 720, "1080p": 1080, "4k": 2160}
     base_h = qual_map.get(quality, 1080)
     if orientation == "Landscape (16:9)":
-        width = make_even(base_h * (16/9)); height = make_even(base_h)
-    else: # Portrait (9:16)
-        width = make_even(base_h); height = make_even(base_h * (16/9))
+        width, height = make_even(base_h * (16/9)), make_even(base_h)
+    else:
+        width, height = make_even(base_h), make_even(base_h * (16/9))
     return f"{width},{height}"
 
 def scale_animation_times(code, factor):
-    """
-    Scales run_time and wait() calls, enforcing a minimum run_time to prevent render errors.
-    """
+    """Scales run_time and wait() calls."""
     print(f"⚡ Scaling animation times by a factor of {factor} for preview.", flush=True)
-    MIN_RUN_TIME = 0.1  # A safe minimum duration for any animation clip.
-
-    def scale_runtime(m):
-        new_time = max(float(m.group(2)) * factor, MIN_RUN_TIME)
-        return f"{m.group(1)}{new_time}"
-
-    def scale_wait(m):
-        new_time = float(m.group(2)) * factor
-        return f"{m.group(1)}{new_time}"
-
-    code = re.sub(r"(run_time\s*=\s*)(\d+\.?\d*)", scale_runtime, code)
-    code = re.sub(r"(self\.wait\s*\(\s*)(\d+\.?\d*)", scale_wait, code)
+    MIN_RUN_TIME = 0.1
+    def scale(m, is_wait):
+        val = float(m.group(2)) * factor
+        return f"{m.group(1)}{val if is_wait else max(val, MIN_RUN_TIME)}"
+    code = re.sub(r"(run_time\s*=\s*)(\d+\.?\d*)", lambda m: scale(m, False), code)
+    code = re.sub(r"(self\.wait\s*\(\s*)(\d+\.?\d*)", lambda m: scale(m, True), code)
     return code
 
 def run_manim(code_str, orientation, quality, timeout):
     timeout_sec = float(timeout) if timeout and float(timeout) > 0 else None
-    print(f"🎬 Starting Render: {orientation} @ {quality} (Timeout: {timeout_sec}s)...", flush=True)
+    print(f"🎬 Starting Full Render: {orientation} @ {quality} (Timeout: {timeout_sec}s)...", flush=True)
     
-    # Write code to file
-    with open("scene.py", "w", encoding="utf-8") as f: 
-        f.write(code_str)
+    with open("scene.py", "w", encoding="utf-8") as f: f.write(code_str)
     
     timestamp = int(time.time())
     output_filename = f"video_{timestamp}.mp4"
     res_str = get_resolution_flags(orientation, quality)
     
-    # Manim command
     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
-    ]
+    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)
 
     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')
+        stdout_log, stderr_log = process.stdout.decode('utf-8', 'ignore'), process.stderr.decode('utf-8', 'ignore')
         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
-
     except subprocess.TimeoutExpired as e:
         print(f"⌛ Render timed out after {timeout_sec} seconds.", 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}"
-        return None, f"❌ ERROR: Timed out.\n{timeout_logs}", False
+        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
 
-    # ---------------------------------------------------------
-    # 2. LOCATE OUTPUT FILE
-    # ---------------------------------------------------------
-    
-    # Strategy A: Look for the expected Video File (.mp4)
     media_video_base = os.path.join("media", "videos", "scene")
-    found_video_path = None
-    
     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)
-                break
-
-    if found_video_path:
-        print(f"✅ Video Render Success: {found_video_path}", flush=True)
-        return found_video_path, f"✅ Rendering Successful\n\n{full_logs}", True
-
-    # Strategy B: Look for a Static Image (.png) and convert to Video
-    media_image_base = os.path.join("media", "images", "scene")
-    expected_image_name = output_filename.replace('.mp4', '.png')
-    found_image_path = None
-
-    if os.path.exists(media_image_base):
-        for root, _, files in os.walk(media_image_base):
-            # Manim Community v0.18.0 changed naming for -o. Let's find the single png.
-            png_files = [f for f in files if f.endswith(".png")]
-            if len(png_files) == 1:
-                 found_image_path = os.path.join(root, png_files[0])
-                 break
-
-    if found_image_path:
-        print(f"🖼️ Static scene detected (0 animations). converting image to video: {found_image_path}", flush=True)
-        converted_video_path = os.path.join(os.path.dirname(found_image_path), output_filename)
-        ffmpeg_cmd = [
-            "ffmpeg", "-y", "-loop", "1", 
-            "-i", found_image_path, 
-            "-t", "1", 
-            "-c:v", "libx264", 
-            "-pix_fmt", "yuv420p",
-            converted_video_path
-        ]
-        ffmpeg_proc = subprocess.run(ffmpeg_cmd, capture_output=True, check=False)
-        if ffmpeg_proc.returncode == 0 and os.path.exists(converted_video_path):
-             return converted_video_path, f"✅ Static Scene Rendered (Converted to 1s Video)\n\n{full_logs}", True
-        else:
-             print(f"❌ FFMPEG Conversion Failed: {ffmpeg_proc.stderr.decode()}", flush=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)
     return None, f"Video file not created despite success code. Check logs:\n{full_logs}", False
 
@@ -215,30 +130,17 @@ 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: Integrated Pyflakes Pre-Check ---
-        print("🕵️ Running static analysis with pyflakes...", flush=True)
-        static_errors = check_code_with_pyflakes(code)
-        if static_errors:
-            print(f"❌ Static analysis failed:\n{static_errors}", flush=True)
-            # Return the error report immediately without trying to render
-            return None, static_errors, gr.Button(visible=True)
-        print("✅ Static analysis passed.", flush=True)
-        # --- END: Integrated Pyflakes 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:
             return None, "Error: No valid code to render.", gr.Button(visible=False)
         
-        code_to_render = code
-        if quality == "Preview (360p)":
-            try:
-                factor = float(preview_factor)
-                if factor <= 0: factor = 0.5
-            except (ValueError, TypeError):
-                factor = 0.5
-            code_to_render = scale_animation_times(code, factor)
-
+        code_to_render = code if quality != "Preview (360p)" else scale_animation_times(code, float(preview_factor) or 0.5)
         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:
@@ -253,22 +155,19 @@ DEFAULT_CODE = """from manim import *
 class GenScene(Scene):
     def construct(self):
         c = Circle(color=BLUE, fill_opacity=0.5)
-        self.play(Create(c))  # Animation adds runtime
-        self.wait(1)          # Pause adds runtime
+        self.play(Create(c))
+        self.wait(1)
 """
 
 with gr.Blocks(title="Manim Render API") as demo:
-    # Components are now visible for direct interaction
     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)
     preview_speed_factor_input = gr.Number(label="Preview Speed Factor", value=0.5, visible=True)
-
     video_output = gr.Video(label="Result")
     status_output = gr.Textbox(label="Status/Logs")
     fix_btn_output = gr.Button("Fix Error & Re-render", variant="stop", visible=True)
-
     render_btn = gr.Button("Render")
     
     render_btn.click(