Update app.py

app.py

@@ -21,9 +21,48 @@ os.makedirs(TEMP_DIR, exist_ok=True)
 # API Key for security (optional)
 API_KEY = "rkmentormindzofficaltokenkey12345"
 
+import textwrap
+from manim import *
+
+def make_wrapped_paragraph(content, max_width, color, font, font_size, line_spacing, align_left=True):
+    """
+    Build a vertically stacked group of Text lines that together form a paragraph.
+    It splits content into lines that fit within max_width by measuring rendered width.
+    Each line is a separate Text object joined into a VGroup and arranged downward.
+    """
+    words = content.split()
+    lines = []
+    current = ""
+
+    # Create a temporary Text to measure width; use the same font/size as final lines
+    temp = Text("", color=color, font=font, font_size=font_size)
+
+    for w in words:
+        test = w if not current else current + " " + w
+        test_obj = Text(test, color=color, font=font, font_size=font_size)
+        if test_obj.width <= max_width:
+            current = test
+        else:
+            # flush the current line
+            line = Text(current, color=color, font=font, font_size=font_size)
+            lines.append(line)
+            current = w
+    if current:
+        lines.append(Text(current, color=color, font=font, font_size=font_size))
+
+    if not lines:
+        return VGroup()
+
+    para = VGroup(*lines)
+    # Space lines vertically; arrange them as a column
+    para.arrange(DOWN, buff=line_spacing)
+    if align_left:
+        para = para.align_to(LEFT)
+    return para.strip()
 
 def create_manim_script(problem_data, script_path):
     """Generate Manim script from problem data with robust wrapping for title, text, and equations."""
+
     # Defaults
     settings = problem_data.get("video_settings", {
         "background_color": "#0f0f23",
@@ -35,14 +74,19 @@ def create_manim_script(problem_data, script_path):
         "title_size": 48,
         "wrap_width": 12.0  # in scene width units; adjust to taste
     })
+
     slides = problem_data.get("slides", [])
     if not slides:
         raise ValueError("No slides provided in input data")
+
     slides_repr = repr(slides)
+
     # Use a dedicated wrap width in scene units; you can adapt how max_width is computed
     wrap_width = float(settings.get("wrap_width", 12.0))
