Update app.py

app.py

@@ -76,82 +76,117 @@ def render_translated_overlay(original_image: Image.Image, text_to_overlay: str,
     font_size = 100
     final_wrapped_lines = []
     
-    # ### --- FIX --- ###: Process RTL text BEFORE line wrapping
-    # First, reshape and process the entire text for proper RTL handling
-    try:
-        reshaped_text = arabic_reshaper.reshape(text_to_overlay)
-        processed_text = get_display(reshaped_text)
-    except Exception as e:
-        print(f"RTL processing error: {e}")
-        processed_text = text_to_overlay  # Fallback to original text
-    
-    while font_size > 10:
-        font = ImageFont.truetype(PERSIAN_FONT_PATH, font_size)
-        
-        # ### --- FIX --- ###: Split by spaces but work with processed RTL text
-        words = processed_text.split()
-        if not words: 
-            break
-            
-        raw_lines = []
-        current_line = ""
+    # ### --- COMPLETE FIX --- ###: Handle RTL text properly
+    def wrap_persian_text(text, font, max_width):
+        """Properly wrap Persian text maintaining RTL flow"""
+        words = text.split()  # Split ORIGINAL text, not processed text
+        lines = []
+        current_line_words = []
         
         for word in words:
-            test_line = (current_line + " " + word).strip()
-            # Test the width with the actual text that will be rendered
-            line_width = draw.textbbox((0, 0), test_line, font=font)[2]
+            # Test with current line + new word
+            test_words = current_line_words + [word]
+            test_line = ' '.join(test_words)
+            
+            # Process this test line for RTL to get actual display width
+            try:
+                reshaped_test = arabic_reshaper.reshape(test_line)
+                display_test = get_display(reshaped_test)
+                test_width = draw.textbbox((0, 0), display_test, font=font)[2]
+            except:
+                # Fallback if RTL processing fails
+                test_width = draw.textbbox((0, 0), test_line, font=font)[2]
             
-            if line_width <= target_width:
-                current_line = test_line
+            if test_width <= max_width:
+                current_line_words.append(word)
             else:
-                if current_line:  # Only append if current_line is not empty
-                    raw_lines.append(current_line)
-                current_line = word
+                # Save current line and start new one
+                if current_line_words:
+                    lines.append(' '.join(current_line_words))
+                current_line_words = [word]
         
-        if current_line:  # Don't forget the last line
-            raw_lines.append(current_line)
+        # Don't forget the last line
+        if current_line_words:
+            lines.append(' '.join(current_line_words))
         
-        # Calculate total height
+        return lines
+    
+    # Find the right font size
+    while font_size > 10:
+        font = ImageFont.truetype(PERSIAN_FONT_PATH, font_size)
+        
+        # Wrap text with current font size
+        wrapped_lines = wrap_persian_text(text_to_overlay, font, target_width)
+        
+        # Calculate total height needed
         total_height = 0
-        for line in raw_lines:
-            line_bbox = draw.textbbox((0, 0), line, font=font)
-            line_height = line_bbox[3] - line_bbox[1]
-            total_height += line_height
+        for line in wrapped_lines:
+            try:
+                # Process each line for RTL to get accurate height
+                reshaped_line = arabic_reshaper.reshape(line)
+                display_line = get_display(reshaped_line)
+                line_bbox = draw.textbbox((0, 0), display_line, font=font)
+                line_height = line_bbox[3] - line_bbox[1]
+                total_height += line_height
+            except:
+                # Fallback height calculation
+                line_bbox = draw.textbbox((0, 0), line, font=font)
+                line_height = line_bbox[3] - line_bbox[1]
+                total_height += line_height
+        
+        # Add spacing between lines
+        total_height += (len(wrapped_lines) - 1) * (font_size * 0.3)
         
         if total_height <= overlay_height * 0.9:
-            final_wrapped_lines = raw_lines
+            final_wrapped_lines = wrapped_lines
             break
         else:
             font_size -= 2
     
-    if not final_wrapped_lines and raw_lines:  # Fallback
-        final_wrapped_lines = raw_lines
+    if not final_wrapped_lines:  # Fallback
+        final_wrapped_lines = [text_to_overlay]
 
-    # ### --- FIX --- ###: Render with proper spacing
+    # ### --- RENDER TEXT WITH PROPER RTL --- ###
     final_font = ImageFont.truetype(PERSIAN_FONT_PATH, font_size)
     line_spacing = font_size * 0.3
     
-    # Calculate line heights properly
+    # Calculate line heights and positions
     line_heights = []
+    processed_lines = []  # Store the RTL-processed lines
+    
     for line in final_wrapped_lines:
-        line_bbox = draw.textbbox((0, 0), line, font=final_font)
-        line_height = line_bbox[3] - line_bbox[1]
-        line_heights.append(line_height)
+        try:
+            # Process each line individually for RTL
+            reshaped_line = arabic_reshaper.reshape(line)
+            display_line = get_display(reshaped_line)
+            processed_lines.append(display_line)
+            
+            line_bbox = draw.textbbox((0, 0), display_line, font=final_font)
+            line_height = line_bbox[3] - line_bbox[1]
+            line_heights.append(line_height)
+        except Exception as e:
+            print(f"RTL processing failed for line '{line}': {e}")
+            # Fallback to original line
+            processed_lines.append(line)
+            line_bbox = draw.textbbox((0, 0), line, font=final_font)
+            line_height = line_bbox[3] - line_bbox[1]
+            line_heights.append(line_height)
     
-    total_text_height = sum(line_heights) + (len(final_wrapped_lines) - 1) * line_spacing
+    total_text_height = sum(line_heights) + (len(processed_lines) - 1) * line_spacing
     y_start = (overlay_height - total_text_height) / 2
     
+    # Draw each line
     current_y = y_start
-    for i, line in enumerate(final_wrapped_lines):
+    for i, display_line in enumerate(processed_lines):
         # Calculate line width and center position
-        line_bbox = draw.textbbox((0, 0), line, font=final_font)
+        line_bbox = draw.textbbox((0, 0), display_line, font=final_font)
         line_width = line_bbox[2] - line_bbox[0]
         x_position = (overlay_width - line_width) / 2
         
         # Draw shadow for better readability
-        draw.text((x_position + 1, current_y + 1), line, font=final_font, fill=(0, 0, 0, 180))
+        draw.text((x_position + 1, current_y + 1), display_line, font=final_font, fill=(0, 0, 0, 180))
         # Draw main text
-        draw.text((x_position, current_y), line, font=final_font, fill=(255, 255, 255, 255))
+        draw.text((x_position, current_y), display_line, font=final_font, fill=(255, 255, 255, 255))
         
         current_y += line_heights[i] + line_spacing