Update app.py

app.py

@@ -1,7 +1,6 @@
 import os
 import tempfile
 import base64
-import io
 import gradio as gr
 from PIL import Image, ImageDraw, ImageFont
 
@@ -19,230 +18,195 @@ def draw_dot_grid(draw, width, height, spacing=50, color=(220, 220, 220)):
             draw.ellipse([(x-2, y-2), (x+2, y+2)], fill=color)
 
 def draw_lattice_grid(draw, width, height, spacing=100, color=(235, 235, 235)):
-    """Draws a lattice grid on the image."""
+    """Draws a lattice/graph paper grid on the image."""
+    # Draw vertical lines
     for x in range(0, width, spacing):
-        draw.line([(x, 0), (x, height)], fill=color, width=1)
+        draw.line([(x, 0), (x, height)], fill=color, width=2)
+    # Draw horizontal lines
     for y in range(0, height, spacing):
-        draw.line([(0, y), (width, y)], fill=color, width=1)
+        draw.line([(0, y), (width, y)], fill=color, width=2)
 
-def create_text_image(text, width=1080, height=1080, font_size=40, line_spacing=20, margin=50, bg_style="lines"):
-    """Creates an image with the given text and background style."""
-    
-    # Create image with white background
-    img = Image.new('RGB', (width, height), 'white')
-    draw = ImageDraw.Draw(img)
-    
-    # Apply background style
-    if bg_style == "lines":
-        draw_horizontal_lines(draw, width, height)
-    elif bg_style == "dots":
-        draw_dot_grid(draw, width, height)
-    elif bg_style == "grid":
-        draw_lattice_grid(draw, width, height)
-    # "plain" style has no additional background
-    
-    # Use default font
-    try:
-        font = ImageFont.truetype("arial.ttf", font_size)
-    except:
-        try:
-            font = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", font_size)
-        except:
-            font = ImageFont.load_default()
-    
-    # Calculate text area
-    text_width = width - 2 * margin
-    y = margin
-    
-    # Split text into paragraphs
-    paragraphs = text.split('\n')
-    
-    for paragraph in paragraphs:
-        if paragraph.strip() == "":
-            y += line_spacing
-            continue
-            
-        # Word wrap for each paragraph
-        words = paragraph.split(' ')
-        lines = []
-        current_line = ""
-        
-        for word in words:
-            # Check if adding this word would exceed the width
-            test_line = current_line + " " + word if current_line else word
-            bbox = draw.textbbox((0, 0), test_line, font=font)
-            if bbox[2] - bbox[0] <= text_width:
-                current_line = test_line
-            else:
-                if current_line:
-                    lines.append(current_line)
-                    current_line = word
-                else:
-                    lines.append(word)  # Single word that's too long
-        
-        if current_line:
-            lines.append(current_line)
-        
-        # Draw the lines
-        for line in lines:
-            draw.text((margin, y), line, fill='black', font=font)
-            y += font_size + line_spacing
-        
-        # Add extra space between paragraphs
-        y += line_spacing // 2
-    
-    return img
 
-def text_to_images_generator(text_content: str = "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.\n\nOne day, a young girl with eyes as curious as a cat's wandered into his shop. She wasn't interested in the shiny new watches but was drawn to the grandfather clock in the corner. \"What's its story?\" she asked, her voice soft. Alistair smiled, for he knew he had found the next guardian of the stories. The legacy of the whispering clock would live on.", style: str = "lines") -> str:
+def text_to_images_generator(text_content, style='lines'):
     """
-    Converts a given string of text into images and returns the result.
-    
+    Converts a given string of text into a single combined image and returns the file path.
+    This is compatible with both UI and MCP.
+
     Args:
-        text_content: The text to be converted.
-        style: The background style ('plain', 'lines', 'dots', 'grid').
-    
+        text_content (str): The text to be converted.
+        style (str): The background style ('plain', 'lines', 'dots', 'grid').
+
     Returns:
-        For MCP: Base64 encoded image data
-        For Gradio: PIL Image object
+        str: Message with the path to the generated combined image file.
     """
+    if not text_content or not text_content.strip():
+        return "Error: Input text is empty. Please enter some text to generate images."
+
+    # --- Configuration ---
+    IMG_WIDTH = 1080
+    IMG_HEIGHT = 1080
+    BACKGROUND_COLOR = (255, 255, 255)
+    TEXT_COLOR = (10, 10, 10)
+    STYLE_COLOR = (225, 225, 225) # Color for lines/dots/grid
+    
+    PADDING_X = 80
+    PADDING_Y = 80
+
+    FONT_SIZE = 48
+    LINE_SPACING = 20
     
