Update app.py

app.py

@@ -11,36 +11,65 @@ import glob
 # ---------------------------------------------------------
 
 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.
+    """
     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)
         return code
+
+    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):
         try:
             val = float(m.group(2))
             new_val = val * factor
             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)
+        except ValueError:
+            return m.group(0)
+
     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
 
 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.
+    """
+    print("🕵️ Running fast pre-check with 'manim -s'...", flush=True)
     fast_code = modify_animation_times(code_str, for_precheck=True)
-    with open("scene_pre_check.py", "w", encoding="utf-8") as f: f.write(fast_code)
+    
+    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", "-o", "pre_check_output"]
+
     try:
         process = subprocess.run(cmd, capture_output=True, timeout=30, check=False)
-        if process.returncode == 0: return True, "Pre-check successful."
-        else: return False, f"⚠️ ERROR: Pre-check failed.\n\n--- ERROR LOG ---\n{process.stderr.decode('utf-8', 'ignore')}"
+        if process.returncode == 0:
+            print("✅ Pre-check passed.", flush=True)
+            return True, "Pre-check successful."
+        else:
+            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:
+        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():
-    if os.path.exists('media'):
-        try: shutil.rmtree('media')
+    media_dir = 'media'
+    if os.path.exists(media_dir):
+        try: shutil.rmtree(media_dir)
         except OSError: pass
 
 def make_even(n):
@@ -49,46 +78,87 @@ def make_even(n):
 def get_resolution_flags(orientation, quality):
     qual_map = {"Preview (360p)": 360, "480p": 480, "720p": 720, "1080p": 1080, "4k": 2160}
     base_h = qual_map.get(quality, 1080)
-    width, height = (make_even(base_h * (16/9)), make_even(base_h)) if orientation == "Landscape (16:9)" else (make_even(base_h), make_even(base_h * (16/9)))
+    if orientation == "Landscape (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 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)
+    
     with open("scene.py", "w", encoding="utf-8") as f: f.write(code_str)
-    timestamp, output_filename = int(time.time()), f"video_{int(time.time())}.mp4"
+    
+    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]
     
+    cmd = ["manim", "--resolution", res_str, *frame_rate_flags, "--disable_caching", 
+           "--progress_bar", "none", "scene.py", "GenScene", "-o", output_filename]
+    
+    full_logs = ""
+
     try:
         process = subprocess.run(cmd, capture_output=True, timeout=timeout_sec, check=False)
-        full_logs = f"--- STDOUT ---\n{process.stdout.decode('utf-8', 'ignore')}\n\n--- STDERR ---\n{process.stderr.decode('utf-8', 'ignore')}"
-        if process.returncode != 0: print(f"❌ Render Failed (Error Code: {process.returncode})", flush=True)
+        
+        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}"
+        
+        if process.returncode != 0:
+            print(f"❌ Render Failed (Process Error). Return Code: {process.returncode}", flush=True)
+
     except subprocess.TimeoutExpired as e:
-        full_logs = f"--- STDOUT ---\n{e.stdout.decode('utf-8', 'ignore') if e.stdout else ''}\n\n--- STDERR ---\n{e.stderr.decode('utf-8', 'ignore') if e.stderr else ''}"
-        print(f"⌛ Render timed out. Attempting recovery...", flush=True)
-        path_matches = re.findall(r"movie file written in\s*'([^']+?)'", full_logs, flags=re.DOTALL)
+        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
+        
+        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_dir = os.path.dirname("".join(path_matches[-1].split()))
-            if os.path.exists(partial_dir):
-                chunks = sorted(glob.glob(os.path.join(partial_dir, 'uncached_*.mp4')), key=lambda f: int(re.search(r'(\d+)\.mp4$', f).group(1)))
-                if chunks:
-                    list_path = os.path.join(partial_dir, "file_list.txt")
-                    with open(list_path, 'w') as f:
-                        for chunk in chunks: f.write(f"file '{os.path.abspath(chunk)}'\n")
-                    combined_path = os.path.join(os.path.dirname(partial_dir), f"combined_partial_{timestamp}.mp4")
-                    ffmpeg_cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_path, "-c", "copy", combined_path]
-                    ffmpeg_proc = subprocess.run(ffmpeg_cmd, capture_output=True, text=True, check=False)
-                    if ffmpeg_proc.returncode == 0 and os.path.exists(combined_path):
-                        return combined_path, f"⚠️ WARNING: Render Timed Out. Recovered partial video.\n\n{full_logs}", True
-        print("❌ Recovery failed.", flush=True)
-
-    media_base = os.path.join("media", "videos", "scene")
-    if os.path.exists(media_base):
-        for root, _, files in os.walk(media_base):
+            partial_files_dir = os.path.dirname("".join(path_matches[-1].split()))
+            
+            if os.path.exists(partial_files_dir):
+                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")
+
+                    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)
+
+    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:
-                return os.path.join(root, output_filename), f"✅ Rendering Successful\n\n{full_logs}", True
-    return None, f"❌ Failure: Video file not created.\n\n{full_logs}", False
+                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
+    
+    return None, f"❌ Failure: Video file was not created.\n\n{full_logs}", False
 
 # ---------------------------------------------------------
 # 2. Main API Function