+
     manim_code = f'''
 from manim import *
+import textwrap
 class GeneratedMathScene(Scene):
     def construct(self):
         # Scene settings
@@ -54,6 +98,7 @@ class GeneratedMathScene(Scene):
         equation_size = {settings.get('equation_size', 42)}
         title_size = {settings.get('title_size', 48)}
         wrap_width = {wrap_width}
+        
         # Helper to wrap text into lines that fit within max width
         def make_wrapped_paragraph(content, color, font, font_size, line_spacing=0.2):
             lines = []
@@ -73,10 +118,13 @@ class GeneratedMathScene(Scene):
                 return VGroup()
             para = VGroup(*lines).arrange(DOWN, buff=line_spacing)
             return para
+        class GeneratedMathSceneInner(Scene):
+            pass
         content_group = VGroup()
         current_y = 3.0
         line_spacing = 0.8
         slides = {slides_repr}
+        
         # Build each slide
         for idx, slide in enumerate(slides):
             obj = None
@@ -84,22 +132,32 @@ class GeneratedMathScene(Scene):
             animation = slide.get("animation", "write_left")
             duration = slide.get("duration", 1.0)
             slide_type = slide.get("type", "text")
+            
             if slide_type == "title":
                 # Wrap title text
                 title_text = content
                 # Use paragraph wrapping to keep multi-line titles readable
-                lines_group = make_wrapped_paragraph(title_text, highlight_color, default_font, title_size, line_spacing=0.2)
-                obj = lines_group if len(lines_group) > 0 else Text(title_text, color=highlight_color, font=default_font, font_size=title_size)
+                lines = []
+                if title_text:
+                    lines = []
+                    # Reuse make_wrapped_paragraph by simulating a single paragraph
+                    lines_group = make_wrapped_paragraph(title_text, highlight_color, default_font, title_size, line_spacing=0.2)
+                    obj = lines_group if len(lines_group) > 0 else Text(title_text, color=highlight_color, font=default_font, font_size=title_size)
+                else:
+                    obj = Text("", color=highlight_color, font=default_font, font_size=title_size)
                 if obj.width > wrap_width:
                     obj.scale_to_fit_width(wrap_width)
+                
                 obj.move_to(ORIGIN)
                 self.play(FadeIn(obj), run_time=duration * 0.8)
                 self.wait(duration * 0.3)
                 self.play(FadeOut(obj), run_time=duration * 0.3)
                 continue
+            
             elif slide_type == "text":
                 # Use wrapping for normal text
                 obj = make_wrapped_paragraph(content, default_color, default_font, text_size, line_spacing=0.25)
+            
             elif slide_type == "equation":
                 # Wrap long equations by splitting content into lines if needed
                 # Heuristic: if content is too wide, create a multi-line TeX using \\ line breaks
@@ -112,16 +170,19 @@ class GeneratedMathScene(Scene):
                     mid = len(parts)//2
                     line1 = " ".join(parts[:mid])
                     line2 = " ".join(parts[mid:])
-                    wrapped_eq = f"{{line1}} \\\\ {{line2}}"
+                    wrapped_eq = f"{{line1}} \\\\\\\\ {{line2}}"
                     obj = MathTex(wrapped_eq, color=default_color, font_size=equation_size)
                 else:
                     obj = MathTex(eq_content, color=default_color, font_size=equation_size)
+                
                 if obj.width > wrap_width:
                     obj.scale_to_fit_width(wrap_width)
+            
             if obj:
                 # Position and animate
                 obj.to_edge(LEFT, buff=0.3)
                 obj.shift(UP * (current_y - obj.height/2))
+                
                 obj_bottom = obj.get_bottom()[1]
                 if obj_bottom < -3.5:
                     scroll_amount = abs(obj_bottom - (-3.5)) + 0.3
@@ -129,6 +190,7 @@ class GeneratedMathScene(Scene):
                     current_y += scroll_amount
                     obj.shift(UP * scroll_amount)
                     obj.to_edge(LEFT, buff=0.3)
+                
                 if animation == "write_left":
                     self.play(Write(obj), run_time=duration)
                 elif animation == "fade_in":
@@ -138,41 +200,49 @@ class GeneratedMathScene(Scene):
                     self.play(obj.animate.set_color(highlight_color), run_time=duration * 0.4)
                 else:
                     self.play(Write(obj), run_time=duration)
+                
                 content_group.add(obj)
                 # Decrease y for next item
                 current_y -= (getattr(obj, "height", 0) + line_spacing)
                 self.wait(0.3)
+        
         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)
             self.wait(1.5)
     '''
+
     with open(script_path, 'w', encoding='utf-8') as f:
         f.write(manim_code)
+    
     print(f"Generated script preview (first 500 chars):{manim_code[:500]}...")
 
-
 @app.route("/")
 def home():
     return "Flask Manim Video Generator is Running"
 
-
 @app.route("/generate", methods=["POST", "OPTIONS"])
 def generate_video():
     # Handle preflight
     if request.method == "OPTIONS":
         return '', 204
+    
     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
+
+
         # Try reading raw body text
         raw_body = request.data.decode("utf-8").strip()
         data = None
+        
         if not raw_body:
             return jsonify({"error": "No input data provided"}), 400
+        
         # Try to detect if input is JSON or plain string
         if raw_body.startswith("{") or raw_body.startswith("["):
             # Likely JSON, try parsing
@@ -182,12 +252,15 @@ def generate_video():
             except json.JSONDecodeError:
                 # Not valid JSON, fallback to manual parse
                 data = None
