Update app.py

app.py

@@ -1,5 +1,5 @@
 from flask import Flask, request, jsonify, send_file
-from werkzeug.utils import secure_filename
+from flask_cors import CORS
 import os
 import subprocess
 import tempfile
@@ -9,6 +9,7 @@ import traceback
 import json
 
 app = Flask(__name__)
+CORS(app)  # Enable CORS for all routes
 
 # Configuration
 BASE_DIR = "/app"
@@ -17,10 +18,11 @@ TEMP_DIR = os.path.join(BASE_DIR, "temp")
 os.makedirs(MEDIA_DIR, exist_ok=True)
 os.makedirs(TEMP_DIR, exist_ok=True)
 
+# API Key for security (optional)
+API_KEY = "rkmentormindzofficaltokenkey12345"
+
 def create_manim_script(problem_data, script_path):
     """Generate Manim script from problem data"""
-    
-    # Default settings
     settings = problem_data.get("video_settings", {
         "background_color": "#0f0f23",
         "text_color": "WHITE",
@@ -36,7 +38,6 @@ def create_manim_script(problem_data, script_path):
     if not slides:
         raise ValueError("No slides provided in input data")
     
-    # Generate Manim script
     manim_code = f'''
 from manim import *
 
@@ -51,13 +52,11 @@ class GeneratedMathScene(Scene):
         equation_size = {settings.get('equation_size', 42)}
         title_size = {settings.get('title_size', 48)}
         
-        # Content group for scrolling
         content_group = VGroup()
         current_y = 3.0
         line_spacing = 0.8
         screen_bottom = -3.5
         
-        # Process slides
         slides = {json.dumps(slides)}
         
         for idx, slide in enumerate(slides):
@@ -67,7 +66,6 @@ class GeneratedMathScene(Scene):
             duration = slide.get("duration", 1.0)
             slide_type = slide.get("type", "text")
             
-            # Create title (centered)
             if slide_type == "title":
                 obj = Text(content, color=highlight_color, font=default_font, font_size=title_size)
                 obj.move_to(ORIGIN)
@@ -76,20 +74,16 @@ class GeneratedMathScene(Scene):
                 self.play(FadeOut(obj), run_time=duration * 0.3)
                 continue
             
-            # Create text
             elif slide_type == "text":
                 obj = Text(content, color=default_color, font=default_font, font_size=text_size)
             
-            # Create equation
             elif slide_type == "equation":
                 obj = MathTex(content, color=default_color, font_size=equation_size)
             
             if obj:
-                # Position at left edge
                 obj.to_edge(LEFT, buff=0.3)
                 obj.shift(UP * (current_y - obj.height/2))
                 
-                # Check if scrolling needed
                 obj_bottom = obj.get_bottom()[1]
                 if obj_bottom < screen_bottom:
                     scroll_amount = abs(obj_bottom - screen_bottom) + 0.3
@@ -97,7 +91,6 @@ class GeneratedMathScene(Scene):
                     current_y += scroll_amount
                     obj.shift(UP * scroll_amount)
                 
-                # Animations
                 if animation == "write_left":
                     self.play(Write(obj), run_time=duration)
                 elif animation == "fade_in":
@@ -112,7 +105,6 @@ class GeneratedMathScene(Scene):
                 current_y -= (obj.height + line_spacing)
                 self.wait(0.3)
         
-        # Highlight final answer
         if len(content_group) > 0:
             final_box = SurroundingRectangle(content_group[-1], color=highlight_color, buff=0.2)
             self.play(Create(final_box), run_time=0.8)
@@ -122,72 +114,33 @@ class GeneratedMathScene(Scene):
     with open(script_path, 'w') as f:
         f.write(manim_code)
 
-@app.route('/', methods=['GET'])
+@app.route("/")
 def home():
-    """Health check endpoint"""
-    return jsonify({
-        "status": "running",
-        "message": "Manim Video Generation API",
-        "endpoints": {
-            "/generate": "POST - Generate video from JSON",
-            "/health": "GET - Health check"
-        }
-    })
+    return "Flask Manim Video Generator is Running"
 
-@app.route('/health', methods=['GET'])
-def health():
-    """Health check"""
-    return jsonify({"status": "healthy"})
-
-@app.route('/generate', methods=['POST'])
+@app.route("/generate", methods=["POST", "OPTIONS"])
 def generate_video():
-    """
-    Generate Manim video from JSON input
+    # Handle preflight
+    if request.method == "OPTIONS":
+        return '', 204
     
-    Expected JSON format:
-    {
-        "video_settings": {
-            "background_color": "#0f0f23",
-            "text_color": "WHITE",
-            "highlight_color": "YELLOW",
-            "font": "CMU Serif",
-            "text_size": 36,
-            "equation_size": 42,
-            "title_size": 48
-        },
-        "slides": [
-            {
-                "type": "title",
-                "content": "Your Title",
-                "animation": "fade_in",
-                "duration": 1.0
-            },
-            {
-                "type": "text",
-                "content": "Your text content",
-                "animation": "write_left",
-                "duration": 0.8
-            },
-            {
-                "type": "equation",
-                "content": "x = \\\\frac{-b \\\\pm \\\\sqrt{b^2 - 4ac}}{2a}",
-                "animation": "write_left",
-                "duration": 1.2
-            }
-        ]
-    }
-    """
     try:
+        # Optional: Check API key
+        api_key = request.headers.get('X-API-KEY')
+        if api_key and api_key != API_KEY:
+            return jsonify({"error": "Invalid API key"}), 401
+        
         # Get JSON data
-        if not request.json:
+        data = request.get_json()
+        if not data:
             return jsonify({"error": "No JSON data provided"}), 400
         
-        problem_data = request.json
-        
         # Validate input
-        if "slides" not in problem_data or not problem_data["slides"]:
+        if "slides" not in data or not data["slides"]:
             return jsonify({"error": "No slides provided in request"}), 400
         
+        print(f"Received request with {len(data['slides'])} slides")
+        
         # Create unique temporary directory
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         temp_work_dir = os.path.join(TEMP_DIR, f"manim_{timestamp}")
@@ -195,9 +148,10 @@ def generate_video():
         
         # Generate Manim script
         script_path = os.path.join(temp_work_dir, "scene.py")
-        create_manim_script(problem_data, script_path)
+        create_manim_script(data, script_path)
+        print(f"Created Manim script at {script_path}")
         
-        # Render video
+        # Render video using subprocess
         quality = request.args.get('quality', 'l')  # l=low, m=medium, h=high
         render_command = [
             "manim",
@@ -208,6 +162,8 @@ def generate_video():
             "GeneratedMathScene"
         ]
         
+        print(f"Running command: {' '.join(render_command)}")
+        
         result = subprocess.run(
             render_command,
             capture_output=True,
@@ -218,11 +174,14 @@ def generate_video():
         
         if result.returncode != 0:
             error_msg = result.stderr or result.stdout
+            print(f"Manim rendering failed: {error_msg}")
             return jsonify({
                 "error": "Manim rendering failed",
                 "details": error_msg
             }), 500
         
+        print("Manim rendering completed successfully")
+        
         # Find generated video
         quality_map = {'l': '480p15', 'm': '720p30', 'h': '1080p60'}
         video_quality = quality_map.get(quality, '480p15')
@@ -236,39 +195,46 @@ def generate_video():
         )
         
         if not os.path.exists(video_path):
+            print(f"Video not found at expected path: {video_path}")
             return jsonify({
                 "error": "Video file not found after rendering",
                 "expected_path": video_path
             }), 500
         
-        # Copy to media directory for serving
+        print(f"Video found at: {video_path}")
+        
+        # Copy to media directory
         output_filename = f"math_video_{timestamp}.mp4"
         output_path = os.path.join(MEDIA_DIR, output_filename)
         shutil.copy(video_path, output_path)
+        print(f"Video copied to: {output_path}")
         
         # Clean up temp directory
         try:
             shutil.rmtree(temp_work_dir)
-        except:
-            pass
+            print("Cleaned up temp directory")
+        except Exception as e:
+            print(f"Failed to clean temp dir: {e}")
         
-        # Return video file
+        # Return video file as blob
         return send_file(
             output_path,
             mimetype='video/mp4',
-            as_attachment=True,
+            as_attachment=False,
             download_name=output_filename
         )
         
     except subprocess.TimeoutExpired:
+        print("Video rendering timeout")
         return jsonify({"error": "Video rendering timeout (120s)"}), 504
     except Exception as e:
+        print(f"Error: {str(e)}")
+        traceback.print_exc()
         return jsonify({
             "error": str(e),
             "traceback": traceback.format_exc()
         }), 500
 
 if __name__ == '__main__':
-    # Use gunicorn in production, Flask dev server for local testing
     port = int(os.environ.get('PORT', 7860))
     app.run(host='0.0.0.0', port=port, debug=False)