Update app.py

app.py

@@ -47,6 +47,7 @@ import json
 from concurrent.futures import ThreadPoolExecutor
 from functools import lru_cache
 from typing import List, Tuple, Optional, Dict
+import heapq
 
 import edge_tts
 from pydub import AudioSegment
@@ -103,136 +104,108 @@ def clean_text_for_tts(text: str) -> str:
     
     return text.strip()
 
-def split_by_word_boundary(text: str) -> List[str]:
+def split_by_language_and_words(text: str) -> List[Tuple[str, str]]:
     """
-    Intelligently splits text by language boundaries while preserving code-switched words.
-    Example: "Voltage னு" → ["Voltage", " னு"]
+    Intelligently splits text by language boundaries and groups words logically.
+    Returns list of (text_segment, language)
     """
     if not text:
         return []
     
     segments = []
     current_segment = ""
-    current_lang = None  # 'en', 'ta', or None
+    current_lang = None
     
-    i = 0
-    while i < len(text):
-        char = text[i]
+    words = text.split()
+    
+    for word in words:
+        # Check if word contains Tamil characters
+        has_tamil = any('\u0B80' <= char <= '\u0BFF' for char in word)
         
-        # Detect language of current character
-        if '\u0B80' <= char <= '\u0BFF':  # Tamil range
-            char_lang = 'ta'
-        elif char.isalpha() or char in '-':
-            char_lang = 'en'
+        # Determine language for this word
+        if has_tamil:
+            word_lang = 'ta'
         else:
-            char_lang = current_lang  # Punctuation/space keeps current language
+            word_lang = 'en'
+        
+        # Check for code-switched hyphenated words like "simple-ஆ"
+        if '-' in word:
+            parts = word.split('-')
+            if len(parts) == 2:
+                first_has_tamil = any('\u0B80' <= char <= '\u0BFF' for char in parts[0])
+                second_has_tamil = any('\u0B80' <= char <= '\u0BFF' for char in parts[1])
+                
+                if first_has_tamil and not second_has_tamil:
+                    word_lang = 'ta'  # Tamil-English
+                elif not first_has_tamil and second_has_tamil:
+                    word_lang = 'ta'  # English-Tamil
+                elif first_has_tamil and second_has_tamil:
+                    word_lang = 'ta'
+                else:
+                    word_lang = 'en'
         
         # Start new segment on language boundary
-        if current_lang and char_lang and current_lang != char_lang:
-            # Don't split on hyphens in code-switched words like "simple-ஆ"
-            if char == '-' and i > 0 and i < len(text) - 1:
-                # Check if it's a code-switched hyphen (English-Tamil)
-                prev_char = text[i-1]
-                next_char = text[i+1]
-                if prev_char.isalpha() and ('\u0B80' <= next_char <= '\u0BFF'):
-                    # Keep hyphen with current segment
-                    current_segment += char
-                    i += 1
-                    continue
-            
+        if current_lang and current_lang != word_lang:
             if current_segment.strip():
-                segments.append(current_segment)
-            current_segment = char
-            current_lang = char_lang
+                segments.append((current_segment.strip(), current_lang))
+            current_segment = word
+            current_lang = word_lang
         else:
-            current_segment += char
-            current_lang = char_lang or current_lang
-        
-        i += 1
+            if current_segment:
+                current_segment += " " + word
+            else:
+                current_segment = word
+            current_lang = word_lang or current_lang
     
+    # Add final segment
     if current_segment.strip():
-        segments.append(current_segment)
+        segments.append((current_segment.strip(), current_lang))
     
     return segments
 
-def chunk_text_with_overlap(text: str, max_chars: int = 250) -> List[Tuple[str, int]]:
+def create_intelligent_chunks(text: str, max_chars: int = 250) -> List[Tuple[str, int, str]]:
     """
-    Creates chunks with overlap for smooth transitions.
-    Returns list of (chunk_text, chunk_index)
+    Create chunks that respect language boundaries and logical grouping.
+    Returns list of (chunk_text, chunk_index, language)
     """
-    # Clean first
     cleaned = clean_text_for_tts(text)
     if not cleaned:
         return []
     
-    # Split into segments by language boundary
-    segments = split_by_word_boundary(cleaned)
+    # Split into language-based segments
+    language_segments = split_by_language_and_words(cleaned)
     
-    # Group segments into chunks
     chunks = []
     current_chunk = ""
-    current_words = []
+    current_lang = None
+    chunk_index = 0
     