+        
         if data is None:
             print("⚙️ Detected raw string input (non-JSON). Parsing manually...")
+        
             # Handle format like: [ [...], [...]] &&& Tamil explanation
             parts = raw_body.split("&&&")
             slides_part = parts[0].strip()
             extra_info = parts[1].strip() if len(parts) > 1 else ""
+        
             try:
                 slides = json.loads(slides_part)
             except json.JSONDecodeError as e:
@@ -196,22 +269,22 @@ def generate_video():
                     "details": str(e),
                     "raw_snippet": slides_part[:200]
                 }), 400
-            # Convert list of lists → list of dicts with defaults for missing fields
+        
+            # Convert list of lists → list of dicts
             slides_json = []
             for s in slides:
-                slide_type = s[0] if len(s) > 0 else "text"
-                content = s[1] if len(s) > 1 else (s[0] if len(s) > 0 else "")
-                animation = s[2] if len(s) > 2 else "write_left"
-                duration = s[3] if len(s) > 3 else 2.0
-                slides_json.append({
-                    "type": slide_type,
-                    "content": content,
-                    "animation": animation,
-                    "duration": duration
-                })
+                if len(s) >= 4:
+                    slide_type, content, animation, duration = s
+                    slides_json.append({
+                        "type": slide_type,
+                        "content": content,
+                        "animation": animation,
+                        "duration": duration
+                    })
+        
             data = {
                 "slides": slides_json,
-                "language": extra_info if extra_info else "English",
+                "language": "Tamil" if "Tamil" in extra_info else "English",
                 "explanation": extra_info,
                 "video_settings": {
                     "background_color": "#0f0f23",
@@ -220,19 +293,29 @@ def generate_video():
                     "font": "CMU Serif"
                 }
             }
-        # Final validation
+        
+        # ✅ Final validation
         if "slides" not in data or not data["slides"]:
             return jsonify({"error": "No slides provided in request"}), 400
+        
         print(f"✅ Parsed {len(data['slides'])} slides successfully.")
+        
+        # Validate input
+        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}")
         os.makedirs(temp_work_dir, exist_ok=True)
+        
         # Generate Manim script
         script_path = os.path.join(temp_work_dir, "scene.py")
         create_manim_script(data, script_path)
         print(f"Created Manim script at {script_path}")
+        
         # Render video using subprocess
         quality = request.args.get('quality', 'l')  # l=low, m=medium, h=high
         render_command = [
@@ -243,7 +326,9 @@ def generate_video():
             script_path,
             "GeneratedMathScene"
         ]
+        
         print(f"Running command: {' '.join(render_command)}")
+        
         result = subprocess.run(
             render_command,
             capture_output=True,
@@ -251,6 +336,7 @@ def generate_video():
             cwd=temp_work_dir,
             timeout=120
         )
+        
         if result.returncode != 0:
             error_msg = result.stderr or result.stdout
             print(f"Manim rendering failed: {error_msg}")
@@ -258,10 +344,13 @@ def generate_video():
                 "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')
+        
         video_path = os.path.join(
             temp_work_dir,
             "videos",
@@ -269,24 +358,29 @@ def generate_video():
             video_quality,
             "GeneratedMathScene.mp4"
         )
+        
         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
+        
         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)
             print("Cleaned up temp directory")
         except Exception as e:
             print(f"Failed to clean temp dir: {e}")
+        
         # Return video file as blob
         return send_file(
             output_path,
@@ -294,6 +388,7 @@ def generate_video():
             as_attachment=False,
             download_name=output_filename
         )
+        
     except subprocess.TimeoutExpired:
         print("Video rendering timeout")
         return jsonify({"error": "Video rendering timeout (120s)"}), 504
@@ -305,7 +400,6 @@ def generate_video():
             "traceback": traceback.format_exc()
         }), 500
 
-
 if __name__ == '__main__':
     port = int(os.environ.get('PORT', 7860))
     app.run(host='0.0.0.0', port=port, debug=False)