@@ -97,60 +167,61 @@ def run_manim(code_str, orientation, quality, timeout):
 def render_video_from_code(code, orientation, quality, timeout, preview_factor):
     try:
         is_valid, logs = run_manim_pre_check(code)
-        if not is_valid: return None, logs, gr.Button(visible=True)
+        if not is_valid:
+            return None, logs, gr.Button(visible=True)
+        
         cleanup_media_directory()
-        if not code or "from manim import" not in code: return None, "Error: No valid code.", gr.Button(visible=False)
-        code_to_render = modify_animation_times(code, factor=float(preview_factor) or 0.5) if quality == "Preview (360p)" else code
+        if not code or "from manim import" not in code:
+            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)
+        else:
+            code_to_render = code
+
         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:
         return None, f"Rendering failed: {str(e)}", gr.Button(visible=True)
 
 # ---------------------------------------------------------
-# NEW: Audio Merging Functions (with RENAMING FIX)
+# NEW: Audio Merging Functions
 # ---------------------------------------------------------
 
-def ensure_file_extension(file_path: str, expected_ext: str) -> str:
-    """
-    Checks if a file has an extension. If not, renames it to include one.
-    This is CRITICAL for ffprobe to work with Gradio API's extension-less 'blob' files.
-    """
-    if not file_path or not os.path.exists(file_path):
-        return file_path # Return original path if it's invalid, let downstream fail
-    
-    _, current_ext = os.path.splitext(file_path)
-    if not current_ext:
-        new_path = file_path + expected_ext
-        print(f"🔧 Renaming extension-less file '{os.path.basename(file_path)}' to '{os.path.basename(new_path)}'", flush=True)
-        shutil.move(file_path, new_path)
-        return new_path
-    return file_path
-
 def get_media_duration(file_path):
-    cmd = ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", file_path]
+    """Uses ffprobe to get the duration of a media file."""
+    cmd = [
+        "ffprobe",
+        "-v", "error",
+        "-show_entries", "format=duration",
+        "-of", "default=noprint_wrappers=1:nokey=1",
+        file_path
+    ]
     try:
         result = subprocess.run(cmd, capture_output=True, text=True, check=True)
         return float(result.stdout.strip())
-    except (subprocess.CalledProcessError, FileNotFoundError) as e:
-        print(f"⚠️ Could not get duration for {file_path}. Error: {e}", flush=True)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print(f"⚠️ Could not get duration for {file_path}. Is ffprobe installed?", flush=True)
         return None
 
 def build_atempo_filter(factor):
+    """Builds a chained atempo filter for FFmpeg to handle extreme speed changes."""
     filters = []
+    # FFmpeg's atempo filter is limited to the range [0.5, 100.0]
     while factor > 100.0:
-        filters.append("atempo=100.0"); factor /= 100.0
+        filters.append("atempo=100.0")
+        factor /= 100.0
     while factor < 0.5:
-        filters.append("atempo=0.5"); factor /= 0.5
+        filters.append("atempo=0.5")
+        factor /= 0.5
+    
     if 0.5 <= factor <= 100.0:
         filters.append(f"atempo={factor}")
+    
     return ",".join(filters)
 
 def merge_audio_to_video(video_path, audio_path):
-    # --- FIX APPLIED HERE ---
-    video_path = ensure_file_extension(video_path, ".mp4")
-    # Gradio's gr.Audio component often saves to .wav by default
-    audio_path = ensure_file_extension(audio_path, ".wav") 
-
+    """Merges audio into a video, stretching the audio to match the video's duration."""
     if not video_path or not audio_path:
         return None, "Error: Please provide both a video and an audio file."
 
