app.py

import os
import tempfile
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 single combined image.
    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:
        str: Path to the generated combined image file.
    """
    if not text_content or not text_content.strip():
        # Return None and show a warning if there is no text
        gr.Warning("Input text is empty. Please enter some text to generate images.")
        return None

    # --- 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 ---
    try:
        line_height = font.getbbox("A")[3] - font.getbbox("A")[1]
    except AttributeError:
        line_height = 12
    
    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
        
        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
        
        # Paste this page onto the combined image
        combined_img.paste(page_img, (0, page_idx * IMG_HEIGHT))

    # Save combined image to temporary file
    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
    combined_img.save(temp_file.name, format='PNG')
    temp_file.close()
    
    return temp_file.name

# --- 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.Image(label="Generated Image", 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'. You can download the image from below.",
    allow_flagging="never"
)

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