Update app.py

app.py

@@ -2,7 +2,7 @@ import asyncio
 import os
 import shutil
 import subprocess
-import tempfile
+import tempfile # Import the tempfile module
 from typing import List
 import logging
 
@@ -95,15 +95,21 @@ def generate_video_outline(concept: str) -> VideoOutline:
 
 def create_video_from_code(code: str, chapter_number: int) -> str:
     """Creates a video from Manim code and returns the video file path using subprocess.Popen."""
-    with open("temp.py", "w") as temp_file:
+    # Use tempfile to create a temporary Python file
+    # This ensures that the script has write permissions and handles cleanup
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as temp_file:
         temp_file.write(code)
         temp_file_name = temp_file.name
 
     process = None
     try:
+        # Manim needs the class name from the code to correctly generate the video file name.
+        # It also implicitly determines the output path based on the current working directory
+        # unless specified. We will get the output path later.
         command = ["manim", temp_file_name, "-ql", "--disable_caching"]
+        logging.info(f"Executing Manim command: {' '.join(command)}")
         process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, text=True)
-        stdout, stderr = process.communicate(timeout=60)  # Add a timeout to prevent indefinite blocking
+        stdout, stderr = process.communicate(timeout=120)  # Increased timeout for potentially longer renders
 
         if process.returncode == 0:
             logging.info(f"Manim execution successful for chapter {chapter_number}.")
@@ -123,17 +129,38 @@ def create_video_from_code(code: str, chapter_number: int) -> str:
         logging.error("Error: The 'manim' command was not found. Ensure Manim is installed and in your system's PATH.")
         raise
     finally:
-        pass
-        # if os.path.exists(temp_file_name):
-        #     os.remove(temp_file_name)
+        # Ensure the temporary file is deleted after Manim tries to use it
+        if os.path.exists(temp_file_name):
+            os.remove(temp_file_name)
+            logging.info(f"Deleted temporary Manim script: {temp_file_name}")
 
     # Construct the video file name. Manim names the file based on the class name.
-    # Extract the class name from the python code.
+    # The output directory for Manim in this configuration is ./media/videos/temp/480p15/
     match = re.search(r"class\s+(\w+)\(Scene\):", code)
     if match:
         class_name = match.group(1)
         video_file_name = f"{class_name}.mp4"
-        return os.path.join("./media/videos/temp/480p15/", video_file_name)
+        # Manim renders to a specific default output path if not specified
+        # Adjust this path if your Manim configuration or command differs
+        manim_output_dir = "./media/videos/temp/480p15/"
+        # Ensure the output directory exists
+        os.makedirs(manim_output_dir, exist_ok=True)
+        video_file_path = os.path.join(manim_output_dir, video_file_name)
+
+        # In some cases, Manim might output to the current directory before moving it.
+        # We need to make sure we're checking the correct path where Manim places the final video.
+        # A more robust solution might involve parsing Manim's stdout for the actual path.
+        # For now, let's assume the default output path.
+        if not os.path.exists(video_file_path):
+            logging.warning(f"Expected Manim output at {video_file_path} but not found. Checking current directory for {video_file_name}.")
+            # Fallback check in current directory, although not typical for default Manim behavior
+            if os.path.exists(video_file_name):
+                video_file_path = video_file_name
+                logging.info(f"Found video in current directory: {video_file_name}")
+            else:
+                raise FileNotFoundError(f"Manim output video file '{video_file_name}' not found at '{video_file_path}' or current directory after successful execution.")
+
+        return video_file_path
     else:
         raise ValueError(f"Could not extract class name from Manim code for chapter {chapter_number}")
 
@@ -155,6 +182,7 @@ async def generate_video(concept: str):
 
         while attempts < max_attempts and not success:
             try:
+                st.info(f"Attempting to render chapter {i + 1}: {chapter.title} (Attempt {attempts + 1}/{max_attempts})")
                 video_file = create_video_from_code(manim_code, i + 1)
                 video_files.append(video_file)
                 logging.info(f"Video file created for chapter {i + 1}: {video_file}")
@@ -162,19 +190,25 @@ async def generate_video(concept: str):
             except subprocess.CalledProcessError as e:
                 attempts += 1
                 logging.error(f"Manim execution failed for chapter {i + 1} (Attempt {attempts}): {e}")
