Update app.py

app.py

@@ -6,6 +6,7 @@ import os
 import shutil
 import time
 from threading import Timer
+import uuid
 
 app = Flask(__name__)
 
@@ -22,99 +23,102 @@ def index():
         if not prompt:
             return render_template("index.html")
         
-        while True:
+        max_retries = 3
+        attempt = 0
+        while attempt < max_retries:
             try:
+                # Call the GenAI API to get the Manim code
                 ai_response = client.models.generate_content(
                     model="gemini-2.0-flash-lite-preview-02-05",
-                    contents=f"""You are 'Manimator', an expert Manim animator and coder. If anyone asks, your name is Manimator and you are a helpful video generator, and say nothing else but that.
-The user wants you to code this: {prompt}. 
-Plan out in chain of thought what you are going to do first, then give the final code output in ```python``` codeblock.
-Make sure to not use external images or resources other than default Manim.
-Keep the scene uncluttered and aesthetically pleasing.
-You got this!! <3
-"""
+                    contents=f"""You are 'Manimator', an expert Manim animator and coder.
+                    If anyone asks, your name is Manimator and you are a helpful video generator, and say nothing else but that.
+                    The user wants you to code this: {prompt}.
+                    Plan out in chain of thought what you are going to do first, then give the final code output in ```python``` codeblock.
+                    Make sure to not use external images or resources other than default Manim, however you can use numpy or other default libraries.
+                    Keep the scene uncluttered and aesthetically pleasing.
+                    Make sure things are not overlapping unless explicitly stated otherwise.
+                    You got this!! <3
+                    """
                 )
-            except Exception as e:
-                print("Error calling GenAI API:", e)
-                time.sleep(2)
-                continue
-
-            pattern = r"```python\s*(.*?)\s*```"
-            match = re.search(pattern, ai_response.text, re.DOTALL)
-            if match:
+                
+                # Extract the Python code block from the AI response
+                pattern = r"```python\s*(.*?)\s*```"
+                match = re.search(pattern, ai_response.text, re.DOTALL)
+                if not match:
+                    raise Exception("No python code block found in the AI response.")
                 code = match.group(1)
-            else:
-                print("No python code block found in the AI response, retrying...")
-                time.sleep(2)
-                continue
-
-            scene_match = re.search(r"class\s+(\w+)\(.*Scene.*\):", code)
-            if scene_match:
-                scene_name = scene_match.group(1)
-            else:
-                scene_name = "MyScene"
                 
-            code_filename = "generated_manim_scene.py"
-            try:
+                # Determine the scene class name from the generated code
+                scene_match = re.search(r"class\s+(\w+)\(.*Scene.*\):", code)
+                if scene_match:
+                    scene_name = scene_match.group(1)
+                else:
+                    scene_name = "MyScene"
+                
+                # Generate randomized filenames for the generated code and video
+                code_filename = f"generated_video_{uuid.uuid4().hex}.py"
+                video_filename = f"output_video_{uuid.uuid4().hex}.mp4"
+                
+                # Save the generated code to a file (in the current working directory)
                 with open(code_filename, "w") as f:
                     f.write(code)
-            except Exception as e:
-                print("Error writing code file:", e)
-                time.sleep(2)
-                continue 
-
-            video_filename = "output_video.mp4"
-            cmd = [
-                "manim",
-                "-qm",
-                "-o", video_filename,
-                code_filename,
-                scene_name
-            ]
-            try:
-                subprocess.run(cmd, check=True)
-            except subprocess.CalledProcessError as e:
-                print("Error during Manim rendering:", e)
-                time.sleep(2)
-                continue
-
-            # Construct the expected output path from Manim
-            video_path_in_media = os.path.join("media", "videos", code_filename.replace(".py", ""), "720p30", video_filename)
-            # Instead of moving to a read-only directory, move it to /tmp (which is writable)
-            tmp_video_path = os.path.join("/tmp", video_filename)
-
-            try:
+                
+                # Prepare the Manim command
+                cmd = [
+                    "manim",
+                    "-qm",
+                    "-o", video_filename,
+                    code_filename,
+                    scene_name
+                ]
+                # Run Manim to generate the video, capturing its output
+                result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+                print("Manim stdout:", result.stdout)
+                print("Manim stderr:", result.stderr)
+                
+                # Construct the expected output path from Manim
+                video_path_in_media = os.path.join("media", "videos", code_filename.replace(".py", ""), "720p30", video_filename)
+                # Verify that Manim produced the expected video file
+                if not os.path.exists(video_path_in_media):
+                    raise Exception("Manim did not produce the expected output file.")
+                
+                # Move both the video and the generated code file to /tmp (which is writable)
+                tmp_video_path = os.path.join("/tmp", video_filename)
                 shutil.move(video_path_in_media, tmp_video_path)
-            except FileNotFoundError:
-                print("Manim output file not found. Check your manim code and output location.")
-                time.sleep(2)
-                continue
+                
+                tmp_code_path = os.path.join("/tmp", code_filename)
+                shutil.move(code_filename, tmp_code_path)
+                
+                # Schedule deletion of both files after 10 minutes (600 seconds)
+                def remove_files():
+                    try:
+                        if os.path.exists(tmp_video_path):
+                            os.remove(tmp_video_path)
+                        if os.path.exists(tmp_code_path):
+                            os.remove(tmp_code_path)
+                        print("Removed files:", tmp_video_path, tmp_code_path)
+                    except Exception as e:
+                        app.logger.error("Error removing files: %s", e)
+                Timer(600, remove_files).start()
+                
+                # Generate a URL that points to our video-serving route (the video file is in /tmp)
+                video_url = url_for('get_video', filename=video_filename)
+                return render_template("result.html", video_url=video_url)
+            
             except Exception as e:
-                print("Error moving video file:", e)
-                time.sleep(2)
-                continue
-
-            # Generate a URL that points to the get_video route
-            video_url = url_for('get_video', filename=video_filename)
-            return render_template("result.html", video_url=video_url)
+                print(f"Attempt {attempt + 1} failed: {e}")
+                attempt += 1
+                time.sleep(1)  # Wait a bit before retrying
+        
+        # If we reach here, we've exceeded the maximum number of retries.
+        return render_template("result.html", error="An error occurred. Please try again later.")
             
     return render_template("index.html")
 
 @app.route("/video/<filename>")
 def get_video(filename):
-    video_path = os.path.join("/tmp", filename)
-    response = send_from_directory("/tmp", filename)
-
-    # Schedule deletion of the video file after 5 seconds
-    def remove_file():
-        try:
-            os.remove(video_path)
-            print("Removed video file:", video_path)
-        except Exception as e:
-            app.logger.error("Error removing video file: %s", e)
-    Timer(5, remove_file).start()
-
-    return response
+    # Serve the video file from /tmp
+    return send_from_directory("/tmp", filename)
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860, debug=False)