-    for segment in segments:
-        test_chunk = current_chunk + segment if current_chunk else segment
-        test_words = test_chunk.split()
-        
-        if len(test_chunk) <= max_chars and len(test_words) <= 20:
-            current_chunk = test_chunk
-            current_words = test_words
-        else:
-            # Need to start new chunk
+    for segment, seg_lang in language_segments:
+        if not segment:
+            continue
+            
+        # If this is a new language or chunk would be too long, start new chunk
+        if (current_lang and current_lang != seg_lang) or \
+           (current_chunk and len(current_chunk + " " + segment) > max_chars):
+            
             if current_chunk:
-                chunks.append(current_chunk)
+                chunks.append((current_chunk, chunk_index, current_lang))
+                chunk_index += 1
             
-            # Handle long segments
-            if len(segment) > max_chars:
-                # Split long segment by words
-                words = segment.split()
-                temp_chunk = ""
-                temp_words = []
-                
-                for word in words:
-                    test = temp_chunk + " " + word if temp_chunk else word
-                    if len(test) <= max_chars:
-                        temp_chunk = test
-                        temp_words.append(word)
-                    else:
-                        if temp_chunk:
-                            chunks.append(temp_chunk)
-                        temp_chunk = word
-                        temp_words = [word]
-                
-                if temp_chunk:
-                    current_chunk = temp_chunk
-                    current_words = temp_words
+            current_chunk = segment
+            current_lang = seg_lang
+        else:
+            if current_chunk:
+                current_chunk += " " + segment
             else:
                 current_chunk = segment
-                current_words = segment.split()
+            current_lang = seg_lang
     
     # Add final chunk
     if current_chunk:
-        chunks.append(current_chunk)
+        chunks.append((current_chunk, chunk_index, current_lang))
     
-    # Add overlap between chunks (last 3 words of chunk N become first 3 words of chunk N+1)
-    overlapped_chunks = []
-    for i, chunk in enumerate(chunks):
-        if i > 0:
-            # Get last 3 words from previous chunk
-            prev_chunk = chunks[i-1]
-            prev_words = prev_chunk.split()
-            overlap_words = prev_words[-3:] if len(prev_words) >= 3 else prev_words
-            
-            if overlap_words:
-                overlap_text = " ".join(overlap_words)
-                # Add overlap if it won't make the chunk too long
-                test_chunk = overlap_text + " " + chunk
-                if len(test_chunk) <= max_chars:
-                    chunk = test_chunk
-        
-        overlapped_chunks.append((chunk, i))
-    
-    return overlapped_chunks
+    return chunks
 
 async def generate_safe_audio(text: str, voice: str, semaphore: asyncio.Semaphore,
                              chunk_index: int) -> Tuple[Optional[str], int]:
