Update app.py

app.py

@@ -1,6 +1,7 @@
 import os
 import tempfile
 import base64
+import io
 import gradio as gr
 from PIL import Image, ImageDraw, ImageFont
 
@@ -18,195 +19,230 @@ 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/graph paper grid on the image."""
-    # Draw vertical lines
+    """Draws a lattice grid on the image."""
     for x in range(0, width, spacing):
-        draw.line([(x, 0), (x, height)], fill=color, width=2)
-    # Draw horizontal lines
+        draw.line([(x, 0), (x, height)], fill=color, width=1)
     for y in range(0, height, spacing):
-        draw.line([(0, y), (width, y)], fill=color, width=2)
+        draw.line([(0, y), (width, y)], fill=color, width=1)
 
+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, style='lines'):
+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:
     """
-    Converts a given string of text into a single combined image and returns the file path.
-    This is compatible with both UI and MCP.
-
+    Converts a given string of text into images and returns the result.
+    
     Args:
-        text_content (str): The text to be converted.
-        style (str): The background style ('plain', 'lines', 'dots', 'grid').
-
+        text_content: The text to be converted.
+        style: The background style ('plain', 'lines', 'dots', 'grid').
+    
     Returns:
-        str: Message with the path to the generated combined image file.
+        For MCP: Base64 encoded image data
+        For Gradio: PIL Image object
     """
-    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
     
-    # --- Font Loading ---
-    font = None
+    # 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)
+    
     try:
-        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.truetype("arial.ttf", 40)
+    except:
+        try:
+            font = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", 40)
+        except:
             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()]
     
-    all_lines_and_breaks = []
-    for i, paragraph in enumerate(paragraphs):
-        words = paragraph.split()
+    # 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(' ')
         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
-                    else:
-                        temp_word += char
-                word = temp_word
-
-            if font.getlength(current_line + " " + word) <= drawable_width:
-                current_line += " " + word
+            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
             else:
-                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
+                    current_line = word
+                else:
+                    total_lines += 1
         
-        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 current_line:
+            total_lines += 1
+        total_lines += 0.5  # Extra space between paragraphs
     
-    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 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 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')
         
-        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
+        # Calculate pages
+        pages = max(1, required_height // 1080)
         
-        # Paste this page onto the combined image
-        combined_img.paste(page_img, (0, page_idx * IMG_HEIGHT))
+        return f"""Image generated successfully!
 
-    # 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
+📊 Image Details:
+- Dimensions: 1080x{required_height} pixels
+- Pages: {pages}
 - Style: {style}
 - Format: PNG
 
-Base64 encoded image (you can copy this and paste into a base64 image viewer):
+🖼️ Base64 Image Data:
 data:image/png;base64,{img_base64}
 
-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"""
+💡 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
 
 # --- Gradio 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"
-)
+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
 
-# --- Main Execution ---
 if __name__ == "__main__":
-    demo.launch(mcp_server=True)
+    # Create and launch the interface
+    interface = create_gradio_interface()
+    interface.launch(server_name="0.0.0.0", server_port=7860)