Update app.py

app.py

@@ -21,8 +21,49 @@ 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
+
 def create_manim_script(problem_data, script_path):
-    """Generate Manim script from problem data"""
+    """Generate Manim script from problem data with robust wrapping for title, text, and equations."""
+
+    # Defaults
     settings = problem_data.get("video_settings", {
         "background_color": "#0f0f23",
         "text_color": "WHITE",
@@ -30,21 +71,25 @@ def create_manim_script(problem_data, script_path):
         "font": "CMU Serif",
         "text_size": 36,
         "equation_size": 42,
-        "title_size": 48
+        "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
         self.camera.background_color = "{settings.get('background_color', '#0f0f23')}"
         default_color = {settings.get('text_color', 'WHITE')}
         highlight_color = {settings.get('highlight_color', 'YELLOW')}
@@ -52,14 +97,38 @@ class GeneratedMathScene(Scene):
         text_size = {settings.get('text_size', 36)}
         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 = []
+            words = content.split()
+            current = ""
+            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 <= wrap_width * 0.9:  # a bit of padding
+                    current = test
+                else:
+                    lines.append(Text(current, color=color, font=font, font_size=font_size))
+                    current = w
+            if current:
+                lines.append(Text(current, color=color, font=font, font_size=font_size))
+            if not lines:
+                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
-        screen_bottom = -3.5
-        
+
         slides = {slides_repr}
         
+        # Build each slide
         for idx, slide in enumerate(slides):
             obj = None
             content = slide.get("content", "")
@@ -68,9 +137,20 @@ class GeneratedMathScene(Scene):
             slide_type = slide.get("type", "text")
             
             if slide_type == "title":
-                obj = Text(content, color=highlight_color, font=default_font, font_size=title_size)
-                if obj.width > 12:
-                    obj.set_width(12)
+                # Wrap title text
+                title_text = content
+                # Use paragraph wrapping to keep multi-line titles readable
+                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)
@@ -78,27 +158,37 @@ class GeneratedMathScene(Scene):
                 continue
             
             elif slide_type == "text":
-                # Wrap long text to multiple lines automatically
-                if len(content) > 50:
-                    lines = textwrap.wrap(content, width=50)
-                    wrapped_content = "\
-".join(lines)
-                    obj = Text(wrapped_content, color=default_color, font=default_font, font_size=text_size, line_spacing=1)
-                else:
-                    obj = Text(content, color=default_color, font=default_font, font_size=text_size)
+                # Use wrapping for normal text
+                obj = make_wrapped_paragraph(content, default_color, default_font, text_size, line_spacing=0.25)
             
             elif slide_type == "equation":
-                obj = MathTex(content, color=default_color, font_size=equation_size)
-                if obj.width > 12:
-                    obj.scale(12 / obj.width)
+                # Wrap long equations by splitting content into lines if needed
+                # Heuristic: if content is too wide, create a multi-line TeX using \\ line breaks
+                eq_content = content
+                # Optional: insert line breaks at common math breakpoints if needed
+                test = MathTex(eq_content, color=default_color, font_size=equation_size)
+                if test.width > wrap_width:
+                    # naive wrap: insert line breaks at spaces near the middle
+                    parts = eq_content.split(" ")
+                    mid = len(parts)//2
+                    line1 = " ".join(parts[:mid])
+                    line2 = " ".join(parts[mid:])
+                    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 < screen_bottom:
-                    scroll_amount = abs(obj_bottom - screen_bottom) + 0.3
+                if obj_bottom < -3.5:
+                    scroll_amount = abs(obj_bottom - (-3.5)) + 0.3
                     self.play(content_group.animate.shift(UP * scroll_amount), run_time=0.5)
                     current_y += scroll_amount
                     obj.shift(UP * scroll_amount)
@@ -114,15 +204,16 @@ class GeneratedMathScene(Scene):
                     self.play(Write(obj), run_time=duration)
                 
                 content_group.add(obj)
-                current_y -= (obj.height + line_spacing)
+                # 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)