@@ -314,38 +287,31 @@ async def bilingual_tts_optimized(text: str, output_file: str = "audio0.mp3",
     print("Starting bilingual TTS processing...")
     
     try:
-        # Split text into chunks with overlap
-        chunks_with_indices = chunk_text_with_overlap(text, max_chars=250)
-        if not chunks_with_indices:
+        # Create intelligent chunks
+        chunks_info = create_intelligent_chunks(text, max_chars=250)
+        if not chunks_info:
             print("Error: No valid text chunks after processing")
             return None
         
-        print(f"Processing {len(chunks_with_indices)} text chunks...")
+        print(f"Processing {len(chunks_info)} text chunks...")
         
-        # Determine which chunks need Tamil voice
-        chunks_to_generate = []
-        for chunk_text, chunk_index in chunks_with_indices:
-            has_tamil = any('\u0B80' <= char <= '\u0BFF' for char in chunk_text)
-            
-            if VOICE_TA and has_tamil:
+        # Prepare tasks with proper voice assignment
+        tasks = []
+        semaphore = asyncio.Semaphore(max_concurrent)
+        
+        for chunk_text, chunk_index, chunk_lang in chunks_info:
+            # Determine voice for this chunk
+            if VOICE_TA and chunk_lang == 'ta':
                 voice = VOICE_TA
             else:
                 voice = VOICE_TA or VOICE_EN
             
-            chunks_to_generate.append((chunk_text, voice, chunk_index))
-        
-        # Semaphore for rate limiting
-        semaphore = asyncio.Semaphore(max_concurrent)
-        
-        # Prepare tasks
-        tasks = []
-        for chunk_text, voice, chunk_index in chunks_to_generate:
             tasks.append(generate_safe_audio(chunk_text, voice, semaphore, chunk_index))
         
         # Generate all audio files
         results = await asyncio.gather(*tasks, return_exceptions=False)
         
-        # Filter successful results and maintain order
+        # Filter successful results and sort by INTEGER index (not string!)
         audio_data = []
         for result in results:
             if isinstance(result, tuple) and result[0] and os.path.exists(result[0]):
@@ -355,7 +321,7 @@ async def bilingual_tts_optimized(text: str, output_file: str = "audio0.mp3",
             print("Error: No audio was successfully generated")
             return None
         
-        # Sort by chunk index
+        # Sort by chunk index (integer)
         audio_data.sort(key=lambda x: x[1])
         
         print(f"Successfully generated {len(audio_data)} audio segments")
@@ -364,7 +330,7 @@ async def bilingual_tts_optimized(text: str, output_file: str = "audio0.mp3",
         with ThreadPoolExecutor(max_workers=min(len(audio_data), 8)) as executor:
             processed = list(executor.map(process_audio_segment_fast, audio_data))
         
-        # Filter and sort
+        # Filter and sort by index
         processed = [(seg, idx) for seg, idx in processed if seg is not None]
         processed.sort(key=lambda x: x[1])
         
@@ -374,25 +340,26 @@ async def bilingual_tts_optimized(text: str, output_file: str = "audio0.mp3",
             print("Error: No audio segments were successfully processed")
             return None
         
-        print(f"Merging {len(audio_segments)} audio segments with crossfade...")
+        print(f"Merging {len(audio_segments)} audio segments...")
         
-        # Merge with crossfade for smooth transitions
+        # Merge segments in correct order
         merged_audio = audio_segments[0]
         
-        for segment in audio_segments[1:]:
-            # Crossfade 30ms for smooth transition
-            merged_audio = merged_audio.append(segment, crossfade=30)
+        for i in range(1, len(audio_segments)):
+            # Add a small pause between segments
+            pause = AudioSegment.silent(duration=100)
+            merged_audio = merged_audio + pause + audio_segments[i]
         
         # Apply compression for consistent volume
         try:
             merged_audio = merged_audio.compress_dynamic_range(
                 threshold=-20.0,
-                ratio=2.5,  # Gentler compression for more natural sound
+                ratio=2.5,
                 attack=5.0,
                 release=50.0
             )
         except:
-            pass  # Skip if compression fails
+            pass
         
         merged_audio = normalize(merged_audio)
         
@@ -403,7 +370,7 @@ async def bilingual_tts_optimized(text: str, output_file: str = "audio0.mp3",
             print(f"✅ Audio successfully generated: {output_file}")
             return output_file
         else:
-            print(f"Error: Generated file is empty or missing")
+            print("Error: Generated file is empty or missing")
             return None
         
     except Exception as main_error:
@@ -487,9 +454,8 @@ def audio_func(id: int, lines, lang: str) -> Tuple[Optional[float], Optional[str
         print(f"Error in audio_func: {e}")
         traceback.print_exc()
         return None, None
-
-def create_manim_script(problem_data, script_path, audio_path, scale=1):
-    """Generate Manim script from problem data with robust wrapping."""
+def create_manim_script(problem_data, script_path, audio_path, audio_length):
+    """Generate Manim script with selective timing adjustment - only equations scale to audio."""
 
     settings = problem_data.get("video_settings", {
         "background_color": "#0f0f23",
@@ -506,6 +472,27 @@ def create_manim_script(problem_data, script_path, audio_path, scale=1):
     if not slides:
         raise ValueError("No slides provided in input data")
 
+    # Calculate separate durations for different slide types
+    equation_duration = 0.0
+    text_title_duration = 0.0
+
+    for slide in slides:
+        slide_duration = float(slide.get("duration", 1.0))
+        if slide.get("type") == "equation":
+            equation_duration += slide_duration
+        else:  # text or title
+            text_title_duration += slide_duration
+
+    # Calculate equation scale factor to fill remaining audio time
+    target_equation_time = audio_length - text_title_duration
+
+    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)
+        equation_scale = max(0.5, min(2.5, equation_scale))
+    else:
+        equation_scale = 1.0
+
     slides_repr = repr(slides)
     audio_path_repr = repr(audio_path)
 
@@ -519,6 +506,7 @@ def create_manim_script(problem_data, script_path, audio_path, scale=1):
     title_size = settings.get("title_size", 48)
 
     manim_code = f"""from manim import *
+
 class GeneratedMathScene(Scene):
     def construct(self):
         # Scene settings
@@ -531,55 +519,47 @@ class GeneratedMathScene(Scene):
         equation_size = {equation_size}
         title_size = {title_size}
         wrap_width = {wrap_width}
-        
+        equation_scale = {equation_scale}  # Only equations scale to audio
+
         def make_inline_segments(content, color, font, text_size, equation_size):
             if not content:
                 return VGroup()
-            
-            # Split by # separator
+
             segments = content.split("#")
-            all_lines = []  # Store all lines
-            current_line = []  # Current line being built
-            current_width = 0
-            
+            all_lines = []
+            current_line = []
+
             for segment in segments:
                 segment = segment.strip()
                 if not segment:
                     continue
-                
-                # Create the mobject (Text or MathTex)
+
                 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)
-                
-                # Calculate what width would be if we add this segment
+
                 test_line = current_line + [mob]
                 test_group = VGroup(*test_line).arrange(RIGHT, buff=0.05)
-                
-                # Check if adding this segment exceeds wrap_width
+
                 if test_group.width > wrap_width and len(current_line) > 0:
-                    # Save current line and start new line
                     line_group = VGroup(*current_line).arrange(RIGHT, buff=0.05)
                     all_lines.append(line_group)
-                    current_line = [mob]  # Start new line with current segment
+                    current_line = [mob]
                 else:
-                    # Add to current line
                     current_line.append(mob)
-            
-            # Add the last 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()
-            
-            # Stack all lines vertically
+
             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()
@@ -603,28 +583,31 @@ class GeneratedMathScene(Scene):
                 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")
-            scalelen = slide.get("duration", 1.0)
-            duration = scalelen * {scale}
+            base_duration = slide.get("duration", 1.0)
             slide_type = slide.get("type", "text")
-            
+
+            # Apply scale ONLY to equations, not text or title
+            if slide_type == "equation":
+                duration = base_duration * equation_scale
+            else:
+                duration = base_duration  # Keep original timing for text/title
+
             if slide_type == "title":
-                # Use inline segments for title
                 obj = make_inline_segments(content, highlight_color, default_font, title_size, equation_size)
-                
-                # Fallback to simple text if no inline segments
+
                 if len(obj) == 0:
                     obj = Text(content, 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)
@@ -632,19 +615,16 @@ class GeneratedMathScene(Scene):
                 self.wait(duration * 0.3)
                 self.play(FadeOut(obj), run_time=duration * 0.3)
                 continue
-            
+
             elif slide_type == "text":
-                # Use inline segments for text
                 obj = make_inline_segments(content, default_color, default_font, text_size, equation_size)
-                
-                # Fallback if no inline segments detected
+
                 if len(obj) == 0:
                     obj = make_wrapped_paragraph(content, default_color, default_font, text_size, line_spacing=0.25)
-                
-                # Handle width overflow
+
                 if obj.width > wrap_width:
                     obj.scale_to_fit_width(wrap_width)
-            
+
             elif slide_type == "equation":
                 eq_content = content
                 test = MathTex(eq_content, color=default_color, font_size=equation_size)
@@ -653,25 +633,25 @@ 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:
                 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":
@@ -681,11 +661,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)
@@ -696,16 +676,14 @@ 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"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")
     except Exception as e:
         print(f"Error writing script: {e}")
         raise
 
 
-@app.route("/")
-def home():
-    return "Flask Manim Video Generator is Running"
-
-
 @app.route("/generate", methods=["POST"])
 def generate_video():
     temp_work_dir = None
@@ -730,11 +708,9 @@ def generate_video():
             return jsonify({"error": f"Failed to parse slide data: {str(e)}"}), 400
 
         datalst = []
-        total = 0.0
 
         for line in range(len(nlist)):
             try:
-                total += float(nlist[line][3])
                 datalst.append({
                     "type": nlist[line][0].strip(),
                     "content": nlist[line][1].strip(),
@@ -744,9 +720,6 @@ def generate_video():
             except (IndexError, ValueError) as e:
                 return jsonify({"error": f"Invalid slide data at index {line}: {str(e)}"}), 400
 
-        if total <= 0:
-            total = 1.0
-
         data = {
             "video_settings": {
                 "background_color": "#0f0f23",
@@ -767,24 +740,25 @@ def generate_video():
         except:
             lang = "English"
 
-        length, audio_path = audio_func(0, lines, lang)
+        audio_length, audio_path = audio_func(0, lines, lang)
 
-        if not length or not audio_path or not os.path.exists(audio_path):
+        if not audio_length or not audio_path or not os.path.exists(audio_path):
             return jsonify({"error": "Failed to generate audio"}), 500
 
-        scale = float(length) / total if total > 0 else 1.0
-
         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")
+        print(f"Audio length: {audio_length}s")
 
         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)
 
         script_path = os.path.join(temp_work_dir, "scene.py")
-        create_manim_script(data, script_path, audio_path, scale)
+
+        # Pass audio_length instead of scale
+        create_manim_script(data, script_path, audio_path, audio_length)
         print(f"Created Manim script at {script_path}")
 
         quality = 'l'