Update app.py

app.py

@@ -7,6 +7,7 @@ import shutil
 import time
 from threading import Timer
 import uuid
+import sys
 
 app = Flask(__name__)
 
@@ -16,6 +17,10 @@ if not API_KEY:
     raise ValueError("Missing GOOGLE_API_KEY environment variable.")
 client = genai.Client(api_key=API_KEY)
 
+# Define a dedicated media directory in /tmp
+media_dir = os.path.join("/tmp", "manim_media")
+os.makedirs(media_dir, exist_ok=True)
+
 @app.route("/", methods=["GET", "POST"])
 def index():
     if request.method == "POST":
@@ -25,9 +30,11 @@ def index():
         
         max_retries = 3
         attempt = 0
+        last_error = None
         while attempt < max_retries:
             try:
-                # Call the GenAI API to get the Manim code
+                print("Calling GenAI API...")
+                sys.stdout.flush()
                 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.
@@ -47,6 +54,8 @@ You got this!! <3
                 if not match:
                     raise Exception("No python code block found in the AI response.")
                 code = match.group(1)
+                print("Extracted code (first 200 chars):", code[:200])
+                sys.stdout.flush()
                 
                 # Determine the scene class name from the generated code
                 scene_match = re.search(r"class\s+(\w+)\(.*Scene.*\):", code)
@@ -63,11 +72,7 @@ You got this!! <3
                 with open(code_filename, "w") as f:
                     f.write(code)
                 
-                # Set a dedicated media directory for Manim output in /tmp
-                media_dir = os.path.join("/tmp", "manim_media")
-                os.makedirs(media_dir, exist_ok=True)
-                
-                # Prepare the Manim command with the --media_dir flag
+                # Prepare the Manim command with --media_dir flag
                 cmd = [
                     "manim",
                     "-qm",
@@ -76,29 +81,27 @@ You got this!! <3
                     code_filename,
                     scene_name
                 ]
-                # Run Manim to generate the video, capturing its output
+                print("Running Manim command:", " ".join(cmd))
+                sys.stdout.flush()
                 result = subprocess.run(cmd, check=True, capture_output=True, text=True)
                 print("Manim stdout:", result.stdout)
                 print("Manim stderr:", result.stderr)
+                sys.stdout.flush()
+                
+                # Debug: list the media directory structure
+                for root, dirs, files in os.walk(media_dir):
+                    print(root, dirs, files)
+                sys.stdout.flush()
                 
                 # Construct the expected output path from Manim.
-                # With --media_dir set, Manim should write the video to:
-                # {media_dir}/videos/<code_filename_without_.py>/720p30/<video_filename>
-                video_path_in_media = os.path.join(
-                    media_dir,
-                    "videos",
-                    code_filename.replace(".py", ""),
-                    "720p30",
-                    video_filename
-                )
-                # Verify that Manim produced the expected video file
+                expected_dir = os.path.join(media_dir, "videos", code_filename.replace(".py", ""), "720p30")
+                video_path_in_media = os.path.join(expected_dir, video_filename)
                 if not os.path.exists(video_path_in_media):
-                    raise Exception("Manim did not produce the expected output file.")
+                    raise Exception(f"Manim did not produce the expected output file at {video_path_in_media}")
                 
-                # Move both the video and the generated code file to /tmp (a writable location)
+                # Move both the video and the generated code file to /tmp
                 tmp_video_path = os.path.join("/tmp", video_filename)
                 shutil.move(video_path_in_media, tmp_video_path)
-                
                 tmp_code_path = os.path.join("/tmp", code_filename)
                 shutil.move(code_filename, tmp_code_path)
                 
@@ -110,27 +113,27 @@ You got this!! <3
                         if os.path.exists(tmp_code_path):
                             os.remove(tmp_code_path)
                         print("Removed files:", tmp_video_path, tmp_code_path)
+                        sys.stdout.flush()
                     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(f"Attempt {attempt + 1} failed: {e}")
+                print(f"Attempt {attempt + 1} failed: {type(e).__name__}: {e}")
+                sys.stdout.flush()
+                last_error = e
                 attempt += 1
-                time.sleep(1)  # Wait a bit before retrying
+                time.sleep(1)
         
-        # 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("result.html", error=f"Error: {last_error}")
             
     return render_template("index.html")
 
 @app.route("/video/<filename>")
 def get_video(filename):
-    # Serve the video file from /tmp
     return send_from_directory("/tmp", filename)
 
 if __name__ == "__main__":