-    # Check if we're in MCP context by looking at the execution environment
-    import inspect
-    frame = inspect.currentframe()
-    is_mcp_context = False
-    
-    # Look through the call stack to detect MCP context
-    while frame:
-        if frame.f_code.co_filename and ('mcp' in frame.f_code.co_filename.lower() or 'sse' in frame.f_code.co_filename.lower()):
-            is_mcp_context = True
-            break
-        frame = frame.f_back
-    
-    if not text_content.strip():
-        if is_mcp_context:
-            return "Error: No text content provided."
-        else:
-            return None
-    
-    # Calculate required dimensions for the text
-    temp_img = Image.new('RGB', (1080, 1080), 'white')
-    temp_draw = ImageDraw.Draw(temp_img)
-    
+    # --- Font Loading ---
+    font = None
     try:
-        font = ImageFont.truetype("arial.ttf", 40)
-    except:
-        try:
-            font = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", 40)
-        except:
+        font_paths_to_try = [
+            "Arial.ttf", "arial.ttf", "DejaVuSans.ttf",
+            "/System/Library/Fonts/Supplemental/Arial.ttf",
+            "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
+        ]
+        for f_path in font_paths_to_try:
+            try:
+                font = ImageFont.truetype(f_path, FONT_SIZE)
+                break
+            except IOError:
+                continue
+        if not font:
             font = ImageFont.load_default()