@@ -160,36 +231,62 @@ def merge_audio_to_video(video_path, audio_path):
 
     if video_duration is None or audio_duration is None:
         return None, "Error: Could not determine media durations. Check server logs."
+
     if video_duration == 0:
         return None, "Error: Input video has zero duration."
 
     speed_factor = audio_duration / video_duration
     atempo_filter = build_atempo_filter(speed_factor)
     
+    print(f"Video Duration: {video_duration}s, Audio Duration: {audio_duration}s, Speed Factor: {speed_factor}", flush=True)
+    print(f"Applying FFmpeg atempo filter: '{atempo_filter}'", flush=True)
+
     output_dir = "temp_outputs"
     os.makedirs(output_dir, exist_ok=True)
-    output_path = os.path.join(output_dir, f"merged_video_{int(time.time())}.mp4")
+    timestamp = int(time.time())
+    output_path = os.path.join(output_dir, f"merged_video_{timestamp}.mp4")
 
-    ffmpeg_cmd = ["ffmpeg", "-y", "-i", video_path, "-i", audio_path, "-c:v", "copy", "-filter:a", atempo_filter, "-map", "0:v:0", "-map", "1:a:0", "-shortest", output_path]
+    ffmpeg_cmd = [
+        "ffmpeg",
+        "-y",                   # Overwrite output file if it exists
+        "-i", video_path,       # Input video
+        "-i", audio_path,       # Input audio
+        "-c:v", "copy",         # Copy video stream (no re-encoding, preserves quality)
+        "-filter:a", atempo_filter, # Apply speed change to audio
+        "-map", "0:v:0",        # Select video from the first input
+        "-map", "1:a:0",        # Select audio from the second input
+        "-shortest",            # Ensure output duration matches the shortest stream (video)
+        output_path
+    ]
     
     process = subprocess.run(ffmpeg_cmd, capture_output=True, text=True)
     
     if process.returncode != 0:
         error_message = f"FFmpeg Error:\n{process.stderr}"
+        print(error_message, flush=True)
         return None, error_message
 
+    print(f"✅ Audio merged successfully: {output_path}", flush=True)
     return output_path, "✅ Audio merged successfully!"
 
 # ---------------------------------------------------------
 # 3. Gradio Interface
 # ---------------------------------------------------------
 
-with gr.Blocks(title="Manim AI Tools") as demo:
+DEFAULT_CODE = """from manim import *
+
+class GenScene(Scene):
+    def construct(self):
+        c = Circle(color=BLUE, fill_opacity=0.5)
+        self.play(Create(c))
+        self.wait(1)
+"""
+
+with gr.Blocks(title="Manim Render API") as demo:
     with gr.Tab("🎬 Manim Video Renderer"):
-        gr.Markdown("## Create Animations with Manim")
         with gr.Row():
             with gr.Column(scale=1):
-                code_input = gr.Code(label="Python Code", language="python", value="from manim import *\n\nclass GenScene(Scene):\n    def construct(self):\n        c = Circle()\n        self.play(Create(c))", visible=True)
+                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)
@@ -199,7 +296,13 @@ with gr.Blocks(title="Manim AI Tools") as demo:
                 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.click(fn=render_video_from_code, inputs=[code_input, orientation_opt, quality_opt, timeout_input, preview_speed_factor_input], outputs=[video_output, status_output, fix_btn_output], api_name="render")
+        
+        render_btn.click(
+            fn=render_video_from_code,
+            inputs=[code_input, orientation_opt, quality_opt, timeout_input, preview_speed_factor_input],
+            outputs=[video_output, status_output, fix_btn_output],
+            api_name="render"
+        )
 
     with gr.Tab("🎤 Add Audio to Video"):
         gr.Markdown("## Merge Audio into Video")
@@ -212,7 +315,13 @@ with gr.Blocks(title="Manim AI Tools") as demo:
             with gr.Column():
                 video_output_audio_tab = gr.Video(label="Merged Video")
                 status_audio_tab = gr.Textbox(label="Status")
-        merge_audio_btn.click(fn=merge_audio_to_video, inputs=[video_input_audio_tab, audio_input_audio_tab], outputs=[video_output_audio_tab, status_audio_tab], api_name="add_audio")
+
+        merge_audio_btn.click(
+            fn=merge_audio_to_video,
+            inputs=[video_input_audio_tab, audio_input_audio_tab],
+            outputs=[video_output_audio_tab, status_audio_tab],
+            api_name="add_audio"
+        )
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)