Update app.py

app.py

@@ -1,10 +1,10 @@
-import gradio as gr
 import os
+import gradio as gr
 import tempfile
-import traceback
-import gc
 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):
@@ -21,330 +21,191 @@ def draw_lattice_grid(draw, width, height, spacing=100, color=(235, 235, 235)):
     # Draw vertical lines
     for x in range(0, width, spacing):
         draw.line([(x, 0), (x, height)], fill=color, width=2)
-    # Draw horizontal lines  
+    # Draw horizontal lines
     for y in range(0, height, spacing):
         draw.line([(0, y), (width, y)], fill=color, width=2)
 
-def text_to_images_mcp(text_content, style='lines', font_path=None):
+
+def text_to_images_generator(text_content, style='lines', font_path=None):
     """
-    Converts text to images and returns a list of image objects.
-    
+    Converts a given string of text into a series of images and returns their file paths.
+    This version is adapted for Gradio to return image paths from a temporary directory.
+
     Args:
         text_content (str): The text to be converted.
-        style (str): The background style ('plain', 'lines', 'dots', 'grid').
+        style (str, optional): The background style ('plain', 'lines', 'dots', 'grid').
         font_path (str, optional): The path to a .ttf font file.
-    
+
     Returns:
-        list: List of PIL Image objects for display in Gradio.
+        list: A list of file paths for the generated images.
     """
-    try:
-        # 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()
-
-        # --- 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 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
 
-        if not paragraphs:
-            return []
+    FONT_SIZE = 48
+    LINE_SPACING = 20
+    
+    # Create a temporary directory to save images for the Gradio gallery
+    output_dir = tempfile.mkdtemp()
 
-        all_lines_and_breaks = []
-        for i, paragraph in enumerate(paragraphs):
-            words = paragraph.split()
-            current_line = ""
-            for word in words:
+    # --- Font Loading ---
+    font = None
+    try:
+        # Prioritize provided font path if it exists
+        if font_path and os.path.exists(font_path):
+            font = ImageFont.truetype(font_path, FONT_SIZE)
+        else:
+            # Otherwise, search for common system fonts
+            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:
-                    # 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:
-                        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())
-            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:
-                line_height = FONT_SIZE
-        except Exception:
-            line_height = FONT_SIZE
-        
-        PARAGRAPH_SPACING = line_height
-        generated_images = []
-
-        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)
-
-                # 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)
+                    font = ImageFont.truetype(f_path, FONT_SIZE)
+                    break
+                except IOError:
+                    continue
+        # Fallback to default if no font is found
+        if not font:
+            gr.Warning("Could not find a standard .ttf font. Falling back to the basic default font. Text may look pixelated.")
+            font = ImageFont.load_default()
+    except Exception as e:
+        print(f"An unexpected error occurred during font loading: {e}")
+        font = ImageFont.load_default()
 
-                # 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
+    # --- 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:
+            # Handle very long words by breaking them up
+            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:
-                        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 y_text + item_height > IMG_HEIGHT - PADDING_Y:
-                img_count += 1
-                create_image_page(page_content, img_count)
+                        temp_word += char
+                word = temp_word
 
-                page_content = [item]
-                y_text = PADDING_Y + item_height + (0 if is_break else LINE_SPACING)
+            if font.getlength(current_line + " " + word) <= drawable_width:
+                current_line += " " + word
             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
+                all_lines_and_breaks.append(current_line.strip())
+                current_line = word
+        all_lines_and_breaks.append(current_line.strip())
         
-    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.
-
-Every midnight, as the city slept, the clock would chime, not with bells, but with whispers of forgotten tales. Stories of ancient kings, lost love, and adventures in lands woven from starlight and dreams. Alistair would sit by the fire, listening, his heart filled with the magic of the past. He was the keeper of time, and in turn, time had made him its confidant.
-
-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. "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."""
-
-def create_app():
-    """Create and configure the Gradio app with better error handling."""
+        # Add a placeholder for paragraph breaks
+        if i < len(paragraphs) - 1:
+            all_lines_and_breaks.append(None)
+
+    # --- Image Generation ---
+    generated_files = []
+    img_count = 0
+    page_content = []
+    y_text = PADDING_Y
     
