Update app.py

app.py

@@ -488,7 +488,7 @@ def audio_func(id: int, lines, lang: str) -> Tuple[Optional[float], Optional[str
         traceback.print_exc()
         return None, None
 def create_manim_script(problem_data, script_path, audio_path, audio_length):
-    """Generate Manim script with selective timing adjustment - only equations scale to audio."""
+    """Generate Manim script with proper wrapping and audio-video sync."""
 
     settings = problem_data.get("video_settings", {
         "background_color": "#0f0f23",
@@ -505,6 +505,15 @@ def create_manim_script(problem_data, script_path, audio_path, audio_length):
     if not slides:
         raise ValueError("No slides provided in input data")
 
+    # FIX #2: Calculate timing overhead for accurate audio-video sync
+    num_slides = len(slides)
+    num_titles = sum(1 for s in slides if s.get("type") == "title")
+    
+    overhead_time = (num_slides - num_titles) * 0.3  # wait after each content slide
+    overhead_time += num_titles * 0.4  # title animation overhead
+    overhead_time += 2.3  # final highlight + wait
+    overhead_time += (num_slides / 3) * 0.5  # estimated scroll overhead
+    
     # Calculate separate durations for different slide types
     equation_duration = 0.0
     text_title_duration = 0.0
@@ -513,15 +522,14 @@ def create_manim_script(problem_data, script_path, audio_path, audio_length):
         slide_duration = float(slide.get("duration", 1.0))
         if slide.get("type") == "equation":
             equation_duration += slide_duration
-        else:  # text or title
+        else:
             text_title_duration += slide_duration
 
-    # Calculate equation scale factor to fill remaining audio time
-    target_equation_time = audio_length - text_title_duration
+    # FIX #2: Subtract overhead from available time before calculating scale
+    available_time = audio_length - text_title_duration - overhead_time
 
-    if equation_duration > 0 and target_equation_time > 0:
-        equation_scale = target_equation_time / equation_duration
-        # Prevent extreme scaling (between 0.5x and 2.5x)
+    if equation_duration > 0 and available_time > 0:
+        equation_scale = available_time / equation_duration
         equation_scale = max(0.5, min(2.5, equation_scale))
     else:
         equation_scale = 1.0
@@ -539,7 +547,6 @@ def create_manim_script(problem_data, script_path, audio_path, audio_length):
     title_size = settings.get("title_size", 48)
 
     manim_code = f"""from manim import *
-
 class GeneratedMathScene(Scene):
     def construct(self):
         # Scene settings
@@ -552,139 +559,153 @@ class GeneratedMathScene(Scene):
         equation_size = {equation_size}
         title_size = {title_size}
         wrap_width = {wrap_width}
-        equation_scale = {equation_scale}  # Only equations scale to audio
-
+        equation_scale = {equation_scale}
+        
+        # FIX #1: Improved wrapping function - check width BEFORE arranging
         def make_inline_segments(content, color, font, text_size, equation_size):
             if not content:
                 return VGroup()
-
+            
             segments = content.split("#")
             all_lines = []
             current_line = []
-
+            current_width = 0.0
+            
             for segment in segments:
                 segment = segment.strip()
                 if not segment:
                     continue
-
+                
+                # Create mobject
                 if segment.startswith("%"):
                     latex_content = segment[1:]
                     mob = MathTex(latex_content, color=color, font_size=equation_size)
                 else:
                     mob = Text(segment, color=color, font=font, font_size=text_size)
-
-                test_line = current_line + [mob]
-                test_group = VGroup(*test_line).arrange(RIGHT, buff=0.05)
-
-                if test_group.width > wrap_width and len(current_line) > 0:
+                
+                # FIX #1: Check width BEFORE adding to line
+                mob_width = mob.width
+                potential_width = current_width + mob_width + (0.05 * len(current_line))
+                
+                if potential_width > wrap_width and len(current_line) > 0:
+                    # Line is full, save it and start new line
                     line_group = VGroup(*current_line).arrange(RIGHT, buff=0.05)
                     all_lines.append(line_group)
                     current_line = [mob]
+                    current_width = mob_width
                 else:
+                    # Add to current line
                     current_line.append(mob)
-
+                    current_width = potential_width
+                
+                # Safety: If single item exceeds width, scale it down
+                if len(current_line) == 1 and mob.width > wrap_width:
+                    mob.scale_to_fit_width(wrap_width * 0.95)
+                    current_width = mob.width
+            
+            # Add final line
             if current_line:
                 line_group = VGroup(*current_line).arrange(RIGHT, buff=0.05)
                 all_lines.append(line_group)
-
+            
             if not all_lines:
                 return VGroup()
-
+            
             final_group = VGroup(*all_lines).arrange(DOWN, aligned_edge=LEFT, buff=0.2)
             return final_group
-
+        
         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:
+                
+                if test_obj.width <= wrap_width * 0.95:
                     current = test
                 else:
                     if current:
                         line_obj = Text(current, color=color, font=font, font_size=font_size)
                         lines.append(line_obj)
                     current = w
+            
             if current:
                 lines.append(Text(current, color=color, font=font, font_size=font_size))
+            
             if not lines:
                 return VGroup()
+            
             first_line = lines[0]
             for ln in lines:
                 ln.align_to(first_line, LEFT)
+            
             para = VGroup(*lines).arrange(DOWN, aligned_edge=LEFT, buff=line_spacing)
             return para
-
+        
         content_group = VGroup()
         current_y = 3.0
         line_spacing = 0.8
         slides = {slides_repr}
-
+        
         for idx, slide in enumerate(slides):
             obj = None
             content = slide.get("content", "")
             animation = slide.get("animation", "write_left")
             base_duration = slide.get("duration", 1.0)
             slide_type = slide.get("type", "text")
-
-            # Apply scale ONLY to equations, not text or title
+            
+            # Apply scale ONLY to equations
             if slide_type == "equation":
                 duration = base_duration * equation_scale
             else:
-                duration = base_duration  # Keep original timing for text/title
-
+                duration = base_duration
+            
             if slide_type == "title":
                 obj = make_inline_segments(content, highlight_color, default_font, title_size, equation_size)
-
                 if len(obj) == 0:
                     obj = Text(content, color=highlight_color, font=default_font, font_size=title_size)
-
+                
+                # FIX #1: Ensure title fits within screen
                 if obj.width > wrap_width:
-                    obj.scale_to_fit_width(wrap_width)
+                    obj.scale_to_fit_width(wrap_width * 0.95)
+                
                 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":
                 obj = make_inline_segments(content, default_color, default_font, text_size, equation_size)
-
                 if len(obj) == 0:
                     obj = make_wrapped_paragraph(content, default_color, default_font, text_size, line_spacing=0.25)
-
+                
+                # FIX #1: Safety check for text overflow
                 if obj.width > wrap_width:
-                    obj.scale_to_fit_width(wrap_width)
-
+                    obj.scale_to_fit_width(wrap_width * 0.95)
+            
             elif slide_type == "equation":
                 eq_content = content
-                test = MathTex(eq_content, color=default_color, font_size=equation_size)
-                if test.width > wrap_width:
-                    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)
+                obj = MathTex(eq_content, color=default_color, font_size=equation_size)
+                
+                # FIX #1: Scale equation instead of splitting by spaces
                 if obj.width > wrap_width:
-                    obj.scale_to_fit_width(wrap_width)
-
+                    obj.scale_to_fit_width(wrap_width * 0.95)
+            
             if obj:
                 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
                     self.play(content_group.animate.shift(UP * scroll_amount), run_time=0.5)
                     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":
@@ -694,11 +715,11 @@ 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)
                 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)
@@ -709,9 +730,12 @@ class GeneratedMathScene(Scene):
         with open(script_path, 'w', encoding='utf-8') as f:
             f.write(manim_code)
         print(f"Generated script at {script_path}")
+        print(f"Audio length: {audio_length:.2f}s")
+        print(f"Overhead time: {overhead_time:.2f}s")
         print(f"Equation scale factor: {equation_scale:.2f}x")
         print(f"Text/Title duration: {text_title_duration:.2f}s (unchanged)")
         print(f"Equation duration: {equation_duration:.2f}s -> {equation_duration * equation_scale:.2f}s")
+        print(f"Expected total: {text_title_duration + (equation_duration * equation_scale) + overhead_time:.2f}s")
     except Exception as e:
         print(f"Error writing script: {e}")
         raise