Update app.py

app.py

@@ -2,7 +2,7 @@ import asyncio
 import os
 import shutil
 import subprocess
-import tempfile # Import the tempfile module
+import tempfile
 from typing import List
 import logging
 
@@ -95,26 +95,87 @@ 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."""
-    # 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
+    temp_dir = None
+    temp_file_name = None
+    video_file_path = None
 
-    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=120)  # Increased timeout for potentially longer renders
+        # Create a temporary directory for Manim's output
+        temp_dir = tempfile.mkdtemp()
+        logging.info(f"Created temporary directory for Manim output: {temp_dir}")
+
+        # Use tempfile to create a temporary Python file within the temporary directory
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, dir=temp_dir) as temp_file:
+            temp_file.write(code)
+            temp_file_name = temp_file.name
+        logging.info(f"Created temporary Manim script: {temp_file_name}")
+
+        process = None
+        # Manim command needs to specify the output directory
+        # The -o flag followed by a filename will output the video to that specific path relative to the current working directory,
+        # or an absolute path if provided.
+        # Alternatively, we can use -o with just the class name and specify the output directory using --output_directory
+        # For simplicity, we'll try to explicitly specify the output path if the Manim version supports it,
+        # or we'll ensure the manim command is executed from within the temporary directory.
+
+        # We need to extract the class name to get Manim's default filename
+        match = re.search(r"class\s+(\w+)\(Scene\):", code)
+        if not match:
+            raise ValueError(f"Could not extract class name from Manim code for chapter {chapter_number}")
+        class_name = match.group(1)
+        expected_output_filename = f"{class_name}.mp4"
+
+        # Construct the command. We will run manim from the temporary directory.
+        # Manim by default creates media/videos/<resolution>/<filename>.mp4
+        # We want it in our temp_dir. The easiest way is to change the CWD.
+        # So the manim command becomes `manim <script_name> -ql --media_dir <temp_dir>`
+        # This will put the videos inside <temp_dir>/videos/<resolution>/
+        command = [
+            "manim",
+            os.path.basename(temp_file_name), # Just the filename, as we're changing CWD
+            "-ql",
+            "--disable_caching",
+            "--media_dir", # Specify the media directory directly
+            temp_dir
+        ]
+        logging.info(f"Executing Manim command in '{temp_dir}': {' '.join(command)}")
+
+        # Execute Manim from within the temporary directory
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=temp_dir, # Crucial: set the current working directory for the subprocess
+            shell=True,
+            text=True
+        )
+        stdout, stderr = process.communicate(timeout=120)
 
         if process.returncode == 0:
             logging.info(f"Manim execution successful for chapter {chapter_number}.")
             logging.debug(f"Manim stdout:\n{stdout}")
             logging.debug(f"Manim stderr:\n{stderr}")
+            # Manim 0.16.0+ changed output paths slightly.
+            # It usually creates a structure like <media_dir>/videos/<quality>/<scene_name>.mp4
+            # We explicitly set media_dir to temp_dir, so the video should be in:
+            # temp_dir/videos/temp/480p15/<class_name>.mp4
+            # Or if --output_file is used, it directly goes to temp_dir/<filename>.
+            # With --media_dir, it will stick to its internal folder structure.
+            manim_rendered_video_subdir = "videos/temp/480p15" # This is Manim's internal structure
+            video_file_path_in_temp = os.path.join(temp_dir, manim_rendered_video_subdir, expected_output_filename)
+
+            if not os.path.exists(video_file_path_in_temp):
+                logging.error(f"Manim output file not found at expected path: {video_file_path_in_temp}")
+                # As a fallback, try to find it directly in temp_dir if Manim changed its behavior or a custom flag was added
+                fallback_path = os.path.join(temp_dir, expected_output_filename)
+                if os.path.exists(fallback_path):
+                    logging.info(f"Found video at fallback path: {fallback_path}")
+                    video_file_path = fallback_path
+                else:
+                    raise FileNotFoundError(f"Manim output video file '{expected_output_filename}' not found at '{video_file_path_in_temp}' or '{fallback_path}' after successful execution. Check Manim's output configuration.")
+            else:
+                video_file_path = video_file_path_in_temp
+
         else:
             error_msg = f"Manim execution failed for chapter {chapter_number} with return code {process.returncode}:\nStdout:\n{stdout}\nStderr:\n{stderr}"
             logging.error(str(error_msg).split('\n')[-1])
@@ -128,41 +189,32 @@ def create_video_from_code(code: str, chapter_number: int) -> str:
     except FileNotFoundError:
         logging.error("Error: The 'manim' command was not found. Ensure Manim is installed and in your system's PATH.")
         raise
+    except Exception as e:
+        logging.error(f"An unexpected error occurred during video creation: {e}")
+        raise
     finally:
         # Ensure the temporary file is deleted after Manim tries to use it
-        if os.path.exists(temp_file_name):
+        if temp_file_name and os.path.exists(temp_file_name):
             os.remove(temp_file_name)
             logging.info(f"Deleted temporary Manim script: {temp_file_name}")
+        # Clean up the entire temporary directory created for Manim output
+        # It's important to do this AFTER the video file has been moved or processed
+        if temp_dir and os.path.exists(temp_dir):
+            try:
+                # Need to wait until the video is processed/moved by the calling function.
+                # For now, let's assume the video_file_path returned will be copied.
+                # If we don't copy, we need to defer this cleanup.
+                # Since the final combination happens in `generate_video`,
+                # it's better to clean up the `temp_dir` there after all clips are loaded.
+                # For now, we'll only clean up the script itself.
+                pass # Shifting temp_dir cleanup to generate_video for safer handling
+            except Exception as e:
+                logging.error(f"Error cleaning up temporary directory {temp_dir}: {e}")
 
-    # Construct the video file name. Manim names the file based on the class name.
-    # 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"
-        # 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}")
+    # The video_file_path now points to a file within temp_dir.
+    # The calling function (generate_video) will need to load this using moviepy,
+    # and then we can clean up the temp_dir after all clips are loaded.
+    return video_file_path
 
 async def generate_video(concept: str):
     """Generates a video explanation for a given concept using Manim with error correction."""
@@ -170,7 +222,9 @@ async def generate_video(concept: str):
     outline = generate_video_outline(concept)
     logging.info(f"Video outline: {outline}")
 
-    video_files = []
+    video_files_paths = [] # Renamed for clarity, these are paths in temp dirs
+    temp_dirs_to_clean = [] # To keep track of temporary directories to delete
+
     for i, chapter in enumerate(outline.chapters):
         logging.info(f"Processing chapter {i + 1}: {chapter.title}")
         manim_code = generate_manim_code(chapter)
@@ -178,14 +232,24 @@ async def generate_video(concept: str):
 
         success = False
         attempts = 0
-        max_attempts = 2  # Try fixing the code once
+        max_attempts = 2
 
         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}")
+                # create_video_from_code will return the path within a temp dir
+                video_file_path_for_chapter = create_video_from_code(manim_code, i + 1)
+                video_files_paths.append(video_file_path_for_chapter)
+                # We need to extract the base temp directory for cleanup later
+                # It's usually the parent of 'videos/temp/480p15'
+                # Find the root temp directory path from video_file_path_for_chapter
+                # Example: /tmp/tmpxyz/videos/temp/480p15/MyScene.mp4 -> /tmp/tmpxyz
+                # This assumes temp_dir is directly below the media/videos structure
+                root_temp_dir = os.path.abspath(os.path.join(video_file_path_for_chapter, os.pardir, os.pardir, os.pardir))
+                if root_temp_dir not in temp_dirs_to_clean:
+                    temp_dirs_to_clean.append(root_temp_dir)
+
+                logging.info(f"Video file created for chapter {i + 1}: {video_file_path_for_chapter}")
                 success = True
             except subprocess.CalledProcessError as e:
                 attempts += 1
@@ -196,14 +260,10 @@ async def generate_video(concept: str):
             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
+                return None
             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.")
+                logging.error(f"Manim or output file not found for chapter {i + 1}: {e}")
+                st.error(f"Manim or its output file was not found for chapter {i + 1}: {e}. Please ensure Manim is installed and configured correctly.")
                 return None
             except subprocess.TimeoutExpired:
                 attempts += 1
@@ -211,6 +271,11 @@ async def generate_video(concept: str):
                 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}")
+            except Exception as e:
+                logging.error(f"An unexpected error occurred during chapter {i + 1} processing: {e}")
+                st.error(f"An unexpected error occurred for chapter {i + 1}: {e}")
+                return None
+
 
         if not success:
             logging.error(f"Failed to generate video for chapter {i + 1} after {max_attempts} attempts. Skipping chapter.")
@@ -219,17 +284,17 @@ async def generate_video(concept: str):
 
     # Combine the video files
     final_video_path = None
-    if video_files:
+    if video_files_paths:
         logging.info("Combining video files...")
         st.info("Combining all chapter videos...")
+        clips = []
         try:
-            clips = []
-            for vf in video_files:
-                if os.path.exists(vf):
-                    clips.append(VideoFileClip(vf))
+            for vf_path in video_files_paths:
+                if os.path.exists(vf_path):
+                    clips.append(VideoFileClip(vf_path))
                 else:
-                    logging.warning(f"Skipping non-existent video file: {vf}")
-                    st.warning(f"Skipping missing chapter video: {vf.split('/')[-1]}")
+                    logging.warning(f"Skipping non-existent video file for concatenation: {vf_path}")
+                    st.warning(f"Skipping missing chapter video for final combination: {vf_path.split('/')[-1]}")
 
             if clips:
                 final_video_path = f"final_video.mp4"
@@ -244,53 +309,18 @@ async def generate_video(concept: str):
         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 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):
-                    os.remove(video_file)
-                    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.info("No video files were successfully generated.")
-
-    return final_video_path
-
-def main():
-    st.title("Explanatory Video Generator")
-    concept = st.text_input("Enter the concept for the video:")
-
-    if st.button("Generate Video"):
-        if concept:
-            with st.spinner("Generating video... This might take a few minutes."):
-                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 after generation.")
-            else:
-                st.info("Video generation process completed without creating a final video.")
-        else:
-            st.warning("Please enter a concept.")
-
-if __name__ == "__main__":
-    main()
+        finally:
+            # Clean up all temporary directories after all clips are loaded and combined
+            for clip in clips: # Ensure all clips are closed
+                try:
+                    clip.close()
+                except Exception as close_e:
+                    logging.warning(f"Error closing clip: {close_e}")
+
+            for temp_dir_path in temp_dirs_to_clean:
+                try:
+                    if os.path.exists(temp_dir_path):
+                        shutil.rmtree(temp_dir_path) # Recursively remove the temporary directory
+                        logging.info(f"Deleted temporary directory: {temp_dir_path}")
+                except Exception as e:
+                    logging.error(f"Error deleting temporary directory {temp_dir_path}: {e}")