+    except Exception as e:
+        print(f"An unexpected error occurred during font loading: {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()]
     
-    # Calculate how many lines we need
-    margin = 50
-    text_width = 1080 - 2 * margin
-    line_height = 40 + 20  # font_size + line_spacing
-    
-    total_lines = 0
-    paragraphs = text_content.split('\n')
-    
-    for paragraph in paragraphs:
-        if paragraph.strip() == "":
-            total_lines += 1
-            continue
-            
-        words = paragraph.split(' ')
+    all_lines_and_breaks = []
+    for i, paragraph in enumerate(paragraphs):
+        words = paragraph.split()
         current_line = ""
-        
         for word in words:
-            test_line = current_line + " " + word if current_line else word
-            bbox = temp_draw.textbbox((0, 0), test_line, font=font)
-            if bbox[2] - bbox[0] <= text_width:
-                current_line = test_line
+            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
+                    else:
+                        temp_word += char
+                word = temp_word
+
+            if font.getlength(current_line + " " + word) <= drawable_width:
+                current_line += " " + word
             else:
-                if current_line:
-                    total_lines += 1
-                    current_line = word
-                else:
-                    total_lines += 1
+                all_lines_and_breaks.append(current_line.strip())
+                current_line = word
+        all_lines_and_breaks.append(current_line.strip())
         
-        if current_line:
-            total_lines += 1
-        total_lines += 0.5  # Extra space between paragraphs
-    
-    # Calculate required height
-    required_height = max(1080, int(total_lines * line_height + 2 * margin))
-    
-    # Create the final image
-    final_image = create_text_image(
-        text_content, 
-        width=1080, 
-        height=required_height, 
-        bg_style=style
-    )
+        if i < len(paragraphs) - 1:
+            all_lines_and_breaks.append(None)
+
+    # --- Image Generation ---
+    try:
+        line_height = font.getbbox("A")[3] - font.getbbox("A")[1]
+    except AttributeError:
+        line_height = 12
     
-    if is_mcp_context:
-        # For MCP: Return base64 encoded image
-        buffer = io.BytesIO()
-        final_image.save(buffer, format='PNG')
-        img_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
+    PARAGRAPH_SPACING = line_height
+
+    # Calculate pages and total height needed
+    pages_content = []
+    current_page = []
+    y_text = PADDING_Y
+
+    for item in all_lines_and_breaks:
+        is_break = item is None
+        item_height = PARAGRAPH_SPACING if is_break else line_height
         
-        # Calculate pages
-        pages = max(1, required_height // 1080)
+        if y_text + item_height > IMG_HEIGHT - PADDING_Y:
+            pages_content.append(current_page)
+            current_page = [item]
+            y_text = PADDING_Y + item_height + (0 if is_break else LINE_SPACING)
+        else:
+            current_page.append(item)
+            y_text += item_height + (0 if is_break else LINE_SPACING)
+            
+    if current_page:
+        pages_content.append(current_page)
+
+    # Create a single combined image with all pages
+    total_height = len(pages_content) * IMG_HEIGHT
+    combined_img = Image.new('RGB', (IMG_WIDTH, total_height), color=BACKGROUND_COLOR)
+    
+    for page_idx, page_content in enumerate(pages_content):
+        # Create individual page
+        page_img = Image.new('RGB', (IMG_WIDTH, IMG_HEIGHT), color=BACKGROUND_COLOR)
+        draw = ImageDraw.Draw(page_img)
+
+        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)
+
+        current_y = PADDING_Y
+        for page_item in page_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
+            else:
+                current_y += PARAGRAPH_SPACING
         
-        return f"""Image generated successfully!
+        # Paste this page onto the combined image
+        combined_img.paste(page_img, (0, page_idx * IMG_HEIGHT))
 
-📊 Image Details:
-- Dimensions: 1080x{required_height} pixels
-- Pages: {pages}
+    # Save combined image to temporary file and also encode as base64
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
+    combined_img.save(temp_file.name, format='PNG')
+    temp_file.close()
+    
+    # Convert to base64 for inline viewing
+    import io
+    img_buffer = io.BytesIO()
+    combined_img.save(img_buffer, format='PNG')
+    img_buffer.seek(0)
+    img_base64 = base64.b64encode(img_buffer.getvalue()).decode('utf-8')
+    
+    return f"""Image successfully generated and saved to: {temp_file.name}
+
+Image details:
+- Total pages: {len(pages_content)}
+- Image dimensions: {IMG_WIDTH} x {total_height} pixels
 - Style: {style}
 - Format: PNG
 
-🖼️ Base64 Image Data:
+Base64 encoded image (you can copy this and paste into a base64 image viewer):
 data:image/png;base64,{img_base64}
 
-💡 To view the image:
-1. Copy the data URL above (including 'data:image/png;base64,')
-2. Paste it into your browser address bar
-3. The image will display directly!"""
-    
-    else:
-        # For Gradio: Return PIL Image object directly
-        return final_image
+To view the image:
+1. Copy the entire data:image/png;base64,... string above
+2. Paste it into your browser's address bar, or
+3. Use an online base64 image viewer like: https://base64.guru/converter/decode/image"""
 
 # --- Gradio Interface ---
 
-def create_gradio_interface():
-    """Creates the Gradio interface for the text-to-image converter."""
-    
-    interface = gr.Interface(
-        fn=text_to_images_generator,
-        inputs=[
-            gr.Textbox(
-                label="Text Content",
-                placeholder="Enter your text here...",
-                lines=10,
-                value="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.\n\nOne day, a young girl with eyes as curious as a cat's wandered into his shop. She wasn't interested in the shiny new watches but was drawn to the grandfather clock in the corner. \"What's its story?\" she asked, her voice soft. Alistair smiled, for he knew he had found the next guardian of the stories. The legacy of the whispering clock would live on."
-            ),
-            gr.Radio(
-                choices=["lines", "dots", "grid", "plain"],
-                label="Background Style",
-                value="lines"
-            )
-        ],
-        outputs=gr.Image(label="Generated Image", type="pil"),
-        title="📝➡️🖼️ Text to Images Generator",
-        description="Convert your text into beautiful images with different background styles. The image will automatically adjust its height based on the text length.",
-        examples=[
-            ["Hello World!\n\nThis is a simple example.", "lines"],
-            ["Chapter 1: Introduction\n\nThis is the beginning of our story...", "dots"],
-            ["• Point 1\n• Point 2\n• Point 3", "grid"],
-            ["Clean and simple text layout.", "plain"]
-        ],
-        theme=gr.themes.Soft()
-    )
-    
-    return interface
+example_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.
+
+One day, a young girl with eyes as curious as a cat's wandered into his shop. She wasn't interested in the shiny new watches but was drawn to the grandfather clock in the corner. "What's its story?" she asked, her voice soft. Alistair smiled, for he knew he had found the next guardian of the stories. The legacy of the whispering clock would live on."""
+
+demo = gr.Interface(
+    fn=text_to_images_generator,
+    inputs=[
+        gr.Textbox(lines=15, label="Text Content", placeholder="Paste your long-form text here...", value=example_text),
+        gr.Radio(['lines', 'dots', 'grid', 'plain'], label="Background Style", value='lines')
+    ],
+    outputs=gr.Textbox(label="Result", show_label=True),
+    title="Text-to-Image Converter",
+    description="Transforms long-form text into a single combined image with multiple pages. Paste your text, choose a style, and click 'Submit'. The result will show the file path where your image was saved.",
+    allow_flagging="never"
+)
 
+# --- Main Execution ---
 if __name__ == "__main__":
-    # Create and launch the interface
-    interface = create_gradio_interface()
-    interface.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(mcp_server=True)