Update app.py

app.py

@@ -1,6 +1,8 @@
 import gradio as gr
 import os
 import tempfile
+import traceback
+import gc
 from PIL import Image, ImageDraw, ImageFont
 
 def draw_horizontal_lines(draw, width, height, spacing=60, color=(230, 230, 230)):
@@ -35,131 +37,201 @@ def text_to_images_mcp(text_content, style='lines', font_path=None):
     Returns:
         list: List of PIL Image objects for display in Gradio.
     """
-    if not text_content.strip():
-        return []
-    
-    # --- Configuration ---
-    IMG_WIDTH = 1080
-    IMG_HEIGHT = 1080
-    BACKGROUND_COLOR = (255, 255, 255)
-    TEXT_COLOR = (10, 10, 10)
-    STYLE_COLOR = (225, 225, 225)
-    
-    PADDING_X = 80
-    PADDING_Y = 80
-    FONT_SIZE = 48
-    LINE_SPACING = 20
-    
-    # --- Font Loading ---
-    font = None
     try:
-        if font_path and os.path.exists(font_path):
-            font = ImageFont.truetype(font_path, FONT_SIZE)
-        else:
-            font_paths_to_try = [
-                "Arial.ttf", "arial.ttf",
-                "/System/Library/Fonts/Supplemental/Arial.ttf",
-                "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
-            ]
-            for f_path in font_paths_to_try:
-                try:
-                    font = ImageFont.truetype(f_path, FONT_SIZE)
-                    break
-                except IOError:
-                    continue
-        if not font:
+        # Input validation
+        if not text_content or not text_content.strip():
+            return []
+        
+        # Limit text length to prevent memory issues
+        if len(text_content) > 10000:  # 10k character limit
+            text_content = text_content[:10000] + "\n\n[Text truncated due to length limit]"
+        
+        # --- Configuration ---
+        IMG_WIDTH = 1080
+        IMG_HEIGHT = 1080
+        BACKGROUND_COLOR = (255, 255, 255)
+        TEXT_COLOR = (10, 10, 10)
+        STYLE_COLOR = (225, 225, 225)
+        
+        PADDING_X = 80
+        PADDING_Y = 80
+        FONT_SIZE = 48
+        LINE_SPACING = 20
+        
+        # Limit maximum number of pages to prevent memory issues
+        MAX_PAGES = 10
+        
+        # --- Font Loading ---
+        font = None
+        try:
+            if font_path and os.path.exists(font_path):
+                font = ImageFont.truetype(font_path, FONT_SIZE)
+            else:
+                font_paths_to_try = [
+                    "Arial.ttf", "arial.ttf",
+                    "/System/Library/Fonts/Supplemental/Arial.ttf",
+                    "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
+                ]
+                for f_path in font_paths_to_try:
+                    try:
+                        font = ImageFont.truetype(f_path, FONT_SIZE)
+                        break
+                    except (IOError, OSError):
+                        continue
+            if not font:
+                font = ImageFont.load_default()
+        except Exception as e:
+            print(f"Font loading error: {e}")
             font = ImageFont.load_default()
-    except Exception as e:
-        font = ImageFont.load_default()
-
-    # --- Text Wrapping Logic ---
-    drawable_width = IMG_WIDTH - 2 * PADDING_X
-    paragraphs = [p.strip() for p in text_content.strip().split('\n') if p.strip()]
-
-    if not paragraphs:
-        return []
-
-    all_lines_and_breaks = []
-    for i, paragraph in enumerate(paragraphs):
-        words = paragraph.split()
-        current_line = ""
-        for word in words:
-            if font.getlength(word) > drawable_width:
-                temp_word = ""
-                for char in word:
-                    if font.getlength(temp_word + char) > drawable_width:
-                        all_lines_and_breaks.append(temp_word)
-                        temp_word = char
+
+        # --- Text Wrapping Logic ---
+        drawable_width = IMG_WIDTH - 2 * PADDING_X
+        paragraphs = [p.strip() for p in text_content.strip().split('\n') if p.strip()]
+
+        if not paragraphs:
+            return []
+
+        all_lines_and_breaks = []
+        for i, paragraph in enumerate(paragraphs):
+            words = paragraph.split()
+            current_line = ""
+            for word in words:
+                try:
+                    # Handle very long words
+                    if hasattr(font, 'getlength') and font.getlength(word) > drawable_width:
+                        temp_word = ""
+                        for char in word:
+                            if font.getlength(temp_word + char) > drawable_width:
+                                all_lines_and_breaks.append(temp_word)
+                                temp_word = char
+                            else:
+                                temp_word += char
+                        word = temp_word
+                    
+                    # Check line length
+                    test_line = current_line + " " + word if current_line else word
+                    if hasattr(font, 'getlength'):
+                        line_width = font.getlength(test_line)
                     else:
-                        temp_word += char
-                word = temp_word
-            if font.getlength(current_line + " " + word) <= drawable_width:
-                current_line += " " + word
-            else:
+                        line_width = len(test_line) * 12  # Rough estimate
+                    
+                    if line_width <= drawable_width:
+                        current_line = test_line
+                    else:
+                        if current_line:
+                            all_lines_and_breaks.append(current_line.strip())
+                        current_line = word
+                except Exception as e:
+                    print(f"Text wrapping error: {e}")
+                    # Fallback to simple character limit
+                    if len(current_line + " " + word) <= 80:  # Rough character limit
+                        current_line += " " + word
+                    else:
+                        all_lines_and_breaks.append(current_line.strip())
+                        current_line = word
+            
+            if current_line:
                 all_lines_and_breaks.append(current_line.strip())
-                current_line = word
-        all_lines_and_breaks.append(current_line.strip())
-        if i < len(paragraphs) - 1:
-            all_lines_and_breaks.append(None)
-
-    # --- Image Generation ---
-    img_count = 0
-    page_content = []
-    y_text = PADDING_Y
-    
-    try:
-        line_height = font.getbbox("A")[3] - font.getbbox("A")[1]
-    except AttributeError:
-        line_height = 12
-    
-    PARAGRAPH_SPACING = line_height
-    generated_images = []
-
-    def create_image_page(content, page_num):
-        """Helper function to create and return a single image page."""
-        img = Image.new('RGB', (IMG_WIDTH, IMG_HEIGHT), color=BACKGROUND_COLOR)
-        draw = ImageDraw.Draw(img)
-
-        # Draw the selected background style first
-        if style == 'lines':
-            line_style_spacing = line_height + LINE_SPACING
-            draw_horizontal_lines(draw, IMG_WIDTH, IMG_HEIGHT, spacing=line_style_spacing, color=STYLE_COLOR)
-        elif style == 'dots':
-            draw_dot_grid(draw, IMG_WIDTH, IMG_HEIGHT, color=STYLE_COLOR)
-        elif style == 'grid':
-            draw_lattice_grid(draw, IMG_WIDTH, IMG_HEIGHT, color=STYLE_COLOR)
-
-        # Draw the text on top of the background
-        current_y = PADDING_Y
-        for page_item in content:
-            if page_item is not None:
-                draw.text((PADDING_X, current_y), page_item, font=font, fill=TEXT_COLOR)
-                current_y += line_height + LINE_SPACING
+            if i < len(paragraphs) - 1:
+                all_lines_and_breaks.append(None)  # Paragraph break
+
+        # --- Image Generation ---
+        img_count = 0
+        page_content = []
+        y_text = PADDING_Y
+        
+        try:
+            if hasattr(font, 'getbbox'):
+                line_height = font.getbbox("A")[3] - font.getbbox("A")[1]
             else:
-                current_y += PARAGRAPH_SPACING
+                line_height = FONT_SIZE
+        except Exception:
+            line_height = FONT_SIZE
         
-        generated_images.append(img)
-        return img
+        PARAGRAPH_SPACING = line_height
+        generated_images = []
 
-    for item in all_lines_and_breaks:
-        is_break = item is None
-        item_height = PARAGRAPH_SPACING if is_break else line_height
-        
-        if y_text + item_height > IMG_HEIGHT - PADDING_Y:
-            img_count += 1
-            create_image_page(page_content, img_count)
+        def create_image_page(content, page_num):
+            """Helper function to create and return a single image page."""
+            try:
+                img = Image.new('RGB', (IMG_WIDTH, IMG_HEIGHT), color=BACKGROUND_COLOR)
+                draw = ImageDraw.Draw(img)
 
-            page_content = [item]
-            y_text = PADDING_Y + item_height + (0 if is_break else LINE_SPACING)
-        else:
-            page_content.append(item)
-            y_text += item_height + (0 if is_break else LINE_SPACING)
+                # Draw the selected background style first
+                if style == 'lines':
+                    line_style_spacing = line_height + LINE_SPACING
+                    draw_horizontal_lines(draw, IMG_WIDTH, IMG_HEIGHT, spacing=line_style_spacing, color=STYLE_COLOR)
+                elif style == 'dots':
+                    draw_dot_grid(draw, IMG_WIDTH, IMG_HEIGHT, color=STYLE_COLOR)
+                elif style == 'grid':
+                    draw_lattice_grid(draw, IMG_WIDTH, IMG_HEIGHT, color=STYLE_COLOR)
+
+                # Draw the text on top of the background
+                current_y = PADDING_Y
+                for page_item in content:
+                    if page_item is not None:
+                        try:
+                            draw.text((PADDING_X, current_y), page_item, font=font, fill=TEXT_COLOR)
+                            current_y += line_height + LINE_SPACING
+                        except Exception as e:
+                            print(f"Text drawing error: {e}")
+                            current_y += line_height + LINE_SPACING
+                    else:
+                        current_y += PARAGRAPH_SPACING
+                
+                # Optimize image for web delivery
+                img = img.convert('RGB')
+                generated_images.append(img)
+                return img
+            except Exception as e:
+                print(f"Image creation error: {e}")
+                # Return a simple error image
+                error_img = Image.new('RGB', (IMG_WIDTH, IMG_HEIGHT), color=(255, 255, 255))
+                error_draw = ImageDraw.Draw(error_img)
+                try:
+                    error_draw.text((PADDING_X, PADDING_Y), f"Error creating page {page_num}", font=font, fill=(255, 0, 0))
+                except:
+                    pass
+                return error_img
+
+        # Process content with page limit
+        for item in all_lines_and_breaks:
+            if img_count >= MAX_PAGES:
+                break
+                
+            is_break = item is None
+            item_height = PARAGRAPH_SPACING if is_break else line_height
             
-    if page_content:
-        img_count += 1
-        create_image_page(page_content, img_count)
+            if y_text + item_height > IMG_HEIGHT - PADDING_Y:
+                img_count += 1
+                create_image_page(page_content, img_count)
 
-    return generated_images
+                page_content = [item]
+                y_text = PADDING_Y + item_height + (0 if is_break else LINE_SPACING)
+            else:
+                page_content.append(item)
+                y_text += item_height + (0 if is_break else LINE_SPACING)
+                
+        if page_content and img_count < MAX_PAGES:
+            img_count += 1
+            create_image_page(page_content, img_count)
+
+        # Memory cleanup
+        gc.collect()
+        
+        return generated_images[:MAX_PAGES]  # Ensure we don't exceed limit
+        
+    except Exception as e:
+        print(f"Critical error in text_to_images_mcp: {e}")
+        print(traceback.format_exc())
+        # Return a simple error image
+        try:
+            error_img = Image.new('RGB', (1080, 1080), color=(255, 255, 255))
+            error_draw = ImageDraw.Draw(error_img)
+            error_draw.text((80, 80), f"Error processing text: {str(e)[:100]}", fill=(255, 0, 0))
+            return [error_img]
+        except:
+            return []
 
 # Sample text for demonstration
 sample_text = """In the heart of a bustling city, there lived a clockmaker named Alistair. His shop, a quaint corner of tranquility amidst the urban chaos, was filled with the gentle ticking of countless timepieces. Each clock was a masterpiece, a testament to his dedication and skill. But Alistair held a secret. One of his clocks, an old grandfather clock in the corner, did not just tell time. It told stories.
@@ -176,7 +248,7 @@ demo = gr.Interface(
             lines=10,
             max_lines=20,
             label="Text Content",
-            placeholder="Enter your long-form text here..."
+            placeholder="Enter your long-form text here (max 10,000 characters)..."
         ),
         gr.Dropdown(
             choices=['plain', 'lines', 'dots', 'grid'],
@@ -193,7 +265,7 @@ demo = gr.Interface(
     ],
     outputs=[
         gr.Gallery(
-            label="Generated Images",
+            label="Generated Images (Max 10 pages)",
             show_label=True,
             elem_id="gallery",
             columns=2,
@@ -204,7 +276,7 @@ demo = gr.Interface(
         )
     ],
     title="📖 Text to Images Converter",
-    description="Transform long-form text into a series of attractive, readable images. Simply paste your text, choose a background style, and preview the generated images. You can download individual images by clicking on them.",
+    description="Transform long-form text into a series of attractive, readable images. Simply paste your text, choose a background style, and preview the generated images. You can download individual images by clicking on them. Limited to 10,000 characters and 10 pages for optimal performance.",
     examples=[
         [sample_text, 'lines', ''],
         [sample_text, 'dots', ''],