-    # Create the demo with enhanced error handling
-    demo = gr.Interface(
-        fn=text_to_images_mcp,
-        inputs=[
-            gr.Textbox(
-                value=sample_text,
-                lines=10,
-                max_lines=20,
-                label="Text Content",
-                placeholder="Enter your long-form text here (max 10,000 characters)..."
-            ),
-            gr.Dropdown(
-                choices=['plain', 'lines', 'dots', 'grid'],
-                value='lines',
-                label="Background Style",
-                info="Choose the background style for your images"
-            ),
-            gr.Textbox(
-                value="",
-                label="Custom Font Path (Optional)",
-                placeholder="/path/to/your/font.ttf",
-                info="Leave empty to use system default font"
-            )
-        ],
-        outputs=[
-            gr.Gallery(
-                label="Generated Images (Max 10 pages)",
-                show_label=True,
-                elem_id="gallery",
-                columns=2,
-                rows=2,
-                object_fit="contain",
-                height="auto",
-                show_download_button=True
-            )
-        ],
-        title="📖 Text to Images Converter (MCP Compatible)",
-        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. This app functions as an MCP server for LLM integration.",
-        examples=[
-            [sample_text, 'lines', ''],
-            [sample_text, 'dots', ''],
-            [sample_text, 'grid', ''],
-            [sample_text, 'plain', '']
-        ],
-        cache_examples=False,
-        show_api=True
-    )
+    try:
+        # Get line height from font metrics if possible
+        line_height = font.getbbox("A")[3] - font.getbbox("A")[1]
+    except AttributeError:
+        # Fallback for default font
+        line_height = 12
     
-    return demo
-
+    PARAGRAPH_SPACING = line_height
+
+    def create_image_page(content, page_num):
+        """Helper function to create and save 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
+            else: # This is a paragraph break
+                current_y += PARAGRAPH_SPACING
+        
+        filename = os.path.join(output_dir, f"page_{page_num}.png")
+        img.save(filename)
+        generated_files.append(filename)
+
+    # Iterate through all lines and create pages
+    for item in all_lines_and_breaks:
+        is_break = item is None
+        item_height = PARAGRAPH_SPACING if is_break else line_height
+        
+        # If adding the next line/break exceeds page height, create the current page
+        if y_text + item_height > IMG_HEIGHT - PADDING_Y:
+            img_count += 1
+            create_image_page(page_content, img_count)
+            # Start a new page
+            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)
+            
+    # Save the last page if it has content
+    if page_content:
+        img_count += 1
+        create_image_page(page_content, img_count)
+
+    return generated_files
+
+# --- Gradio Interface ---
+
+# Example text to pre-fill the textbox
+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."""
+
+# Define the Gradio interface
+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__":
-    # Set up environment for MCP server
-    os.environ["GRADIO_MCP_SERVER"] = "True"
-    
-    # Create the app
-    demo = create_app()
-    
-    # Launch with multiple fallback strategies
-    launch_configs = [
-        # Strategy 1: Full MCP server with explicit settings
-        {
-            "mcp_server": True,
-            "server_name": "0.0.0.0",
-            "server_port": 7860,
-            "share": False,
-            "debug": False,
-            "show_error": False,
-            "quiet": True
-        },
-        # Strategy 2: Environment variable only
-        {
-            "server_name": "0.0.0.0",
-            "server_port": 7860,
-            "share": False,
-            "debug": False,
-            "show_error": False,
-            "quiet": True
-        },
-        # Strategy 3: Minimal configuration
-        {
-            "server_name": "0.0.0.0",
-            "server_port": 7860,
-            "share": False
-        },
-        # Strategy 4: Default configuration
-        {}
-    ]
-    
-    launched = False
-    for i, config in enumerate(launch_configs):
-        try:
-            print(f"Attempting launch strategy {i+1}...")
-            demo.launch(**config)
-            launched = True
-            print(f"Successfully launched with strategy {i+1}")
-            break
-        except Exception as e:
-            print(f"Launch strategy {i+1} failed: {e}")
-            if i < len(launch_configs) - 1:
-                print("Trying next strategy...")
-            continue
-    
-    if not launched:
-        print("All launch strategies failed. Please check your environment and dependencies.")
-        print("You may need to install gradio[mcp] or update your gradio version.") 
+    # Launch the Gradio app as an MCP server
+    # The MCP server allows other applications to call this Gradio app as an API
+    demo.launch(mcp_server=True)