app.py

import os
import gradio as gr
from PIL import Image, ImageDraw, ImageFont

# --- Image Generation Logic (from coverter.py) ---

def draw_horizontal_lines(draw, width, height, spacing=60, color=(230, 230, 230)):
    """Draws horizontal lines on the image."""
    for y in range(0, height, spacing):
        draw.line([(0, y), (width, y)], fill=color, width=2)

def draw_dot_grid(draw, width, height, spacing=50, color=(220, 220, 220)):
    """Draws a dot grid on the image."""
    for x in range(0, width, spacing):
        for y in range(0, height, spacing):
            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
    for x in range(0, width, spacing):
        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=2)


def text_to_images_generator(text_content, style='lines', font_path=None):
    """
    Converts a given string of text into a series of images and returns them
    as a list of PIL Image objects. This is compatible with both UI and MCP.

    Args:
        text_content (str): The text to be converted.
        style (str, optional): The background style ('plain', 'lines', 'dots', 'grid').
        font_path (str, optional): The path to a .ttf font file.

    Returns:
        list: A list of PIL.Image.Image objects.
    """
    if not text_content or not text_content.strip():
        # Return empty list and show a warning if there is no text
        gr.Warning("Input text is empty. Please enter some text to generate images.")
        return []

    # --- 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
    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", "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:
            gr.Warning("Could not find a standard .ttf font. Falling back to the basic default 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()]
    
    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
                    else:
                        temp_word += char
                word = temp_word

            if font.getlength(current_line + " " + word) <= drawable_width:
                current_line += " " + word
            else:
                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 ---
    generated_images = [] # Store PIL Image objects directly
    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

    def create_image_page(content):
        """Helper function to create a single image page and return it."""
        img = Image.new('RGB', (IMG_WIDTH, IMG_HEIGHT), color=BACKGROUND_COLOR)
        draw = ImageDraw.Draw(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 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
        
        generated_images.append(img) # Add the PIL image to our list

    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:
            create_image_page(page_content)
            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:
        create_image_page(page_content)

    return generated_images

# --- 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.Gallery(label="Generated Images", show_label=True, preview=True),
    title="Text-to-Image Converter",
    description="Transforms long-form text into a series of attractive, readable images. Paste your text, choose a style, and click 'Submit'. You can download the images from the gallery below.",
    allow_flagging="never"
)

# --- Main Execution ---
if __name__ == "__main__":
    demo.launch(mcp_server=True)