-                logging.info(f"Attempting to fix the code...")
+                st.warning(f"Manim rendering failed for chapter {i + 1}. Attempting to fix code...")
                 manim_code = fix_manim_code(str(e), manim_code)
                 logging.debug(f"Fixed Manim code (Attempt {attempts}):\n{manim_code}")
             except ValueError as e:
                 logging.error(f"Error processing Manim code for chapter {i + 1}: {e}")
                 st.error(f"Error processing chapter {i + 1}: {e}")
                 return None  # Stop processing if a critical error occurs with code structure
-            except FileNotFoundError:
-                logging.error("Manim not found. Please ensure it's installed and in your PATH.")
-                st.error("Manim not found. Please ensure it's installed and in your PATH.")
+            except FileNotFoundError as e:
+                if "Manim output video file" in str(e):
+                    logging.error(f"Manim rendering failed to produce expected output file for chapter {i + 1}: {e}")
+                    st.error(f"Manim rendering failed to produce video for chapter {i + 1}. Please check Manim installation and configuration.")
+                else:
+                    logging.error(f"Manim not found or output path issue: {e}")
+                    st.error("Manim not found. Please ensure it's installed and in your PATH, or check Manim's output configuration.")
                 return None
             except subprocess.TimeoutExpired:
-                logging.error(f"Manim process timed out for chapter {i + 1}. Attempting to fix...")
+                attempts += 1
+                logging.error(f"Manim process timed out for chapter {i + 1}. Attempt {attempts}. Attempting to fix...")
+                st.warning(f"Manim rendering timed out for chapter {i + 1}. Attempting to fix code...")
                 manim_code = fix_manim_code(f"Manim process timed out.", manim_code)
                 logging.debug(f"Fixed Manim code (Attempt {attempts}):\n{manim_code}")
 
@@ -187,8 +221,16 @@ async def generate_video(concept: str):
     final_video_path = None
     if video_files:
         logging.info("Combining video files...")
+        st.info("Combining all chapter videos...")
         try:
-            clips = [VideoFileClip(vf) for vf in video_files if os.path.exists(vf)]
+            clips = []
+            for vf in video_files:
+                if os.path.exists(vf):
+                    clips.append(VideoFileClip(vf))
+                else:
+                    logging.warning(f"Skipping non-existent video file: {vf}")
+                    st.warning(f"Skipping missing chapter video: {vf.split('/')[-1]}")
+
             if clips:
                 final_video_path = f"final_video.mp4"
                 final_clip = concatenate_videoclips(clips)
@@ -198,12 +240,13 @@ async def generate_video(concept: str):
                 st.success("Video generation complete!")
             else:
                 logging.warning("No valid video files to combine.")
-                st.warning("No valid video files were generated.")
+                st.warning("No valid video files were generated to combine.")
         except Exception as e:
             logging.error(f"Error combining video files: {e}")
             st.error(f"Error combining video files: {e}")
 
-        # Clean up intermediate video files
+        # Clean up intermediate video files and the temporary Manim output directory if it's no longer needed
+        temp_manim_output_dir = "./media/videos/temp/480p15/"
         for video_file in video_files:
             try:
                 if os.path.exists(video_file):
@@ -211,9 +254,16 @@ async def generate_video(concept: str):
                     logging.info(f"Deleted intermediate video file: {video_file}")
             except Exception as e:
                 logging.error(f"Error deleting intermediate video file {video_file}: {e}")
+        # Optionally, remove the entire temp Manim output directory if it's empty
+        try:
+            if os.path.exists(temp_manim_output_dir) and not os.listdir(temp_manim_output_dir):
+                os.rmdir(temp_manim_output_dir)
+                logging.info(f"Deleted empty Manim temp output directory: {temp_manim_output_dir}")
+        except Exception as e:
+            logging.error(f"Error deleting empty Manim temp output directory {temp_manim_output_dir}: {e}")
     else:
         logging.warning("No video files to combine.")
-        st.warning("No video files were generated.")
+        st.info("No video files were successfully generated.")
 
     return final_video_path
 
@@ -227,8 +277,16 @@ def main():
                 final_video_file = asyncio.run(generate_video(concept))
             if final_video_file and os.path.exists(final_video_file):
                 st.video(final_video_file)
+                # Provide a download button for the video
+                with open(final_video_file, "rb") as file:
+                    st.download_button(
+                        label="Download Video",
+                        data=file,
+                        file_name=os.path.basename(final_video_file),
+                        mime="video/mp4"
+                    )
             elif final_video_file:
-                st.error("Error: Final video file not found.")
+                st.error("Error: Final video file not found after generation.")
             else:
                 st.info("Video generation process completed without creating a final video.")
         else: