Update app.py

app.py

@@ -7,7 +7,6 @@ import shutil
 import time
 from threading import Timer
 import uuid
-import sys
 
 app = Flask(__name__)
 
@@ -33,8 +32,6 @@ def index():
         last_error = None
         while attempt < max_retries:
             try:
-                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.
@@ -48,32 +45,22 @@ You got this!! <3
 """
                 )
                 
-                # 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)
-                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)
-                if scene_match:
-                    scene_name = scene_match.group(1)
-                else:
-                    scene_name = "MyScene"
+                scene_name = scene_match.group(1) if scene_match else "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"
                 
-                # Write the generated code file directly to /tmp
                 code_filepath = os.path.join("/tmp", code_filename)
                 with open(code_filepath, "w") as f:
                     f.write(code)
                 
-                # Prepare the Manim command with --media_dir flag
                 cmd = [
                     "manim",
                     "-qm",
@@ -82,40 +69,25 @@ You got this!! <3
                     code_filepath,
                     scene_name
                 ]
-                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()
+                subprocess.run(cmd, check=True, capture_output=True, text=True)
                 
-                # 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, output should be in:
-                # {media_dir}/videos/<code_filename_without_.py>/720p30/<video_filename>
                 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(f"Manim did not produce the expected output file at {video_path_in_media}")
                 
-                # Move the video file to /tmp (it will be served from here)
                 tmp_video_path = os.path.join("/tmp", video_filename)
                 shutil.move(video_path_in_media, tmp_video_path)
-                # The code file is already in /tmp (at code_filepath)
                 
-                # Schedule deletion of both files after 10 minutes (600 seconds)
+                # The code file is already at code_filepath in /tmp.
+                tmp_code_path = code_filepath
+                
                 def remove_files():
                     try:
                         if os.path.exists(tmp_video_path):
                             os.remove(tmp_video_path)
-                        if os.path.exists(code_filepath):
-                            os.remove(code_filepath)
-                        print("Removed files:", tmp_video_path, code_filepath)
-                        sys.stdout.flush()
+                        if os.path.exists(tmp_code_path):
+                            os.remove(tmp_code_path)
                     except Exception as e:
                         app.logger.error("Error removing files: %s", e)
                 Timer(600, remove_files).start()
@@ -124,20 +96,17 @@ You got this!! <3
                 return render_template("result.html", video_url=video_url)
             
             except Exception as e:
-                print(f"Attempt {attempt + 1} failed: {type(e).__name__}: {e}")
-                sys.stdout.flush()
                 last_error = e
                 attempt += 1
                 time.sleep(1)
         
-        return render_template("result.html", error=f"Error: {last_error}")
+        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):
-    # 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=True)
+    app.run(host="0.0.0.0", port=7860, debug=False)